JDK中的Object类

1 JDK类库的根类：Object

    1.1 这个老祖宗类中的方法我们需要先研究一下，因为这些方法都是所有子类通用的。

    任何一个类默认继承Object。就算没有直接继承，最终也会间接继承。

    

    1.2 Object类当中有哪些常用的方法？

        我们去哪里找这些方法呢？

            第一种方法：去源代码当中。（但是这种方式比较麻烦。源代码也比较难）

            第二种方法：去查阅java的类库的帮助文档。

            

        什么是API?

            应用程序编程接口。（Application Program Interface）

            每个JDK的类库就是一个javase的API。

            每一个API都会配置一套API帮助文档。

            SUN公司提前下好的这套类库就是API。（一般每一份API都对应一份API帮助文档。）

            

        目前为止我们只需要知道这几个方法即可。

        protected Object clone()  //负责对象克隆的

        int hashCode() // 获取对象哈希值的一个方法。

        String toString()  // 将对象转换成字符串形式

        boolean equals(Object obj)  // 获取对象哈希值的一个方法

        protected void finalize()  //垃圾回收器负责调用的方法

        

    1.3 toString()方法

        以后所有类的toString()方法是需要重写的。

        重写规则，越简单越明了就好。

        

        System.out.println(引用);这个会自动调用“引用.”的toString()方法。

        

        String类是SUN写的，toString()方法已经重写了。

        

        String类是SUN写的，toString方法已经重写了。

        

    1.4 equals()方法

        以后所有类的equals方法也需要重写，因为Object中的equals方法比较的是两个对象的内存地址，我们应该比较内容，所以需要重写。

        

        重写规则：自己定，主要看是什么和什么相等时表示两个对象相等。

        

        基本数据类型比较使用==

        对象和对象比较：调用equals方法

        

        String类是SUN编写的，所以String类的equals方法重写了。

        以后判断两个字符串是否相等，最好不要使用==，要调用字符串对象的equals方法。

        

        注意：重写equals方法的时候要彻底。

        

    1.5 finalize()方法。

        这个方法是protected修饰的，在Object类中这个方法的源代码是？

            protected void finalize() throws Throwable{ }

 

 

 

重写toString()方法的案例：

/*
* 关于Object类中的toString()方法
*   1 源代码长什么样？
*   public String toString(){
*       return this.getClass().getName() + "@" + Integer.toHexString(hashCode());
*   }
*   源代码上toString()方法默认实现是：
*       类名@对象的内存地址转换成十六进制的形式
*
*   2 SUN公司设计toString()方法的目的是什么？
*       toString()方法的作用是：
*           toString()方法的设计目的是：通过调用这个方法可以将一个“java对象”转换成“字符串”的形式。
*
*   3 其实SUN公司开发java语言的时候，建议所有的子类都去重写toString()方法。
*   toString()方法应该是一个简洁的、详实的、易阅读的。
* */
public class Test01 {
    public static void main(String[] args) {
        MyTime myTime = new MyTime(1970,1,1);
        // 一个日期对象转换成字符串形式的话，我可能还是希望看到具体的日期信息。
        String s1 = myTime.toString();


        //MyTime类重写toString()方法之前
        System.out.println(s1);// MyTime@十六进制   MyTime@10f87f48


        //MyTime类重写toString()方法之后
        System.out.println(myTime.toString());// 1970年1月1日


        // 注意：输出引用的时候，会自动调用该引用的toString()方法。
        System.out.println(s1);
    }
}


class MyTime{
    int year;
    int month;
    int day;


    public MyTime() {
    }


    public MyTime(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }


    // 重写toString()方法
    // 这个toString()方法怎么重写呢？
    // 越简洁越好，可读性越强越好
    // 向简洁的、详实的、易阅读的方向发展


    public String toString(){
       return this.year + "年" + this.month + "月" + this.day + "日";
    }
}

重写Object中的equals方法案例：

