[JAVA]接口与克隆

由于接口和克隆的一些有点复杂，于是自己梳理一下，仅做笔记。

接口技术

在Java中，接口不是类，而是对类的一组需求描述。

例子：Arrays类中的sort方法承诺可以对对象数组进行排序，前提是：对象所属的类必须实现了Comparable接口，代码如下：

public interface Comparable
{
int compareTo(Object other);
}

也就是说，任何实现Comparable接口的类都需要包含compareTo方法，并且这个方法的参数必须是一个Object对象，返回一个整数数值。

此外，接口还有一点要求没有明确说明：在调用x.compareTo(y)时，compareTo方法必须确实比较两个对象的内容，并返回比较的结果。当x<y，返回一个负数；当x>y，返回一个正数；当两者相等，返回0。

接下来，我们用一个例子说明接口在实际运用的使用方法：

假设，我们希望使用Arrays类中的sort方法对Employee对象数组进行排序，Employee类就必须实现Comparable接口，步骤如下：

1. 将类声明为实现给定的接口。使用关键词implements

class Employee implements Comparable

2. 对接口的所有方法进行定义。

使用接口后，要想使用sort方法，就必须满足接口要求：Employee类需要提供compareTo方法。（假设比较职员的薪水）

public int compareTo(Employee other)
{
	return Double.compare(salary, other.salary);//使用静态方法比较。
}

给出上述例子的完整代码：

package interfaces;//

import java.util.*;

public class EmployeeSortTest {
	public static void main(String[] args)
	{
		EmployeInter[] staff = new EmployeInter[3];
		
		staff[0] = new EmployeInter("Harry", 50000);
		staff[1] = new EmployeInter("Cral", 400000);
		staff[2] = new EmployeInter("Tony", 60000);
		
		Arrays.sort(staff);
		
		//print out information about all Employee objects
		for (EmployeInter e : staff)
			System.out.println("name:" + e.getName() + ",salary" + e.getSalary());
	}
}

package interfaces;

public class EmployeInter implements Comparable<EmployeInter>{
	private String name;
	private double salary;
	
	public EmployeInter(String n, double s)
	{
		name = n;
		salary = s;
	}
	
	public String getName()
	{
		return name;
	}
	
	public double getSalary()
	{
		return salary;
	}
	
	public void raiseSalary(double byPercent)
	{
		double raise = salary * byPercent / 100;
		salary += raise;
	}
	
	/**
	 * Compares employees by salary
	 * @param other another EmployeInter object
	 * @return a negative value if this employee has a lower salary than other object,
	 * 0 if the salaries are the same, a positive value otherwise.
	 */
	public int compareTo(EmployeInter other)
	{
		return Double.compare(salary, other.salary);
	}

}

使用克隆接口

回顾以前的知识，当拷贝一个变量时，原始变量与拷贝变量引用自同一个对象，改变其中一个会影响另外一个。要想互不影响，就要用到克隆。

Employee original = new Employee("John", 500000);
Employee copy = original.clone();

想法比较直接，但是却没那么简单，这是因为clone方法是Object类的一个proteced方法，也就是说用户在编写代码时不能直接调用它。只有在Employee类中，才能进行克隆Employee对象的操作。（这句话是不是很难理解，看了下面三种访问情况，你就可以理解了。）

一、假如直接克隆，结果如下：

1.对象访问自己类型的clone()方法

就如同上面的思路，让我们试试直接克隆会有什么结果？

package test;

public class CloneTest1 {
	public static void main(String[] args)
	{
		CloneTest1 original= new CloneTest1();//CloneTest1类型对象调用Object的clone()方法。
		CloneTest1 cClone = original.clone();
	}
}

提示：Type mismatch: cannot convert from Object to CloneTest1，出错的在类型转换，而不是访问权限。

解释(在CloneTest1类中，CloneTest1类型对象调用Object的clone()方法)：

1. CloneTest1类继承自Object类，在CloneTest1类中，可以通过自身实例访问Object的protected的clone方法。
2. 通过使用继承父类的clone方法得到的对象也是Object类型的。

2.对象访问其他类型的clone（）方法

package test;

