java常用类Object类

java常用类Object类

Object类是所有类的公共的父类
Object类是类层次结构的跟类，每个类都使用Object类作为超类(包括数组)，所有对象都实现这个类的方法。
Object类常用的方法:
1.int hashCode()方法
2.Class<?> getClass()方法
3.String toString()方法
4.boolean equals()方法
5.Object clone()方法

hashCode()方法

hashCode()方法就是返回该对象的哈希值。是通过该对象的内部地址转换成一个整数来实现的，这样能保障每个对象的哈希值不一样。
哈希值和地址值是不同的，哈希值是通过哈希算法散列得来的，而地址值是通过和物理层有关的，是系统分配的，是不存在相同的，而哈希值是可以通过强制手段设置相同的，也就是哈希值是一种逻辑上的确保唯一性，而地址值就是一种物理上的确保唯一性。

public class MyTest {
    
    
    public static void main(String[] args) {
    
    
        Object obj = new Object();
        System.out.println(obj);       //打印obj对象的地址值
        System.out.println(obj.hashCode());    //打印obj对象的哈希值
        System.out.println("=================");
        Object obj2 = new Object();
        System.out.println(obj2);     //打印obj2的地址值
        System.out.println(obj2.hashCode());    //打印obj2的哈希值
    }
}

getClass()方法

getClass()方法就是返回Object运行时类。
可以通过Class类中的一个方法，获取对象的真实类的全名称。
Class <?>  Class这个类型，用来表示是 字节码文件类型
Object.java文件开始进行编译，然后编译文件Object.class加载进入内存，JVM虚拟机就会给Object.class创建对象，通过getClass()获取字节码文件对象。

public class MyTest {
    
    
    public static void main(String[] args) {
    
    
        Object obj = new Object();
        Class<?> objClass = obj.getClass();
        System.out.println(objClass);
        System.out.println("================");
        Object obj2 = new Object();
        Class<?> obj2Class = obj2.getClass();
        System.out.println(obj2Class);
        System.out.println(obj==obj2);   //false   地址不相同
        System.out.println(objClass==obj2Class);  //true  两个对象的类名称相同
    }
}

toString()方法

toString()返回该对象的字符串表示
源代码:
public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
它的值等于:
		getClass().getName() + "@" + Integer.toHexString(hashCode());
由于默认情况下的数据对我们没有意义，一般建议重写该方法。
一般都是将该类的所有成员变量组成返回即可。

public class MyTest {
    
    
    public static void main(String[] args) {
    
    
        Object obj = new Object();
        String s = obj.toString();
        System.out.println(obj);    //当你打印这个对象名时，这个对象名就是在调用toString()方法
        System.out.println(s);     //以后，当你输出一个对象名时，返回的不是地址值，那么就说明它重写
        System.out.println("=========");                       //过toString()方法
        Object obj2 = new Object();
        String s2 = obj2.toString();
        System.out.println(obj2);         
        System.out.println(s2);
    }
}

equals()方法

equals()指示其他某个对象是否与此对象“相等”。
源代码:
public boolean equals(Object obj) {
        return (this == obj);
    }
默认情况下比较的是对象的引用是否相等。
由于默认情况下的比较对我们没有意义，一般建议重写该方法，一般用于成员变量的值是否相等
==和equal的区别
==：
	基本类型:比的是值相等
	引用类型:比的是地址值是否相等
equals:
	基本类型：不是类，不能用equals()方法比较
	引用类型:分两种情况
1)在Object类中：==和equals没有区别，都是比较地址值
2)在String类中(对Object中的equals方法进行重写):equals比较的是两个对象的内容是否相等。

public class MyTest {
    
    
    public static void main(String[] args) {
    
    
        Object obj = new Object();
        Object obj2 = new Object();
        boolean b = obj.equals(obj2);
        System.out.println(b);   //false   地址值不同
        System.out.println(obj==obj2);  //false
        String s="abc";
        String s1="abc";
        boolean b1 = s.equals(s1);   //true  String类重写了equals方法比较的是两个对象的内容是否
        System.out.println(b1);                                               //相等
    }
}

clone()方法

clone()方法就是创建并返回此对象的一个副本
clone()方法修饰符是protected(受保护的)，在用的时候，需要该类重写此方法，并将修饰符改成(Public)。
clone()方法返回的是一个Object类型的对象，我们必须强制类型转换得到我们需要的类型。
Object类中的clone()方法执行特定的复制操作。首先，如果此对象的类不能实现接口Cloneable,则会抛出CloneNotsupportedException
Cloneable标记接口，就是接口中没有任何方法，就是给类打一标记，告诉JVM可能要实现某种操作，让JVM支持这种操作。
为了克隆能够被支持，需要该类实现Cloneable这个标记接口
克隆不会调用构造方法

public class MyTest2 {
    
    
    public static void main(String[] args) throws CloneNotSupportedException {
    
    
        Dog dog = new Dog("旺财", 5);
        Dog dog1 = (Dog) dog.clone();   //克隆dog对象
        System.out.println(dog1);   //dog1.toString() 打印dog1中的成员
    }
}
class Dog implements Cloneable{
    
    
    String name;
    int age;
    public Dog() {
    
    
    }
    public Dog(String name, int age) {
    
    
        this.name = name;
        this.age = age;
    }
    @Override   //重写clone()方法将protected修改成public
    public Object clone() throws CloneNotSupportedException {
    
      
        return super.clone();
    }
    @Override
    public String toString() {
    
    
        return "Dog{"+name+'\''+",age="+age+'}';   //重写toString()方法打印该类种的成员
    }
}

Object类中的clone()方法属于浅克隆
浅克隆:就是克隆一个对象时，如果克隆对象中维护另一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份。
深克隆:就是克隆一个对象时，如果克隆对象中维护另一个类的对象，这时候克隆是将另外一个对象的地址还有对象都克隆了一份。

public class MyTest3 {
    
    
    public static void main(String[] args) throws CloneNotSupportedException{
    
    
        PersonPlay personPlay = new PersonPlay("游戏");
        Person p = new Person("李四", 23,personPlay);
        Person p1 =(Person) p.clone();
        p.personPlay.name="游泳";
        p1.personPlay.name="聚会";
        System.out.println(p.personPlay.name);
        System.out.println(p1.personPlay.name);
    }
}
class Person implements Cloneable{
    
    
    String name;
    int age;
    PersonPlay personPlay;
    Person(){
    
    }
    Person(String name,int age,PersonPlay personPlay){
    
    
        this.name=name;
        this.age=age;
        this.personPlay=personPlay;
    }
    @Override
    public Object clone() throws CloneNotSupportedException {
    
    
        return super.clone();
    }
}
class PersonPlay{
    
    
    String name;
    PersonPlay(String name){
    
    
        this.name=name;
    }
}

上述代码内存图

从图中可以看出p1只是克隆了PersonPlay的地址并没有连对象一起克隆，所以clone()方法就是浅克隆