实例初始化

类的提取:
名词提取法，转换为现实世界中的事物的类别==》计算机程序中的类
类的设计: .
类的成员的设计
5大成员(5大组成部分) :
1、属性:数据特征

2、方法:行为特征，功能特征

3、构造器:创建对象时用

类的第三个组成部分 : 构造器，也称为构造方法，因为 (1) 它长的像方法
 (2) 它编译后是一个实例初始化方法
1、构造器的作用
(1)构造对象，创建对象
和 new 一起使用，每次调用它就是在创建新的对象
2、构造器的特点
(1)所有类都有构造器
(2)如果一个类没有显式声明构造器，那么编译器将会自动生成一个默认的无参构造
(3)如果一个类显式声明了构造器，那么编译器将不会自动生成默认的无参构造了
(4)构造器的名称必须与类名相同
(5)构造器没有返回值类型，也不写void
(6)构造器可以重载

	3、构造器的语法结构
	[修饰符] 类名(){
    
	[修饰符]类名 (形参列表) {
    
	}

4、代码块:在类初始化和对象初始化时用的

5、内部类:在某个大的事物中，包含了一个独立的小的事物类别，而且一般这个小的事物只为大的事物服务时。

(4)代码块

	①非静态代码块
	②静态代码块:后面讲，和static一起

2、非静态代码块
声明的格式:
[修饰符] class类名{
{
非静态代码块;
}

(2)非静态代码块中的代码什么时候执行?

①在“每次”创建对象的时候执行
②比构造器早

(3)实例初始化过程：创建对象时，为对象进行初始化的操作

①为成员变量显式赋值
②执行非静态代码块
③执行构造器

public class TestBlock {
    
    public static void main(String[] args) {
    
        MyClass my1 = new MyClass();    //调用无参构造
        MyClass my2 = new MyClass("atguigu");   //调用有参构造
    }
}

class MyClass {
    
    private String str ="hello"; //显示赋值;

    public MyClass() {
    
        System.out.println("无参构造");
    }

    public MyClass(String str) {
    
        this.str = str;
        System.out.println("有参构造");
    }

    public String getStr() {
    
        return str;
    }

    public void setStr(String str) {
    
        this.str = str;
    }

    {
    
        System.out.println("非静态代码块");
    }

}

Java编译器其实，会把这三个部分的代码，合成一个叫做( [形参列表] )实例初始化方法
即编译后的.class字节码信息中，是没有构造器这个概念。

( [形参列表] )实例初始化方法的代码就是由三个部分组成:

①成员变量显式赋值的代码
②非静态代码块中的代码
③构造器中的代码

其中的①和②按顺序执行，而③-定是它们当中的最后执行。

而且，有几个构造器，就会有几个实例初始化方法，那么当你创建对象的时候，调用对应的构造器时，其实执行的是对应的实例初始化方法( […])

package Day10;

public class TestBlock {
    
    public static void main(String[] args) {
    
        MyClass my1 = new MyClass();    //调用无参构造
        MyClass my2 = new MyClass("atguigu");   //调用有参构造
    }
}

class MyClass {
    
    {
    
        System.out.println("非静态代码块 ①");
    }
    private String str =assign();//显示赋值

    public MyClass() {
    
        System.out.println("无参构造");
    }

    public MyClass(String str) {
    
        this.str = str;
        System.out.println("有参构造");
    }

    public String getStr() {
    
        return str;
    }

    public void setStr(String str) {
    
        this.str = str;
    }


    {
    
        System.out.println("非静态代码块 ②");
    }

    public String assign(){
    
        System.out.println("assign方法");
        return "hello";
    }

}

.class文件反编译得到的数据中有的字段（底层没有构造器的概念，只要实例初始化方法）

大致简化为：

class MyClass {
    
    private String str;
    
    // 无参的实例初始化方法
<init>() {
    
        System. out. print1n("非静态代码块1");
        str = assign();//调用方法,来为str进行显式赋值
        System.out.println(“非静态代码块2") ;                  

        System.out.print1n("无参构造“);
    }
    
    //  有参的实例初始化方法
<init>(String str) {
    
        System.out.println("非静态代码块1"):
        str = assign();//调用方法,来为str进行显式赋值
        System.out.println("非静态代码块2" ) ;
        this.str = str;                                     
        System.out.println("有参构造" ) ;
    }
    public String assign() {
    
        Syst em. out. println(" assign方法^ );
        return "hello" ;

    }
    
}

构造器的易错点：

package Day10;

public class TestInit {
    
    public static void main(String[] args) {
    

        Son s = new Son();

    }
}

class Father {
    

    public Father() {
    
        System.out.println("父类的无参构造器");
    }
}

class Son extends Father {
    
    public Son() {
    
        //隐含了super(); 子类的构造器中一定会调用父类的构造器，默认调用父类的无参构造
        System.out.println("子类的无参构造器");
    }

package Day10;

public class TestInit {
    
    public static void main(String[] args) {
    

        Son s = new Son();
        Son s2 = new Son("hello");

    }
}

class Father {
    

    public Father() {
    
        System.out.println("父类的无参构造器");
    }
}

class Son extends Father {
    

    private String str;

    public Son() {
    
        //隐含了super(); 子类的构造器中一定会调用父类的构造器，默认调用父类的无参构造
        System.out.println("子类的无参构造器");
    }

    public Son(String str) {
    
        this.str = str;
        System.out.println("子类的有参构造器");
    }
}

package Day10;

public class TestInit {
    
    public static void main(String[] args) {
    

        Son s = new Son();
        Son s2 = new Son("hello");

        Son s3 = new Son("ahello",2);
    }
}

class Father {
    

    public Father() {
    
        System.out.println("父类的无参构造器");
    }
}

class Son extends Father {
    

    private String str;
    private int num;

    public Son() {
    
        //隐含了super(); 子类的构造器中一定会调用父类的构造器，默认调用父类的无参构造
        System.out.println("子类的无参构造器");
    }

    public Son(String str) {
    
        this.str = str;
        System.out.println("子类的有参构造器1");
    }

    public Son(String str,int num) {
    
        this(str);
        this.num =num;
        System.out.println("子类的有参构造器2");
    }
}

package Day10;

/*
*
*(1)先执行父类的实例初始化方法
`它由三部分:
    `   ①成员变量的显式赋值
        ②非静态代码块
        ③构造器
(2)再执行子类的实例初始化方法
它由三部分:
        ①成员变量的显式赋值
        ②非静态代码块
        ③构造器
super( )或super(实参列表)之前说的是调用父类的构造器，其实是调用父类对应的实例初始化方法
super( )或super(实例列表)之前说的是在子类构造器的首行，其实是在子类实例初始化方法的首行

* */

public class TestInit2 {
    

    public static void main(String[] args) {
    

        Zi z =new Zi();

    }
}

class  Fu{
    

    {
    
        System.out.println("1 父类的非静态代码块") ;
    }

    public Fu() {
    
        System.out.println("2 父类的无参构造");
    }
}

class Zi extends Fu{
    

    {
    
        System.out.println("3 子类的非静态代码块");
    }

    public Zi() {
    
        // super( ) == >调用父类的实例初始化方法，而且它在子类实例初始化方法的首行

        System.out.println("4 子类的无参构造");
    }

}

package Day10;

/*
*
*(1)先执行父类的实例初始化方法
`它由三部分:
    `   ①成员变量的显式赋值
        ②非静态代码块
        ③构造器
(2)再执行子类的实例初始化方法
它由三部分:
        ①成员变量的显式赋值
        ②非静态代码块
        ③构造器
super( )或super(实参列表)之前说的是调用父类的构造器，其实是调用父类对应的实例初始化方法
super( )或super(实例列表)之前说的是在子类构造器的首行，其实是在子类实例初始化方法的首行

* */

public class TestInit2 {
    

    public static void main(String[] args) {
    

        Zi z =new Zi();

    }
}

class  Fu{
    

    private String strFu =assignFu();

    {
    
        System.out.println("1 父类的非静态代码块") ;
    }

    public Fu() {
    
        System.out.println("2 父类的无参构造");
    }
    public String assignFu(){
    

        System.out.println("3 父类的assign()");
        return "fu";
    }
}

class Zi extends Fu {
    
    private String strZi =assignZi();

    {
    
        System.out.println("4 子类的非静态代码块");
    }

    public Zi() {
    
        // super( ) == >调用父类的实例初始化方法，而且它在子类实例初始化方法的首行

        System.out.println("5 子类的无参构造");
    }

    public String assignZi(){
    

        System.out.println("6 子类的assign()");
        return "zi";
    }
}

package Day10;

public class TestInit3 {
    

    public static void main(String[] args) {
    
        Er  r = new Er();
    }


}


class  Ba{
    

    private String str =assign();

    {
    
        System.out.println("1 父类的非静态代码块") ;
    }

    public Ba() {
    
        System.out.println("2 父类的无参构造");
    }
    public String assign(){
    

        System.out.println("3 父类的assign()");
        return "bs";
    }
}

class Er extends Ba {
    
    private String str =assign();

    {
    
        System.out.println("4 子类的非静态代码块");
    }

    public Er() {
    
        // super( ) == >调用父类的实例初始化方法，而且它在子类实例初始化方法的首行

        System.out.println("5 子类的无参构造");
    }

    public String assign(){
    

        System.out.println("6 子类的assign()");
        return "er";
    }
}

初始化分析：