引例#

张三养了3只狗，一只1岁白色萨摩亚，一只2岁黄白柯基，一只3岁黄色金毛

解决方案:

• 单独变量模拟
• 数组方式模拟

Code

1
public static void main(String[] args) {
2
        // 单独变量解决
3
        // 第一只dog
4
        String dogName1 = "萨摩耶";
5
        String dogColor1 = "白色";
6
        int dogAge1 = 1;
7

8
        // 第二只狗
9
        String dogName2 = "柯基";
10
        String dogColor2 = "黄白色";
11
        int dogAge2 = 2;
12

13
        // 第三只狗
14
        String dogName3 = "金毛";
15
        String dogColor3 = "黄色";
16
        int dogAge3 = 3;
17
        // 数组方式解决
18

19
        String[] dog1 = {"萨摩耶", "白色", "1"};
20
        String[] dog2 = {"柯基", "黄白色", "2"};
21
        String[] dog3 = {"金毛", "黄色", "3"};
22
}

单独变量解决==》不利于数据管理

数组解决==》数据类型无法体现，取值只能通过下标，变量名跟内容很难关联起来

缺点：不利于数据管理，效率低

为了解决上述问题, 我们引入了类与对象.

对象的概念#

在生活中，我们每个人都是独立的个体，还有一些客观存在的个体，个体之间通过交互共同组成了这个世界。

面向对象程序的世界就是对现实生活的模拟，就是把现实生活中的场景搬到程序中。

Java 是面向对象的编程语言，独立的个体就是对象（Object），对象就是面向对象程序设计的核心。

对象之间相互协作，共同实现程序的功能。

现实中存在的个体，Ta们具有特定的属性和特定的行为，程序世界中的对象也类似，具有以下特点：

• 属性：个体的状态信息（数据）
• 行为：个体能够做什么（操作）

类的概念#

现在我们知道了对象对程序世界的重要性，为了完成程序开发，我们程序员的工作就变成了：

创建一个个对象，并维护对象之间的交互。

在这个过程中，最基本，最先要解决的问题就是——对象的创建，怎么得到一个对象呢？

就像上帝造人，女娲造人是以自身为模板一样。我们程序员创建程序中的对象，也需要一个”模板”。

在Java中把创建对象的”模板”，称之为类（class）。

也就是说，到目前为止，我们终于可以给我们之前天天用的类（class）下一个明确的定义了：

创建对象的模板就是类！类就是创建对象的模板！

既然类是模板，那么：

类就抽取了同类别的所有对象属性和行为上的共性，通过这个模板，你可以创建（实例化）千千万万个对象，每个对象都遵循这个模板的结构和行为规范.

类与对象的关系#

类和对象的关系：

1. 类描述了，同种类型的对象，在属性和行为上的共性特征。

   所以：

   类是抽象的，而对象是具体的，所以对象也称为实例（instance）。

2. 类只规定了共性，只是描述对象该有什么属性，该有什么行为。

   但是：

   具体对象属性的取值，即便是同类型对象也可能有差异。一个类可以创建出千千万万个不同的对象。

类的定义#

定义类包括定义类本身，和定义类中结构两部分。

1
[类修饰符列表] class 类名{
2
  // 类体
3
}

1
[修饰符列表] 数据类型 成员变量名;

1
[访问权限修饰符] 返回值类型 方法名(形参列表){
2
  // 方法体
3
}

1
class Student{
2
    // 属性
3
  public String name;
4
  public int age;
5
    // 行为
6
    public void study(){
7

8
    }
9
}

对象的创建与使用#

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

1
Student s = new Student();

注意事项#

1. 类可以嵌套定义称之为内部类， 但是请现在不要嵌套定义类，一个Java文件中定义多个class应该并列而不是包含。
2. 一个Java文件中的多个class是同包（文件夹）关系。
3. 一个类当中，应该开门见山的定义成员变量，而后再写成员方法。
4. 类中没有的属性和行为，对象是不可能有的，类是模板，模板中有才能体现在对象中。
5. 使用new关键字就会创建新的对象，两条new语句创建的对象是完全独立的。
6. 成员变量，在类的全局生效，不像局部变量仅在作用域内生效！成员变量，在整个类体中生效，在整个类中的成员方法中都可以访问它！

基本概念#

先回顾一下，在Java基础语法部分，我们给出的数据类型的概念/定义：

数据类型： 表示的是一组数据的集合，和基于该数据集合的一组合法操作。

那么这个定义能不能套在引用数据类型中呢？能否用数据类型的概念来统一基本数据类型和引用数据类型呢？

在类的定义中，我们知道类中的成员包括2部分：

1. 成员变量
2. 成员方法

成员变量本质上就是数据，成员方法本质上就是操作，那么假设做以下类比：

1. 数据的集合： 类中成员变量的集合
2. 操作的集合： 类中成员方法的集合

于是，就可以做出以下总结：

1. 一个类的定义，实际上就是定义了一种全新的数据类型，一种自定义的数据类型。
2. 这种完全不同于基本数据类型的数据类型，我们称之为”引用数据类型”。

类加载介绍#

当我们在程序中使用一个基本数据类型时，由于基本数据类型是JVM当中已经预先定义好的（所以基本数据类型叫”内置数据类型”），JVM可以清楚的知道这个基本数据类型变量在内存中的存储方式（占用空间大小、结构等等），JVM能够正常开辟空间，正常给变量初始化赋值。

但是类这种引用数据类型，并不是内置数据类型，而是我们自定义的数据类型。

现在我们要根据一个类来创建它的对象，要让JVM帮助我们开辟空间创建引用和对象，JVM怎么知道到底要创建什么呢？难道它未卜先知吗？

