接口

1、接口不是类，而是对类的一组需求描述，这些类要遵从接口描述的统一格式进行定义

2、定义接口，如：

public interface Abc{

int aaa(Object other)

}

3、接口中的所有方法自动地属于public，声明在接口中的内部类自动成为static和public

4、接口不能含有实例域，也不能在接口中实现方法，提供实例域和方法实现的任务应该由实现接口的那个类完成

5、为了让类实现一个接口，需要如下两个步骤：

① 将类声明为实现给定的接口，需要使用implements关键字，如：class Employee implements Compable

② 对接口中的所有方法进行定义

6、在接口声明中的方法不需要声明为public，但在实现接口时必须把方法声明为public，否则编译器会发出警告

7、如果存在一种通用算法，它能够对两个不同的子类对象进行比较，在应该在超类中提供一个compareTo方法，并将这个方法声明为final

8、接口的特性

① 接口不是类，不能使用new运算符实例化一个接口，但能够声明接口的变量，如：Comparable x;

② 接口变量必须引用实现了接口的类对象：x = new Employee(...)

③ 可以使用instanceof检查一个对象是否实现了某个特定的接口，如：if(anObject instanceof Comparable){...}

④ 接口可以被扩展，如：有一个成为Moveable的接口：

public interface Moveable{

void move(double x, double y);

}  //然后可以以它为基础扩展一个叫做Powered的接口：

public interface Powered entends Moveable{

public milesPerGallon();

}

⑤ 在接口中不能包含实例域或静态方法，但却可以包含常量，如：

public interface Powered entends Moveable{

double milesPerGallon();

double SPEED_LIMIT = 95;

}  //类中的域将被自动设定为public static final

——有些程序员为了提高清晰度的考虑，将接口方法标记为public，将域标记为public static final，虽然这在Java中是允许的，但Java语言规范却建议不要书写这些多余的关键字

⑥ 实现多个接口，如：class Employee implements Clonealbe, Comparable，使用逗号将实现的对个接口隔开

克隆

1、clone方法是Object类的一个proteced方法，该方法只能实现浅拷贝，若浅拷贝对象共享的子对象是不可变的，那就不会出现什么问题，但如果需要拷贝的对象里有可变的子对象，那就需要编写该类自己的clone方法

2、一个类需要实现了Cloneable接口才能实现克隆操作，否则编译不通过，可以使用if(obj instanceof Cloneable)...来检查是否实现了该接口，该接口用来表明这个类需要拥有克隆的能力

3、即使clone的默认实现（浅拷贝）能够满足需求，也应该实现Cloneable接口，将clone重定义为public，并调用super.clone()，如：

class Employee implements Cloneable{

public Employee clone() throws CloneNotSupportedException{

Employee cloned = (Employee)super.clone();

}

}

4、建立深拷贝clone方法的示例：

class Employee implements Cloneable{

public Employee clone() throws CloneNotSupportedException{

Employee cloned = (Employee)super.clone();

cloned.hireDay = (Date)hireDay.clone();

return cloned;

}

}

回调

1、回调是一种程序设计模式，在这种模式中可以指出某个特定事件发生时应该采取的动作

2、java.swing包中有一个Timer类可以使用它在到达个顶的时间间隔时发出通告，需要设置一个时间间隔，将某一个类的对象传递给定时器可以设置定时器定时进行的操作，这要求传递的对象所属的类实现了java.awt.event包的ActionListener接口，该接口如下：

public interface ActionListener{

void actionPerformed(ActionEvent event);

}  //当到达指定的时间间隔时，定时器就调用actionPerformed方法

3、回调的示例：

import java.awt.event.*;

import java.util.*;

import javax.swing.*;

import javax.swing.Timer;

public class TimerTest{

public static void main(String[] args){

ActionListener listener = new TimePrinter();

Timer t = new Timer(1000, listener);

t.start();

JOptionPane.showMessageDialog(null, "quit program?");

System.exit(0);

}

}

class TimePrinter implements ActionListener{

public void actionPerformed(ActionEvent event){

Date now = new Date();

System.out.println("At the time is " + now);

}

}

内部类

1、内部类是定义在另一个类中的类，使用内部类的主要原因有：

① 内部类方法可以访问该类定义所在的作用域中的数据，包括私有的数据

② 内部类可以对同一个包中的其他类隐藏起来

③ 当先要定义一个回调函数且不想编写大量代码时，使用匿名内部类比较便捷

2、内部类既可以访问自身的数据域，也可以访问创建它的外围类对象的数据域

3、若在A类中定义了内部类B，则只有A类的方法才能够生成B对象，只有内部类是私有类，而常规类只可以具有包可见性或者公有可见性

4、表达式OuterClass.this表示外围类引用，如A类是外围类，在内部类B里要使用A类的成员变量可以这样：A.this.xxx，可以使用下列语法格式来编写内部对象的构造器：outerObject.new InnerClass(构造方法变量列表)，如this.new B();这里的this限定词是多余的，不过可以通过显式地命名将外围类引用设置为其他的对象，如果B是A的内部类，对于任意的A对象都可以构造一个B对象：

A abc0 = new A();

A.B abc1 = abc0.new B();

5、局部内部类

即在一个方法中定义的类，局部类不能用public或private进行声明，它的作用域被限定在声明这个局部类的块中，其优点有：

① 可以对外部世界外圈地隐蔽起来

② 它不仅可以访问包含它们的外部类，还可以访问被声明为final的局部变量

final关键字可以应用于局部变量、实例变量和静态变量中，在所有这些情况下，它们的含义都是：在创建这个变量后，只能够为之赋值一次，此后，再也不能修改它的值了，在定义final变量的时候，不必进行初始化

6、匿名内部类

① 假如只创建某个类的一个对象，就不必命名了，这种类叫做匿名内部类，如：

public void start(int interval, final boolean beep){

ActionListener listener = new ActionListener(){

public void actionPerformed(ActionEvent event){

Date now = new Date();

System.out.println("At the tone, the time is " + now);

if(beep) Toolkit.getDefaultToolkit().beep();

}

};

Timer t = new Timer(interval, listener);

t.start();

}  //创建一个实现ActionListener接口的新对象，需要实现的方法actionPerformed定义在括号{}内

② 用于构造对象的任何参数都要被放在超类/接口/类名后面的括号()内，通常的语法格式是：

new SuperType(构造方法变量列表){

inner class methods and data

}

③ 由于匿名类没有类名，所以匿名类不能有构造器，取而代之的是将构造器参数传递给超类构造器，尤其是在内部类实现接口的时候不能有任何构造参数，还要加上一组()，如果构造参数的闭圆括号后跟一个花括号，则表示定义的是匿名内部类

7、静态内部类

① 有时候，使用内部类只是为了把一个类隐藏在另外一个类的内部，并不需要内部类引用外围类对象，为此可以将内部类声明为static，以便取消产生的引用

② 只有内部类可以声明为static，静态内部类的对象除了没有对生成它的外围类对象的引用特权外，与其他所有内部类完全一样

③ 注：在内部类不需要访问外围类对象的时候，应该使用静态内部类；声明在接口中的内部类自动成为public和static