【Java】构造方法及类的初始化

ゞ浴缸里的玫瑰 2023-09-28 20:39 11阅读 0赞

活动地址：[CSDN21天学习挑战赛][CSDN21]  
![在这里插入图片描述][078b66f87e3c4e309d7f34d79c5776c4.gif_pic_center]✨**博客主页:**[ **XIN-XIANG荣**][_XIN-XIANG]  
✨**系列专栏:**[**【Java SE】**][Java SE]  
✨**一句短话:** **难在坚持,贵在坚持,成在坚持!**

#### 文章目录 ####

*  一. 利用构造方法给对象初始化
 *   *  1. 构造方法的概念
     *  2. 构造方法的特性
     *  3. 子类构造方法
     *  4. 避免在构造方法中调用重写的方法
 *  二. 对象的默认初始化
 *  三. 就地初始化对象
 *  四. 类的初始化顺序
 *   *  1. 普通类（没有继承关系）
     *  2. 派生类（ 有继承关系）

## 一. 利用构造方法给对象初始化 ##

### 1. 构造方法的概念 ###

**构造方法(也称为构造器)是一个特殊的成员方法，其名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。**

构造方法的作用就是给对象中的成员进行初始化，并不负责给对象开辟空间。

public class Date {
        
        public int year;
        public int month;
        public int day;
    
        // 构造方法：
        // 名字与类名相同，没有返回值类型，设置为void也不行
        // 一般情况下使用public修饰
        // 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
        public Date(int year, int month, int day) {
        
            this.year = year;
            this.month = month;
            this.day = day;
            System.out.println("Date(int,int,int)方法被调用了");
        }
    
        public void printDate() {
        
            System.out.println(year + "-" + month + "-" + day);
        }
    
        public static void main(String[] args) {
        
            // 此处创建了一个Date类型的对象，并没有显式调用构造方法
            Date d = new Date(2021, 6, 9);
            // 输出Date(int,int,int)方法被调用了
            d.printDate(); // 2021-6-9
        }
    }

### 2. 构造方法的特性 ###

1.  **名字必须与类名相同**
2.  **没有返回值类型**，设置为void也不行
3.  **创建对象时**由编译器自动调用，并且**在对象的生命周期内只调用一次**
4.  绝大多数情况下使用public来修饰，特殊场景下会被private修饰
5.  **构造方法可以重载**(用户根据自己的需求提供不同参数的构造方法)； 下面两个构造方法：名字相同，参数列表不同，因此构成了方法重载

public class Date {
        
        public int year;
        public int month;
        public int day;
        
        // 无参构造方法
        public Date(){
        
            this.year = 1900;
            this.month = 1;
            this.day = 1;
        }
        
        // 带有三个参数的构造方法
        public Date(int year, int month, int day) {
        
            this.year = year;
            this.month = month;
            this.day = day;
        }
        public void printDate(){
        
            System.out.println(year + "-" + month + "-" + day);
        }
        public static void main(String[] args) {
        
            Date d = new Date();
            d.printDate();
        }
    }

1.  **如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的； 一旦用户定义，编译器则不再生成**；下面代码中，没有定义任何构造方法，编译器会默认生成一个不带参数的构造方法。

public class Date {
        
        public int year;
        public int month;
        public int day;
        public void printDate(){
        
            System.out.println(year + "-" + month + "-" + day);
        }
        public static void main(String[] args) {
        
            Date d = new Date();
            d.printDate();
        }
    }

1.  **构造方法中，可以通过this调用其他构造方法来简化代码**

【注意事项】

*  构造方法中，通过this(…)去调用其他构造方法，这条语句必须是构造方法中第一条语句
 *  多个构造方法不可以互相调用（不能形成环）， 会形成构造器的递归调用，但却没有调用的结束条件

public class Date {
        
        public int year;
        public int month;
        public int day;
    // 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
    // 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
    // 但是this(2022,8,16);必须是构造方法中第一条语句
        
        public Date(){
        
    //System.out.println(year); 注释取消掉，编译会失败
            this(2022, 8, 16);
    //this.year = 1900;
    //this.month = 1;
    //this.day = 1;
        }
        
        // 带有三个参数的构造方法
        public Date(int year, int month, int day) {
        
            this.year = year;
            this.month = month;
            this.day = day;
        }
    }

