Java 第五周 动手动脑

一、以下代码为何无法通过编译？哪儿出错了？

原因分析：这是一个常见的构造错误，错误的自己构建了构造方法，导致系统无法正常的进行变量的构造，系统默认的构造方法无法正常运行

二、

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

    }

}

package demo;

public class Chushihua {

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

    }
    

}

package demo;

class Foo {
    int value;

}

原因：对象变量不能相互判断相等

 

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

源代码：

package demo;

class Root {
    static{
        System.out.println("Root的静态初始化块");
    }
    {
        System.out.println("Root的普通初始化块");
    }
    public Root()
    {
        System.out.println("Root的无参数的构造器");
    }
}

package demo;

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

}

package demo;

class Leaf extends Mid
{
    static
    {
        System.out.println("Leaf的静态初始化块");
    }
    {
        System.out.println("Leaf的普通初始化块");
    }    
    public Leaf()
    {
        //通过super调用父类中有一个字符串参数的构造器
        super("Java初始化顺序演示");
        System.out.println("执行Leaf的构造器");
    }
}

package demo;

public class TestStaticInitializeBlock {

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

    }

}

原因：

静态块在第一个对象创建时运行，初始化块在每一个对象创建时运行，区别是静态块只执行一次，操作的内存在静态区，初始化块每个对象构造时都需要执行一次，操作的内村在用户区

四、

源代码：

package demo;

class InitializeBlockClass {

    {
        field=200;
    }
    public int field=100;
    public InitializeBlockClass(int value)
    {
        this.field=value;
    }
    public InitializeBlockClass()
    {}
}

package demo;

public class Chushihua {

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

    }

}

程序截图：

原因分析：

类字段的初始化规律：1.执行类成员定义时指定的默认值或初始化块，到底执行哪一个要看哪一个排在前面。2:执行类的构造函数；

初始化第一次是用了类的初始化块，第二次用了public的int初始化，所以第二次覆盖了第一次，输出100；在main 函数InitializeBlockClass赋初值300，所以覆盖100，输出的是300

五、

源代码：

package demo;
//import jxlPacakge.MyPackageClass;
public class TTT {

    protected String alpha;    
    public void dt()
    {        
        System.out.println("abcd");    
        }    
    public static void main(String[] args) 
    {            
        TTT t = new TTT();                   
        t.dt();    
        }

}

程序截图：

原因分析：

程序最终都将在内存中执行，变量只有在内存中占有一席之地时才能被访问。

类的静态成员(变量和方法)属于类本身，在类加载的时候就会分配内存，可以通过类名直接去访问；非静态成员（变量和方法）属于类的对象，所以只有在类的对象产生（创建类的实例）时才会分配内存，然后通过类的对象（实例）去访问。

在一个类的静态成员中去访问其非静态成员之所以会出错是因为在类的非静态成员不存在的时候类的静态成员就已经存在了，访问一个内存中不存在的东西当然会出错

 

转载于:https://www.cnblogs.com/sist1437493141/p/4888568.html