第三次动手动脑

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

public class Test{    
       public static void main(String []args){
             Foo obj1=new Foo();
        }
}
class Foo{
    int value;
    public Foo(int initValue){
                value=initValue;
     }
}

错误在于在构造函数时有参数，在调用时没有填写int型的参数。

2.根据以下代码的输出结果，自行总结Java字段初始化的规律。

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

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

输出结果：在初始化之后200，300；在初始化在前100，300.

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

2）执行类的构造函数

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

3.运行TestStaticIniitializeBlock.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();
        

    }
}

1）静态初始化块只执行一次

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

4.一个有趣的问题

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

请编写代码验证你的想法

class Test{
    static int num;
    int qwe;
    static void foo() {
        num=0;
        Test t=new Test();
        t.qwe=0;
    }
}

5.Interger类的装箱和拆箱到底是怎样实现的？

装箱，自动根据数值创建对应的 Integer对象；拆箱，自动将包装器类型转换为基本数据类型。

6.两对整数明明完全一样，为何一个输出true，一个输出false？

public class Test 
{
    public static void main(String[] args)
    {
        Integer i1=100;
       
        Integer j1=100;
        
        System.out.println(i1==j1);

        
        Integer i2=129;
        
        Integer j2=129;
        
        System.out.println(i2==j2);
    }
}

在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象。

上面的代码中i1和i2的数值为100，因此会直接从cache中取已经存在的对象，所以i1和i2指向的是同一个对象，而i3和i4则是分别指向不同的对象。

第三次 动手动脑

猜你喜欢