显然是不可能的，某个类在一开始并不被JVM”认识”——它不知道类中有什么，必然不可能做任何操作。

所以在对某个类做任何操作之前，都需要让JVM来”认识”这个类型。

在Java中，把JVM”认识”一个类的过程，称之为类加载

关于类加载：

1. 类加载的具体过程，我们后面会详细学习。这里我们先不用了解它的详细过程。
2. 类加载是通过把某个类的二进制字节码文件（class文件）通过I/O流的形式，读取进JVM内存中的方法区实现的。
3. 通过读取二进制字节码文件，并加载进JVM内存。这是JVM了解这个类型的过程。
4. 类加载之后，就可以做很多类型相关的操作了。
5. 类加载要在创建对象之前进行，换句话说创建一个类的对象必然触发该类的类加载！

我们通过画对象内存图，来展示这一过程：

1. 一个对象的内存图，一个对象的创建过程。(创建1个Student对象)
2. 三个对象的内存图，其中有两个引用指向同一个对象。(创建3个Teacher对象,并进行显式赋值)

总结：

1. 一个类的类加载在一次程序运行过程中，最多只有一次。

2. 多个引用指向同一个对象时，某个引用修改了对象的状态（成员变量的取值），再用其它引用访问会得到修改后的结果。

   注：这一点实际上和数组是一样的。

3. 类加载IO流操作, 很耗费性能，所以JVM在进行类加载时是”懒加载”的, 迫不得已才加载.

   我们把一定会触发类加载的场景，称之为类加载的时机，目前已经学过的有：

   1. 首次创建该类对象
   2. 启动该类中的main方法

两者的区别#

局部变量和成员变量的比较，我们从以下五个方面去比较：

1. 在类中定义的位置不同
2. 在内存中的位置不同
3. 生命周期不同
4. 有无默认初始化不同
5. 作用范围

在类中定义的位置不同

1. 局部变量定义在：方法、方法的形参或者代码块结构等局部位置。
2. 成员变量 定义在：类体中、非局部位置的成员位置。

在内存中的位置不同

1. 局部变量存储在栈上的栈帧中
2. 成员变量存储在堆中的对象中

生命周期不同

1. 局部变量随着方法的执行，而被创建，随着方法的执行结束就会被销毁。局部变量和方法”同生共死”。

2. 成员变量在对象创建以后就存在了，对象被销毁回收内存自然就不存在了。

   但实际上只要该对象栈上的引用被销毁，对象成为”垃圾”，对象中的成员变量也就失去意义了。

有无默认初始化不同

1. 局部变量没有默认初始化过程，必须手动初始化赋值。
2. 成员变量，有默认的初始值。和数组一样，这里不再赘述。

作用范围

1. 局部变量只在作用域的局部生效。

2. 成员变量在整个类的成员方法中都可以使用，所以很多书籍也把成员变量称之为”全局变量”。

   注意，加static的方法不是成员方法，成员变量不能在其中使用（原因后面再讲）

成员变量的赋值#

限于目前的学习进度，其实你只知道两种给成员变量赋值的手段：

1. 默认初始化，具有默认值。

2. 显式赋值。即在类中定义成员变量时，直接了当的给出该成员变量的取值，就是显式赋值！比如：

   成员变量的显式赋值演示

   1
   class Student{
   2
     // 类体
   3
     String name = "张三"；
   4
   }

显式赋值和默认初始化赋值的顺序，任何时候都要记住，对象中的元素，默认初始化永远是第一步！在任何给成员变量赋值的手段执行前，默认初始化都已经执行了！

可以认为默认初始化是JVM在创建对象的内存结构时，它”顺手”给出的！

引例#

学习完对象与类后，做以下练习：

创建一个汽车类，有颜色（color）和速度（speed）两个属性，行为是可以跑（run）。

实现：

1. 在run成员方法中访问速度和颜色两个属性，调用该方法查看结果。
2. 在run成员方法的形参列表中，添加一个局部变量speed，不修改方法体，调用该方法查看结果。

思考：

1. 两次方法调用的结果一样吗？为什么？
2. 如果我想在2中得到1的访问结果，怎么办呢？

code

1
public class Demo {
2
    public static void main(String[] args) {
3
        // 创建Car对象
4
        car car = new car();
5
        // 调用成员方法
6
        //car.run();
7
        car.run(200);
8
    }
9
}
10

11
class car{
12
    // 定义成员变量
13
    String color = "黑色";
14

15
    double speed = 120.0;
16

17
    //// 定义成员方法
18
    //public void run(){
19
    //    System.out.println(color + "的车在高速公路上以" + speed + "公里每小时疾驰!");
20
    //}
21

22

23
    // 定义成员方法
24
    public void run(double speed){
25
        System.out.println(color + "的车在高速公路上以" + this.speed + "公里每小时疾驰!");
26
    }
27

28
}

很明显，由于就近原则的影响：

当方法中存在同名的局部变量和成员变量时，访问该同名变量，访问到的必然是距离访问语句更近的局部变量，而不是同名的成员变量。

这个时候，如果还想访问同名成员变量，普通的手段是做不到了，就需要this关键字来实现访问。

概念#

this关键字（重点）：

Java类中的每个成员方法的形参列表中都隐含了一个传参（隐式传参），传入的是当前对象，用this关键字指向!(为什么类中的所有成员方法都可以访问到成员变量---->就是因为this的存在)

所以：

1. this是一个引用，这个引用指向当前对象。

2. 何为当前对象？

   很多同学，在初学this时，会经常疑惑何为当前对象呢？

   其实非常简单：

   this指向当前对象，是类中成员方法的一个隐式传参。

   成员方法总会需要一个对象，使用对象名点来调用，那么这个调用该成员方法的对象，就是当前对象！

