4. Java 基础：构造方法

目录：
一、 概述
二、 构造方法的重载
三、 类的初始化过程
四、this 关键字
五、子父类中的构造方法
六、 super 关键字
七、 static 关键字
八、 final 关键字

---

一、 概述

1. 构造方法作用和定义

• 构造方法作用：new 对象的同时给成员变量赋值，给对象属性进行 初始化
• 构造方法定义:

修饰符 构造方法名 (参数列表){

}

2. 构造方法的特点

构造方法 没有返回值类型，连 void 也没有

也不需要写返回值。因为它是为构建对象的，对象创建完，方法就执行结束。

• 构造 方法名 必须和 类名 保持一致
• 只有在 创建对象 的时候 自动 调用执行，而且只执行 一次

3. 注意事项

• 每一 class 类都 必须有一个构造方法，如果自己不写，系统会给出 默认 构造方法
• 编译 的时候，系统会自动检查类中是否有构造方法，如果没有编译器就会自动添加一个构造方法
• 如果你提供了构造方法，系统将不再提供默认的构造方法
• 构造方法也是可以 重载 的
• 在创建对象时，会调用与 参数列表对应 的构造方法

构造方法的内存图

构造方法

二、 构造方法的重载

• 一个类中可以有 多个 构造方法，多个构造方法是以 重载 的形式存在的

意义在于：可以根据不同的需求，定义不同的构造方法，灵活地初始化对象的成员变量

• 构造方法是可以被 private 修饰，作用是：其他程序无法创建该类的对象

class Person {
    private int age;
    private String name;

    // 私有无参数的构造方法，即外界不能通过new Person();语句创建本类对象
    private Person() {
    }
    // 多个构造方法是以重载的形式存在
    Person(int a) {
        age = a;
    }
    Person(String nm, int a) {
        name = nm;
        age = a;
    }
}

三、 类的初始化过程

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

1. 加载 Student.class 文件进入内存
2. 在栈内存为 s 开辟空间
3. 在堆内存为学生对象开辟空间
4. 对学生对象的成员变量进行默认初始化
5. 对学生对象的成员变量进行显示初始化
6. 通过构造方法对学生对象的成员变量赋值
7. 学生对象初始化完毕，把对象地址赋值给 s 变量

• 类的初始化过程内存图

完整对象初始化过程

四、this 关键字

1. this 关键字：本类对象的引用

• this 是在方法中使用的，哪个对象调用了该方法，那么， this 就代表调用该方法的对象引用
• this 什么时候存在的？ 当创建对象的时候， this 就存在了
• this 的作用：用来区别同名的成员变量与局部变量（this .成员变量）

2. 成员变量隐藏

• 在局部变量作用域中，如果定义了一个和成员变量同名的局部变量，此时，在局部变量作用域中，就无法用变量名访问到成员变量，而只能访问到同名的局部变量
• 当需要访问成员变量是，只需要在成员变量前面加上 this. 即可
• 调用其他构造方法的语句 必须 定义在构造方法的 第一行，原因是初始化动作要 最先执行。

五、子父类中的构造方法

1. 调用

• 在创建子类对象时，父类的构造方法会 先执行，因为子类中所有构造方法的第一行有默认的隐式 super(); 语句，它是用来访问父类中的空参数构造方法，进行父类成员的初始化操作
• this()是调用本类的构造方法，super() 是调用父类的构造方法, 且两条语句 不能同时存在
• 无论如何，子类的所有构造方法，直接或间接 必须调用 到父类构造方法; 子类的构造方法什么都不写，默认 的构造方法第一行super()

子类初始化内存图：

子类初始化

2. 当父类中没有无参数构造方法的时候，怎么办？

• 通过super(参数) 访问父类有参构造方法
• 通过 this(参数) 访问本类中其他构造方法

注意：本类中的其他构造方法必须已经能够正常访问父类构造方法

3. 为什么子类对象创建都要访问父类中的构造方法？

• 因为子类继承了父类的内容，所以创建对象时，必须要先看父类是如何对其内容进行初始化的。
• 所以子类在初始化时，必须先到父类中去执行父类的初始化动作。这样，才可以使用父类中的内容。