/*
* 关于Object类中的equals()方法
*   1 equals方法的源代码
*   public boolean equals(Object obj){
*       return (this == obj);
*   }
*   以上这个方法是Object类的默认实现
*
*   2 SUN公司设计equals方法的目的是什么？
*       以后编程的过程中，都要通过equals方法来判断两个对象是否相等。
*       equals方法是判断两个对象是否是相等的。
*
*   3 我们需要研究一下Object类给的这个默认的equals方法够不够用!!!!
*       在Object类中的equals方法当中，默认采用的是“==”判断两个java对象是否相等。
*       而“==”判断的是两个java对象的内存地址，我们应该判断两个java对象的内容是否相等，所以老祖宗的equals方法不够用。
*       需要子类重写equals。
*
*   4 判断两个java是否相等，不能用“==”，因为“==”比较的是两个对象的内存地址。
* */
public class Test02 {
    public static void main(String[] args) {
        // 判断两个基本数据类型的数据是否相等直接使用“==”就行。
        int a = 100;
        int b = 100;
        // 这个“==”是判断a中保存的100和b中保存的100是否相等。
        System.out.println(a == b);// true 相等  false 不相等


        // 判断两个java对象是否相等，我们怎么办？能直接使用“==”吗？
        // 创建一个日期对象是：1970年1月1日。
        MyTime1 t1 = new MyTime1(1970,1,1);// MyTime t1 = 0x1234;
        // 创建一个新的日期对象，但表示的日期也是：1970年1月1日。
        MyTime1 t2 = new MyTime1(1970,1,1);// MyTime t1 = 0x2345;


        // 测试一下：比较两个对象是否相等，能不能使用“==”？？？
        // 这里的“==”判断的是：t1中保存的对象地址和t2中保存的对象地址是否相等。
        System.out.println(t1 == t2);//false


        // 重写Object equals方法之前(比较的是对象的内存地址)
        /*boolean flag = t1.equals(t2);
        System.out.println(flag);*/


        // 重写Object equals方法之后(比较的是内容)
        boolean flag = t1.equals(t2);
        System.out.println(flag);


        MyTime1 t3 = new MyTime1(1970,1,22);
        boolean flag1 = t1.equals(t3);
        System.out.println(flag1);


        // 我们这个程序有bug吗？可以运行，但是效率怎么样？低（怎么改造）
        MyTime1 t4 = null;
        System.out.println(t1.equals(t4));
    }
}


class MyTime1{
    int year;
    int month;
    int day;


    public MyTime1() {
    }


    public MyTime1(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }


    // 默认的equals方法
    /*public boolean equals(Object obj){
       return (this == obj);
    }*/


    // 重写Object类的equals方法
    // 怎么重写？赋值黏贴。相同的返回值类型、相同的方法名、相同的形式参数列表。
    // equals到底应该怎么重写？你自己定，你认为两个对象什么相等的时候表示相等，你就怎么重写。
    /*public boolean equals(Object obj){
        // 当年相同，月相同，日也相同的时候，表示两个日期相同。
        // 两个对象相等。
        // 获取第一个日期的年月日
        // 获取第二个日期的年月日
        // 开始比对


        // 获取第一个日期的年月日
        int year1 = this.year;
        int month1 = this.month;
        int day1 = this.day;


        // 获取第二个日期的年月日
        *//*int year2 = obj.year;
        int month2 = obj.month;
        int day2 = obj.day;*//*


        if (obj instanceof MyTime1){
            MyTime1 t = (MyTime1)obj;
            int year2 = t.year;
            int month2 = t.month;
            int day2 = t.day;


            if (year1 == year2 && month1 == month2 && day1 == day2){
                return true;
            }
        }


        // 如果程序能够执行到此处表示日期不相等。
        return false;
    }*/


    // 改良equals方法
    /*public boolean equals(Object obj){
        // 如果obj是空，直接返回false
        if (obj == null){
            return false;
        }


        // 如果obj的类型不是MyTime1的话，也返回false
        if(!(obj instanceof MyTime1)){
            return false;
        }


        // 如果this和obj保存的内存地址相同，没必要比较了，直接返回true。
        // 内存地址相同的时候指向的堆内存的对象肯定是同一个咯。
        if (this == obj){
            return true;
        }


        // 程序能够执行到此处说明什么？
        // 说明obj不是null。obj是MyTime1类型。
        MyTime1 t = (MyTime1) obj;
        if(this.year == t.year && this.month == t.month && this.day == t.day){
            return true;
        }


        // 程序能到这里返回false
        return false;
    }*/


    // 再次改良
    /*public boolean equals(Object obj){
        // 如果obj是空，直接返回false
        if (obj == null){
            return false;
        }


        // 如果obj的类型不是MyTime1的话，也返回false
        if(!(obj instanceof MyTime1)){
            return false;
        }


        // 如果this和obj保存的内存地址相同，没必要比较了，直接返回true。
        // 内存地址相同的时候指向的堆内存的对象肯定是同一个咯。
        if (this == obj){
            return true;
        }


        // 程序能够执行到此处说明什么？
        // 说明obj不是null。obj是MyTime1类型。
        MyTime1 t = (MyTime1) obj;
        return this.year == t.year && this.month == t.month && this.day == t.day;
    }*/


    // 再再次改良
    public boolean equals(Object obj){
        // 如果obj是空，直接返回false
        if (obj == null && !(obj instanceof MyTime1)){
            return false;
        }


        // 如果this和obj保存的内存地址相同，没必要比较了，直接返回true。
        // 内存地址相同的时候指向的堆内存的对象肯定是同一个咯。
        if (this == obj){
            return true;
        }


        // 程序能够执行到此处说明什么？
        // 说明obj不是null。obj是MyTime1类型。
        MyTime1 t = (MyTime1) obj;
        return this.year == t.year && this.month == t.month && this.day == t.day;
    }
}