Demo

1
Student stu = new Student();
2
stu.study();
3
stu.sleep();

成员方法study()和sleep()的this指向当前对象，指向的就是stu对象。

验证当前对象就是调用方法的那个对象

1
package _04oop.com.cskaoyan._02this._02verfiy;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/11/8 9:55
7
 **/
8

9
public class Demo {
10
    public static void main(String[] args) {
11
        // 创建对象
12
        Student student = new Student();
13
        // 调用方法
14
        student.printThis();
15
        // 打印对象
16
        System.out.println(student);
17
    }
18
}
19

20
class Student{
21
    // 定义成员方法
22
    public void printThis(){
23
        System.out.println(this);
24
    }
25
}

可以发现和在main方法中打印对象名（引用）结果一致，证明当前对象就是调用方法的那个对象。

this关键字的作用#

既然this已经指向当前对象，是一个引用，那么它基本的用途就有：

1. 在成员方法中，用this引用去访问类中成员变量和调用类中成员方法。由于this本身就是隐含的，所以一般情况下，可以省略this，直接访问类中成员。
2. 特殊情况下，当成员方法中的局部变量和成员变量同名时，可以用 “this.”访问 来表示访问同名成员变量，来和同名局部变量做区分。这种情况，this是不能省略的。
3. 在成员方法中只要使用 “this.”访问 一个变量，那么该变量一定是成员变量。在代码比较复杂的情况下，可以显著增加代码可读性, 可以使用this.成员变量对成员变量进行赋值--->set方法

注意事项#

1. this指向当前对象的隐含传参，必须是在普通成员方法中，加static的方法中，没有该this传参。（所以static方法不能直接访问类的成员，需要先创建对象才能访问。）
2. 既然this指向当前对象，那么不同的this指向的对象必然不同。

引例#

创建一个教师类，有课程和年龄两个属性，行为是上课。

现在我们需要创建以下对象：

1. 18岁的Java老师对象
2. 28岁的C++老师对象
3. 30岁的Python老师对象
4. …

按照之前我们的做法，需要先创建出对象，再进行成员变量的赋值。

Code

1
        Teacher teacher = new Teacher();
2
        teacher.course = "Java";
3
        teacher.age = 20;
4
        teacher.teach();
5

6
        Teacher teacher2 = new Teacher();
7
        teacher2.course = "C++";
8
        teacher2.age = 21;
9
        teacher2.teach();
10

11

12
        Teacher teacher3 = new Teacher();
13
        teacher3.course = "Python";
14
        teacher3.age = 22;
15
        teacher3.teach();

如果属性很多, 需要创建很多对象，就有点过于麻烦了。

对象的属性，能不能”出厂”的时候就设定好呢？想要在创建教师对象时，就直接指定这个对象的属性？

有这种需求时，就需要构造方法（constructor，也叫构造器）来完成了。

构造器语法#

构造方法也是方法，但属于一种特殊的方法

1
[访问权限修饰符] 类名(形参列表){
2
  // 构造方法体
3
}

说明:

1. 权限修饰符先使用public

2. 构造方法名必须跟类名相同(一模一样,包括大小写)

3. 构造方法没有返回值, 也不需要写返回值

4. 形参列表可以为空, 称为无参构造方法,非空为有参构造方法

5. 构造方法体，和一般方法类似，可以写语句

构造器作用与使用#

构造器的作用是用来给成员变量赋值的，完成对对象的初始化

说明：

1. new关键字去创建对象的时候，JVM自动去调用构造方法，构造方法无法通过普通方法的调用方式调用。
2. 构造器的作用不是创建对象，创建对象是JVM的事情。构造器只是告诉JVM在创建对象过程中，给成员变量赋什么值。

使用方式是：

1
new 类名(实参列表);

通过实参列表的不同，来判断调用哪个构造器。这实际也是方法重载的应用！

需求:

使用构造方法改进引例, 在创建教师对象时，就直接指定这个对象的属性(完成成员变量的赋值操作)

Code:

1
package _04oop.com.cskaoyan._03constructor._02defineuse;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/11/8 10:04
7
 **/
8
/*
9
使用构造方法改进引例, 在创建教师对象时，
10
就直接指定这个对象的属性(完成成员变量的赋值操作)
11

12
1. 18岁的Java老师对象
13
2. 28岁的C++老师对象
14
3. 30岁的Python老师对象
15
 */
16
public class Demo {
17
    public static void main(String[] args) {
18
        // 创建对象
19
        Teacher t1 = new Teacher("Java", 18);
20
        Teacher t2 = new Teacher("C++", 28);
21
        Teacher t3 = new Teacher("Pyhond", 30);
22

23
        // 调用方法
24
        t1.teach();
25
        t2.teach();
26
        t3.teach();
27
    }
28
}
29

30
// 定义教师类
31
class Teacher{
32
    // 定义成员变量
33
    String course;
34
    int age;
35

36
    /*
37
    [访问权限修饰符] 类名(形参列表){
38
  // 构造方法体
39
    }
40
     */
41

42
    // 无参构造方法
43
    public Teacher(){
44
        // 方法体
45
        System.out.println("无参的构造方法执行了");
46
    }
47

48
    // 有参构造方法
49
    public Teacher(String tCourse, int tAge){
50
        // 方法体
51
        System.out.println("有2个参数的构造方法执行了");
52
        // 给成员变量赋值
53
        course = tCourse;
54
        age = tAge;
55
    }
56

57
    // 定义成员方法
58
    public void teach(){
59
        System.out.println(age + "的老师讲" + course);
60
    }
61

62
    //public void teach(String name){
63
    //    System.out.println(age + "的老师讲" + course);
64
    //}
65
}

