JAVA笔记-12

== 和 equals 的对比

== (是一个比较运算符)

1. 既可以判断基本类型，又可以判断引用类型
2. 如果判断 基本类型，判断的是值是否相等
3. 如果判断 引用类型，判断的是地址是否相等，即判定是不是同一个对象

public static void main(String[] args) {
        A a = new A();
        A b = a;
        A c = b;
        System.out.println(a == c);
        System.out.println(b == c);
        B obj = a;
        System.out.println(obj == c);
        int num1 = 10;
        double num2 = 10.00;
        System.out.println(num1 == num2);

        //equals方法，源码查看
        //把光标放在equals方法上，直接键盘快捷键Ctrl+b
        "hello".equals("abc");

        //object 的 equals 方法默认就是比较对象的地址是否相同，也就是判断两个对象是否为同一对象
        /*
        public boolean equals(Object obj){
            return (this == obj);
        }
         */

        Integer integer1 = new Integer(1000);
        Integer integer2 = new Integer(1000);
        //为假判断的是地址或对象是否相等
        System.out.println(integer1 == integer2);
        //为真判断的是值是否相等
        System.out.println(integer1.equals(integer2));

        //判断字符串
        String s1 = new String("hello");
        String s2 = new String("hello");
        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));
    }
class A extends B{

}
class B{

}

equals是Object类中的方法，只能判断引用类型
默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等

public static void main(String[] args) {
        Person p1 = new Person("邪星",18, '男');
        Person p2 = new Person("邪星",18, '男');
        System.out.println(p1.equals(p2));
        //没有重写，调用的是object的equals方法，所以返回的是假
        //object的equals方法默认比较的是地址
    }
class Person{
    private String name;
    private int age;
    private char gender;

    /**
     * 重写object的equals方法
     */
    public boolean equals(Object obj){
        //如果比较的两个对象是同一个对象则直接返回true
        if (this == obj){
            return true;
        }
        //进行类型的判断，是Person，才进行比较
        if (obj instanceof Person){
            //进行类型转换，向下转型,因为需要得到obj的各个属性
            Person p = (Person) obj;
            return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;
        }
        return false;
    }
}

hashCode方法

1.提高具有哈希结构的容器的效率
2.两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
3.两个引用，如果指向的是不同对象，则哈希值是不一样的
4.哈希值主要根据地址号来的，不能完全将哈希值等价于地址
5.在后面学到集合的时候，hashCode如果需要的话，也会重写

    public static void main(String[] args) {
        AA aa = new AA();
        AA aa1 = new AA();
        AA aa2 = aa;
        System.out.println(aa.hashCode());
        System.out.println(aa1.hashCode());
        System.out.println(aa2.hashCode() == aa.hashCode());
    }
}
class AA {
    
}

toString方法

基本介绍：
默认返回：全类名(包名加类名) + @ + 哈希值的十六进制
子类往往重写toString方法，用于返回对象的属性信息
重写toString方法，打印对象或拼接对象时，都会自动调用该对象的toStrong形式
当直接输出一个对象时，toString方法会被默认调用

public static void main(String[] args) {
        Monster mon = new Monster("神魔","king",10000);
        System.out.println(mon);
    }

class AA{
    private String name;
    private String job;
    private double sal;
    
    /**
     * 重写toString方法
     */
    public String toString() {
        return "Monster{" +
                "name='" + name + '\'' +
                ", job='" + job + '\'' +
                ", sal=" + sal +
                '}';
    }
    
}

Finalize方法

1. 当对象被回收时，系统自动调用该对象的Finalize方法，子类可以重写该方法
   做一些释放资源的操作

2. 什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾
   对象，就会使用垃圾回收机制来销毁该对象，在销毁对象前，会先调用Finalize方法

3. 垃圾回收机制的调用，是由系统来决定的(即有自己的GC算法)，也可以通过System.gc();
   主动触发垃圾回收机制

public static void main(String[] args) {
        Car car = new Car("奔驰");
        //置空，这时car对象就是一个垃圾，垃圾回收器就会销毁car对象
        //在销毁对象前会调用对象的finalize方法
        //如果不重写finalize方法，那么就会调用object类的finalize，即默认处理
        //如果重写finalize方法，就可以实现一些自己的业务逻辑
        car = null;
        //主动调用垃圾回收器
        System.gc();
        System.out.println("程序退出...");
    }

class Car{
    private String name;

    public Car(String name) {
        this.name = name;
    }
    
    /**
     * 重写finalize方法
     */
    @Override
    protected void finalize() throws Throwable {
        System.out.println("销毁car对象" + name);
    }
}