十月21日作业 动手动脑

（1）

int value=100;

MyClass obj = new MyClass();

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

不一样，前者int是一种原始数据类型，直接进行定义和初始化就可以了。而后者是通过类名创建对象，再由对象创建对象变量，初始化需要依靠它本身的构造函数。

（2）

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

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

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

package text;

public class Text {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
  
        Foo obj1=new Foo();
        Foo obj2=new Foo();
        System.out.println(obj1==obj2);
    }
}
class Foo
{
   int value=100;    
}

得到的答案是一个（flase）

即，==两边是基本数据类型时，比较的是值的内容。而当他们是像class这样的再造数据类型的话，就是比较两者的地址，即是否是引用的同一对象。

(3)

请输入并运行以下代码，

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

很明显，这是一个构造方法，特点如下

1、构造方法名一定与类同名

2、构造方法无返回值类型（void 也不行）

3、构造方法可以没有（默认一个无参构造方法），也可以有多个构造方法，他们之间构成重载关系

4、如果定义有参构造函数，则无参构造函数将被自动屏蔽

5、构造方法不能被继承

6、构造方法不能手动调用，在创建类实例的时候自动调用构造方法

（4）

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

创建Foo的对象时，会调用其构造方法，却没有传进一个int型参数。如果类提供了一个自定义的构造方法，将导致系统不再提供默认构造方法。

 （5）

package text;

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{
    public int field=100;
    {
        field=200;
    }
    public InitializeBlockClass(int value){
        this.field=value;
    }
    public InitializeBlockClass(){
        
    }
}

结果是：200

           300

package text;

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的构造器

所以，我们由此可知：先执行静态的初始化块，并且只执行一次，之后才会执行构造方法，如果还有还有非静态初始化块，则会在构造方法之前执行