注意事项与使用细节#

1. 一个类中，是允许同时定义多个构造方法的，即构造方法重载，多个构造器的形参必须不同。

   • 比如: 我们可以给Teacher类定义一个构造器, 用来创建对象的时候, 只指定课程, 不指定年龄

2. 构造方法的名字必须和类名一模一样

3. 构造器没有返回值

4. 构造器是完成对象的初始化(给对象赋值), 并不是创建对象, 创建对象时, 系统根据实参列表自动调用该类的构造器

5. 类中默认提供的无参构造方法，是在该类没有任何构造器的情况下才有的。但是如果类中有任一构造器（有参/无参），那么就没有默认无参存在了

6. 在构造器中也会隐含this传参, 我们可利用this对成员变量进行赋值, 也可以使用快捷键, alt + insert快速生成构造器.

7. 构造器中还可以用this表示调用其它构造器，语法：

1
this(实参列表);

表示调用类中的其它构造器，根据实参列表决定调用哪个构造器。

注意，在构造器中使用this(实参)表示调用类中其他构造器时，这行代码一定要处在构造器代码的第一行！

当然，既然必须在第一行，那么也只能用一次了。

构造器的赋值顺序#

这里我们不妨总结一下，学完构造器后，三种给成员变量赋值的方式：

1. 默认初始化，具有默认值。
2. 显式赋值，直接将值写在成员变量声明的后面。
3. 构造器赋值。

通过下面的例子分析程序执行流程 , 以上三种赋值方式的执行顺序

1
class Person{
2
    String name;
3
    int age = 20;
4

5
    public Person(String name, int age) {
6
        this.name = name;
7
        this.age = age;
8
    }
9

10
    public Person() {
11
    }
12
}
13

14
// 创建Person对象,成员变量的值分别是什么
15
Person p = new Person("张三", 30);

执行流程:

1. 加载Person类信息, 只会加载一次
2. 堆中分配空间
3. 完成对象初始化
   1. 默认初始化
   2. 显示赋值
   3. 构造器赋值
4. 堆中的对象的地址返回给p(对象的引用)

在各式各样给成员变量赋值的方式中，构造器是最后执行的！！！

对象创建流程#

Debug练习 对于下列程序代码，请指出创建Student对象，程序每一步的执行流程：

构造器Debug模式练习

1
public class Demo{
2
public static void main(String[] args){
3
Student stu = new Student(18,"王冰冰");
4
  }
5
}
6
class Student {
7
int age = 10;
8
String name = "张三";
9
double a = 100;
10

11
public Student(int age) {
12
  System.out.println("Student age");
13
  this.age = age;
14
}
15

16
public Student() {
17
}
18

19
public Student(int age, String name) {
20
  this(age);
21
  System.out.println("Student age，name");
22
  this.name = name;
23
}
24
}

在这个案例中，我们发现Student双参构造器中，有使用this调用单参构造器，那么它们的执行顺序是：

1. 类加载不要忘记了。
2. 程序会先找到，Student的双参构造器，但是并不会执行，而是
3. 先跳转执行this构造器，但是this构造器中的代码，也不会立刻执行（因为构造器赋值一定最后执行），而是
4. 先从上到下执行成员变量的显示赋值，然后
5. 跳回执行this构造器代码
6. 最后执行双参构造器代码

对象与类#

完成以下案例，思考一下怎么能够找到系统中类、对象究竟是哪些？

1. 用面向对象的思想模拟LOL当中盖伦的战斗
2. 用面向对象的思想模拟植物大战僵尸

如何从需求中找到对象和类呢？

对象描述的是程序世界中的个体/实体，所以一般都是名词。

抽取出全体对象的共性特征，也就是成员变量和方法，就可以定义一个类。

注意事项：

1. 对象之间如果需要交互，可以考虑持有对方的引用作为成员变量。

2. 日常开发中，不建议随便把很多类定义在同一个Java文件中。

   正确情况下，建议一个Java文件中，仅定义一个public class和文件名保持一致。

   当然，如果确有需求，也是可以定义非public class的。（少见但不是见不到）

3. 一个Java文件下的所有类，属于同包关系。

LOL

1
public class Demo {
2
    public static void main(String[] args) {
3
        Legend galen = new Legend("Galen", "沉默打击", "勇气", "爱的魔力转圈圈", "大宝剑");
4
        galen.fight();
5
    }
6
}
7

8
// 英雄类
9
class Legend {
10
    String name;
11
    String skillQ;
12
    String skillW;
13
    String skillE;
14
    String skillR;
15

16
    /*
17
        定义构造器,从代码规范上来说,构造器写在
18
        成员变量的下面
19
        成员方法的上面
20
        而且都要写在一起(实际上所有构造方法重载的方法都应该写在一起)
21
        写在一起的顺序: 可以按照参数个数的多少去排列,个数少的在上面,多的在下面
22
      */
23
    public Legend() {
24
    }
25

26
    public Legend(String name, String skillQ, String skillW, String skillE, String skillR) {
27
        this.name = name;
28
        this.skillQ = skillQ;
29
        this.skillW = skillW;
30
        this.skillE = skillE;
31
        this.skillR = skillR;
32
    }
33

34
    public void fight() {
35
        System.out.println("名字为" + name + "的英雄,正在使用"+skillR+"技能战斗!");
36
    }
37

38
}

植物大战僵尸

