Java 对象的创建 之 实例初始化

一、类的成员

　　1、属性：成员变量

　　2、方法：成员方法

　　3、构造器：构造方法

　　4、代码块：初始化块

　　5、内部类

二、非静态代码块

　　1、非静态代码块格式

【修饰符】 class 类名{
 	{
 	　　非静态代码块;
 	}
 }

　　

　　2、非静态代码中的代码执行时机

　　　　（1）在“每次”创建对象的时候执行；

　　　　（2）比构造器要早；

三、实例初始化

　　1、实例初始化是什么？

　　　　实例初始化过程：每次创建对象时，为对象进行初始化的操作。

　　2、对象的初始化有那几部分组成？

　　　　（1）成员变量显示赋值；

　　　　（2）执行非静态代码块；

　　　　（3）执行构造器；

　　3、实例初始化是怎样的？

　　　　Java 编译器其实，会把上面三个部分的代码，合成一个叫做 <init>(【形参列表】)实例初始化方法。

　　　　即 编译后的 .class 字节码信息中，是没有构造器这个概念的。

　　　　<init>(【形参列表】) 实例初始化方法的代码就是由三个部分组成的：

　　　　（1）成员变量显示赋值的代码；

　　　　（2）非静态代码块中的代码；

　　　　（3）构造器中的代码；

　　　　 注意：

　　　　　　① 其中（1）和（2）将会按照先后顺序执行，而构造器一定是它们当中的最后执行。

　　　　　　② 而且，有几个构造器，就会有几个实例初始化方法。那么当我们创建对象的时候，调用对应的构造器时，其实执行的是对应的实例初始化方法<init>(【...】)

　　4、

四、案例

　　1、案例一

public class TestInit {
    public static void main(String[] args) {
        MyClass my1 = new MyClass();//调用无参构造
        MyClass my2 = new MyClass("test");//调用有参构造
    
        System.out.println("-----------------");
        
        Demo d1 = new Demo();//调用无参构造，本质上是调用<init>()实例初始化方法
        Demo d2 = new Demo("test");//调用有参构造，本质上是调用<init>(形参列表)实例初始化方法
    }
}
class MyClass{
    private String str = "hello";//显式赋值
    
    public MyClass(){
        System.out.println("无参构造");
    }
    public MyClass(String str){
        this.str = str;
        System.out.println("有参构造");
    }
    
    {
        System.out.println("非静态代码块");
    }
}

class Demo{
    {
        System.out.println("非静态代码块1");
    }
    
    private String str = assign();//调用方法，来为str进行显式赋值
    
    public Demo(){
        System.out.println("无参构造");
    }
    public Demo(String str){
        this.str = str;
        System.out.println("有参构造");
    }
    
    {
        System.out.println("非静态代码块2");
    }
    
    public String assign(){
        System.out.println("assign方法");
        return "hello";
    }
}

//运行结果
非静态代码块
无参构造
非静态代码块
有参构造
-----------------
非静态代码块1
assign方法
非静态代码块2
无参构造
非静态代码块1
assign方法
非静态代码块2
有参构造

 　　

　　2、案例二

public class TestInit {
    public static void main(String[] args) {
        /*
        Father f = new Father();
        //父类的无参构造
        */
        
        /*
         * Son s = new Son();
         * 父类的无参构造
            子类的无参构造
         */
        
        //Son s2 = new Son("test");
        /*
         * 父类的无参构造
        子类的有参构造
         */
        
        Son s3 = new Son("test", 10);
        /*
         * 父类的无参构造
            子类的有参构造1
            子类的有参构造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){
        //隐含了super()
        this.str = str;
        System.out.println("子类的有参构造1");
    }
    
    public Son(String str,int num){
        this(str);
        this.num = num;
        System.out.println("子类的有参构造2");
    }
}

//运行结果
父类的无参构造
子类的有参构造1
子类的有参构造2

　　3、案例三

/*  父子类的实例初始化过程：
 * （1）先执行父类的实例初始化方法
 * 　　它由三部分：
 * 　　　　①成员变量的显式赋值
 * 　　　　②非静态代码块
 * 　　　　③构造器
 * （2）再执行子类的实例初始化方法
 * 　　它由三部分：
 * 　　　　①成员变量的显式赋值
 * 　　　　②非静态代码块
 * 　　　　③构造器
 * 
 * super()或super(实参列表)之前说的是调用父类的构造器，其实是调用父类对应的实例初始化方法
 * super()或super(实例列表）之前说的是在子类构造器的首行，其实是在子类实例初始化方法的首行
 */
public class TestInit2 {
    public static void main(String[] args) {
        Zi z = new Zi();//312645
    }
}
class Fu{
    private String strFu = assignFu();
    {
        System.out.println("(1)父类的非静态代码块");
    }
    public Fu(){
        System.out.println("(2)父类的无参构造");
    }
    public String assignFu(){
        System.out.println("(3)父类的assignFu()");
        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)子类的assignZi()");
        return "zi";
    }
}

//运行结果
(3)父类的assignFu()
(1)父类的非静态代码块
(2)父类的无参构造
(6)子类的assignZi()
(4)子类的非静态代码块
(5)子类的无参构造

　　4、案例四

public class TestInit3 {
    public static void main(String[] args) {
        Er r = new Er();//612645，因为子类重写了assign()
        
//      Ba b = new Ba();
    }
}
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 "ba";
    }
}
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";
    }
}


//运行结果
(6)子类的assign()
(1)父类的非静态代码块
(2)父类的无参构造
(6)子类的assign()
(4)子类的非静态代码块
(5)子类的无参构造

 

六、总结

　　实例初始化过程：

　　　　实例初始化方法就是执行类的 <init>() 方法：

• <init>() 方法可能重载有多个，有几个构造器就有几个 <init>方法；
• <init>() 方法由非静态实例变量显示赋值代码和非静态代码块、对应构造器代码组成；
• 非静态实例变量显示赋值代码和非静态代码块从上到下顺序执行，而对应构造器的代码最后执行；
• 每次创建实例对象，调用对应构造器，执行的就是对应的<init>方法；
• <init> 方法的首行是 super() 或 super(实参列表)，即对应父类的 <init>() 方法；