java常用API-Object

Object类是java中所有类的祖宗类，因此，java中所有的类的对象都可以直接使用Object类中提供的一些方法

Clone-对象克隆

clone 就是复制，在Java语言中， clone方法被对象调用，所以会复制对象。所谓的复制对象，首先要分配一个和源对象同样大小的空间，在这个空间中创建一个新的对象。

这和new 也是大同小异的：

new与clone创建对象的区别

new操作符的本意是分配内存 。程序执行到new操作符时，首先去看new操作符后面的类型，根据类型分配内存，再调用构造函数，填充对象的各个域，这一步就叫对象的初始化。初始化完毕后，可以把他的引用（地址）发布到外部，在外部就可以通过引用操纵这个对象。 clone在第一步是和new相似的，都是分配内存，调用clone方法时，分配的内存和源对象一样，然后再使用源对象中对应的各个域，填充新对象的域。同样可以可以把这个新对象的引用发布到外部。

基本使用

本次就用users这个类来做实验

当然要注意的是在使用clone的时候，需要对象重写clone方法 ，对象才可以使用，并且要实现Cloneable这个接口

typescript 复制代码

public class Users implements Cloneable {
    private String name;
    private String address;
    private int age;
    private char sex;
    private String[] obj;

    public Users() {
    }

    public Users(String name, String address, int age, char sex, String[] obj) {
        this.name = name;
        this.address = address;
        this.age = age;
        this.sex = sex;
        this.obj = obj;
    }

    public String getName() {
        return name;
    }

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public int getAge() {
        return age;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public String[] getObj() {
        return obj;
    }

    public void setObj(String[] obj) {
        this.obj = obj;
    }

  // 重写clone方法
   @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

然后就可以进行简单的克隆了

ini 复制代码

public class ObjectDemo1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        String[] s1={"hh","feig"};
        String[] s2={"hh","feiwg"};
        Users users=new Users("张三","重庆市",19,'男',s1);
        Users users1=new Users("张三","重庆市",19,'男',s2);
        Users clone = (Users) users.clone();
        System.out.println(clone);
        // 如果相等说明是同一个对象，就是浅拷贝
       System.out.println(clone);//Users{name='张三', address='重庆市', age=19, sex=男, obj=[hh, feig]}
  

    }
}

浅拷贝和深拷贝

上面age是基本数据类型，对它的拷贝直接将一个4字节的整数值拷贝过来就行。但name是String类型的，只是一个引用，指向一个真正的String对象，对它的拷贝有两种：

浅拷贝: 直接将源对象中的name的引用值拷贝给新对象的name字段；
深拷贝： 根据User源对象中的name指向的字符串对象创建一个新的相同的字符串对象，将这个新字符串对象的引用赋给新拷贝的User对象的name字段。

Java中的clone方法是浅拷贝。

ini 复制代码

public class ObjectDemo1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        String[] s1={"hh","feig"};
        String[] s2={"hh","feiwg"};
        Users users=new Users("张三","重庆市",19,'男',s1);
        Users users1=new Users("张三","重庆市",19,'男',s2);
        Users clone = (Users) users.clone();
        System.out.println(clone);
        // 如果相等说明是同一个对象，就是浅拷贝
        System.out.println(clone.getObj() == users.getObj());// true 
  

    }
}

== 如果两方是对象，那么比较的就是地址，所有上面克隆的对象和源对象的数组是指向的同一个地址，所以是浅拷贝

如果想要实现深拷贝， 可以通过覆盖重写Object中的clone方法的方式。要在clone对象时进行深拷贝，就要implements Clonable接口，覆盖并实现clone方法，除了调用父类中的clone方法得到新的对象， 还要将该类中的引用变量也clone出来。如果只是用Object中默认的clone方法，是浅拷贝的。

php 复制代码

@Override
protected Object clone() throws CloneNotSupportedException {
    Users clone = (Users) super.clone(); //基本的数据类型可以直接拷贝
    //引用类型的数据就需要重新再复制一次，就可以实现深拷贝
    clone.obj= clone.obj.clone();
    return clone;
}

ini 复制代码

public class ObjectDemo1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        String[] s1={"hh","feig"};
        String[] s2={"hh","feiwg"};
        Users users=new Users("张三","重庆市",19,'男',s1);
        Users users1=new Users("张三","重庆市",19,'男',s2);
        Users clone = (Users) users.clone();
        System.out.println(clone);
        // 如果相等说明是同一个对象，就是浅拷贝
        System.out.println(clone.getObj() == users.getObj());// false
  

    }
}

toString-返回对象的字符串形式

一般都是让对象重写的方法，如果不重写那么返回的就是一个地址

主要作用：就是方便返回子类对象的内容

ini 复制代码

public class ObjectDemo1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        String[] s1={"hh","feig"};
        String[] s2={"hh","feiwg"};
        Users users=new Users("张三","重庆市",19,'男',s1);
        Users users1=new Users("张三","重庆市",19,'男',s2);
        //没有重写toString 方法
         // System.out.println(users.toString());  直接打印是一个地址
        System.out.println(users.toString()); //常用API2.Users@cbdc0179
    }
}

当我们在对象中重写了toString 方法后：

返回的数据的样式是可以根据自己的需求来进行修改的

python 复制代码

@Override
public String toString() {
    return "Users{" +
            "name='" + name + ''' +
            ", address='" + address + ''' +
            ", age=" + age +
            ", sex=" + sex +
            ", obj=" + Arrays.toString(obj) +
            '}';
}

ini 复制代码

public class ObjectDemo1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        String[] s1={"hh","feig"};
        String[] s2={"hh","feiwg"};
        Users users=new Users("张三","重庆市",19,'男',s1);
        Users users1=new Users("张三","重庆市",19,'男',s2);
        //没有重写toString 方法
         // System.out.println(users.toString());  直接打印是一个地址
        System.out.println(users.toString()); //  //Users{name='张三', address='重庆市', age=19, sex=男, obj=[hh, feig]}
    }
}

equals(Object o )-判断两个对象是否相等

一般都是让对象重写的方法，如果不重写那么就是基础的''=='' 判断，主要比较的就是两个对象的地址

typescript 复制代码

public boolean equals(Object obj) {
    return (this == obj);
}

主要作用：就是方便对象中特定内容的值是否相等

ini 复制代码

public class ObjectDemo1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        String[] s1={"hh","feig"};
        String[] s2={"hh","feiwg"};
        Users users=new Users("张三","重庆市",19,'男',s1);
        Users users1=new Users("张三","重庆市",19,'男',s2);\
        //是两个不同的对象，地址是不相同的
       System.out.println(users.equals(users1)); //false
    }
}

当我们在对象中重写了equals 方法后，就可以根据需要来比较对象里面的值

比如只比较age，或者sex等等

ini 复制代码

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Users users = (Users) o;
    return age == users.age && sex == users.sex && Objects.equals(name, users.name) && Objects.equals(address, users.address) && Arrays.equals(obj, users.obj);
}

ini 复制代码

public class ObjectDemo1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        String[] s1={"hh","feig"};
        String[] s2={"hh","feiwg"};
        Users users=new Users("张三","重庆市",19,'男',s1);
        Users users1=new Users("张三","重庆市",19,'男',s2);\
        //是两个不同的对象，地址是不相同的
       System.out.println(users.equals(users1)); //false
    }
}

toString存在的意义: toString()方法存在的意义就是为了被子类重写，以便返回对象具体的内容。

equals存在的意义:直接比较两个对象的地址是否相同完全可以用"=="替代equals,equals存在的意义就是为了被子类重写，以便子类自己来定制比较规则（比如比较对象内容)。