1
public class Plant {
2
    String name;
3
    int price;
4
    int hp;
5
    // 攻击力
6
    int damage;
7
    /*
8
        在开发中为了方便两个对象之间的交互
9
        往往会让某个对象持有另外一个对象的引用作为自身的成员变量
10
        这样对象之间的交互会更加灵活,是常用的做法
11
     */
12
    Zombie plantZ;
13

14
    public Plant() {
15
    }
16

17
    public Plant(String name, int price, int hp, int damage) {
18
        this.name = name;
19
        this.price = price;
20
        this.hp = hp;
21
        this.damage = damage;
22
    }
23

24
    // 行为
25
    public void attack() {
26
        System.out.println(name + "正在攻击" + plantZ.name);
27
    }
28

29
    public void beAttacked() {
30
        System.out.println(name + "正在被" + plantZ.name + "攻击,现在还剩下" + (hp - plantZ.damage));
31
    }
32
}
33

34

35
public class Zombie {
36
    String name;
37
    int hp;
38
    // 攻击力
39
    int damage;
40
    double speed;
41

42
    Plant zombieP;
43

44
    public Zombie() {
45
    }
46

47
    public Zombie(String name, int hp, int damage, double speed) {
48
        this.name = name;
49
        this.hp = hp;
50
        this.damage = damage;
51
        this.speed = speed;
52
    }
53

54
    // 行为
55
    public void attack() {
56
        System.out.println(name + "正在攻击" + zombieP.name);
57
    }
58

59
    public void beAttacked() {
60
        System.out.println(name + "正在被" + zombieP.name + "攻击,现在还剩下" + (hp - zombieP.damage));
61
    }
62

63
    public void move() {
64
        System.out.println(name + "正在以" + speed + "的速度,接近你的脑子~~");
65
    }
66

67
    public void eat() {
68
        System.out.println(name + "吃掉了你的脑子~真香~");
69
    }
70
}

值传递练习#

学习对象与类后，再复习一下如果方法的参数是需要一个对象，值传递是怎样进行的。

练习： 定义一个学生类，该类具有一个int属性age 1.在测试类中写一个方法，交换两个Student对象的age属性 请问能够交换成功吗？原因是什么？

2.在测试类中写一个方法，交换两个Student对象的引用（地址） 请问能够交换成功吗？原因是什么？

结论：

1. Java只有值传递
2. Java当中的方法可以改变对象的状态（成员变量的取值）但是无法直接交换两个引用（无法改变局部变量）

成员变量赋值顺序练习#

1
public class Demo {
2
 public static void main(String[] args) {
3
     Student s = new Student(18, "长风");
4
     System.out.println(s.age);
5
     System.out.println(s.name);
6
     System.out.println(s.var);
7
     System.out.println(s.cat.price);
8
 }
9
}
10
class Student {
11
 int age = 10;
12
 String name = "张三";
13
 double var = 20;
14

15
 public Student(int age) {
16
     System.out.println("Student age");
17
     this.age = age;
18
 }
19

20
 public Student() {
21
 }
22

23
 public Student(int age, String name) {
24
     this(age);
25
     System.out.println("Student age,name");
26
     this.name = name;
27
 }
28

29
 Cat cat = new Cat(1000);
30
 Cat c2;
31
}
32

33
class Cat {
34
 double price;
35

36
 public Cat() {
37
 }
38

39
 public Cat(double price) {
40
     System.out.println("Cat price");
41
     this.price = price;
42
 }
43
}

思考程序输出的顺序，搞清楚其中赋值的顺序。

1
1.Demo类加载,main方法执行
2
2.Student类加载,创建Student对象,调用2参构造
3
3.此时2参构造不会执行,会因为this(单参)调用单参构造,
4
4.此时单参构造不会执行,会先对对象中成员变量默认初始化,进行默认赋值
5
5.进行显式赋值
6
6.Cat cat = new Cat(1000);执行到这里,会触发Cat类加载
7
7.调用Cat单参构造方法
8
8.Cat单参构造方法先不执行,先默认赋值,没有显式赋值,执行构造方法进行赋值
9
9.Student类中的成员全部显式赋值成功--->进行构造器赋值
10
10.Student的单参构造器先执行,再执行两参构造器
11
11.Student对象创建成功并完成了赋值--->回到main方法继续执行
12
12.输出相应结果

引例#

场景如下:

一场篮球比赛, 梦之队有5名顶级球员Kobe, James, Stephen… 都是神射手擅长投3分,投篮必进

每进一球, 队伍分数+3, 比赛结束, 统计一下该队伍得分情况, 写程序模拟这个场景.

思路:

• main里面定义int count, 用来记录分数
• 每当有1个球员进球, 分数+3

Code:

1
package _04oop.com.cskaoyan._04static._01introuction;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/11/11 9:48
7
 **/
8
/*
9
一场篮球比赛, 梦之队有5名顶级球员Kobe, James, Stephen...... 都是神射手擅长投3分,投篮必进
10

11
每进一球, 队伍分数+3, 比赛结束, 统计一下该队伍得分情况,  写程序模拟这个场景.
12

13
思路:
14

15
- main里面定义int count, 用来记录分数
16
- 每当有1个球员进球, 分数+3
17
 */
18
public class Demo {
19
    public static void main(String[] args) {
20
        // 定义一个计数器
21
        int count = 0;
22
        Player p1 = new Player("Kobe");
23
        p1.shot();
24
        count += 3;
25
        System.out.println("分数: " + count);
26

27
        Player p2 = new Player("James");
28
        p2.shot();
29
        count += 3;
30
        System.out.println("分数: " + count);
31

32
        Player p3 = new Player("Stephen");
33
        p3.shot();
34
        count += 3;
35
        System.out.println("分数: " + count);
36

37
    }
38
}
39

