java常用API-Object
Object类是java中所有类的祖宗类，因此，java中所有的类的对象都可以直接使用Object类中提供的一些方法
Clone-对象克隆
clone 就是复制 ， 在Java语言中， clone方法被对象调用，所以会复制对象。所谓的复制对象，首先要分配一个和源对象同样大小的空间，在这个空间中创建一个新的对象。
这和new 也是大同小异的：
new与clone创建对象的区别
new操作符的本意是分配内存。程序执行到new操作符时， 首先去看new操作符后面的类型，根据类型分配内存，再调用构造函数，填充对象的各个域，这一步就叫对象的初始化。初始化完毕后，可以把他的引用（地址）发布到外部，在外部就可以通过引用操纵这个对象。 clone在第一步是和new相似的，都是分配内存，调用clone方法时，分配的内存和源对象一样，然后再使用源对象中对应的各个域，填充新对象的域。同样可以可以把这个新对象的引用发布到外部 。
基本使用
本次就用users这个类来做实验
当然要注意的是在使用clone的时候，需要对象重写clone方法，对象才可以使用，并且要实现Cloneable这个接口
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();
}
}
然后就可以进行简单的克隆了
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方法是浅拷贝。
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方法，是浅拷贝的。
@Override
protected Object clone() throws CloneNotSupportedException {
Users clone = (Users) super.clone(); //基本的数据类型可以直接拷贝
//引用类型的数据就需要重新再复制一次，就可以实现深拷贝
clone.obj= clone.obj.clone();
return clone;
}
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-返回对象的字符串形式
一般都是让对象重写的方法，如果不重写那么返回的就是一个地址
主要作用：就是方便返回子类对象的内容
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 方法后：
返回的数据的样式是可以根据自己的需求来进行修改的
@Override
public String toString() {
return "Users{" +
"name='" + name + ''' +
", address='" + address + ''' +
", age=" + age +
", sex=" + sex +
", obj=" + Arrays.toString(obj) +
'}';
}
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 )-判断两个对象是否相等
一般都是让对象重写的方法，如果不重写那么就是基础的‘’==‘’ 判断，主要比较的就是两个对象的地址
public boolean equals(Object obj) {
return (this == obj);
}
主要作用：就是方便对象中特定内容的值是否相等
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等等
@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);
}
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存在的意义就是为了被子类重写，以便子类自己来定制比较规则（比如比较对象内容)。
