Object类详解

免责声明：java基础资料均来自于韩顺平老师的《循序渐进学Java零基础》教案，具体视频内容可以去B站观看，这些资料仅用于学习交流，不得转载用于商业活动

1.1 equals方法

1.1.1 ==和equals的对比

1. ==是一个比较运算符
2. ==：既可以判断基本类型，又可以判断引用类型
3. ==：如果判断基本类型，判断的是值是否相等
4. ==：如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象
5. equals：是Object类中的方法，只能判断引用类型
6. 默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等

1.1.2  Object的equals方法

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

1.1.3 String类重写equals方法

//String类的equals把Object的equals方法重写了，变成了比较两个字符串值是否相同
    @Override
    public boolean equals(Object anObject){
        if(this == anObject) {//如果是同一个对象
            return true;//true
        }
        if(anObject instanceof String){//判断类型
            String anotherString=(String) anObject;//向下转型
            int n=value.length;
            if(n == anotherString.value.length){//如果长度相同
                char v1[] = value;
                char v2[] = anObject.value;
                int i = 0;
                while(n-- != 0){//然后一个一个的比较字符
                    if(v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;//如果两个字符串的所有字符都相等，则返回true
            }
        }
        return false;//如果比较的不是字符串，则返回false
    }

1.1.4 Integer类重写equals方法

    //Integer也重写了Object的equals方法，
    //变成了判断两个值是否相同
    public boolean equals(Object obj){
        if(obj instanceof Integer){
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

Equals01.java

public class Equals01 {
    public static void main(String[] args){
        A a = new A();
        A b = a;
        A c = b;
        System.out.println(a == c);//true
        System.out.println(b == c); //true
        B bObj = a;
        System.out.println(bObj == c);//true
        int num1 = 10;
        double num2 = 10.0;
        System.out.println(num1 == num2); //基本数据类型，判断值是否相等

        Integer integer1 = new Integer(1000);
        Integer integer2 = new Integer(1000);
        System.out.println(integer1 == integer2); //false
        System.out.println(integer1.equals(integer2));//true

        String str1 = new String("hello");
        String str2 = new String("hello");
        System.out.println(str1 == str2); //false
        System.out.println(str1.equals(str2)); //true
    }

}

class B{}
class A extends B{}

1.1.5 如何重写equals方法

例如：判断两个Person对象的内容是否相等，如果两个Person对象的各个属性值都一样则返回true,否则返回false

public class Equals02 {
    public static void main(String[] args){
        Person person1 = new Person("jack",10,'男');
        Person person2 = new Person("jack",20,'男');
        System.out.println(person1.equals(person2));//false

        //当使用 == 来判断两个变量是否相等时，如果两个变量是基本类型变量，
        // 且都是数值类型（不一定要求数据类型严格相同），则只要两个变量的值相等，就返回true。
        int i = 65;
        float f = 65.0f;
        System.out.println("65和65.0f是否相等？"+(i == f));//true
    }
}

//判断两个Person对象的内容是否相等
//如果两个Person对象的各个属性值都一样，则返回true,否则返回false
class Person{//extends Object
    private String name;
    private int age;
    private char gender;

    public Person(String name,int age,char gender){
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public String getName(){
        return name;
    }

    public void setName(String name){
        this.name = name;
    }

    public int getAge(){
        return age;
    }

    public void setAge(int age){
        this.age = age;
    }

    public char getGender(){
        return gender;
    }

    public void setGender(char gender){
        this.gender = gender;
    }

    //重写Object的equals方法
    public boolean equals(Object obj){
        //判断如果比较的两个对象是同一个对象，则返回true
        if(this == obj){
            return true;
        }

        //类型判断
        if(obj instanceof Person){//是Person，我们才比较
            //进行向下转型，因为我们需要得到obj的各个属性
            Person p = (Person) obj;
            return this.name.equals(p.name)
                    && this.age == p.age
                    && this.gender == p.gender;
        }
        //如果不是Person，则直接返回false
        return false;
    }
}

1.2 hashCode方法

小结：

1. 提高具有哈希结构的容器的效率
2. 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
3. 两个引用，如果指向的是不同对象，则哈希值是不一样的
4. 哈希值主要根据地址号来的，不能完全将哈希值等价于地址

public class HashCode_ {
    public static void main(String[] args){
        AA aa = new AA();
        AA aa2 = new AA();
        AA aa3 = aa;
        System.out.println("aa.hashCode=" + aa.hashCode());//aa.hashCode=1627674070
        System.out.println("aa2.hashCode=" + aa2.hashCode());//aa2.hashCode=1360875712
        System.out.println("aa3.hashCode=" + aa3.hashCode());//aa3.hashCode=1627674070
    }
}

class AA{}

1.3 toString方法

1）基本介绍

默认返回：全类名+@+哈希值的十六进制

子类往往重写toString方法，用于返回对象的属性信息

2）重写toString方法，打印对象或拼接对象时，都会自动调用该对象的toString形式

3）当直接输出一个对象时，toString方法会被默认的调用，比如System.out.println(monster);就会默认调用monster.toString()

1.3.1 Object的toString()源码

    /*
    * Object的toString()源码
    * （1）getClass().getName()类的全类名（包名+类名）
    * （2）Integer.toHexString(hashCode())将对象的hashCode值转换成16进制字符串
    * */
    public String toString(){
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
}

1.3.2 重写toString()方法

public class ToString_ {                                                          
    public static void main(String[] args) {                                      
        Monster monster = new Monster("小钻风","巡山的",1000);                          
        System.out.println(monster.toString() + "hashCode" + monster.hashCode()); 
        System.out.println("==当直接输出一个对象时，toString方法会被默认调用==");                    
        System.out.println(monster);//等价于monster.toString();                      
    }                                                                             
                                                                                  
}                                                                                 
                                                                                  
class Monster{                                                                    
    private String name;                                                          
    private String job;                                                           
    private double salary;                                                        
                                                                                  
    public Monster(String name,String job,double salary){                         
        this.name = name;                                                         
        this.job = job;                                                           
        this.salary = salary;                                                     
    }                                                                             
                                                                                  
    //重写toString方法，输出对象的属性                                                        
    //使用快捷键即可 alt+insert->toString                                                
                                                                                  
    @Override                                                                     
    public String toString() {   //重写后一般是把对象的属性值输出，当然程序员也可以自己定制                   
        return "Monster{" +                                                       
                "name='" + name + '\'' +                                          
                ", job='" + job + '\'' +                                          
                ", salary=" + salary +                                            
                '}';                                                              
    }                                                                             
}                                                                                 

1.4 finalize方法

1. 当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，做一些释放资源的操作
2. 什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁对象前，会先调用finalize方法
3. 垃圾回收机制调用，是由系统来决定（即有自己的GC算法），也可以通过System.gc()主动触发垃圾回收机制
4. 在实际开发中，几乎不会运用finalize,所以更多就是为了应付面试

public class Finalize_ {
    public static void main(String[] args){
        Car bmw = new Car("宝马");
        //这时car对象就是一个垃圾，垃圾回收器就会回收(销毁)对象,在销毁对象之前，会调用该对象的finalize方法
        //程序员就可以在finalize中，写自己的业务逻辑代码（比如释放资源：数据库连接，或者打开的文件...）
        //如果程序员不重写finalize，那么就会调用Object类的finalize，即默认处理
        bmw = 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("我们销毁 汽车" + name);
        System.out.println("释放了某些资源...");
    }
}