40
// 定义一个Player类
41
class Player {
42
    // 定义成员变量
43
    String name;
44

45
    public Player(String name) {
46
        this.name = name;
47
    }
48

49
    // 定义成员方法
50
    public void shot() {
51
        System.out.println(name + "进球了!");
52
    }
53
}

问题分析:

int count这个值是个局部变量, 独立于对象之外的, 使用起来不是很方便

引出来static关键字.

静态成员#

根据static修饰的内容不同, 有以下分类

• 静态成员变量, static修饰成员变量 (有的资料里也称为类变量, 类属性指的都是静态成员变量)
• 静态成员方法, static修饰成员方法(有的资料里也称为类方法, 指的还是静态成员方法)

统称为类的静态成员

静态成员变量#

基本语法

1
[访问权限修饰符] static 数据类型 变量名;

使用与特点:

• 和普通成员变量一样,都具有默认值（默认值和普通成员变量是一样的）
• 静态成员变量属于类的，完全不需要创建对象使用。
• 访问和使用静态成员变量不推荐使用”对象名.”，而应该使用”类名.”！
• 静态成员变量的访问/赋值/使用都不依赖于对象, 而是依赖于类

使用案例:

设计一个int 类型的count值来表示球队得分, 每有一个球员得分, 那么count值+3, 要求count被所有对象所共享的即可. 使用静态成员变量修改之前的引例.

1
class Player{
2
  String name;
3
  // 使用static关键字修饰成员变量, 使其成为静态成员变量.
4
  static int count;
5
}

Code

1
package _04oop.com.cskaoyan._04static._02static_field;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/11/11 9:58
7
 **/
8
/*
9
设计一个int 类型的count值来表示球队得分, 每有一个球员得分,
10
那么count值+3, 要求count被所有对象所共享的即可. 使用静态成员变量修改之前的引例.
11
 */
12
public class Demo {
13
    public static void main(String[] args) {
14
        // 静态成员变量可以通过类名.方式访问
15
        // 推荐使用类名.方式访问
16
        System.out.println("得分: " + Player.count);
17

18
        // 创建Player对象
19
        Player p1 = new Player("Kobe");
20
        // 投篮
21
        p1.shot();
22
        // 更改分数 + 3
23
        p1.count += 3;
24
        System.out.println("得分: " + p1.count);
25

26
        // 创建Player对象
27
        Player p2 = new Player("James");
28
        // 投篮
29
        p2.shot();
30
        // 更改分数 + 3
31
        p2.count += 3;
32
        System.out.println("得分: " + p2.count);
33

34
        // 创建Player对象
35
        Player p3 = new Player("Stephen");
36
        // 投篮
37
        p3.shot();
38
        // 更改分数 + 3
39
        p3.count += 3;
40
        System.out.println("得分: " + p3.count);
41

42
    }
43
}
44

45
// 定义一个Player类
46
class Player {
47
    // 定义成员变量
48
    String name;
49

50
    // 定义一个静态的成员变量,表示球队得分
51
    static int count;
52

53
    public Player(String name) {
54
        this.name = name;
55
    }
56

57
    // 定义成员方法
58
    public void shot() {
59
        System.out.println(name + "进球了!");
60
    }
61
}

展开收起

内存及原理解析:

静态成员的访问并不依赖于创建对象，可以直接通过类名访问，其原因在于：

随着类加载完毕，静态成员就存在，并且能够使用了！

某个类的某个静态成员变量只有一份，且被所有对象共享，属于类，无需创建对象使用。

注意事项:

• 只存在静态成员变量，不存在”静态局部变量”

局部变量，已经被方法限制了作用域，不能用static修饰它！

1
[访问权限修饰符] static 返回值类型 方法名(形参列表){
2
  //方法体
3
}

类加载时机#

静态成员需要在类加载时期，完成准备，类加载结束就能够使用。

所以访问类的静态成员，一定会触发该类的类加载。

总结，到目前学习过的类加载时机：

1. new直接创建该类的对象。(首次)
2. 启动该类中的main方法。
3. 访问该类的静态成员（方法和变量) (首次)

static VS 非static#

当我们了解static成员的特点后，静态成员和非静态成员的区别就很明显

我们从以下四个角度比较（拿成员变量为例）

1. 成员的所属
2. 在内存中的位置
3. 在内存中出现的时间
4. 调用方式

其比较的结论如下：

• 所属不同
  1. 静态成员变量属于类，所以也称为为类变量
  2. （普通）成员变量属于对象，所以也称为对象变量（实例变量）
• 在内存中的位置不同
  1. 堆上的这个类所对应的字节码文件对象,即Class对象中，被所有对象共享
  2. 成员变量存储于堆内存，每个对象独享自己的成员变量
• 在内存中出现时间不同
  1. 静态变量随着类的加载而加载，比成员变量出现的要早
  2. 成员变量随着对象的创建而存在
• 调用方式不同
  1. 静态变量可以通过类名调用，也可以通过对象调用（不推荐）
  2. 成员变量只能通过对象名调用，必须创建对象

使用场景#

这里，根据static关键字的一些特点来明确它的使用场景，给大家以后使用static关键字做一下参考。

