01.Java基础之类与对象（上）

一．面向对象

1:面向对象思想

面向对象是基于面向过程的编程思想。

面向过程：强调的是每一个功能的步骤

面向对象：强调的是对象，然后由对象去调用功能

2:面向对象的思想特点

A:是一种更符合我们思想习惯的思想

B:可以将复杂的事情简单化

C:将我们从执行者变成了指挥者

举例：

买电脑：

面向过程：我的了解电脑--了解我自己的需求--找对应的参数信息--去中关村买电脑--讨价还价--买回电脑

面向对象：我知道我要买电脑 -- 班长去给我买 -- 班长就买回来了

洗衣服：

面向过程：把衣服脱下--找一个盆--放点洗衣粉--加点水--把衣服扔进去--搓一搓--清洗衣服--拧干--晾起来

面向对象：把衣服脱下--打开全自动洗衣机--扔进去--一键即可--晾起来

吃饭：

面向过程：去超市买菜--摘菜--洗菜--切菜--炒菜--盛起来--吃

面向对象：上饭店吃饭，你--服务员(点菜)--厨师(做菜)--服务员(端菜)--吃

3:开发，设计，特征

面向对象开发

就是不断的创建对象，使用对象，指挥对象做事情。

面向对象设计

其实就是在管理和维护对象之间的关系。

 

面向对象特征

封装(encapsulation)

继承(inheritance)

多态(polymorphism)

 

二．类与对象及其使用

1.类的定义及使用

A:类的定义

成员变量 定义格式和以前一样，就是位置不同，在类中，方法外。

成员方法 定义格式和以前一样，就是去掉了static。

B:使用类的内容

a:创建对象? 格式

类名 对象名 =  new 类名();

b:如何使用成员变量和成员方法呢

对象名.成员变量

对象名.成员方法()

2.案例：

A:学生类的定义和使用

//这是学生类

class Student {

//姓名

String name; //null

//年龄

int age; //0

//地址

String address; //null

//学习

public void study() {

System.out.println("学生爱学习");

}

//吃饭

public void eat() {

System.out.println("学习饿了，要吃饭");

}

//睡觉

public void sleep() {

System.out.println("学习累了，要睡觉");

}

}

 

//这是学生测试类

class StudentDemo {

public static void main(String[] args) {

//类名 对象名 = new 类名();

Student s = new Student();

//输出成员变量值

System.out.println(s.name+"---"+s.age+"---"+s.address)；

//给成员变量赋值

s.name = "林青霞";

s.age = 27;

s.address = "北京";

//赋值后的输出

System.out.println(s.name+"---"+s.age+"---"+s.address);

//调用方法

s.study();

s.eat();

s.sleep();

}

}

 

三.成员变量和局部变量的区别

在类中的位置不同

成员变量 类中方法外

局部变量 方法内或者方法声明上

在内存中的位置不同

成员变量 堆内存

局部变量 栈内存

生命周期不同

成员变量 随着对象的存在而存在，随着对象的消失而消失

局部变量 随着方法的调用而存在，随着方法的调用完毕而消失

初始化值不同

成员变量 有默认的初始化值

局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。

注意事项：

局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

 

四.匿名对象(理解)

(1)没有名字的对象

(2)应用场景

a:调用方法，仅仅只调用一次的时候。

          Student s = new Student();

s.show();

  new Student().show();

好处：

    匿名对象调用完以后就是垃圾，可以被垃圾回收启回收。

b:可以作为实际参数传递。

五．封装(private)

1.定义一个学生类：

成员变量：name，age

成员方法：show()方法

我们在使用这个案例的过程中，发现了一个问题：

通过对象去给成员变量赋值，可以赋值一些非法的数据。这是不合理的。应该是这个样子的：在赋值之前，先对数据进行判断。

 

判断到底在哪里做比较合适呢?

StudentDemo类是一个测试类，测试类一般只创建对象，调用方法。

所以，这个判断应该定义在Student类中。

而我们在成员变量的位置可不可以进行数据判断呢?

是不可以的，因为做数据校验，必须要依靠一些逻辑语句。

逻辑语句是应该定义在方法中的，所以，我们最终决定在Student类中提供一个方法来对数据进行校验。

按照我们前面的分析，我们给出了一个方法进行校验。

但是呢，它偏偏不调用方法来赋值，还是直接赋值了，这样我们的方法就没有起到作用我就应该要求你必须使用我的方法，而不能直接调用成员变量赋值。

怎么去强制要求不能直接使用成员变量呢?

针对这种情况，Java就提供了一个关键字 private

private:私有的。可以修饰成员变量和成员方法。

注意：被private修饰的成员只能在本类中访问。

