java Object类中常用API分享
作者：闲不住的码
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方法，是浅拷贝的。
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存在的意义就是为了被子类重写，以便子类自己来定制比较规则（比如比较对象内容)。
到此这篇关于java Object类中常用API分享的文章就介绍到这了,更多相关java object API内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！