java学习class5

一.Java字段初始化的规律

1.源代码

package class5;


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(){
        
    }
}

2.结果截图

3.Java字段初始化的规律

a.有参构造函数与无参构造函数执行的先后，在于什么时候创建该类型对象

b.调用无参的构造函数时，按照类中的顺序执行，后面的数值将同名的数值的值覆盖掉，之后才会去调用构造函数

c.调用有参的构造函数时，直接执行有参构造函数中的内容，不执行类的其他内容

二.Java静态初始化块的执行顺序

1.源代码

package class5Task;

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静态初始化块执行顺序

a.如果存在静态初始化，则先创建静态初始化块

b.如果该类存在父类，则先创建该父类的静态初始化块，之后直接创建该类的静态初始化块

三.在静态方法中访问类的实例成员（即没有附加static关键字的字段或方法）

1.源代码

package class5Task;

public class VisitnotStatic {

    private int num = 0;
    
    public static int test(VisitnotStatic a)//用来测试
    {
        int result;
        result = a.num;
        result = 1;
        return result;
    }
    
    public static void main(String[] args)
    {
        VisitnotStatic a = new VisitnotStatic();
        System.out.println(test(a));
    }

}

2.结果截图

3.设计思想

a.静态方法中只允许访问静态数据，所以，为了在静态方法中访问类的实例成员，就需要创建一个对象。通过这个对象来完成对非静态变量的访问。

b.所以就创建了一个函数，以一个类的对象作为参数，对这个对象的值进行了更改，在返回更改之后的结果。

c.输出修改之后的值，并在主函数中创建对象，调用刚刚的函数。

d.输出结果，验证是否成功

e.结果与预期的相同，成功对非静态的变量进行了访问，并进行了修改。

四.同名类的构造问题

1.源代码

package class5Task;

public class Test {

    public static void main(String[] args) 
    {
        Foo obj1 = new Foo();
    }

}
class Foo
{
    int value;
    public Foo(int initValue)
    {
        value = initValue;
    }
}

2.结果截图

3.分析原因

在类中自定义了一个构造函数后，系统就不会执行默认的构造函数，也就是说调用构造函数时，必须加上相应的参数。

四.同名类的构造问题

1.源代码

 1 package class5Task;
 2 
 3 public class Test {
 4 
 5     public static void main(String[] args) 
 6     {
 7         Foo obj1 = new Foo();
 8     }
 9 
10 }
11 class Foo
12 {
13     int value;
14     public Foo(int initValue)
15     {
16         value = initValue;
17     }
18 }

2.结果截图

3.分析原因

在类中自定义了一个构造函数后，系统就不会执行默认的构造函数，也就是说调用构造函数时，必须加上相应的参数。