### 3. 子类构造方法 ###

**在继承基础上，子类对象构造时，需要先调用基类构造方法，然后执行子类的构造方法。**

在子类构造方法中，并没有写任何关于基类构造的代码，但是在构造子类对象时，先执行基类的构造方法，然后执行子类的构造方法，

原因在于：子类对象中成员是有两部分组成的，基类继承下来的以及子类新增加的部分 。父类和子类， 肯定是先有父再有子，所以**在构造子类对象时候 ，子类构造方法中先要调用基类的构造方法，将从基类继承下来的成员构造完整 ，然后再完成子类自己的构造，将子类自己新增加的成员初始化完整** 。

【注意事项】

1.  若父类**显式定义无参或者默认**的构造方法，在**子类构造方法第一行默认有隐含的super()调用**，即调用基类构造方法

public class Base {
        
        public Base(){
        
            System.out.println("Base()");
        }
    }
    
    public class Derived extends Base{
        
        public Derived(){
        
    // super(); // 注意子类构造方法中默认会调用基类的无参构造方法：super(),
    // 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
    // 并且只能出现一次
            System.out.println("Derived()");
        }
    }
    
    public class Test {
        
        public static void main(String[] args) {
        
            Derived d = new Derived();
        }
    }

1.  如果**父类构造方法是带有参数的**，此时**需要用户为子类显式定义构造方法**，**并在子类构造方法中选择合适的父类构造方法调用**，否则编译失败。

public class Animal {
        
        public String name;
        public int  age;
    
       public Animal(String name, int age) {
        
            this.name = name;
            this.age = age;
           System.out.println("Animal(String , int )");
        }
    
    }
    
    public class Dog extends Animal{
        
        //傻狗  是狗的属性
        public boolean silly;
    
       public Dog(String name,int age,boolean silly) {
        
            //1. 先帮助父类部分初始化 必须放到第一行
            super(name,age);
            this.silly = silly;
            System.out.println("Dog(String ,int ,boolean )");
       }
        public static void main(String[] args) {
        
            Animal animal2 = new Dog("金毛",6,false);
        }
    }

1.  在子类构造方法中，super(…)调用父类构造时，**必须是子类构造方法中第一条语句。**
2.  **super(…)只能在子类构造方法中出现一次，由与this(…)调用时也要在第一条语句，所以super(…)不能和this(…)同时出现，也就是是说子类构造方法中不能使用this(…)**

### 4. 避免在构造方法中调用重写的方法 ###

一段有坑的代码. 我们创建两个类, B 是父类, D 是子类. D 中重写 func 方法. 并且在 B 的构造方法中调用 func

class B {
        
        public B() {
        
    // do nothing
            func();
        }
        public void func() {
        
            System.out.println("B.func()");
        }
    }
    class D extends B {
        
        private int num = 1;
        @Override
        public void func() {
        
            System.out.println("D.func() " + num);
        }
    }
    public class Main {
        
        public static void main(String[] args) {
        
            D d = new D();
        }
    }

执行结果：

![img][]

*  构造 D 对象的同时, 会调用 B 的构造方法.
 *  B 的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到 D 中的 func
 *  此时 D 对象自身还没有构造, num 处在未初始化的状态, 值为 0；如果具备多态性，num的值应该是1.
 *  所以在构造函数内，尽量避免使用实例方法，除了final和private方法。

【结论】：

“用尽量简单的方式使对象进入可工作状态”, 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题.

## 二. 对象的默认初始化 ##

在Java**方法内部定义一个局部变量**时，用户**必须要将其赋值或者初始化**，否则会编译失败；

但**对象中的字段（成员变量）**，**用户不需要将其初始化就可直接访问使用**，这里其原因在于new对象时，jvm会给出字段的默认初始化。

下面是new对象是时，**jvm**层面执行的概述：

1.  检测对象对应的类是否加载了，如果没有加载则加载
2.  为对象分配内存空间
3.  处理并发安全问题  
    比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突
4.  **初始化所分配的空间**  
    **即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值**

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>0.0f</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>0.0</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>/u0000</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td>reference (引用类型)</td> 
   <td>null</td> 
  </tr> 
 </tbody> 
</table>

