类和对象

1.类与对象的初步认识

c语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

Java是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

面向过程注重的是过程，就像我们用手洗衣服，我们需要先用盆接水，然后放入衣服，然后放入洗衣粉，然后用手搓，然后拧干晒起来。

面向对象注重的是对象，就像我们用洗衣机洗衣服，只要把衣服和洗衣服放入洗衣机，然后晒干就可以了，不用去管洗衣机是如何去洗衣服的。

2.类和类的实例化

类就是一类对象的统称。对象就是这一类具体化的一个实例。

类相当于一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象。

声明一个类就是创建一个新的数据类型，而类在Java中属于引用类型，Java使用关键字class来声明类。我们来看以下简单的声明一个类。

基本语法

//创建类
class <class_name>{field;    //  成员属性method;    //  成员方法
}//实例化对象
<class_name> <对象名> = new <class_name>();

class为定义类的关键字，ClassName为类的名字，{}中为类的主体。

类中的元素称为：成员属性。类中的函数称为：成员方法。

示例：

class Person{public int age;    //  成员属性  实例变量public String name;public String sex;public void eat(){    //成员方法System.out.println("吃饭！");}public void sleep(){System.out.println("睡觉！");}
}

注意事项

和之前写的方法不同，此处写的方法不带static关键字，我们我们会详细解释static是干什么的。

类的实例化

用类类型创建对象的过程，称为类的实例化

1. 类只是一个模型一样的东西，限定了类有哪些成员。
2. 一个类可以实例化出多个对象，实例化出的对象，占用实际的物理空间，存储类成员变量。

class Person{public int age;    //  成员属性  实例变量public String name;public String sex;public void eat(){    //成员方法System.out.println("吃饭！");}public void sleep(){System.out.println("睡觉！");}
}public class DemoTest {public static void main(String[] args) {Person person = new Person();    //  通过new实例化对象Person.eat();    //  成员方法调用需要通过对象的引用调用Person.sleep();//  产生对象  实例化对象Person person2 = new Person();Person person3 = new Person();}
}

输出结果为：

吃饭！
睡觉！

注意事项

1. new关键字用于创建一个对象的实例。

2. 使用.来访问对象中的属性和方法。

3. 同一个类可以创建多个实例。

3.类的成员

类的成员包含以下：字段、方法、代码块、内部类和接口等。

此处我们重点介绍前三个。

3.1字段/属性/成员变量

在类中，但是方法外部定义的变量。这样的变量我们称为"字段"或"属性"或"成员变量"(三种称呼都可以，一般不会严格区分)，用于描述一个类中包含哪些数据。

class Person{public String name;    //  字段public int age;
}public class TestDemo {public static void main(String[] args) {Person person=new Person();System.out.println(person.name);System.out.println(person.age);}
}//执行结果
null
0

注意事项

1. 使用.访问对象的字段。
2. "访问"既包含读，也包含写。
3. 对于一个对象的字段如果没有显式设置初始值，那么会被设置一个默认的初值。

默认值规则

对于各种数字类型，默认值为0。

对于boolean类型，默认值为false。

对于引用类型(String,Array,以及自定制类)，默认值为null.

Person person = null;
//这个引用不指向任何的对象Person person = new Person();
Person person2=person;
//person2这个引用指向person这个引用所指向的对象Person person = new Person();
person = new Person();
person = new Person();
person = new Person();
//一个引用不可以同时指向多个对象 实际指向的是最后一个对象

字段就地初始化

很多时候我们不希望字段使用默认值，而是需要我们显式设定初值，可以这样写：

class Person{public String name = "ljj";    public int age = 18;
}public class TestDemo {public static void main(String[] args) {Person person=new Person();System.out.println(person.name);System.out.println(person.age);}
}//执行结果
ljj
18

3.2方法

用于描述一个对象的行为。

class Person{public String name = "ljj";    public int age = 18;public void show(){System.out.println("我叫"+name+",今年"+age+"岁")； }
}public class TestDemo {public static void main(String[] args) {Person person = new Person();person.show();}
}//执行结果
我叫ljj,今年18岁

此处的show方法，表示Person这个对象具有一个"展示自我"的行为。

这样的show方法是和person实例相关联的，如果创建了其他实例，那么show的行为就会发生变化。

Person person2 = new Person();
person2.name = "李四";
person2.age = 20;
person.show();//执行结果
我叫李四，今年20岁

3.3 static关键字

1. 修饰属性
2. 修饰方法
3. 代码块
4. 修饰类

a）修饰属性，Java静态属性和类相关，和具体的实例无关。换句话说，同一个类的不同实例共用一个静态属性。

class TestDemo1{public int a;public static int count;
}public class TestDemo {public static void main(String[] args) {TestDemo1 t1 = new TestDemo1();t1.a++;TestDemo1.count++;System.out.println(t1.a);System.out.println(TestDemo1.count);System.out.println("===============");TestDemo1 t2 = new TestDemo1();t2.a++;TestDemo1.count++;System.out.println(t2.a);System.out.println(TestDemo1.count);}
}

输出结果为：

1
1
===============
1
2

b)修饰方法

