11月14日课程笔记-代码块

1.创建类的对象时，其构造方法会被调用

        Student stu=new Student( );

        如果没有对构造方法重载，调用构造方法创建类的对象时，不传入参数。

        如果构造方法已经重载，根据构造方法的参数列表的不同，创建不同的类对象时，传入的参数也不同

public Text() {}
Text t=new Text();

public Text(String s) {}
private String s;
Text ts=new Text(s);

public Text(double d){}
private double d;
Text td=new Text(d);

2.类的运行原理

加载相应的.class的类文件，到内存的方法区。
堆中创建各级类的对象（Object类,当前类及其父类或子类，子类的对象中有一个引用super指向其父类对象），并且完成对象的初始化。
将对象的地址赋值给栈中引用（栈中类的引用指向堆中的类对象）。
调用类的方法，开始执行时压栈，执行完毕出栈
类的对象无更多的引用指向时，垃圾回收器会回收对象资源，释放内存。
运行垃圾回收器： System.gc()

3.在main方法中创建某个类的对象（不一定是当前类的对象）并运行时：这个新对象的所属类，以及往上各级所有父类的构造方法都会被调用（同时这些类的对象会被创建）。                                而只要这些构造方法里面有可以输出的内容，就会从上往下一级一级的实现输出。无论这个main方法是写在任何一个父类，子类或者测试类中，运行时输出的结果均不会受到影响

举例：父类Creature,其子类二级父类Animals,二级子类Cattle

  在Animals类中写入main方法，方法体中创建一个二级子类Cattle的对象

//父类Creature,构造方法被调用时输出"Creature"
public class Creature {
    public Creature() {
        System.out.println("Creature");
    }
}

//Creature的子类Animals,构造方法被调用时输出"Animals"
public class Animals extends Creature{
    public Animals() {
        System.out.println("Animals");
    }

    public static void main(String[] args) {
        Cattle c=new Cattle();
    }
}

//Animals的子类Cattle，构造方法被调用时输出"Cattle"
public class Cattle extends Animals{
    public Cattle() {
        System.out.println("Cattle");
    }

    public static void main(String[] args) {
        Cattle c=new Cattle();
    }
}

运行后，可以看到输出结果中依次调用了Animals的父类构造，Animals本类构造，以及Animals的子类构造

输出结果：

Creature
Animals
Cattle
 

4.两种代码块的运行时间

   1.代码块（对象被创建之前）
   作用：完成一些对象初始化工作。
   2.静态代码块（类加载时）
   作用: 该类程序执行之前的初始化工作。

举例：定义Person类，子类Student,测试类Test

public class Person {
    {
        System.out.println("Person代码块");
    }
    static {
        System.out.println("Person静态代码块");
    }
    public Person(){
        System.out.println("调用Person构造，创建Person对象");
    }
}

public class Student extends Person{
    {
        System.out.println("Stu代码块");
    }
    static {
        System.out.println("Stu静态代码块");
    }
    public Student(){
        System.out.println("调用stu构造，创建Stu对象");
    }
}

public class Test {
    public static void main(String[] args) {
        Student stu1 = new Student();
        System.out.println("--------------------");
        Student stu2 = new Student();
    }
}

输出结果：

Person静态代码块    //加载Person类时运行了Person静态代码块
Stu静态代码块          //加载Student类时运行了Student静态代码块
Person代码块            //Person对象被创建之前运行了Person代码块
调用Person构造，创建Person对象
Stu代码块                   //Student对象被创建之前运行了Student代码块
调用stu构造，创建Stu对象
--------------------
Person代码块               //创建第二个对象时不再运行静态代码块
调用Person构造，创建Person对象
Stu代码块
调用stu构造，创建Stu对象