10月14日课堂动手动脑

动手动脑

一、为何下面的代码无法编译

public class D1 {
public static void main(String[] args) {
    //int a=1;
    Foo f=new Foo();
    //System.out.println(f.value);
}
}
class Foo{
    int value;
    public Foo(int i)
    {
        value=i;
    }
}

原因是当类中有自己定义的构造函数时，初始化时要传参进行初始化。

如果类提供了一个自定义的构造方法，将导致系统不再提供默认构造方法。

二、

以下代码输出结果是什么？

public class InitializeBlockDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {

        InitializeBlockClass obj=new InitializeBlockClass();
        System.out.println(obj.field);

        obj=new InitializeBlockClass(300);
        System.out.println(obj.field);
    }

}

class InitializeBlockClass{
    //下面这句在初始化块之前与之后，会影响到field字段的初始值
    //public int field=100;

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

    }
}

结果是100和300

Java字段初始化的规律：

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

2.执行类的构造函数。

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

在Java中定义一个类后，有三种方式可以对其中的变量进行初始化：直接输入，初始化块，构造函数。

而对于这三者的优先级，其应该是：1.类的构造函数（构造方法）2.看类的初始化块和在执行类成员的时候默认给出的值是哪个排在类中的前面

三、静态初始化块的执行顺序

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

    }
}

结果：

Root的静态初始化块
Mid的静态初始化块
Leaf的静态初始化块
Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器，其参数值：Java初始化顺序演示
Leaf的普通初始化块
执行Leaf的构造器

结论：

静态初始化块只执行一次。

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

执行顺序:

1. 在加载类时执行一次静态初始化块（之后不再调用）。
2. 在每次初始化实例对象时：先执行非静态初始化块。
3. 再执行构造方法。

原文地址：https://www.cnblogs.com/a155-/p/11681849.html