如果在任何方法上应用static关键字，此方法称为静态方法。

1. 静态方法属于类，而不属于类的对象。
2. 可以直接调用静态方法，而无需创建类的实例。
3. 静态方法可以访问静态数据成员，并可以更改静态数据成员的值。

class TestDemo1{public int a;public static int count;public static void change(){count = 100;//a = 10;  error  不可以访问非静态数据成员}
}public class TestDemo {public static void main(String[] args) {TestDemo1.change();    //  无需创建实例对象就可以调用System.out.println(TestDemo1.count);}
}

输出结果：

100

注意事项1：静态方法和实例无关，而是和类相关。因此导致了两个情况：

1. 静态方法不能直接使用非静态数据成员或调用非静态方法(非静态数据成员和方法都是和实例相关的)。
2. this和super两个关键字不能在静态上下文中使用(this是当前实例的引用，super是当前实例父类实例的引用，也是和当前实例相关)。

注意事项2：

1. 我们曾经写的方法为了简单，都统一加上了static。但实际上一个方法具体要不要带static，都需要视情形而定。
2. main方法为static方法。

4.封装

软件开发的本质就是对程序复杂程度的管理，如果一个软件代码复杂程度太高，那么就无法继续维护。如何管理复杂程度？封装就是最基本的方法。

在我们写代码的时候经常会涉及两种角色：类的实现者和类的调用者。

封装的本质就是让类的调用者不必了解类的实现者是如何实现类的，只要知道如何使用就行了。

这样就降低了类使用者的学习和使用成本，从而降低了复杂程度。

4.1 private实现封装

private/public这两个关键字表示"访问权限控制"。

被public修饰的成员变量或者成员方法，可以直接被类的调用者使用。

被private修饰的成员变量或者成员方法，不能被类的调用者使用。

直接使用public

class Person{public String name = "ljj";    public int age = 18;public class TestDemo {public static void main(String[] args) {Person person = new Person();System.out.println("我叫"+person.name+",今年"+person.age+"岁");}
}//执行结果
我叫ljj，今年18岁

这样的代码导致类的使用者(main方法的代码)必须要了解Person类内部的实现，才能够使用这个类，学习成本较高。

一旦类的实现者修改了代码(例如把name改成myName)，那么类的使用者就需要大规模的修改自己的代码，维护成本较高。

范例：使用private封装属性，并提供public方法供类的调用者使用。

class Person{private String name = "ljj";    private int age = 18;public void show(){System.out.println("我叫"+person.name+",今年"+person.age+"岁");}
}public class TestDemo {public static void main(String[] args) {Person person = new Person();person.show();}
}//执行结果
我叫ljj，今年18岁

此时字段已经使用private来修饰，类的调用者(main方法中)不能直接使用。而需要借助show方法。此时类的使用者就不必了解Person类的实现细节。

同时如果类的实现者修改了字段的名字，类的调用者不需要做出任何修改(类的调用者根本访问不到name,age这样的字段)。

注意事项

1. private不光能修饰字段，也能修饰方法。
2. 通常情况下我们会把字段设为private属性，但是方法是否需要设为public，就需要视具体情形而定。一般我们希望一个类只提供"必要的"public方法，而不应该把所有的方法都无脑设为public。

4.2 getter和setter方法

当我们使用private来修饰字段的时候，就无法直接使用这个字段了。

代码示例

class Person{private String name = "ljj";    private int age = 18;public void show(){System.out.println("我叫"+person.name+",今年"+person.age+"岁");}
}public class TestDemo {public static void main(String[] args) {Person person = new Person();person.age=20person.show();}
}//编译出错
java: age可以在Person中访问private

此时如果需要获取或者修改这个private属性，就需要使用getter/setter方法。

代码示例

class Person{private String name;    //  实例成员变量    private int age;public void setName(String name){//name = name;    //  不能这样写this.name = name;    //this引用，表示调用该方法的对象}public String getName(){return name;}public void show(){System.out.println("name:"+name+" age:"+age);}
}public class TestDemo {public static void main(String[] args) {Person person = new Person();person.setName("ljj");String name = person.getName();System.out.println(name);person.show();}
}//运行结果
ljj
name:ljj age:0

注意事项

getName即为getter方法，表示获取这个成员的值。

setName即为setter方法，表示设置这个成员的值。

当set方法的形参名字和类中的成员属性名字一样的时候，如果不使用this，相当于赋值，this表示当前实例的引用。

不是所有的字段都一定要提供setter/getter方法，而是要根据实际情况决定提供哪种方法。

在IDEA中可以使用alt+insert(或者alt+F12)快速生成setter/getter方法。在VSCode中可以使用鼠标右键菜单->源代码操作中自动生成setter/getter方法。

5.构造方法

5.1基本语法

构造方法是一种特殊方法，使用关键字new实例化新对象时会被自动调用，用于完成初始化操作。

new执行过程

1. 为对象分配内存空间

2. 调用对象的构造方法

语法规则

1. 方法名称必须与类名称相同
2. 构造方法没有返回值类型声明
3. 每一个类中一定至少存在一个构造方法(没有明确定义，则系统自动生成一个无参构造)

注意事项

1. 如果类中没有提供任何构造函数，那么编译器会默认生成一个不带参数的构造函数。

2. 若类中定义了构造方法，则默认的无参构造将不再生成。

3. 构造方法支持重载，规则和普通方法的重载一致。

代码示例

class Person{private String name;    //  实例成员变量    private int age;private String sex;//  默认构造函数  构造对象public Person(){this.name = "ljj";this.age = 10;this.sex = "男";}//  带有3个参数的构造函数public person(String name,int age,String sex){this.name = name;this.age = age;this.sex = sex;}public void show(){System.out.println("name:"+name+" age:"+age+"sex:"+sex);}
}public class TestDemo {public static void main(String[] args) {Person person1 = new Person();    //调用不带参数的构造函数  如果程序没有提供会调用不带参数的构造函数p1.show();Person person2 = new Person("李四",80,"男”);    //调用不带参数的构造函数  p2.show();}
}//执行结果
name:ljj age:10 sex:男
name:李四 age:80 sex:男

5.2 this关键字

this表示当前对象引用(注意不是当前对象)，可以借助this来访问对象的字段和方法。

class Person{private String name;    //  实例成员变量    private int age;//  默认构造函数  构造对象public Person(){//  this调用构造函数this("bit",12,"man");    //  必须放在第一行进行显式}//  这两个构造函数之间的关系为重载public person(String name,int age,String sex){this.name = name;this.age = age;this.sex = sex;}public void show(){System.out.println("name:"+name+" age:"+age+"sex:"+sex);}
}
public class TestDemo {public static void main(String[] args) {Person person = new Person();    //  调用不带参数的构造函数person.show();}
}//执行结果
name:bit age:12 sex:man

6.认识代码块

字段的初始化方式有：

1. 就地初始化
2. 使用构造方法初始化
3. 使用代码块初始化

前两种方式前面已经学习过了，接下来我们介绍第三种方式，使用代码块初始化。

6.1什么是代码块

使用{}定义的一段代码。

根据代码块定义的位置以及关键字，又可分为以下四种：

1. 普通代码块
2. 构造块
3. 静态块
4. 同步代码块

6.2普通代码块

普通代码块：定义在方法中的代码块

public class TestDemo {public static void main(String[] args) {{//  直接使用{}定义普通方法块int x = 10;System.out.println("x1 = "+x);}int x = 100;System.out.println("x2 = "+x);}
}//执行结果
x1 = 10
x2 = 100

6.3构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

class Person{private String name;    //  实例成员变量    private int age;private String sex;public Person(){System.out.println("I am Person init()!");}//实例代码块{this.name = "ljj";this.age = 18;this.sex = "man";System.out.println("I am instance init()!");}public void show(){System.out.println("name:"+name+" age:"+age+"sex:"+sex);}
}public class TestDemo {public static void main(String[] args) {Person p1 = new Person();   p1.show();}
}//运行结果
I am instance init()!
I am Person init()!
name:ljj age:18 sex:man

注意事项：实例代码块优先于构造函数执行。

6.4静态代码块

使用static定义的代码块，一般用于初始化静态成员属性。

class Person{private String name;    //  实例成员变量    private int age;private String sex;private static int count = 0;    //  静态成员变量  由类共享数据  方法区public Person(){System.out.println("I am Person init()!");}//实例代码块{this.name = "ljj";this.age = 18;this.sex = "man";System.out.println("I am instance init()!");}//静态代码块static{count = 10;    //  只能访问静态数据成员System.out.println("I am instance init()!");}public void show(){System.out.println("name:"+name+" age:"+age+"sex:"+sex);}
}public class TestDemo {public static void main(String[] args) {Person p1 = new Person();   Person p2 = new Person();    //  静态代码块是否还会被执行？}
}

注意事项

1. 静态代码块不管生成多少个对象，都只会执行一次，且是最先执行的。
2. 静态代码块执行完毕后，实例代码块(构造块)执行，再然后是构造函数执行。