重写Object中equals()方法案例：

import java.util.Objects;


// String对象比较的时候必须使用equals方法。
public class Test03 {
    public static void main(String[] args) {
        /*Student a = new Student("123");
        Student b = new Student("123");


        System.out.println(a == b);
        System.out.println(a.equals(b));*/


        Student a = new Student(111,new String("123"));
        Student b = new Student(111,new String("123"));


        System.out.println(a == b);
        System.out.println(a.equals(b));
    }
}


class Student{
    // 学号
    int no; // 基本数据类型，比较时用==
    // 所在学校
    String school;// 引用数据类型，比较时用equals方法


    public Student() {
    }


    public Student(int no, String school) {
        this.no = no;
        this.school = school;
    }


    // 重写toString()方法
    public String toString(){
        return "学号" + no + "，所在学校名称" + school;
    }


    // 重写equals方法
    // 需求：当一个学生的学号相等，并且学校相同时，表示同一个学生
    // 思考：这个equals该怎么重写呢？
    // equals方法的编写模式都是固定的。架子都是差不多的
    public boolean equals(Object obj) {


        if (obj == null && !(obj instanceof Student)){
            return false;
        }


        if (this == obj){
            return true;
        }


        Student s = (Student)obj;
        return this.no == s.no && this.school.equals(s.school);


        // 字符串用双等号比较可以吗？
        // 不可以
        //return this.no == s.no && this.school == s.school;
    }
}

重写Object中equals()方法案例：

/*
* java语言当中的字符串String有没有重写toString方法，有没有重写equals方法。
*
* 总结：
*   1 String类已经重写了equals方法，比较两个字符串不能使用==，必须使用equals。
*   equals是通用的。
*
*   2 String类已经重写了toString()方法。
*
*   大结论：
*       java中什么类型的数据可以使用“==”来判断。
*           java中基本数据类型比较是否相等，使用==
*
*       java中什么类型的数据需要使用equals来判断。
*           java中所有的引用数据类型统一使用equals方法来判断是否相等。
*
*   这是规矩。
* */
public class Test04 {
    public static void main(String[] args) {


        // 大部分情况下，采用这样的方式创建字符串对象
        String s1 = "Hello";
        String s2 = "abc";


        // 实际上String也是一个类，不属于基本数据类型。
        // 既然String是一类，那么一定存在构造方法
        String s3 = new String("Test1");
        String s4 = new String("Test1");


        // new两次，两个对象内存地址，s3保存的内存地址和s4保存的内存地址不同。
        // == 判断的是内存地址。不是内容。
        System.out.println(s3 == s4);//false


        // 比较两个字符串能不能使用双等号？
        // 不能，必须调用equals方法。
        // equals才是判断对象的值。
        // String类已经重写equals方法了
        System.out.println(s3.equals(s4));


        // String类有没有重写toString()方法呢？
        String s = new String("xlWu");
        // 如果String没有重写toString()方法，输出结果：java.lang.String@十六进制地址
        // 经过测试：String类已经重写了toString()方法
        System.out.println(s.toString());//xlWu
        System.out.println(s);//xlWu
    }
}

重写Object中equals()方法要重写彻底案例：

import java.util.Objects;
// equals方法重写的时候要彻底。
public class Test05 {
    public static void main(String[] args) {
        //Address address = new Address("重庆","渝澳大道","招商锦星汇");
        User u = new User("zhangsan",new Address("重庆","渝澳大道","招商锦星汇"));
        User u1 = new User("zhangsan",new Address("重庆","渝澳大道","招商锦星汇"));


        System.out.println(u.equals(u1));


        User u2 = new User("zhangsan",new Address("重庆","渝澳大道","读书一村"));
        System.out.println(u.equals(u2));


    }
}


class User{
    //用户名
    String name;
    //地址
    Address addr;


    public User() {
    }


    public User(String name, Address addr) {
        this.name = name;
        this.addr = addr;
    }


    // 重写equals方法
    // 重写规则：当一个用户的用户名和家庭住址都相同，表示同一个用户。
    // 这个equals判断的是User对象和User对象是否相等。
    public boolean equals(Object obj) {
        // 用户名和用户名相同，住址和住址相同的时候，认定是同一个用户。
        if(obj == null && !(obj instanceof User)){
            return false;
        }


        if (this == obj){
            return true;
        }


        User user = (User)obj;
        if (this.name.equals(user.name) && this.addr.equals(user.addr)){
            return true;
        }


        return false;
    }
}


