我有一些代码使用 Object.clone 执行深层复制,但我正在尝试使用更“可接受”的复制构造函数技术重写它。下面是我正在尝试做的两个简单示例,第一个使用克隆,第二个使用复制构造函数。
使用克隆的深拷贝
import java.util.*;
abstract class Person implements Cloneable {
String name;
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class Teacher extends Person implements Cloneable {
int courses;
public String toString() { return name + ": courses=" + courses; }
}
class Student extends Person implements Cloneable {
double gpa;
public String toString() { return name + ": gpa=" + gpa; }
}
public class DeepCopy_Clone {
private static List<Person> deepCopy(List<Person> people) throws CloneNotSupportedException {
List<Person> copy = new ArrayList<Person>();
for (Person person : people) {
copy.add((Person)person.clone());
}
return copy;
}
public static void main(String[] args) throws CloneNotSupportedException {
ArrayList<Person> people = new ArrayList<Person>();
Teacher teacher = new Teacher();
teacher.name = "Teacher";
teacher.courses = 5;
people.add(teacher);
Student student = new Student();
student.name = "Student";
student.gpa = 4.0;
people.add(student);
List<Person> peopleCopy = deepCopy(people);
// Invalidate the original data to prove a deep copy occurred
teacher.name = null;
teacher.courses = -1;
student.name = null;
student.gpa = -1;
for (Person person : peopleCopy) {
System.out.println(person.toString());
}
}
}
使用拷贝构造函数进行深拷贝
import java.util.*;
abstract class Person {
String name;
public Person() {}
public Person(Person other) {
this.name = other.name;
}
public Person deepCopy() {
if (this instanceof Teacher) {
return new Teacher((Teacher)this);
} else if (this instanceof Student) {
return new Student((Student)this);
}
throw new Error("Unknown type of person");
}
}
class Teacher extends Person {
int courses;
public Teacher() {}
public Teacher(Teacher other) {
super(other);
this.courses = other.courses;
}
public String toString() { return name + ": courses=" + courses; }
}
class Student extends Person {
double gpa;
public Student() {}
public Student(Student other) {
super(other);
this.gpa = other.gpa;
}
public String toString() { return name + ": gpa=" + gpa; }
}
public class DeepCopy_ConstructorAlternative {
private static List<Person> deepCopy(List<Person> people) {
List<Person> copy = new ArrayList<Person>();
for (Person person : people) {
copy.add(person.deepCopy());
}
return copy;
}
public static void main(String[] args) {
ArrayList<Person> people = new ArrayList<Person>();
Teacher teacher = new Teacher();
teacher.name = "Teacher";
teacher.courses = 5;
people.add(teacher);
Student student = new Student();
student.name = "Student";
student.gpa = 4.0;
people.add(student);
List<Person> peopleCopy = deepCopy(people);
// Invalidate the original data to prove a deep copy occurred
teacher.name = null;
teacher.courses = -1;
student.name = null;
student.gpa = -1;
for (Person person : peopleCopy) {
System.out.println(person.toString());
}
}
}
我发现有趣的是,尽管在 Java 中一直在谈论克隆的弊端,但克隆替代方案需要更少的代码和更少的转换(至少在这种特殊情况下是这样)。
对于复制构造函数替代方案,我将不胜感激。你会做不同的事吗?谢谢。
最佳答案
代替:
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
我更愿意:
public Person clone() {
try {
return (Person) clone();
} catch (CloneNotSupportedException e) {
throw new RuntimeException("This should be impossible ...");
}
}
因此调用者不必处理永远不会发生的异常,也不必强制转换。
在复制构造函数方法中,类型切换更好地以多态方式处理:
abstract class Person {
...
public abstract Person deepCopy();
}
class Student {
...
public Student deepCopy() {
return new Student(this);
}
}
class Teacher {
...
public Teacher deepCopy() {
return new Teacher(this);
}
}
现在编译器可以检查您是否为所有子类型提供了深拷贝,并且您不需要任何转换。
最后,请注意克隆和复制构造函数方法都具有相同的公共(public) api(无论该方法称为 clone()
还是 deepCopy()
都没有很重要),所以你使用哪种方法是一个实现细节。复制构造函数方法更加冗长,因为您同时提供构造函数和调用该构造函数的方法,但它可以更容易地泛化为通用类型转换工具,允许诸如:
public Teacher(Person p) {
...
say("Yay, I got a job");
}
建议:如果您只想要一个相同的副本,请使用克隆;如果您的调用者可能希望请求特定类型的实例,请使用复制构造函数。
关于java - 使用复制构造函数而不是 Object.clone 进行深度复制的正确方法,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/4199429/