类与对象 动手动脑

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

结果：

结果为False

当“==”施加于原始数据类型变量时，是比较变量所保存的数据是否相等 当“==”施加于引用类型变量时，是比较这两个变量是否引用同一对象。

obj1与obj2相当于两个对象。所以不同。

（3）

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

 这是构造方法，其方法名与类名相同，没有返回值，在创建类的对象时会自动调用该方法，该方法可以重载，创建对象时调用与之对应的构造方法。如果没有主动定义构造方法，系统会产生默认的构造方法。

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

结果：

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

先执行静态的初始化块，并且只执行一次，然后执行构造方法，若还有非静态初始化块，则在构造方法前执行

 （6）

package text;

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


}

输出诡异的结果，原因何在？

非new出来的Integer，如果数在-128到127之间，则是true,否则为false。

因为java在编译Integer i2 = 128的时候,被翻译成：Integer i2 = Integer.valueOf(128);

而valueOf()函数会对-128到127之间的数进行缓存。