class Address{
    String city;
    String street;
    String zipcode;


    public Address() {
    }


    public Address(String city, String street, String zipcode) {
        this.city = city;
        this.street = street;
        this.zipcode = zipcode;
    }


    // 注意：这里并没有写
    // 这里的equals方法判断的是：Address对象和Address对象是否相等。
    public boolean equals(Object obj){
        if (obj == null && !(obj instanceof Address)){
            return false;
        }


        if (this == obj){
            return false;
        }
        Address address = (Address)obj;
        if (this.city.equals(address.city) && this.street.equals(address.street) && this.zipcode.equals(address.zipcode)){
            return true;
        }
        return false;
    }
}

 

Object中finalize()方法案例：

/*
* 关于Object类中的finalize()方法（非重点）
*   1 在Object类中的源码：
*       protected void finalize() throws Throwable{ }
*
*   GC:负责调用finalize()方法。
*
*   2 finalize()方法只有一个方法体，里面没有代码，而且这个方法是protected修饰的。
*
*   3 这个方法不需要程序员手动调用，JVM的垃圾回收器负责调用这个方法。
*   不像equals() toString(),equals()和toString()方法是需要你写代码调用的。
*   finalize()只需要重写，重写完将来自动还有程序来调用。
*
*   4 finalize()方法的执行机制：
*       当一个java对象即将被垃圾回收器回收的时候，垃圾回收器负责finalize()方法
*
*   5 finalize()方法实际上是SUN公司为java程序员准备的一个世纪，垃圾销毁机。
*   如果希望在对象销毁时机执行一段代码的话，这段代码要写到finalize()方法中。
*
*   6 静态代码块的作用是什么？
*   static{
*       ...
*   }
*   静态代码块在类加载时刻执行，并且只执行一次。
*   这是一个SUN准备的类加载时机
*
*   finalize()方法同样也是SUN为程序员准备的一个时机。
*   这个时机是垃圾回收时机。
*
*   7 提示：
*       java中的垃圾回收器不是轻易启动的，垃圾太少，或者时间没到，种种条件下，有可能启动，也有可能不启动。
* */
public class Test06 {
    public static void main(String[] args) {
        // 创建对象
        Person person = new Person();


        // 怎么把Person对象变成垃圾？
        person = null;


        // 多制造点垃圾
        for (int i = 0; i < 100000000; i++){
            Person p = new Person();
            p = null;
        }


        // 有一段代码可以建议垃圾回收器启动
        System.gc();// 建议启动垃圾回收器，（只是建议，可能不启动，也可能启动。启动概率高了一些。）
    }
}


/*
* 项目开发中有这样的业务需求：所有对象在JVM中被释放的时候，请记录一下释放时间！！！
* 记录对象被是释放的时间点，这个负责记录的代码写到哪里？
* 写到finalize()方法中。
* */
class Person{


    // 重写finalize()方法
    // Person类型的对象被垃圾回收器回收的时候，垃圾回收器负责调用：p.finalize()。
    protected void finalize() throws Throwable {
        // this代表当前对象
        System.out.println(this + "即将被销毁!");
    }
}

Object中的hashCode()方法案例：

 

/*
* hashCode方法
*   在Object中的hashCode方法是怎样的？
*       public native int hashCode();
*   这个方法不是抽象方法，带有native关键字，底层调用c++程序
*
*   hashCode()方法返回的是哈希值：
*       实际上就是一个java对象的内存地址，经过哈希算法，得出一个值。
*       所以hashCode()方法的执行结果可以等同看做一个java对象的内存地址。
* */
public class Test07 {
    public static void main(String[] args) {
        Object object = new Object();
        int hashCodeValue = object.hashCode();


        // 对象内存地址经过哈希算法转换的一个数字，可以等同看做内存地址
        System.out.println(hashCodeValue);//1915910607


        MyClass myClass = new MyClass();
        int hashCodeValue1 = myClass.hashCode();
        System.out.println(hashCodeValue1);//189568618
    }
}


class MyClass{ }

利用IDEA重写Object中的toString()和equals()方法案例：

 

import java.util.Objects;


/*IDEA自动生成重写方法*/


public class MyTime4 {
    private int year;
    private int month;
    private int day;


    public MyTime4() {
    }


    public MyTime4(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }


    public int getYear() {
        return year;
    }


    public void setYear(int year) {
        this.year = year;
    }


    public int getMonth() {
        return month;
    }


    public void setMonth(int month) {
        this.month = month;
    }


    public int getDay() {
        return day;
    }


    public void setDay(int day) {
        this.day = day;
    }


    public String toString() {
        return "MyTime4{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }


    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MyTime4 myTime4 = (MyTime4) o;
        return year == myTime4.year &&
                month == myTime4.month &&
                day == myTime4.day;
    }
}