1.  设置对象头信息(关于对象内存模型后面会介绍)
2.  调用构造方法，给对象中各个成员赋值

## 三. 就地初始化对象 ##

在声明成员变量时，就直接给出了初始值。

代码编译完成后，**编译器会将所有给成员初始化的这些语句添加到各个构造方法中**

public class Date {
        
        public int year = 1900;
        public int month = 1;
        public int day = 1;
        
        public Date(){
        
        }
        
        public Date(int year, int month, int day) {
        
        }
        
        public static void main(String[] args) {
        
            Date d1 = new Date(2022,8,16);
            Date d2 = new Date();
        }
    }

## 四. 类的初始化顺序 ##

### 1. 普通类（没有继承关系） ###

1.  静态部分（静态变量、常量，静态代码块）

*  在类加载阶段执行，类中存在多个静态部分时，会按顺序执行
 *  静态代码块只会执行一次，且静态的变量、常量等只会创建一份

1.  非静态部分（实例变量、常量、实例代码块）

*  当有对象创建时才会执行，按顺序执行

1.  最后执行构造方法，当有对象创建时才会执行

**代码演示：**

class Person {
        
        public String name;
        public int age;
        public Organ organ = new Organ();
        public Person(String name, int age) {
        
            this.name = name;
            this.age = age;
            System.out.println("构造方法执行");
        }
        {
        
            System.out.println("实例代码块执行");
        }
        static {
        
            System.out.println("静态代码块执行");
        }
    }
    class Organ {
        
        //...
        public Organ() {
        
            System.out.println("实例变量::organ");
        }
    }
    public class TestDemo {
        
        public static void main(String[] args) {
        
            Person person1 = new Person("xin",21);
            System.out.println("==============");
            Person person2 = new Person("xinxin",20);
        }
    }

执行结果：

![img][img 1]

### 2. 派生类（ 有继承关系） ###

1.  静态部分（静态变量、常量，静态代码块）

*  **父类静态代码块优先于子类静态代码块执行**，且是最早执行
 *  **只有第一次实例化子类对象**时，**父类和子类的静态部分会执行**； 之后再实例化子类对象时，父类和子类的静态部分都不会再执行

1.  **父类**非静态部分（实例变量、常量、实例代码块）和**父类**构造方法
2.  **子类**非静态部分（实例变量、常量、实例代码块）和**子类**构造方法

class Person {
        
        public String name;
        public int age;
        public Person(String name, int age) {
        
            this.name = name;
            this.age = age;
            System.out.println("Person：构造方法执行");
        }
        {
        
            System.out.println("Person：实例代码块执行");
        }
        static {
        
            System.out.println("Person：静态代码块执行");
        }
    }
    class Student extends Person{
        
        public Student(String name,int age) {
        
            super(name,age);
            System.out.println("Student：构造方法执行");
        }
        {
        
            System.out.println("Student：实例代码块执行");
        }
        static {
        
            System.out.println("Student：静态代码块执行");
        }
    }
    public class TestDemo4 {
        
        public static void main(String[] args) {
        
            Student student1 = new Student("张三",19);
            System.out.println("===========================");
            Student student2 = new Student("gaobo",20);
    
        }
        public static void main1(String[] args) {
        
            Person person1 = new Person("bit",10);
            System.out.println("============================");
            Person person2 = new Person("gaobo",20);
        }
    }

执行结果：

![img][img 2]

[CSDN21]: https://marketing.csdn.net/p/bdabfb52c5d56532133df2adc1a728fd
[078b66f87e3c4e309d7f34d79c5776c4.gif_pic_center]: https://img-blog.csdnimg.cn/078b66f87e3c4e309d7f34d79c5776c4.gif#pic_center
[_XIN-XIANG]: https://blog.csdn.net/Trong_?spm=1000.2115.3001.5343
[Java SE]: https://blog.csdn.net/trong_/category_11933690.html?spm=1001.2014.3001.5482
[img]: https://img-blog.csdnimg.cn/img_convert/2b97c5f3f58859ea168ce034a9b6e180.png
[img 1]: https://img-blog.csdnimg.cn/img_convert/d7c80b83fe7b7eb2577f5bb055bf5424.png
[img 2]: https://img-blog.csdnimg.cn/img_convert/fb80edc68cd7e18c9c36cbab28e46c8c.png