动手动脑及课后实验问题2

进行试验

class InitializeBlockClass{
    {
        field =200;
    }
    public int field =100;
    public InitializeBlockClass(int valve){
        this.field=valve;
    }
    public InitializeBlockClass(){
        
    }
}
public class Test {

    public static void main(String[] args) {
        InitializeBlockClass obj =new InitializeBlockClass();
        System.out.println(obj.field);
        
        obj =new InitializeBlockClass(300);
        System.out.println(obj.field);

    }

}

请依据代码的输出结果，自行总结Java字段初始化的规律。

初始化顺序：

1.执行类成员定义时指定的默认值或类的初始化块，到底执行哪一个要看哪一个“排在前面”。

2.执行类的构造函数：类的初始化块不接收任何的参数，而且只要一创建类的对象，它们就会被执行。因此，适合于封装那些“对象创建时必须执行的代码”。

初始化模板：

Java进行初始化的地方有两个：初始化块和构造函数，其中初始化块又分为静态初始化块和实例初始化块。静态初始化块是类中由static修饰的初始化块，实例初始化块为类中没有任何关键字修饰的初始化语句。

如果在主函数中创建对象时没有形参时，如果在类中定义了公共的变量并给与了赋值，那么就会把值赋给主函数中的变量，再调用类中的默认构造函数，如果在主函数中创建对象时有形参，则调用类中对应的构造函数。

动手动脑

当多个类之间有继承关系时，创建子类对象会导致父类初始化块的执行。请自行编写示例代码验证结论

class Student//父类
{
    String name;
    {    name="LI"; }
}
//子类继承父类
class Teacher extends Student{
    int age=20;
    float wage =10000;
    void show()
    {
        System.out.println("姓名："+name);
        System.out.println("年龄："+age);
        System.out.println("工资："+wage);
    }
}
public class Inherit {
    public static void main(String[] args){

        Teacher teacher = new Teacher();
        teacher.show();
        }
}

动手动脑2

请运行TestStaticInitializeBlock.java示例，观察输出结果，总结出“静态初始化块的执行顺序”。

class Root
{
    static{
        System.out.println("Root的静态初始化块");
    }
    {
        System.out.println("Root的普通初始化块");
    }
    public Root()
    {
        System.out.println("Root的无参数的构造器");
    }
}
class Mid extends Root
{
    static{
        System.out.println("Mid的静态初始化块");
    }
    {
        System.out.println("Mid的普通初始化块");
    }
    public Mid()
    {
        System.out.println("Mid的无参数的构造器");
    }
    public Mid(String msg)
    {
        //通过this调用同一类中重载的构造器
        this();
        System.out.println("Mid的带参数构造器，其参数值：" + msg);
    }
}
class Leaf extends Mid
{
    static{
        System.out.println("Leaf的静态初始化块");
    }
    {
        System.out.println("Leaf的普通初始化块");
    }    
    public Leaf()
    {
        //通过super调用父类中有一个字符串参数的构造器
        super("Java初始化顺序演示");
        System.out.println("执行Leaf的构造器");
    }

}

public class TestStaticInitializeBlock
{
    public static void main(String[] args) 
    {
        new Leaf();
        

    }
}

如果定义初始化块时使用了static修饰符，则变成了静态初始化块。静态初始化块时类相关的，系统将在类初始化阶段执行静态初始化块，而不是在创建对象时才执行。

因此静态初始化块总是比普通初始化块先执行。

 与普通初始化块类似的是，系统在类初始化阶段执行静态初始化块时，不仅会执行本类的静态初始化块，而且还会一直上溯到 java.lang.Object类,先执行java.lang.Object类中的静态初始化块，然后执行其父类的静态初始化块,最后才执行该类的静态 初始化块。经过这个过程，才完成了该类的初始化过程。只有当类初始化完成后，才可以在系统中使用这个类，包括访问类method、类Field，或者用这个类来创建实例。

 一个有趣的问题

静态方法中只允许访问静态数据，那么，如何在静态方法中访问类的实例成员（即没有附加static关键字的字段或方法）?

请编写代码验证你的想法。

class Exercise{

    int a=0;
    static int b;
    static public int getb(int newb)
    {
        b=newb;
        System.out.println(b);
        return b;
    }

    public int num()
    {
        int a=1;
        return a;
    }
}

public class Test2 {

    public static void main(String[] args){

        Exercise e=new Exercise();

        e.getb(1111);

        e.num();
    }

}

？？？？？？？？？？？？

课后作业

使用类的静态字段和构造函数，我们可以跟踪某个类所创建对象的个数。请写一个类，在任何时候都可以向它查询“你已经创建了多少个对象？”

public class Count {
    public static int number; 
    public Count()
    {
        number ++; //统计个数，每创建一个类, number++
    }
    
    public static int getValue()
    {
        return number;  //返回得到number的最终的值
    }
    
    public static void main (String args[])
    {
        Count c1 = new Count();
        Count c2 = new Count();
        Count c3 = new Count();
        Count c4 = new Count();
        System.out.println("创建对象的个数是:"+Count.getValue());
    }
}