• 静态成员变量：

  1. 属于全体对象所共享而不是独属于某个对象的成员变量

  所以当存在需要所有对象共享的变量时，应该使用static修饰的静态成员变量。

  2. 在整个类全局独一份的（因为类加载只有一次）

  所以，如果希望某个变量在类的全局独一份时，应该使用static修饰的静态成员变量。

  举例1 :

  创建一个学生类，用来描述我们班全体同学

  要求：

  属性：姓名，性别，年龄，学号，学校信息

  行为：吃饭，学习

  我们简单思考可以知道, 无论你是张三或者李四, 学校信息这个属性实质上应该是被全体同学所共有的属性，而不是独属于某个对象的, 这种场景下就可以使用static 修饰学校信息

  举例2:

  创建一个学生类, 有2个属性: 姓名String name , 学号int id

  统计外部创建Student类对象的个数 假设给Student类的对象自动编号

  这个编号第一次创建对象是10001 随后每创建一个新对象就+1

  1
  package _04oop.com.cskaoyan._04static._05use_case;
  2
  
  3
  /**
  4
   * @description:
  5
   * @author: 景天
  6
   * @date: 2022/11/11 15:04
  7
   **/
  8
  /*
  9
  利用了static成员变量类全局唯一 且被共享
  10
  统计外部创建Student类对象的个数  假设给Student类的对象自动编号
  11
  这个编号第一次创建对象是10001 随后每创建一个新对象就+1
  12
  
  13
   */
  14
  public class Demo {
  15
      public static void main(String[] args) {
  16
          Student s1 = new Student();
  17
          System.out.println(s1.id);
  18
  
  19
          Student s2 = new Student();
  20
          System.out.println(s2.id);
  21
  
  22
          Student s3 = new Student();
  23
          System.out.println(s3.id);
  24
  
  25
          Student s4 = new Student();
  26
          System.out.println(s4.id);
  27
  
  28
          System.out.println("共计创建了" + Student.count + "个学生");
  29
  
  30
      }
  31
  }
  32
  
  33
  class Student{
  34
      // 姓名
  35
      String name;
  36
      // 学号
  37
      int id;
  38
  
  39
      // 统计学生数量
  40
      static int count;
  41
  
  42
      // 初始学号
  43
      static int initNumber = 10001;
  44
  
  45
      public Student() {
  46
          // 学生数量+1
  47
          count++;
  48
          // 学号递增
  49
          this.id = initNumber++;
  50
      }
  51
  
  52
  
  53
  }

  展开收起

• 静态成员方法：

  1. 静态方法的最主要特点就是调用简单，无需创建对象即可调用。

  所以如果希望一个方法能够更方便快捷的去调用，可以把它声明为static修饰的静态成员方法。

  2. 根据静态成员方法调用简单的特点，当一个类中全部都是静态成员方法时，

  类中的所有方法的调用都可以使用类名点去完成，这就是Java当中的”工具类”。比较典型的有：数组工具类Arrays、集合工具类Collections、数学工具类Math等等。

static执行顺序练习#

请说明程序的输出结果，并分析流程

1
public class Demo {
2
static Cat cat = new Cat();
3
Dog dog = new Dog();
4
Dog dog2;
5
static Dog dog3;
6

7
public static void main(String[] args) {
8
  System.out.println("hello world!");
9
  Demo d = new Demo();
10
}
11

12
public Demo() {
13
  System.out.println("demo");
14
}
15
}
16

17
class Cat {
18
static Dog dog = new Dog();
19

20
public Cat() {
21
  System.out.println("cat");
22
}
23
}
24

25
class Dog {
26
public Dog() {
27
  System.out.println("dog");
28
}
29
}

什么是匿名对象#

在Java当中，匿名对象指的就是没有名字的对象。

或者，说的更清楚一点，就是：在创建对象时，就没有引用指向的对象，就是匿名对象！

匿名对象的语法很简单，只需要在方法等位置中写下列语法：

1
new 类名();

以上语法就得到了一个匿名对象，从实质上看：

该对象没有栈上的引用指向，没有所谓的**“对象名”**，是一个匿名对象。

匿名对象的用途#

匿名对象主要有两个用途（常见用途）：

1. 使用匿名对象作为方法的实参

   当定义以下方法时，表示该方法需要传入一个对象（这个对象必须是”类名”的对象或者子类对象）

   注：子类对象的概念后面继承中会学习，这里为了文档严谨性写出来，你可以先忽略！

   1
   [修饰符列表] 返回值类型 方法名(类名 对象名){
   2
     //方法体
   3
   }

   这个时候，常规的做法是创建对象，然后传入引用。但实际上这里可以直接传入匿名对象。

   假如一个test方法需要传入一个Student对象，就可以这么写：

   1
   test(new Student());

2. 使用匿名对象作为方法的返回值

   当定义以下方法时，表示该方法需要传入一个对象（这个对象必须是”类名”的对象或者子类对象）

   注：子类对象的概念后面继承中会学习，这里为了文档严谨性写出来，你可以先忽略！

   1
   [修饰符列表] 类名 方法名(形参列表){
   2
     //方法体
   3
     return (匿名对象);
   4
   }

匿名对象的优缺点#

优点：

1. 使用匿名对象，代码简洁（相当于少写了一些代码）这是匿名对象最主要的优点。

2. 匿名对象在使用完毕后会立刻成为”垃圾”等待GC回收，从理论角度上来说，可以提升内存利用率。

   但是GC不具有即时性，并不是一个对象更早成为”垃圾”就会更好回收，这个优点仅是理论上的。

缺点：

匿名对象由于没有引用指向，所以它是一次性的，用完后就无法再次使用了。

匿名对象使用场景#

我们根据匿名对象的优缺点，很容易总结出匿名对象的使用场景：

1. 需要一个对象去实现功能，并且该对象仅需使用一次即可，为了代码简洁，推荐使用匿名对象
2. 但是，如果一个对象可能会被复用，像以下代码频繁创建匿名对象是得不偿失的

不要滥用匿名对象

1
test(new Student());
2
test(new Student());
3
test(new Student());
4
...

创建对象是需要耗时耗费内存空间的，不要为了一时的方便，频繁创建匿名对象。

总之：

如果某个对象，仅使用一次，使用匿名对象简洁方便。

