1、java数据类型
java数据类型分为基本数据类型和引用数据类型
基本数据类型：byte、short、int、long、float、double、boolean、char。
引用类型：常见的有类、接口、数组、枚举等。
2、浅拷贝、深拷贝
以下探讨的浅拷贝、深拷贝是通过Object类中的clone()方法进行的。
Object.java
protected native Object clone() throws CloneNotSupportedException;
2.1 浅拷贝：引用数据类型只复制引用。
Book.java
public class Book {
private String bookName;
private int price;
getter/setter
toString();
}
Persion.java
public class PeoSon implements Cloneable {
private int age;
private Book book;
public PeoSon(int age) {
this.age = age;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
getter/setter
toString();
}
测试:
Book book = new Book("编译原理", 10);
PeoSon p1 = new PeoSon(123);
p1.setBook(book);
PeoSon p2 = (PeoSon) p1.clone();
System.out.println(p1);
System.out.println(p2);
System.out.println("--------p1更改book的name值后--------");
p1.getBook().setBookName("java从入门到入坟");
System.out.println(p1);
System.out.println(p2);
打印结果:
PeoSon{age=123, book=Book{bookName=‘编译原理’, price=10}}
PeoSon{age=123, book=Book{bookName=‘编译原理’, price=10}}
--------p1更改book的name值后--------
PeoSon{age=123, book=Book{bookName=‘java从入门到入坟’, price=10}}
PeoSon{age=123, book=Book{bookName=‘java从入门到入坟’, price=10}}
可以看到，只修改了p1中引用对象book的名称，但是p2中引用对象book的名称也发生了变化！
原因： PeoSon p2 = (PeoSon) p1.clone() 是浅拷贝，p1、p2指向同一块堆内存空间。
修改图书名称后:
上述类PeoSon 类实现Cloneable 接口；使用clone()方法时，必须实现该接口并且复写clone()方法。
public interface Cloneable {
}
Cloneable 只是一个标记性接口，实现这个接口表明要重写clone()。
并且在Object类的clone()方法中也明确说明了：
if the class of this object does not implement the interface Cloneable , then a
CloneNotSupportedException is thrown.
/**
* Creates and returns a copy of this object. The precise meaning
* of "copy" may depend on the class of the object. The general
* intent is that, for any object {@code x}, the expression:
* <blockquote>
* <pre>
* x.clone() != x</pre></blockquote>
* will be true, and that the expression:
* <blockquote>
* <pre>
* x.clone().getClass() == x.getClass()</pre></blockquote>
* will be {@code true}, but these are not absolute requirements.
* While it is typically the case that:
* <blockquote>
* <pre>
* x.clone().equals(x)</pre></blockquote>
* will be {@code true}, this is not an absolute requirement.
* <p>
* By convention, the returned object should be obtained by calling
* {@code super.clone}. If a class and all of its superclasses (except
* {@code Object}) obey this convention, it will be the case that
* {@code x.clone().getClass() == x.getClass()}.
* <p>
* By convention, the object returned by this method should be independent
* of this object (which is being cloned). To achieve this independence,
* it may be necessary to modify one or more fields of the object returned
* by {@code super.clone} before returning it. Typically, this means
* copying any mutable objects that comprise the internal "deep structure"
* of the object being cloned and replacing the references to these
* objects with references to the copies. If a class contains only
* primitive fields or references to immutable objects, then it is usually
* the case that no fields in the object returned by {@code super.clone}
* need to be modified.
* <p>
* The method {@code clone} for class {@code Object} performs a
* specific cloning operation. First, if the class of this object does
* not implement the interface {@code Cloneable}, then a
* {@code CloneNotSupportedException} is thrown. Note that all arrays
* are considered to implement the interface {@code Cloneable} and that
* the return type of the {@code clone} method of an array type {@code T[]}
* is {@code T[]} where T is any reference or primitive type.
* Otherwise, this method creates a new instance of the class of this
* object and initializes all its fields with exactly the contents of
* the corresponding fields of this object, as if by assignment; the
* contents of the fields are not themselves cloned. Thus, this method
* performs a "shallow copy" of this object, not a "deep copy" operation.
* <p>
* The class {@code Object} does not itself implement the interface
* {@code Cloneable}, so calling the {@code clone} method on an object
* whose class is {@code Object} will result in throwing an
* exception at run time.
*
* @return a clone of this instance.
* @throws CloneNotSupportedException if the object's class does not
* support the {@code Cloneable} interface. Subclasses
* that override the {@code clone} method can also
* throw this exception to indicate that an instance cannot
* be cloned.
* @see java.lang.Cloneable
*/
protected native Object clone() throws CloneNotSupportedException;
2.2 深拷贝
Book.java
public class Book implements Cloneable{
private String bookName;
private int price;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
public Book(String bookName, int price) {
this.bookName = bookName;
this.price = price;
}
get/set
toString();
}
Person.java
public class PeoSon implements Cloneable {
private int age;
private Book book;
public PeoSon(int age) {
this.age = age;
}
@Override
protected Object clone() throws CloneNotSupportedException {
PeoSon p = (PeoSon) super.clone();
Book clone = (Book) book.clone();
p.setBook(clone);
return p;
}
get/set
toString();
}
注意：Book.java、Person.java 都实现了Cloneable接口并且复写了clone()方法。
测试：
Book book = new Book("编译原理", 10);
PeoSon p1 = new PeoSon(123);
p1.setBook(book);
PeoSon p2 = (PeoSon) p1.clone();
System.out.println(p1);
System.out.println(p2);
System.out.println("-----p1更改book的name值后-----");
p1.getBook().setBookName("java从入门到入坟");
System.out.println(p1);
System.out.println(p2);
PeoSon{age=123, book=Book{bookName=‘编译原理’, price=10}}
PeoSon{age=123, book=Book{bookName=‘编译原理’, price=10}}
-----p1更改book的name值后-----
PeoSon{age=123, book=Book{bookName=‘java从入门到入坟’, price=10}}
PeoSon{age=123, book=Book{bookName=‘编译原理’, price=10}}
可以看到修改p1中引用数据类型book的bookName属性值后，p2对应属性值不会发生改变。
原因：深拷贝会把所有属性值复制一份，因此改变一个对象的属性值后，其他对象不受影响。
在深度拷贝中，需要被拷贝的对象中的所有引用数据类型都实现Cloneable()接口并且重写clone()方法，如果一个对象有好多引用数据类型，则比较费劲，有没有其他方法呢 ? 使用序列化！
序列化是将对象写到流中便于传输，而反序列化则是把对象从流中读取出来。这里写到流中的对象则是原始对象的一个拷贝，因为原始对象还存在 JVM 中，所以我们可以利用对象的序列化产生克隆对象，然后通过反序列化获取这个对象。
注意每个需要序列化的类都要实现 Serializable 接口，如果有某个属性不需要序列化，可以将其声明为 transient，即将其排除在克隆属性之外。
public Object deepClone() throws Exception {
// 序列化
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
// 反序列化
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return ois.readObject();
}
简单使用案例:
public class CC2 implements Serializable {
private String color;
@Override
public String toString() {
return "CC2{" +
"color='" + color + '\'' +
'}';
}
public CC2(String color) {
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
public class BB2 implements Serializable {
private String name;
private int age;
private CC2 c;
public BB2() {
}
public BB2(String name, int age, CC2 c) {
this.name = name;
this.age = age;
this.c = c;
}
@Override
public String toString() {
return "BB2{" +
"name='" + name + '\'' +
", age=" + age +
", c=" + c +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public CC2 getC() {
return c;
}
public void setC(CC2 c) {
this.c = c;
}
}
public class AA2 implements Serializable {
private int age;
private BB2 b;
public AA2(int age, BB2 b) {
this.age = age;
this.b = b;
}
@Override
public String toString() {
return "AA2{" +
"age=" + age +
", b=" + b +
'}';
}
public Object deepClone() throws Exception {
// 序列化
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
// 反序列化
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return ois.readObject();
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public BB2 getB() {
return b;
}
public void setB(BB2 b) {
this.b = b;
}
}
public class TT2 {
public static void main(String[] args) throws Exception {
AA2 aa2 = new AA2(10, new BB2("李四", 20, new CC2("红色")));
AA2 o = (AA2) aa2.deepClone();
System.out.println(aa2);
System.out.println(o);
System.out.println("----------------------------------");
aa2.getB().setName("新的值");
System.out.println(aa2);
System.out.println(o);
}
}
参考链接
