03-类与对象——课后动手动脑

1.早期我们经常这样定义变量

             int value=100；

     前面的示例中这样定义变量

             MyClass obj = new MyClass();

这两种方式定义的变量是一样的吗？

这两种方式定义的变量是一样的，因为它们都是类的实例化，只是第一种是一个简便的写法，第二种是正常的对类进行实例化。

2.对象变量也可以使用“==”判断两变量值是否相等吗？

当“==”施加于引用类型变量时，是比较这两个变量是否引用同一对象，换句话说，“==”实际上相当于比较两个引用类型变量中保存的对象地址是否相同。

在Java中要比对两个对象的字段值，可以重写基类的equals（）方法。将其改成自己类的一个方法用来调用。

3.请输入并运行以下代码，得到什么结果？

public class Test {

    public static void main(String[] args) {
        Foo obj1=new Foo();
        Foo obj2=new Foo();
        System.out.println(obj1==obj2);
    }

}
class Foo{
    int value=100;
}

运行结果：

原因：按照第2条，我们可知，“==”实际上相当于比较两个引用类型变量中保存的对象地址是否相同。obj1和obj2虽然都是Foo类型的变量，但其指向的空间或者地址不同，所以输出的是false。

4.

请总结一下，这个方法有哪些“与众不同之处”，你能列出几条？

 1.方法名与类名完全相同。

2.无返回值，也没有void关键字。

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

原因：在类中如果提供了一个构造函数，那么在进行类的实例化时，调用的就是这个构造函数。此例中，Foo类本身提供了一个有参构造函数，这就导致系统不会提供默认的构造函数，那么定义obj1时就无法调用无参构造函数，所以整个程序当中会出现错误。

 6.如果一个类中既有初始化块，又有构造方法，同时还设定了字段的初始值，谁说了算？

例：

public class InitializeBlockClass {

    {
        
        field = 200;
        
    }
    
    public int field = 100;
    
    public InitializeBlockClass(int value){
        
        this.field = value;
        
    }
    
    public InitializeBlockClass(){
        
    }
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        InitializeBlockClass obj = new InitializeBlockClass();
        
        System.out.println(obj.field);
        
        
        obj = new InitializeBlockClass(300);
        
        System.out.println(obj.field);
        
    }

}

运行结果：

Java字段初始化的规律：

如果有多个不同地方对字段进行初始化，那么该字段的最终取值取决于最后一次初始化。

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

TestStaticInitializeBlock.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.创建子类型的对象时，也会导致父类型的静态初始化块的执行。

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

在静态方法中使用new进行实例化，然后再调用非静态成员。

例：

public class Task {
    
    public int a = 2;
    
    static int b = 3;
    
    static void display()
    
    {
        
        Task t1 = new Task();
        
        System.out.println("a="+t1.a);
        
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Task t2 = new Task();
        
        t2.display();
        
    }

}

执行结果：

9.请看以下的神奇代码：

public class StrangeIntegerBehavior { 

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

}

执行结果：

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

 首先，利用javap对该程序进行反汇编。结果如图：

可以看到其调用了Integer中的valueOf方法，valueOf方法的源代码为：

可以看到，valueOf(int i)调用了IntegerCache.cache，通过网上查找，我得到了它的源代码如下：

private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }

通过这两段代码，我们可知，在[-128,127]这个区间中“”==”比较的是这两个数的数值，但当超出这个范围时，其就会创建一个新的对象，对于对象来说，我们是无法通过“==”进行比较的，因为“==”比较的是这两个对象所指向的空间是否相同，所以第二个会输出false。