public class CloneTest1 {
	public static void main(String[] args)
	{
		OutClass original= new OutClass();//OutClass类型对象调用Object的clone()方法
		OutClass oClone = original.clone();
	}
}

class OutClass{}

本次在CloneTest1类外定义了一个空的类OutClass，出错有两个提示：

1. Object类型无法转化为Outclass类型。
2. OutClass对象无法访问Object的clone（）方法。

解释（在CloneTest1类中，OutClass类型对象调用Object的clone()方法）：

1. 使用父类Object的clone（）方法，得到的依然是Onject对象。
2. 在CloneTest1类中，无法访问外部类 OutClass所继承的Object的pretected的clone（）方法。

3.访问所继承的父类

CloneTest1类继承自Object类，那么在CloneTest1类中能不能访问父类的protected的clone（）方法呢？代码如下：

package test;

public class CloneTest1 {
	public static void main(String[] args)
	{
		Object original= new Object();//Object类型对象调用Object的clone()方法
		Object oClone = original.clone();
	}
}

结果显示，在CloneTest1类中，无法访问父类的protected的clone（）方法。

总结

1.子类使用继承自父类的clone()方法时，返回的对象仍然是父类类型的对象。

2.在子类CloneTest1中，CloneTest1的对象可以访问自己类型的clone()方法， 却不能访问其父类Object、另一个子类OuterClass的clone()方法。

二、浅克隆和深克隆

1.浅克隆

package test;

public class CloneTest1 {
	public static void main(String[] args)
	{
		CloneTest1 original= new CloneTest1();
		CloneTest1 cClone = original.clone();
	}
}

在上面直接克隆自身实例的代码中，我们可以看到出错的是类型转换，证明克隆是成功的。

而在Object类中实现的clone（）方法中，它对各个域进行相应的拷贝，如果数据是数值或基本类型，那么这种拷贝没有问题。
但是如果对象中包含了子对象的引用的话，拷贝的结果会使两个域引用自同一个子对象，因此原始对象与克隆对象共享这部分信息，即浅拷贝，并没有克隆包含在对象中的内部对象，改变克隆的值，原始的值也会随之改变。（即拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量），而不拷贝对象包含的引用指向的对象。）

虽然clone（）的默认实现（浅拷贝）可以满足需求，但还是应该实现Cloneable接口，下面为示例：其中，按照接口的格式，使用implements，设置为public:

package test;

Class Employee implements Cloneable
{
	public Employee clone() throws CloneNotSupportedException
	{
		return (Employee) super.clone();
	}
	...
}

上述的方法是直接使用父类Object的克隆，是浅拷贝，并没有增加任何新功能。为了实现深拷贝，必须拷贝所有可变域。示例如下：

package test;

Class Employee implements Cloneable
{
	...
	public Employee clone() throws CloneNotSupportedException
	{
		//call Object.clone()
		Employee cloned = (Employee) super.clone();
		//clone mutable fields    （Date类型需要额外拷贝）
		cloned.hireDay = (Date) hireDay.clone();
		
		return cloned;
	}
}

其中，深拷贝要求Date类型也要额外拷贝。
完整代码如下：

package clone;

public class CloneTest {
	public static void main(String[] args)
	{
		try
		{
			EmployeeClone original = new EmployeeClone("John", 50000);
			original.setHireDay(2000, 1, 1);
			EmployeeClone copy = original.clone();
			copy.raiseSalary(10);
			copy.setHireDay(2001, 12, 30);
			System.out.println("original=" + original);
			System.out.println("copy=" + copy);
		}
		catch (CloneNotSupportedException e)
		{
			e.printStackTrace();
		}
	}

}

package clone;

import java.util.Date;
import java.util.GregorianCalendar;

public class EmployeeClone implements Cloneable{
	private String name;
	private double salary;
	private Date hireDay;
	
	public EmployeeClone(String n, double s)
	{
		name = n;
		salary = s;
		hireDay = new Date();
	}
	
	public EmployeeClone clone() throws CloneNotSupportedException
	{
		EmployeeClone cloned = (EmployeeClone) super.clone();//extends from class Object
		
		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()//Object system.out.print
	{ 
		return "EmplyeeClone[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]";
	}
}

运行结果如下: