Core Java (十四) 接口，对象克隆，回调

接口

接口技术用来描述类具有什么功能，而并不给出每个功能的具体实现。

一个类可以实现一个或者多个接口，并在需要借口的地方，随时使用实现了相应接口的对象。

为了让类实现某个接口，通常需要：

将类声明为实现给定的接口
对接口中的所有方法进行定义

以下例子简单的实现了一个接口compareTo：

package com.xujin;

public class Main{
	public static void main(String...args){
		Employee e = new Employee("Lily", 1000);
		System.out.print(e.compareTo(new Employee("Bob", 2000)));//1
	}
}

class Employee implements Comparable<Employee>{
	public Employee(String name, double salary){
		this.name = name;		
		this.salary = salary;		
	}	
	
	public int compareTo(Employee other){
		if(salary > other.salary) return -1;
		if(salary < other.salary) return 1;
		return 0;
	}
	
	//定义变量
	private double salary;
	private String name;
}

接口特性;
接口不是类，不能使用new实例化一个接口。但是可以声明接口的变量，Comparable x = new Employee()；

Comparable x = new Employee("Jim", 4000);//这里x是Employee类型的
		System.out.println(x.getClass().getName());//com.xujin.Employee

这样，创建的x是Employee类型的。
接口中可以包含非静态方法（public）和静态实例域（public static final）。

每个类虽然仅仅能够继承一个超类，但是可以实现多个接口。Java使用接口来实现多继承的大部分功能。

class Employee implements Cloneable, Comparable{
......
}

对象克隆

深拷贝：对象克隆，又称为深拷贝。指的是创建一个新对象，且新对象的状态与原始对象的状态相同，当克隆的新对象修改时，不会影响原来的对象的状态。
浅拷贝：当拷贝一个变量的时候，原始变量与拷贝变量引用同一个对象，这是一种浅拷贝，拷贝出来的对象仍然会对原对象产生影响。
只有一个类实现了Cloneable接口才可以调用clone方法克隆。
如下例，staff是一个浅拷贝，而copy是一个深拷贝。

package com.xujin;

public class Main{
	public static void main(String...args) throws CloneNotSupportedException{		
		Employee a = new Employee("Lily", 1000);		
		
		Employee staff = a;//a与staff同时引用同一个对象
		a.setName("Bob");
		System.out.println(a);//com.xujin.Employee[name = Bob, salary = 1000.0]
		System.out.println(staff);	//com.xujin.Employee[name = Bob, salary = 1000.0]
		
		Employee copy = a.clone();
		a.setName("Jim");
		a.setSalary(2000);
		System.out.println(a);//com.xujin.Employee[name = Jim, salary = 2000.0]
		System.out.println(copy);//com.xujin.Employee[name = Bob, salary = 1000.0]
	}
}

class Employee implements Cloneable{
	public Employee(String name, double salary){
		this.name = name;		
		this.salary = salary;		
	}	
	
	public String getName(){
		return this.name;
	}
	
	public double getSalary(){
		return this.salary;
	}
	
	public void setName(String name){
		this.name = name;
	}
	
	public void setSalary(double salary){
		this.salary = salary;
	}
	
	public String toString(){  
        return getClass().getName() + "[name = " + name + ", salary = " + salary + "]";  
    } 
	
	public Employee clone() throws CloneNotSupportedException{
		return (Employee)super.clone();
	}
	
	//定义变量
	private double salary;
	private String name;
}

接口与回调

回调是一种常见的程序设计模式，可以指定某个特定事件发生时应该采取的动作。
如下例中，Timer类型的t可以在到达给定时间间隔的时候运行监听器listen中的actionPerformed方法。

ackage com.xujin;

import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Date;

import javax.swing.JOptionPane;
import javax.swing.Timer;

public class Main{
	public static void main(String...args){		
		ActionListener listener = new TimePrinter();
		Timer t = new Timer(1000, listener);
		t.start();
		
		JOptionPane.showMessageDialog(null, "Quit?");
		System.exit(0);
	}
}

class TimePrinter implements ActionListener{
	public void actionPerformed(ActionEvent event){
		Date now = new Date();
		System.out.println("At the tone,the time is " + now);
		Toolkit.getDefaultToolkit().beep();
	}
}