其实我讲到现在讲解的是一个封装的思想。

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

 

2.封装概述

是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：

隐藏实现细节，提供公共的访问方式

提高了代码的复用性

提高安全性。

封装原则：

将不需要对外提供的内容都隐藏起来。

把属性隐藏，提供公共方法对其访问

 

3.private关键字：

是一个权限修饰符。

可以修饰成员(成员变量和成员方法)

被private修饰的成员只在本类中才能访问。

 

private最常见的应用：

把成员变量用private修饰

提供对应的getXxx()/setXxx()方法

一个标准的案例的使用

 

//定义学生类

class Student {

private String name;

private int age;

public String getName() {

return name;

}

public void setName(String n) {

name = n;

}

public int getAge() {

return age;

}

public void setAge(int a) {

age = a;

}

}

//测试类

class StudentTest {

public static void main(String[] args) {

//创建学生对象

Student s = new Student();

//使用成员变量

//错误：被私有修饰了，外界不能直接访问了

//System.out.println(s.name+"---"+s.age);

System.out.println(s.getName()+"---"+s.getAge());

//通过方法给赋值

s.setName("林青霞");

s.setAge(27);

System.out.println(s.getName()+"---"+s.getAge());

}

}

 

六．this关键字(掌握)

A.代表当前类的引用对象

记住：哪个对象调用方法，该方法内部的this就代表那个对象

B.this的应用场景：

a:解决了局部变量隐藏成员变量的问题

b:其实this还有其他的应用（后）。

 

七.构造方法

    1. 构造方法作用概述

给对象的数据进行初始化

构造方法格式

方法名与类名相同

没有返回值类型，连void都没有

没有具体的返回值

构造方法注意事项

如果你不提供构造方法，系统会给出默认构造方法

如果你提供了构造方法，系统将不再提供

构造方法也是可以重载的

 

2.类的成员方法

      成员方法其实就是我们前面讲过的方法

方法具体划分：

根据返回值

有明确返回值方法

返回void类型的方法

根据形式参数

无参方法

带参方法

 

3.类的初始化过程

      Student s = new Student();在内存中做了哪些事情?

加载Student.class文件进内存

在栈内存为s开辟空间

在堆内存为学生对象开辟空间

对学生对象的成员变量进行默认初始化

对学生对象的成员变量进行显示初始化

通过构造方法对学生对象的成员变量赋值

学生对象初始化完毕，把对象地址赋值给s变量

 

 

 

4.面向对象练习

A.定义一个类Demo,其中定义一个求两个数据和的方法，

定义一个测试了Test，进行测试。

  变量什么时候定义为成员变量：

    如果这个变量是用来描述这个类的信息的，那么，该变量就应该定义为成员变量。

  变量到底定义在哪里好呢?

变量的范围是越小越好。因为能及时的被回收。

 

//方式1

class Demo {

public int sum() {

int a = 10;

int b = 20;

int c = a + b;

return c;

}

}

//方式1满足了我们的要求，但是不好。

//因为参与操作的数据现在是固定的。

 

//方式2

class Demo {

public int sum(int a,int b) {

return a + b;

}

}

 

//方式2可以满足我们的要求，但是呢我们学习过来面向对象的思想。

//我就再想，a，b可不可以定义为成员变量呢?

//如果可以，我们再改进一版

class Demo {

int a;

int b;

public int sum() {

return a + b;

}

}

//虽然这种方式可以，并且好像是符合了面向对象的思想。

//但是不好。

//因为我们曾经说过：类是一组相关的属性和行为的集合。

//并且类是通过事物转换过来的

//而类中的成员变量就是事物的属性

//属性是用来描述事物的

//同理：成员变量其实是用来描述类的。

 

//测试类

class Test {

public static void main(String[] args) {

//创建对象

//方式1测试

/*

Demo d = new Demo();

System.out.println(d.sum());

*/

//方式2测试

/*

Demo d = new Demo();

int a = 10;

int b = 20;

System.out.println(d.sum(a,b));

*/

//方式3测试

Demo d = new Demo();

d.a = 10;

d.b = 20;

System.out.println(d.sum());

}

}

 

B.定义一个长方形类,定义 求周长和面积的方法，

然后定义一个测试了Test2，进行测试。

 

长方形的类：

成员变量：

长，宽

成员方法：

求周长：(长+宽)*2;

求面积：长*宽

注意：

import必须出现在所有的class前面。

 

import java.util.Scanner;

class ChangFangXing {

//长方形的长

private int length;

//长方形的宽

private int width;

public ChangFangXing(){}

//仅仅提供setXxx()即可

public void setLength(int length) {

this.length = length;

}

public void setWidth(int width) {

this.width = width;

}

//求周长

public int getZhouChang() {

return (length + width) * 2;

}

//求面积

public int getArea() {

return length * width;

}

}

 