但如果有多次使用某个类的对象的需求时，频繁使用匿名对象会导致频繁创建对象，降低代码性能，得不偿失！

概述#

之前，我们理解的代码块就是为了限制局部变量的一个大括号，今天来详细的学习一下代码块。

代码块的定义：由若干条Java语句组成，并且用一对大括号括起来的结构，叫做代码块。

代码块的分类，根据其位置和声明方式的不同，可以分为：

• 局部代码块

• 构造代码块

• 静态代码块

• 同步代码块

注：同步代码块，涉及多线程知识，后面多线程再学习，今天略过它。

构造代码块#

1
//成员位置
2
{
3
  // 局部位置
4
}
5
//成员位置

1
//构造代码块
2
{
3
  a = 10;
4
}
5
int a = 1;

静态代码块#

1
//成员位置
2
static{
3
  // 局部位置
4
}
5
//成员位置

补充类加载过程#

首先，一个类从被加载到JVM内存中开始，到卸载出内存为止，一个类的生命周期包括：

一共是：

1. 加载（Loading）

2. 验证（Verification）

3. 准备(Preparation)

4. 解析(Resolution)

5. 初始化(Initialization)

6. 使用(Using)

7. 卸载(Unloading)

   注：其中，验证、准备和解析可以统称为连接(Linking)。

一个类在JVM中的生命周期，共有七个阶段。

其中”加载 —> 连接 ---> 初始化”这三个步骤，即一个类的类加载过程。

这三步主要做：

1. 加载主要是做通过类加载器(ClassLoader)将class字节码文件读取进JVM内存的操作, 并在内存中生成这个类对应的Class对象

2. 在连接过程中：

   1. 验证，主要目的是为了确保class文件的字节流中包含的信息符合当前JVM的要求，不会影响JVM的安全。

   2. 准备，主要目的是进行静态成员变量的默认初始化，设置初始值。

      这样，就保证了静态成员变量的默认初始化，永远最先进行。

   3. 解析，主要目的是将符号引用替换为直接引用。

3. 初始化是类加载的最后一个步骤。主要目的是执行和static相关的内容，包括：

   执行静态成员变量的显式赋值。

   执行静态代码块。

以上，关于类加载各步骤，大致的作用，我们就了解了。

所以这里要重新认识一个概念：类加载的时机

类加载的时机，说得更准确一点，应该是类初始化的时机。当然，想要初始化一个类，必然要先进行加载和连接。

练习#

类加载过程练习一

1
public class Demo {
2
static {
3
  System.out.println("Demo类开始初始化步骤了!");
4
}
5

6
static Cat cat = new Cat();
7
Dog dog = new Dog();
8

9
public static void main(String[] args) {
10
  System.out.println("hello world!");
11
  Demo d = new Demo();
12
}
13

14
public Demo() {
15
  System.out.println("demo");
16
}
17
}
18

19
class Cat {
20
static {
21
  System.out.println("Cat类开始初始化步骤了!");
22
}
23

24
static Dog dog = new Dog();
25

26
public Cat() {
27
  System.out.println("cat");
28
}
29
}
30

31
class Dog {
32
static {
33
  System.out.println("Dog类开始初始化步骤了!");
34
}
35

36
static Demo demo = new Demo();
37

38
public Dog() {
39
  System.out.println("dog");
40
}
41
}

代码块综合练习

1
public class ExerciseBlock {
2
    static {
3
        System.out.println("main方法静态代码块！");
4
    }
5
    {
6
        System.out.println("main方法构造代码块！");
7
    }
8
    public static void main(String[] args) {
9
        System.out.println("main方法开始执行！");
10
        Star s = new Star(18,"马化腾");
11
        System.out.println(Star.name);
12
        System.out.println(s.age);
13
    }
14
}
15
class Star{
16
    {
17
        age = 18;
18
        Star.name = "杨超越";
19
        System.out.println("我喜欢杨超越");
20
    }
21
    static String name = "王菲";
22
    int age = 28;
23
    static {
24
        name = "杨幂";
25
        System.out.println("我喜欢杨幂");
26
    }
27
    public Star(int age,String name) {
28
        this(age);
29
        System.out.println("age,name：构造器！");
30
        Star.name = name;
31
        Star.name = "刘亦菲";
32
    }
33
    public Star(int age) {
34
        System.out.println("age：构造器！");
35
        this.age = age;
36
    }
37
    public Star() {
38
    }
39
}

通过上述程序，不难得出，代码块执行的顺序：

1. 静态代码块
2. 构造代码块
3. 构造器

package关键字#

package这个关键字我们并不陌生，它写在Java源文件的第一行，用于声明整个Java文件下的所有类的所属包。

语法：

1
package + 包名

当然，一个Java源文件当中，只能有一个public修饰的类。其余非public修饰的类和public类都属于同包的关系。

注意：

package关键字的使用很简单，但是有几个需要注意的地方：：

1. 包名在书写时，如果存在多级包名，需要使用用.隔开
2. package声明必须处在一个Java文件有效代码的第一行，否则会报错
   1. 注释不算有效代码，将package声明放在注释下面也是可以的
   2. 建议将package声明永远放在Java源文件真正意义上的第一行
3. 多数情况下，我们使用idea新建Java文件是无需关心package声明的，因为idea会自动生成
   1. 但是当你从网上或者其它途径弄到的一些代码，可能会出现包名错乱的情况
   2. 这时建议直接删除package声明，然后”Alt + 回车”类名报错的地方即可

全限定类名#

什么是全限定类名？

1. 可以唯一的、准确的定位到一个类的，由包名加上类名组成的字符串，就是全限定类名。
2. 默认情况下，直接输出一个对象的引用，会打印该类的全限定类名

import关键字#