完成clone

mthli · mthli · commit a7a0e9fd4498 · 2014-05-02T13:07:19.000Z
diff --git a/Part6/clone/CloneTest.java b/Part6/clone/CloneTest.java
@@ -0,0 +1,43 @@
+package clone;
+
+/* 
+ * 以下实现的是深拷贝；
+ * 而Java默认的是浅拷贝，
+ * 浅拷贝并没有克隆包含在对象中的内部对象；
+ * 通常来说，使用浅拷贝的情况下，
+ * 如果原始对象与浅克隆对象共享的子对象是不可变的话，
+ * 将不会产生任何问题；
+ * 但更常见的情况是子对象可变，
+ * 所以必须重新定义clone方法，
+ * 以便实现克隆子对象的深拷贝
+ *
+ * 对于每一个类，都需要做出下列判断：
+ * 1. 默认的clone方法是否满足需求
+ * 2. 默认的clone方法是否能够通过调用可变子对象的clone得到修补
+ * 3. 是否应该不是用clone
+ * 实际上，选项3是默认的。如果要选择1或2，类必须：
+ * 1. 实现Cloneabel接口
+ * 2. 使用public访问修饰符重新定义clone方法
+ *
+ * 注意，在Object类中，clone被声明为protected，
+ * 因此无法直接调用anObject.clone()（参阅《Core Java Volumn I》第五章内容）。
+ * 子类只能调用受保护的clone方法克隆它自己。
+ * 为此，必须重新定义clone方法，并将它声明为public，
+ * 这样才能让所有方法克隆对象
+ */
+public class CloneTest {
+    public static void main(String[] args) {
+        try {
+            Employee original = new Employee("John Q. Public", 50000);
+            original.setHireDay(2000, 1, 1);
+            Employee copy = original.clone();
+            copy.raiseSalary(10);
+            copy.setHireDay(2002, 12, 31);
+            System.out.println("original=" + original);
+            System.out.println("copy=" + copy);
+        }
+        catch (CloneNotSupportedException e) {
+            e.printStackTrace();
+        }
+    }
+}
diff --git a/Part6/clone/Employee.java b/Part6/clone/Employee.java
@@ -0,0 +1,36 @@
+package clone;
+
+import java.util.Date;
+import java.util.GregorianCalendar;
+
+public class Employee implements Cloneable {
+    private String name;
+    private double salary;
+    private Date hireDay;
+
+    public Employee(String n, double s) {
+        name = n;
+        salary = s;
+        hireDay = new Date();
+    }
+
+    public Employee clone() throws CloneNotSupportedException {
+        Employee cloned = (Employee) super.clone();
+        cloned.hireDay = (Date) hireDay.clone();
+        return cloned;
+    }
+   
+    public void setHireDay(int year, int month, int day) {
+        Date newHireDay = new GregorianCalendar(year, month - 1, day).getTime();
+        hireDay.setTime(newHireDay.getTime());
+    }
+
+    public void raiseSalary(double byPercent) {
+        double raise = salary * byPercent / 100;
+        salary += raise;
+    }
+
+    public String toString() {
+        return "Employee[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]";
+    }
+}
diff --git a/Part6/interfaces/Employee.java b/Part6/interfaces/Employee.java
@@ -7,6 +7,13 @@
  * 为了让类实现一个接口，通常需要下面几个步骤：
  * 1. 将类声明为实现给定的接口
  * 2. 让接口中的所有方法进行定义
+ *
+ * 在这里讨论一下接口与抽象类之间的区别：
+ *     但是由于Java只支持单继承，而不是C++那样的多重继承，
+ *     所以使用抽象类的时候，每个类都只能扩展于一个类；
+ *     但是却可以实现多个接口，
+ *     接口可以提供多重继承的大多数好处，
+ *     同时还能避免多重继承的复杂性和低效性
  */
 public class Employee implements Comparable<Employee> {
     private String name;
diff --git a/README b/README
@@ -69,4 +69,6 @@
      |
      | ----- interfaces（接口）
      |
+     | ----- clone（克隆对象）
+     |
      | ----- ...

Original file line number	Diff line number	Diff line change
`@@ -69,4 +69,6 @@`
`69`	`69`	`\|`
`70`	`70`	`\| ----- interfaces（接口）`
`71`	`71`	`\|`
	`72`	`+ \| ----- clone（克隆对象）`
	`73`	`+ \|`
`72`	`74`	`\| ----- ...`