类和对象
类与对象的初步认知 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 面向过程注重的是过程，在整个过程中所涉及的行为，就是功能。 面向对象注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来。简而言之 面向对象就是用代码(类)来描述客观世界的事物的一种方式。一个类主要包含一个事物的属性和行为。
2.类和类的实例化 类就是一类对象的统称。对象就是这一类具体化的一个实例。 总的来说：类相当于一个模板，而对象是由模板产生的样本。一个类可以产生无数的对象。 声明一个类就是创建一个新的数据类型，而类在 Java 中属于引用类型，Java 使用关键字 class 来声明类。我们来看以下简单的声明一个类。
基本语法： //创建类 class 类名{ field;//成员属性/变量 method;//成员方法 } // 实例化一个对象 类名 对象名 = new 类名(); 1 2 3 4 5 6 7 class为定义类的关键字，{}中为类的主体。 类中的元素称为：成员属性。类中的函数称为：成员方法。
类的实例化： 用类类型创建对象的过程，称为类的实例化。
类只是一个模型一样的东西，限定了类有哪些成员。 一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量。 类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。 代码示例： class Student { //成员属性 实例变量 public int age; public String name; public String sex; //成员方法 public void eat() { System.out.println(“吃饭!”); } public void sleep() { System.out.println(“睡觉!”); } public void study(){ System.out.println(“上学!”); } } public class Demo{ public static void main(String[] args) { Student student = new Student();//通过new实例化对象 student.eat();//成员方法调用需要通过对象的引用调用 使用"."操作符 student.sleep(); student.study(); //产生对象 实例化对象 开辟空间 Student student2 = new Student(); Student student3 = new Student(); } } 运行结果： 吃饭! 睡觉! 上学! 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 注意： new关键字用于创建一个对象的实例。 使用 . 来访问对象中的属性和方法。 同一个类可以创建多个实例。 3.类的成员 类的成员可以包含以下：字段、方法、代码块、内部类和接口等。 此处我们重点介绍前三个。
3.1字段/属性/成员变量 在类中, 在方法外部定义的变量。这样的变量我们称为 “字段” 或 “属性” 或 “成员变量”(三种称呼都可以, 一般不会严格区分)。 用于描述一个类中包含哪些数据：
class Person { public String name; // 字段 public int age; } class Test { public static void main(String[] args) { Person person = new Person(); System.out.println(person.name); System.out.println(person.age) } } //执行结果 null 0
//空引用 class Test { public static void main(String[] args) { Person person = new Person(); System.out.println(person.name.length()); //获取字符串长度 } } //运行结果：抛出空指针异常 Exception in thread “main” java.lang.NullPointerException at Test.main(Test.java:9) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 注意： 使用 . 访问对象的字段，访问既包括读，也包括写。 对于一个对象的字段如果没有显式设置初始值, 那么会被设置一个默认的初值。 null在java中为"空引用"，表示不引用任何对象。类似于C语言中的空指针。如果对null 进行**.** 操作就会引发异常。 默认值规则：
对于各种数字类型，默认值为0. 对于boolean类型，默认值为false。 对于引用类型(String，Array，以及自定义类)，默认值都为null。 字段就地初始化 很多时候我们不希望字段使用默认值, 而是需要我们显式设定初值. 可以这样写：
class Person { public String name = “张三”; public int age = 18; } class Test { public static void main(String[] args) { Person person = new Person(); System.out.println(person.name); System.out.println(person.age); } } // 执行结果 张三 18 1 2 3 4 5 6 7 8 9 10 11 12 13 14 3.2方法(method) 就是我曾经总结过的方法，用于描述一个对象的行为。 详情参考 java中方法的使用 ，这里不做详细介绍，要注意的一点是如果在类中定义普通成员方法，不用加static关键字。 这里的方法是和这个类相关联的，如果创建了其他实例，那么方法的行为就会发生变化。 要注意的是方法中还有一种特殊的方法称为构造方法 ，在实例化对象时会自动调用。有些时候可能需要进行一些更复杂的初始化逻辑，那么就可以使用构造方法用于对象的初始化。
3.2构造方法(重要) 3.2.1 基本语法 构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作。 new 执行过程：
为对象分配内存空间。 调用对象的构造方法。(完成对象的创建) 语法规则：
1.方法名称必须与类名称相同 2.构造方法没有返回值类型声明 3.每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造） calss Person { public Person() { //默认构造函数 } } 1 2 3 4 5 6 7 8 代码示例： class Person{ public int age; public String name; Person(){ System.out.println(“无参构造函数”); } Person(int age,String name){ System.out.println(“带有2个参数的构造函数”); this.age = age; this.name = name; } Person(int age){ System.out.println(“单参构造函数”); this.age = age; } public void show(){ System.out.println("name: “+this.name+” age: "+this.age); } } public class test { public static void main(String[] args) { Person p1 = new Person(); p1.show(); Person p2 = new Person(18,“张三”); p2.show(); Person p3 = new Person(20); p3.show(); } } //运行结果： 如果在定义了带参构造函数的情况下， 而又没有自己定义无参构造函数。创建p1会抛出异常 Exception in thread “main” java.lang.Error: Unresolved compilation problem: The constructor Person() is undefined at practice.test.main(test.java:26)
在都定义的情况下，创建p1、p2、p3结果是： 无参构造函数 name: null age: 0 带有两个参数的构造函数 name: 张三 age: 18 单参构造函数 name: null age: 20 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 注意事项： 如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数。 若类中定义了构造方法，则默认的无参构造将不再生成。 构造方法支持重载，规则和普通方法的重载一致。 3.2.2 this关键字 细心的同学已经发现，带有参数的构造函数中出现了this关键字。那么，这个this代表的是当前对象的引用(注意不是当前对象)，在类中，可以借助this来访问对象的字段和方法。 代码示例：
class Person{ public int age; public String name; //默认构造函数 构造对象 Person(){ //this调用构造函数 this(12);//必须放在第一行，不然编译不通过 System.out.println(“无参构造函数”); } //这三个构造函数之间的关系为重载。 Person(int age,String name){ System.out.println(“带有两个参数的构造函数”); this.age = age; this.name = name; } Person(int age){ System.out.println(“单参构造函数”); this.age = age; } public void show(){ System.out.println("name: “+this.name+” age: "+this.age); } } public class test { public static void main(String[] args) { Person p4 = new Person(); //调用不带参数的构造函数 p4.show(); } } //运行结果： 单参构造函数 无参构造函数 name: null age: 12 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 在类中，this是隐藏的关键字，但是提倡写代码的时候带上。我们发现，构造函数是用来构造对象的，对象还没有构造好，我们就使用了this，在这里this不是代表的当前对象，而是当前对象的引用。
4.static关键字 4.1修饰属性 static修饰的成员变量是不属于对象的，和具体的实例无关，换句话说，同一个类的不同实例共用一个静态属性。 代码示例：
1 2 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 代码内存解析： n被static所修饰，所有类共享，且不属于对象，访问方式为：类名 . 属性。
4.2修饰方法 如果在任何方法上应用 static 关键字，此方法称为静态方法。 静态方法属于类，而不属于类的对象。可以直接调用静态方法，而无需创建类的实例。静态方法可以访问静态数据成员，并可以更改静态数据成员的值。
代码示例： class Person{ public int a; public static int n; public static void show() { n = 1; //a = 0; error 静态方法中不能访问非静态成员 } } public class test { public static void main(String[] args) { Person.show(); //无需创建实例对象，直接用类名进行调用 System.out.println(Person.n); } } //运行结果： 1 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 注意事项： 静态方法不能调用非静态方法，反之可以。 静态方法内，不能访问非静态成员变量。 普通的成员方法不能定义静态成员变量，但是可以访问。 main方法是静态的，因为如果是普通方法，要依赖于对象的调用，而想要调用main方法要执行test.main(); ，要执行这一句，必然要先进入main方法中，但是没有人调用，所以说没办法执行。所以main方法是静态方法。 在这里插入图片描述 4.3小结 静态成员变量虽然可以通过已实例化的对象来调用，但会有警告，正确的调用方式是直接使用类名来调用。 所有被static修饰的方法或者属性，全部不依赖于对象。 java 中使用局部变量一定要先初始化。 5.封装(重要) 在我们写代码的时候经常会涉及两种角色: 类的实现者和类的调用者。封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了。这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度，提高开发效率。
5.1 private实现封装 private/ public 这两个关键字表示 “访问权限控制” 。 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用。 private 修饰的成员变量或者成员方法, 不能被类的调用者使用。 换句话说, 类的使用者根本不需要知道, 也不需要关注一个类都有哪些 private 的成员. 从而让类调用者以更低的成本来使用类。
直接使用public： public String name = “张三”; public int age = 18; 1 2 这样的代码导致类的使用者(main方法的代码)必须要了解该类内部的实现, 才能够使用这个类。学习成本较高，一旦类的实现者修改了代码(例如把 name 改成 myName), 那么类的使用者就需要大规模的修改自己的代码, 维 护成本较高。
范例： private String name = “张三”; private int age = 18; 1 2 使用 private 封装属性, 并提供 public 方法供类的调用者使用。通常情况下，我们会把字段设置为private属性，但是方法是否需要设为public，就需要视情况而定，一般我们希望一个类只提供必要的public方法，而不应该把所有方法都设置为public。
5.2 getter 和setter方法 当我们使用 private 来修饰字段的时候, 就无法直接使用这个字段了。 此时如果需要获取或者修改这个 private 属性，就需要使用getter 和setter方法。
class Person{ private int age; private String name;
public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; }public class test { public static void main(String[] args) { Person p = new Person(); p.setAge(18); p.setName(“lisi”); System.out.println(p.getAge()); System.out.println(p.getName()); } } //运行结果： 18 lisi 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 注意事项： getName 即为 getter 方法, 表示获取这个成员的值。 setName 即为 setter 方法, 表示设置这个成员的值。 当set方法的形参名字和类中的成员属性的名字一样的时候，如果不使用this, 相当于自赋值。 this 表示当前实例的引用。 不是所有的字段都一定要提供 setter / getter 方法, 而是要根据实际情况决定提供哪种方法。 我们自己可以写setter / getter 方法，也可以根据自己的编译器选项快速生成。 6.代码块 字段的初始化方式有：
就地初始化 使用构造方法初始化 使用代码块初始化 前两种方式前面已经学习过了, 接下来介绍第三种方式，使用代码块初始化。 6.1什么是代码块 使用 {} 定义的一段代码. 根据代码块定义的位置以及关键字，又可分为以下四种： 普通代码块 构造块 静态块 同步代码块(这里不做解释，后面学到再谈)
6.2普通代码块 普通代码块：定义在方法中的代码块。
public class test{ 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 1 2 3 4 5 6 7 8 9 10 11 12 13 这种用法比较少见。
6.3构造代码块 构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。
class Person{ private String name;//实例成员变量 private int age; private String sex;
public Person() { System.out.println(“无参构造函数!”); }
//实例代码块 { this.name = “zhangsan”; this.age = 12; this.sex = “man”; System.out.println(“实例代码块”); } public void show(){ System.out.println("name: “+name+” age: “+age+” sex: "+sex); } public class test { public static void main(String[] args) { Person p1 = new Person(); p1.show(); } } // 运行结果 实例代码块! 无参构造函数! name: zhangsan age: 12 sex: man 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 注意： 实例代码块优先于构造函数执行。
6.4静态代码块 使用static定义的代码块。一般用于初始化静态成员属性。
class Person{ private String name;//实例成员变量 private int age; private String sex; private static int n = 0;//静态成员变量 由类共享数据 方法区 public Person() { System.out.println(“无参构造函数!”); } //静态代码块 static { n = 10;//只能访问静态数据成员 System.out.println(“静态代码块!”); } public class test { public static void main(String[] args) { Person p1 = new Person(); Person p2 = new Person(); } } // 运行结果 静态代码块 无参构造函数 无参构造函数 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 注意事项： 静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。 静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。 7.序列化和匿名对象 7.1 toString方法 我们刚刚注意到，我们在把对象的属性进行打印的时候，都自己实现了show函数，其实，我们大可不必。接下来我们看一些示例代码：
public class test { public static void main(String[] args) { Person p1 = new Person(); System.out.println(p1);
}} 运行结果： Person@7852e922 //这里打印的是一个地址的哈希值 ，原因调用的是object的toString方法 1 2 3 4 5 6 7 8 9 那么此时就需要重写toString这个方法：
class Person { private String name; private int age; public Person(String name,int age) { this.age = age; this.name = name; } //重写Object的toString方法 @Override //表示该方法已经被重写 public String toString() { return “Person{” + “name=’” + name + ‘’’ + “, age=” + age + ‘}’; } } public class test { public static void main(String[] args) { Person p1 = new Person(“zhangsan”,18); System.out.println(p1); } } 运行结果： Person{name=‘zhangsan’, age=18} 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 注意事项：
toString 方法会在 println 的时候被自动调用。 将对象转成字符串这样的操作我们称为序列化。 toString是Object 类提供的方法, 我们自己创建的 Person 类默认继承自 Object类, 可以重写 toString 方法实现我们自己版本的转换字符串方法。 @Override 在 Java 中称为 “注解”, 此处的 @Override 表示下面实现的 toString 方法是重写了父类的方法。 我们自己可以重写toString 方法，也可以根据自己的编译器选项快速生成。 7.2匿名对象 匿名只是表示没有名字的对象。
没有引用的对象称为匿名对象. 匿名对象只能在创建对象时使用. 如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象. 代码示例： class Person { private String name; private int age; public Person(String name,int age) { this.age = age; this.name = name; } public void show() { System.out.println(“name:”+name+" " + “age:”+age); } } public class Main { public static void main(String[] args) { new Person(“lisi”,19).show();//通过匿名对象调用方法 } } //运行结果： name：lisi age：19 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 优点: 只使用一次 缺点：每次使用都要 new 类名(); 来创建一个对象
