java第三讲-类与对象-ClassAndObjectSourceCode

1.通过对象变量使用对象

  1）直接调用类的方法；(添加和调用get()方法取值)
  2）存取类的字段；(设置公有字段)

public class ClassAndObjectTest {
    public static void main(String[] args)
    {
        //创建类的实例，定义一个对象变量引用这一实例
        MyClass obj = new MyClass();
        //通过对象变量调用类的公有方法
        obj.myMethod("Hello");
        //给属性赋值
        obj.setValue(100);
        //输出属性的当前值
        System.out.println(obj.getValue());
        //直接访问对象公有字段
        obj.Information = "Information";
        //输出对象公有字段的当前值
        System.out.println(obj.Information);
    }
}
 /**
  * 自定义Java类的示例
  */
class MyClass
{
    // 公有字段
    public String Information = "";
    // 自定义公有Java实例方法
    public void myMethod(String argu)
    {
        System.out.println(argu);
    }
    // 定义属性：私有字段+get方法+set方法
    private int value;
    public int getValue()
    {
        return value;
    }
    public void setValue(int value)
    {
        this.value = value;
    }
}

2.引用类型与原始数据类型

  1）引用类型：

• “引用”一个对象的变量称为“引用类型”的变量，有时又简称为“对象变量”。
• 当声明一个对象类型的变量时，实际上并没有创建一个对象，此变量=null。
• 不可以直接用 == 来判断值是否相等。只能是比较这两个变量是否引用同一对象，比较的是保存的地址值是否相等。

  2）原始数据类型：

• 诸如int，float之类的变量。
• 定义一个原始类型的变量时，会马上给其分配空间。
• 可以用 == 来比较变量所保存的数据是否相等。

3.Object类

Object 类是Java的最顶层基类

如果在定义类时，不显式指明他的父类时，则默认是Object。

4.Java字段初始化块规律

public class InitializeBlockDemo {
    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(){
    }
}

分析：

如果是上面这种情况，即在初始块之后，输出的结果是  100   300

如果是在初始快之前，输出的结果是  200   300

5.静态初始化块的执行顺序

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

结果：

总结：

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

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

6.包装类Integer，为什么数字一模一样却会判断为不相等呢

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

上网查阅：java Integer等号判断_默而生的博客-CSDN博客_integer判断等于1

-128到127之间不会封装对象而是用常量池的值，不在这个范围才会创建对象。

说明：对于Integer var= ？在-128到127范围内的赋值，Integer对象在IntegerCache.cache产生，会复用已有对象，这个区间的Integer值可以直接使用==进行判断，但是这个区间之外的所有数据都会在堆上产生，并不会复用已有对象，这是一个大坑，推荐使用equals方法进行判断。

所有整形包装类对象之间值的比较，全部使用equals方法比较。