Object基本方法以及浅克隆

Object：是所以类的主类

1. public int hashCode()：返回哈希码值，默认情况下，该方法会按照对象的地址来计算。
2. public final Class getClass()：返回此Object的运行时类。
3. public String toString()：返回对象的字符串表示，返回类名和它的引用地址。一般情况下，返回地址对我们没有用，所以很多类会重写此方法，例如String类，此方法返回的就是字面值。
4. public boolean equals(Object obj)：返回的是布尔类型。默认比较两个对象的引用，相同返回true，不同返回false。同样，比较地址值对我们没有意义，String类重写了此方法，比较的只是字面量。

public class Test {
    public static void main(String args[ ]){
        Object obj=new Object();
        System.out.println(obj.hashCode());
        System.out.println(obj.toString());
        obj="abc";
        System.out.println(obj.toString());
        Object obj2=new Object();
        obj2="abc";
        System.out.println(obj.equals(obj2));
    }
}

运行结果：
460141958
java.lang.Object@1b6d3586
abc
true

浅克隆clone
克隆对象最简单的一个方法是重新创建一个对象，然后将代克隆的每个成员属性的值都拷贝给新的对象的相应成员属性。但是，这种方法成本很高，尤其是当成员变量的类型是自定义的类时，这样做的代价是要写很多不必要的代码，而且很容易出错。因此，我们经常clone方法进行克隆，也就是浅克隆。
使用clone（）的注意事项：

1. clone（）方法的权限修饰符是protected（受保护的），因此我们在使用时需要重写此方法，将权限修饰符改为public即可。
2. 一个对象在用clone（）功能时，必须继承cloneable接口。cloneable接口只是一个接口，没有任何方法。
3. 具体调用clone（）的方法需要抛出异常，throws CloneNotSupportedException。
4. 调用clone()方法时，不会执行构造方法。

package demo2;
public class Test1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Dog d1 = new Dog("阿黄", 7);
        Dog d2 = (Dog) d1.clone();
        Dog d3=new Dog();
        System.out.println(d1);
        System.out.println(d2);
        System.out.println(d1.show());
        System.out.println(d2.show());
    }
}

class Dog implements Cloneable {
    String name;
    int age;
    public Dog(){
        System.out.println("空参构造执行");
    }
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String show() {
        return "名字：" + name + "   年龄：" + age;
    }

    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
运行结果：
空参构造执行
demo2.Dog@1b6d3586
demo2.Dog@4554617c
名字：阿黄   年龄：7
名字：阿黄   年龄：7

我们在使用clone方法时，要注意这仅仅是浅克隆。
对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份。

package demo2;
public class Test3 {
    public static void main(String[] args) throws CloneNotSupportedException{
        DogFood dogFood=new DogFood("王中王");
        Dog dog1=new Dog("大黄",22,dogFood);
        Dog dog2=(Dog)dog1.clone();
        System.out.println(dog1.toString());//大黄 22 王中王
        System.out.println(dog2.toString());//大黄 22 王中王
        dog1.dogfood.foodName="骨头";//改变原对象的引用，克隆对象的引用也会跟着改变。
        System.out.println(dog1.toString());//大黄 22 骨头
        System.out.println(dog2.toString());//大黄 22 骨头
    }
}
class Dog implements Cloneable{
    String name;
    int age;
    DogFood dogfood;
    public Dog(String name, int age,DogFood dogfood) {
        this.name = name;
        this.age = age;
        this.dogfood=dogfood;
    }
    public String toString(){
        return "姓名:"+name + "   年龄："+age + "    狗粮："+dogfood;
    }
    public Object clone() throws CloneNotSupportedException{
        return super.clone();
    }
}
class DogFood{
    String foodName;
    public DogFood(){}
    public DogFood(String foodName){
        this.foodName=foodName;
    }
    public String toString() {
        return foodName;
    }
}

运行结果：
姓名:大黄   年龄：22    狗粮：王中王
姓名:大黄   年龄：22    狗粮：王中王
姓名:大黄   年龄：22    狗粮：骨头
姓名:大黄   年龄：22    狗粮：骨头