总结：子类的初始化要保证，在初始化子类成员之前，必须首先初始化父类成员，因为，子类功能的实现，常常会依赖父类，所以在初始化的时候，保证先初始化父类，再初始化子类

4. 创建子类对象过程的细节

• 如果子类的构造方法 第一行写了 this 调用了本类其他构造方法，那么 super 调用 父类的语句还有吗？

这时是没有的，因为this()或者super()，只能定义在构造方法的第一行，因为初始化动作要先执行。

• 父类构造方法中是否有隐式的 super 呢？

也是有的。只要是构造方法默认第一行都是super();

六、 super 关键字

指的是父类的存储空间(理解为父类的引用)

• 调用父类的成员变量：
  super.成员变量;
• 调用父类的构造方法:
  super(参数);
• 调用方法的成员方法:
  super.成员方法();

关键字super可以在任意的非静态方法中使用

七、 static 关键字

1. static 特点

• 被 static 修饰的成员变量 属于类，不属于这个类的某个对象。优先于对象存在，被类的所有对象共享

也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，其他对象中的static成员变量值会跟着改变，即多个对象共享同一个static成员变量

• 被 static 修饰的成员可以并且建议通过 类名 直接访问

访问静态成员的格式:
1. 类名.静态成员变量名
2. 类名.静态成员方法名(参数)
3. 对象名.静态成员变量名 ------不建议使用该方式，会出现警告
4. 对象名.静态成员方法名(参数) -----不建议使用该方式，会出现警告

2. static 注意事项

• 静态内容是优先于对象存在的，只能访问静态 。静态修饰的内容存于内存的 静态区。
• main 方法为静态方法，仅仅为程序执行入口，它不属于任何一个对象，可以定义在任意类中
• 静态上下文中，不能引用非静态的成员变量或成员方法
• 静态方法中无法访问普通成员； 静态成员方法中，不能调用非静态的成员方法（静态只能访问/调用静态）
• 在静态上下文中，无法使用 this/super 关键字， 因为 this/super 指代的是对象

3. 静态变量和成员变量的区别

• 所属不同

• 静态变量属于 类，所以也称为为 类变量。

• 成员变量属于 对象，所以也称为 实例变量(对象变量)

• 内存中位置不同

• 静态变量存储于方法区的静态区

• 成员变量存储于堆内存

• 内存出现时间不同

• 静态变量随着 类 的加载而加载，随着类的消失而消失

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

• 调用不同

• 静态变量可以通过类名调用，也可以通过对象调用

• 成员变量只能通过 对象名 调用

静态变量和方法的初始化内存图：

静态变量和方法的初始化

4. 定义静态常量

• public static final 修饰的变量来完成定义，此时 变量名用全部大写，多个单词使用 下划线 连接

public static final 数据类型 变量名 = 值;

1. 当我们想 使用类的静态成员 时，不需要创建对象，直接使用类名 来访问即可
2. 接口中的每个成员变量都 默认 使用public static final 修饰。
3. 所有接口中的成员变量已是 静态常量，由于接口没有构造方法，所以必须 显示 赋值。可以直接用 接口名 访问。

八、 final 关键字

1. 概述

• 继承的出现提高了代码的复用性，并方便开发。但随之也有问题，有些类在描述完之后，不想被继承，或者有些类中的部分方法功能是固定的，不想让子类重写。可是当子类继承了这些特殊类之后，就可以对其中的方法进行重写，那怎么解决呢？
• 要解决上述的这些问题，需要使用到一个关键字 final ， final 的意思为最终，不可变。 final 是个修饰符，它可以用来修饰 类，类的成员，以及局部变量

2. 特点

• final 修饰 类 不可以被继承，但是可以继承其他类。
• final 修饰的 方法不可以被覆盖,但父类中没有被 final 修饰方法，子类覆盖后可以加 final
• final 修饰的 变量 称为常量，这些变量只能赋值一次。
• final 修饰的 引用类型的变量 值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改
• final 修饰 成员变量 ，需要在创建对象前赋值，否则报错。(当没有显式赋值时，多个构造方法的均需要为其赋值。)

3. 自定义常量的初始化

• 自定义常量的初始化，可以通过 构造方法 来初始化

注意事项：如果通过构造方法，来对自定义常量进行初始化，要保证，每一个构造方法中都必须有初始化自定义常量的初始化语句