第三讲课后作业2

1）

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

　　int value=100;

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

　　MyClass obj = new MyClass();

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

 【答】：一样，都是类的实例化，只不过第一个是简化的写法，第二个是正常定义对象的方式。

2）

Ø对于原始数据类型的变量（比如int)，可以直接使用“==”判断两变量值是否相等

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

【答】：一般情况下不能，除非是同一个对象才可以判断是否相等。

　　　　Ø当“==”施加于原始数据类型变量时，是比较变量所保存的数据是否相等

　　　　Ø当“==”施加于引用类型变量时，是比较这两个变量是否引用同一对象。

　　　　Ø引用代表地址，所以“==”实际上相当于比较两个引用类型变量中保存的对象地址是否相同。

3）

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

 

【答】

1.此方法的名称与类名相同，

2.此方法对类中的变量进行了赋值，

3.方法前面用Public修饰

Ø上页幻灯片所标出的方法，称为类的“构造方法”，有时也习惯称为“构造函数”

Ø当创建一个对象时，它的构造方法会被自动调用。构造方法与类名相同，没有返回值。

Ø如果类没有定义构造函数，Java编译器在编译时会自动给它提供一个没有参数的“默认构造方法”。

4）

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

 

【答】

Foo类重构了构造函数，但是没有写无参的构造函数。所以在主函数中声明对象时，调用无参构造函数失败，报错。

5）

 

使用上页幻灯片中定义的类，以下代码输出结果是什么？

 

代码：

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

}
}

结果截图：

 

6）

请运行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();

}
}

运行截图：

静态初始化块的执行顺序：

【答】：

静态初始化块总是最先执行，再执行public函数，最后执行函数。

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

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

7）

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

在类的静态方法中访问实例对象首先需要实例化

代码：

public class JingTaiHanShu {

     int x = 3;

     static int  y = 4;

     public static void Method()//静态方法

      {  

       System.out.println("实例变量x = " + new JingTaiHanShu().x);/    System.out.println("静态变量y = " + y);     }

 

     public static void main(String[] args)

        {

        JingTaiHanShu.Method();

        JingTaiHanShu ex = new JingTaiHanShu();

            System.out.println("x = " + ex.x);

        }

}

结果截图：

8）

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

【答】：

输出结果表明i1和i2指向的是同一个对象，而i3和i4指向的是不同的对象。此时只需一看源码便知究竟。

  下面这段代码是Integer的valueOf方法的具体实现：

public static Integer valueOf(int i) {
        if(i >= -128 && i <= IntegerCache.high)
            return IntegerCache.cache[i + 128];
        else
            return new Integer(i);
    }

  而其中IntegerCache类的实现为：

 private static class IntegerCache {
        static final int high;
        static final Integer cache[];

        static {
            final int low = -128;

            // high value may be configured by property
            int h = 127;
            if (integerCacheHighPropValue != null) {
                // Use Long.decode here to avoid invoking methods that
                // require Integer‘s autoboxing cache to be initialized
                int i = Long.decode(integerCacheHighPropValue).intValue();
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - -low);
            }
            high = h;

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

        private IntegerCache() {}
    }

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

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