动手动脑二

一丶

int value=100;
MyClass obj = new MyClass();
这两种方式定义的变量是不一样的，第一种是原始数据类型定义的变量，而第二种是通过引用类名创建一个对象obj出来，obj称为对象变量。

二丶对象变量判断相等

int value1=100;

intvalue2=100;

System.out.println(value1==value2);//true

对于原始数据类型的变量（比如int)，可以直接使用“==”判断两变量值是否相等
但是对于对象变量，无法用“==”来进行判断。

public class ClassAndobject {
    public static void main(String[] args) {
        MyClass obj1=new MyClass();
        MyClass obj2=new MyClass();
        System.out.println(obj1==obj2);//false
    }

class MyClass {
    int value=100;

}

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

如果要比较两个对象的内容是否一致，就意为字段一致的内容，用equals

如上述内容可以把输出语句改为     

package test3;

public class ObjectEquals {

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

}
class MyTestClass
{
    public int Value;
    public boolean equals(MyTestClass obj)
    {
        return obj.Value==this.Value;
    }
    public MyTestClass(int initValue)
    {
        Value=initValue;
    }
}

三丶构造函数
    public MyTestClass(int initValue)
    {
        Value=initValue;
    }
这个是类的构造函数，当创建一个对象时，它的构造方法会被自动调用。构造方法与类名相同，没有返回值。
如果类没有定义构造函数，Java编译器在编译时会自动给它提供一个没有参数的“默认构造方法”


上述自定义了一个构造函数，那么系统就不会再提供默认的构造函数，所以错了。
四丶类字段的初始化顺序

package test3;
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(){
        
    }
}

结果是：
200
300
五丶

package test3;


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

1 静态初始化块的优先级最高，也就是最先执行，并且仅在类第一次被加载时执行

2 非静态初始化块和构造函数后执行，并且在每次生成对象时执行一次；

3 非静态初始化块的代码会在类构造函数之前执行。

六丶神奇的Integer

package test3;

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

非new出来的Integer，如果数在-128到127之间，则是true,否则为false。因为java在编译Integer i2 = 128的时候,被翻译成：Integer i2 = Integer.valueOf(128);而valueOf()函数会对-128到127之间的数进行缓存。