class Test2 {

public static void main(String[] args) {

//创建键盘录入对象

Scanner sc = new Scanner(System.in);

System.out.println("请输入长方形的长：");

int length = sc.nextInt();

System.out.println("请输入长方形的宽：");

int width = sc.nextInt();

//创建对象

ChangFangXing cfx = new ChangFangXing();

//先给成员变量赋值

cfx.setLength(length);

cfx.setWidth(width);

System.out.println("周长是："+cfx.getZhouChang());

System.out.println("面积是："+cfx.getArea());

}

}

 

C. 需求：

定义一个员工类,自己分析出几个成员，

然后给出成员变量，构造方法，getXxx()/setXxx()方法，

以及一个显示所有成员信息的方法。并测试。

 

分析：

员工

成员变量：

员工编号，姓名，年龄

构造方法：

无参构造方法

成员方法：

getXxx()/setXxx()

show();

*/

class Employee {

//员工编号

private String employeeId;

//姓名

private String name;

//年龄

private int age;

//构造方法

public Employee() {}

//getXxx()/setXxx()

public String getEmployeeId() {

return employeeId;

}

public void setEmployeeId(String employeeId) {

this.employeeId = employeeId;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

//显示所有成员信息的方法

public void show() {

System.out.println("员工编号是："+employeeId+"的这个人是："+name+"的年龄是："+age);

}

}

 

class EmployeeTest {

public static void main(String[] args) {

//创建对象

Employee e = new Employee();

//给成员变量赋值

e.setEmployeeId("czbk9527");

e.setName("唐伯虎");

e.setAge(18);

//获取数据

//System.out.println(e.getEmployeeId()+"---"+e.getName()+"---"+e.getAge());

//我们在Employee类中定义了一个show方法。所以，我们改进一下，使用show方法

e.show();

}

}

 

八.static关键字.

    可以修饰成员变量和成员方法

static的特点：(它可以修饰成员变量，还可以修饰成员方法)

A:随着类的加载而加载

回想main方法。

B:优先于对象存在

C:被类的所有对象共享

举例：咱们班级的学生应该共用同一个班级编号。

其实这个特点也是在告诉我们什么时候使用静态?

如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。

举例：

饮水机(用静态修饰)

水杯(不能用静态修饰)

D:可以通过类名调用

其实它本身也可以通过对象名调用。

推荐使用类名调用。

静态修饰的内容一般我们称其为：与类相关的，类成员

 class Student {

//非静态变量

int num = 10;

//静态变量

static int num2 = 20;

}

 

class StudentDemo {

public static void main(String[] args) {

Student s = new Student();

System.out.println(s.num);

System.out.println(Student.num2);

System.out.println(s.num2);

}

}

 

static关键字注意事项

A:在静态方法中是没有this关键字的

如何理解呢?

静态是随着类的加载而加载，this是随着对象的创建而存在。

    静态比对象先存在。

B:静态方法只能访问静态的成员变量和静态的成员方法

    静态方法：

      成员变量：只能访问静态变量

成员方法：只能访问静态成员方法

非静态方法：

成员变量：可以是静态的，也可以是非静态的

成员方法：可是是静态的成员方法，也可以是非静态的成员方法。

简单记：静态只能访问静态。

 A. 定义一个人类

姓名和年龄都是变化的，这个我能接收，因为每个人的姓名和年龄是不同的。

但是，我们现在选取的几个人都是中国人，他们的国籍是一样的。

一样的国籍，我每次创建对象，在堆内存都要开辟这样的空间，

我就觉得有点浪费了。怎么办呢?

针对多个对象有共同的这样的成员变量值的时候，

Java就提高了一个关键字来修饰：static。

 

class Person {

//姓名

String name;

//年龄

int age;

//国籍

//String country;

static String country;

public Person(){}

public Person(String name,int age) {

this.name = name;

this.age = age;

}

public Person(String name,int age,String country) {

this.name = name;

this.age = age;

this.country = country;

}

public void show() {

System.out.println("姓名："+name+",年龄："+age+",国籍："+country);

}

}

 

class PersonDemo {

public static void main(String[] args) {

//创建对象1

Person p1 = new Person("邓丽君",16,"中国");

p1.show();

//创建对象2

//Person p2 = new Person("杨幂",22,"中国");

//p2.show();

Person p2 = new Person("杨幂",22);

p2.show();

//创建对象3

//Person p3 = new Person("凤姐",20,"中国");

//p3.show();

Person p3 = new Person("凤姐",20);

p3.show();

p3.country = "美国";

p3.show();

p1.show();

p2.show();

}

}