Object类的方法

API

Application Programming Interface      应用程序编程接口

Object类

a.类层次结构的根类

b.所有类都直接或间接继承该类

构造方法

public object（）

hashCode ()方法

public int hashCode()             返回值对象的哈希码值

• 默认情况下，该方法会根据对象的地址来计算；

• 不同的对象的hashCode（）一般是不相同的，但是在同一个对象的hashCode()值是相同的；

• 不同对象的实际地址值，可以理解为逻辑地址值；

public class Mytest {
    public static void main(String[] args) {
        Object obj = new Object();
        //  int hashCode () 返回该对象的哈希码值。不同对象的哈希码值，是不一样的。
        System.out.println(obj);
        int i = obj.hashCode();
        System.out.println(i);
        Object obj2 = new Object();
        int i1 = obj2.hashCode();
        System.out.println(i1);


    }
}
结果：
java.lang.Object@1540e19d
356573597
1735600054

getClass（）方法

public final Class getClass（）             返回该类的字节码文件对象

• 返回此Object的运行时类
• 可以通过Class类中的一个方法，获取对象的真实类的全名称；

public class Mytest {
    public static void main(String[] args) {
        // Class<?> getClass () 返回该类的字节码文件对象
        Object obj = new Object();
        Class c1 = obj.getClass(); //Object.class---->字节码文件对象。
        Object obj2 = new Object();
        Class c2 = obj2.getClass();
        Object obj3 = new Object();
        Class c3= obj3.getClass();

        System.out.println(obj==obj2); //false
        System.out.println(c1==c2);
        System.out.println(c2==c3);

    }
}
结果：
false
true
true

public string getName（）

toString（）的方法

public string toString()             返回该对象的字符串表示；

 

源代码:
        public String toString() {
                        return getClass().getName() + "@" + Integer.toHexString(hashCode());
                }

值等于： 
        getClass().getName() + '@' + Integer.toHexString(hashCode()) 

利用软件重写toString（）方法 ， alt+insert   选toStirng()方法，就会重写 

public class Mytest {
    public static void main(String[] args) {
        Object obj = new Object();
        String s = obj.toString(); //获取该对象的地址值的字符串表现形式
        System.out.println(s);
        Object o = new Object();
        System.out.println(o.toString());
       
    }
}
结果：
java.lang.Object@1540e19d
java.lang.Object@677327b6

equals（）方法

public boolean equals（object obj）         比较两个人对象的引用（地址值）是否相同

• 由于比较对象的引用没有意义，一般建议重写该方法，比较成员变量的值是否相等；

==：

是比较运算符，一般用于比较基本数据类型和引用数据类型

        基本数据类型：比较两个对象的值的大小是否相等；

        引用数据类型：比较的是两个对象的地址值是否相等 ；

equals：

默认比较两个对象的地址值是否相等

• equals 方法的代码优化

1.提高效率；

2.提高健壮性（instanceof）；

package com.zhang.demo.Test;

public class Mytest {
    public static void main(String[] args) {
                Object obj = new Object();
                Object obj2 = new Object();
                // boolean equals (Object obj) 判断两个对象的地址值是否相同
                System.out.println(obj == obj2);
                boolean b = obj.equals(obj2);
                System.out.println(b);

                System.out.println("---------------------");
                Student s1 = new Student("张三", 23);
                Student s2 = new Student("张三", 23);
                System.out.println(s1 == s2);//false
               //重写之后的输出
               System.out.println(s1.equals(s2)); //true

                boolean b2 = s1.equals(s1);
                System.out.println(b2);

            }
        }

        class Student {
            private String name;
            private int age;

            public Student(String name, int age) {
                this.name = name;
                this.age = age;
            }

            @Override
            public boolean equals(Object obj) {
                //如果是自己跟自己比，直接就是true
                if (this == obj) {
                    return true;
                }
               //向下转型
                Student stu = (Student) obj;
                return this.name.equals(stu.name) && this.age == stu.age;

            }
}



结果：
false
false
---------------------
false
true
true

clone()方法

clone（）方法的权限修饰符是受保护的，使用的时候，该类重写该方法并把权限修饰符改为public；

    浅克隆 ：  

1. 如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。

2. Cloneable接口只不过是一个标识接口而已，没有任何方法。

3. 对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把 另外一个对象也克隆一份。

4. 对象的浅克隆也不会调用到构造方法的。

    深克隆：

克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象 克隆的时候不仅要克隆这个对象，还有克隆这个对象里面维护的那个对象

采用IO流来实现，使用 ObjectOutputStream 将对象写入文件中,然后再用ObjectInputStream读取回来

import java.io.ObjectOutputStream;
import java.util.zip.DeflaterOutputStream;


public class MyTest {

    public static void main(String[] args) throws CloneNotSupportedException {
        //克隆时注意两点：1.这个clone方法是一个受保护的方法，我们在使用时，需要子类重写一下，但是重写逻辑还是用父类的clone逻辑
        //2.这个类必须实现一个Cloneable接口，这样克隆才会被支持
        DogFood dogFood = new DogFood("王中王");
        Dog dog = new Dog("旺财", 3, dogFood);
        dog.dogFood.name = "双汇";
        Dog dog1 = (Dog) dog.clone();
        dog1.dogFood.name = "金锣";

        System.out.println(dog.dogFood.name);//
        System.out.println(dog1.dogFood.name);//

        new Object().hashCode();

        //对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份。
        //深克隆：克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象 克隆的时候不仅要克隆这个对象，还有克隆这个对象里面维护的那个对象  深克隆：可以通过序列化流来实现，后期学到IO流的时候讲
    }
}

class Dog implements Cloneable {
    public String name;
    public int age;
    public DogFood dogFood;

    public Dog() {
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public Dog(String name, int age, DogFood dogFood) {
        this.name = name;
        this.age = age;
        this.dogFood = dogFood;
    }
}

class DogFood {
    public String name;

    public DogFood(String name) {
        this.name = name;
    }
}


结果：
金锣
金锣

内存图：