3 动手动脑以及实验性操作总结体会

 1、运行以下代码，查看输出结果    

package demo;

public class test {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        Foo obj1=new Foo();
        Foo obj2=new Foo();
        System.out.println(obj1==obj2);
    }
}
class Foo{
    int value=100;
}

输出结果为 空白

分析：对象变量不可以判断是否相等

2、

public class test {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        Foo obj1=new Foo();
    }
}
class Foo{
    int value;
    public Foo(int initValue);
    value=initValue;
}

无法运行程序，因为类提供了一个自定义的构造方法，导致系统不再提供默认构造方法，
3、

public class test {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        InitializeBlockClass obj=new InitializeBlockClass();
        System.out.println(obj.field);
        
        obj=new InitializeBlockClass(300);
        System.out.println(obj.field);
    }
}
class InitializeBlockClass{
    {
        field=200;
    }
    public int field=100;
    public InitializeBlockClass(int value)
    {
        this.field=value;
    }
    public InitializeBlockClass()
    {}
}

输出结果：

总结：首先是执行对象的构造器方法，创建一个空的对象，然后对对象的字段赋予默认值。 然后依次对字段进行赋值，这个是字段初始化过程， 字段初始化完成之后再 执行类的{}语句块,如果有多个{}语句块，则按照代码顺序依次执行，{}语句执行完成之后，则执行构造器方法i = 2

4、当多个类之间有继承关系时，创建子类对象会导致父类初始化块的执行

    

class Fu{
    static
    {
        System.out.println("父类静态块");
    }
    public Fu(){
        System.out.println("父类构造方法");
    }
}

class Zi extends Fu{
    static
    {
        System.out.println("子类静态块");
    }
}

public class Test {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        new Zi();
    }
}

 

     创建子类型的对象时，会导致父类型的静态初始化块的执行。

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

（1）源代码

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();
        

    }
}

（2）运行结果截图

（3）总结静态初始化的执行顺序

      系统在类初始化阶段执行静态初始化块时，除了执行本类静态初始化块以外，还会一直上溯到java.lang.Object类，先执行java.lang.Object类中的静态初始化块，然后执行其父类的静态初始化块，最后才执行该类的静态初始化块。

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

 

public class Test1 {    
    protected String alpha;    
    public void mini()
    {        
        System.out.println("ssss");    
        }    
    public static void main(String[] args) 
    {            
        Test1 one = new Test1();                   
        one.mini();    
        }
    }

 

      在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。如果静态方法中必须要调用非静态方法，可以先new(实例)，之后通过new实例化的引用调用此类的方法。

7、不使用Eclipse，直接使用命令行运行Test1.java，Test2.Java，Test3.Java

（1）Test1.java

    

(2)Tes2t.java

   

(2)Test3,java