6 接口与内部类

• 后面将介绍Java的几种常用的高级技术，掌握以完善自己的Java工具箱。
• 首先，接口(interface)技术，这种技术主要用来描述类具有什么功能，而并不给出每个功能的具体实现。一个类可以实现(implement)一个或多个接口，并在需要接口的地方，随时使用实现了相应几口的对象。
• 克隆对象（有时又叫深拷贝）。对象的克隆是指创建一个新对象，且新对象的状态与原始对象的状态相同。当对克隆的新对象进行修改时，不会影响原始对象的状态。
• 内部类(inner class)机制。内部类是定义在另一个类的内部，其中的方法可以访问包含它们外部类的域，这是一项比较复杂的技术。内部类的技术主要应用于设计具有相互协作关系的类集合。特别是在编写处理GUI事件的代码时，使用它可以让代码看起来更加简洁专业。
• 代理(proxy)，这是一种实现任意接口的对象。代理是一种非常专业的构造工具，它可以用来构建系统级的工具。初学可以跳过这部分。

6.1 接口

• 在Java中，接口不是类，而是对类的一组需求描述，这些类要遵从接口描述的统一格式进行定义。“如果类遵从某个特定接口，那么就履行这项服务”。下面给出一个具体的示例。Arrays类中的sort方法承诺可以对对象数组进行排序，但要求满足下列前提：对象所属的类必须实现了Comparable接口。下面是Comparable接口的代码：
  public interface Comparable{
  int compareTo(Object other);
  }
  这就是说，任何实现Comparable接口的类都需要包含compareTo方法，并且这个方法的参数必须是一个Object对象，返回一个整型数值。

  • 在Java SE 5.0中，Comparable接口已经改进为泛型类型。
    public interface Comparable<T>{
    int compareTo(T other);//parameter has type T
    }
    例如，在实现Comparable<Employee>接口的类中，必须提供方法：int compareTo(T other)，也可以使用没有类型参数的“原始”Comparable类型，但必须手工地将compareTo方法的参数转换所希望的类型。

• 接口中的所有方法自动地属于public。因此，在接口中声明方法时，不必提供关键字public。

• 接口中还有一个没有明确说明的附加要求：在调用x.compareTo(y)的时候，这个compareTo方法必须确实比较这两个对象的内容，并返回比较的结果。例如：当x小于y时，返回一个负数；当x等于y时，返回0；否则返回一个正数。

• 上面的接口只有一个方法，而有些接口可能包含多个方法。在接口中还可以定义常量。然而，更为重要的是要知道接口不能提供哪些功能。接口绝不能含有实例域，也不能在接口中实现方法。提供实例域和方法实现的任务应该由实现接口的那个类来完成。因此，可以将接口看成是没有实例域的抽象类。但是这两个概念还是有一定区别的，之后将给出解释。

• 现在，假设希望使用Arrays类的sort方法对Employee对象数组进行排序，Employee类就必须实现Comparable接口。为了类实现一个接口，通常需要下面两个步骤：

  • 1）让类声明为实现给定的接口
  • 2）对接口中的所有方法进行定义

  要将类声明为实现某个接口，需要使用关键字implements：
  class Employee implements Comparable
  当然，这里的Employee类需要提供compareTo方法。假设根据希望根据雇员的薪水进行比较。以下是compareTo方法的实现:
  public int compareTo(Object otherObject){
  Employee other = (Employee)otherObject;
  return Double.compare(salary, other.salary);
  }
  在这里，我们使用静态的Double.compare方法，如果第一个参数小于第二个参数，它会返回以一个负值；如果二者相等则返回0；否则返回一个正值。

  • Warning：在接口的声明中，没有将compareTo方法声明为public，这是因为在接口中的所有方法都自动地市public。不过，在实现接口时，必须把方法声明为public；否则编译器将认为这个方法的访问属性是包可见性，即默认的访问属性，之后编译器就会给出试图提供更严格的访问权限的警告信息。

• 在Java SE 5.0中，可以做得更好一些。可以将上面的实现替换为Comparable<Employee>接口的实现。
  class Employee implements Comparable<Employee>{
  public int compareTo(Employee other){
  return Double.compare(salary, other.salary);
  }
  ...
  }
  将参数Object进行类型转换总是让人感觉不舒服，但是现在已经不见了。

  • Tips：comparable接口中的compareTo方法返回一个整型数值。这中方法在比较两个整数域时非常有用，通常返回两个参数的差值就可以。但是，在比较浮点值时，由于精度问题，差值在四舍五入后很可能变为0。所以不适用。

• 现在，我们已经看到，要让一个类使用排序服务必须让它实现compareTo方法。这是理所当然的，因为要向sort方法提供对象的比较方式。但是为什么不能在Employee类直接提供一个compareTo方法，而必须实现Comparable接口呢？ 主要原因在于，Java是一种强类型(strongly typed)的语言，在调用方法时，编译器将会检查这个方法是否存在。在sort方法中可能存在下面这样的语句：
  if (a[i].compareTo(a[j]) > 0){
  //rearrange a[i] and a[j]
  ...
  }
  为此，编译器必须确认a[i]一定有compareTo方法。如果a是一个Comparable对象数组，就可以确保拥有compareTo方法，因为每个实现comparable接口的类都必须提供这个方法的定义。

  • Tips：有人认为，将Arrays类中的中的sort方法定义为接收一个Comparable[]数组就可以在使用元素类型没有实现Comparable接口的数组作为参数调用sort时，由编译器给出错误报告。但事实并非如此。在这种情况下，sort方法可以接收一个Object[]数组，并对其进行笨拙的类型转换：
    //Approach used in the standard library--not recommended
    if (((Comparable)a[i]).compareTo(a[j]) > 0){
    //rearrange a[i] and a[j]
    ...
    }
    如果a[i]不属于实现了Comparable接口的类，那么虚拟机就会抛出一个异常。
  • Tips：语言标准规定：对于任意的x和y，实现必须能够保证sgn(x.compareTo(y))= -sgn(y.compareTo(x))。（也就是说，如果y.compareTo(x)抛出一个异常，那么x.compareTo(y)也应该抛出一个异常。）这里的“sgn”是一个数值的符号，简单地讲，如果调换compareTo的参数，结果的符号也应该调换（而不是实际值）。与equals方法一样，在继承过程中有可能会出现问题。
    这是因为Manager扩展了Employee，而Employee实现的是Comparable<Employee>，而不是Comparable<Manager>。如果Manager覆盖了compareTo，就必须要有经理与雇员进行比较的思想准备，绝不能仅仅将雇员转换成经理。
    class Manager extends Employee{
    public int compareTo(Employee other){
    Manager otherManager = (Manager)other;//NO
    ...
    }
    ...
    }
    这不符合“反对称”的规则。如果x是一个Employee对象，y是一个Manager对象，调用x.compareTo(y)不会抛出异常，它只是将x和y都作为雇员进行比较。但是反过来，y.compareTo(x)将会抛出一个ClassCastException。
    有两种不同的办法解决：如果子类之间的比较含义不一样，那就属于不同对象的非法比较。每个compareTo方法都应该在开始时进行此类检测：
    if (getClass()!=other.getClass()) throw new ClassException();
    如果存在这样一种通用算法，它能够对两个不同的子类对象进行比较，则应在超类中提供一个compareTo方法，并将这个方法声明为final。

.1接口的特性

• 接口不是类，尤其不能使用new运算实例化一个接口。然而，尽管不能构造接口的对象，却能够声明接口的变量，接口的变量必须引用实现了接口的类对象：
  x = new Comparable(...);//ERROR
  Comparable x;//OK
  x = new Employee(...);//Provided Employee implements Comparable
• 可以使用instanceof检查一个对象是否实现了某个特定的接口：
  if (anObject instanceof Comparable){...}
• 接口可以被拓展。这里允许存在多条具有较高通用性的接口到较高专用性的接口的链。例如，假设有一个称为Moveable的接口：
  public interface Moveable{
  void move(double x, double y);
  }
  然后，可以以它为基础拓展一个叫做Powered的接口：
  public interface Powered extends Moveable{
  double milesPerGallon();
  double SPEED_LIMIT = 95;//a public static final constant
  }
  虽然在接口中不能包含实例或者静态方法，但却可以包含常量。与接口中的方法自动设置为public一样，接口中的域将被自动设为public static fianl。
• 每个类只能有一个超类，但是可以实现多个接口。

.2接口和抽象类

• 使用抽象类表示通用属性存在这样一个问题：每个类只能拓展于一个类。假设Employee类已经拓展于一个类，例如Person，它就不能再拓展第二个类：
  class Employee extends Person, Comparable;//ERROR
  但是可以实现多个接口：
  class Employee extends Person implements Comparable;//OK
• 接口可以提供多继承（multiple inheritance）的好处，同时还能避免多重继承的复杂性和低效性。

6.2对象克隆

• 当拷贝一个变量时，原始变量与拷贝变量引用同一个对象。这就是说，改变一个变量所引用的对象将会对另一个变量产生影响。如果创建一个对象的新的copy，它的最初状态与original一样，但以后将可以各自改变各自的状态，那就需要使用clone方法。

  
  
  6_1

• clone方法是Object类的一个proteced方法。也就是说，在用户编写过程中不能直接调用它。只有Employee类才能够克隆Employee方法。这种限制是有一定道理的：由于这个类对具体的类对象一无所知，所以只能将各个域进行对应的拷贝。如果对象中的所有数据域都属于数值或基本类型，这样的拷贝没有任何问题。但是，如果在对象中包含了子对象的引用，拷贝的结果会使得两个域引用同一个子对象，因此原始对象与克隆对象共享这部分信息。

• 默认的克隆操作是浅拷贝，它没有克隆包含在对象中的内部对象。
  

  6_2
  
  如果原始对象与浅拷贝对象共享的子对象是不可变的，那将不会产生任何问题。例如，子对象属于像String类这样的不允许改变的类；也有可能子对象在其生命周期内不会发生变化，既没有更改它们的方法，也没有创建对它引用的方法。
  然而，更常见的情况是子对象可变，因此必须重新定义clone方法，以便实现克隆子对象的深拷贝。在列举的示例中，hireDay域属于Date类，这就是一个可变的子对象。

• 对于每一个类，都需要做出下列判断：

• 1)默认的clone方法是否满足要求

• 2)默认的clone方法是否能够通过调用可变子对象的clone得到修补

• 3)是否不应该使用clone
  实际上，选项3是默认的。如果要选择1和2，类必须：

• 实现Cloneable接口

• 使用public访问修饰符重新定义clone方法
  Cloneable接口的出现与接口的正常使用没有任何关系。尤其是，它并没有指定clone方法，这个方法是从Object类继承而来的。接口在这里只是作为一个标记，表明类设计者知道要进行克隆处理。如果一个对象需要克隆，而没有实现Cloneable接口，就会产生一个已检验异常（checked exception）。

• Cloneable接口是Java提供的几个标记接口（tagging interface）之一（有些程序员将它们称为标记接口（marker interface））。标记接口没有方法，使用它的唯一目的是可以用instanceof进行类型检查：
  if(obj instanceof Cloneable)...建议在自己编写程序时，不要使用这种技术。

• 即使clone的默认实现（浅拷贝）能够满足需求，也应该实现Cloneable接口，将clone重定义为public，并调用super.clone()。示例：
  class Employee implements Cloneable{
  //raise visibility level to public, change return type
  public Employee clone() throws CloneNotSupportedException{
  return (Employee) super.clone();
  }
  }

• 为了实现深拷贝，必须克隆所有可变的实例域：
  class Employee implements Cloneable{
  ...
  public Employee clone() throws CloneNotSupportedException{
  //call object.clone()
  Employee cloed = (Employee) super.clone();
  //clone mutable fields
  cloned.hireDay = (Date) hireDay.clone();

            return cloned;
        }
    }
  

只要在clone中含有没有实现Cloneable接口的对象，Object类的clone方法就会抛出一个CloneNotSupportedException异常。

• 适用于final类的写法：
  public Employee clone(){
  try{
  return (Employee) super.clone();
  }catch(CloneNotSupportedException e){
  return null;
  //this won't happen, since we are Cloneable
  }
  }
• 必须谨慎地实现子类的克隆。例如，一旦为Employee类定义了clone方法，任何人都可以利用它克隆Manager对象。由于可能含有需要深拷贝的域，没有人能够保证子类实现的clone一定正确。鉴于这个原因，应将Object类中的clone方法声明为protected。但是，如果想让用户调用clone方法，就不应该这么做。因此，clone方法有一些笨拙。
• 所有的数组类型均包含一个clone方法，这个方法是被设为public，而不是protected。可以使用这个方法创建一个包含所有数据元素拷贝的新数组。例如：
  int[] luckyNumbers = {2,3,5,7,11,13};
  int[] cloned = luckyNumbers.clone();
  cloned[5] = 12;//doesn't change luckyNumbers[5]

6.3接口与回调

• 回调（callback）是一种常见的程序设计模式。在这个模式中，可以指出某个特定事件发生时应该采取的动作。简单的情况，在java.swing包中有一个Timer类，可以使用它在到达给定的时间间隔时发出通告。假如程序中有一个时钟，就可以请求每秒获得一个通告，以便达到更新时钟画面。
  （Li：例如okhttp中的callback用于处理请求的resposnse）

6.4内部类

• 内部类（inner class）是定义在另一个类中的类。为什么需要使用内部类呢？其主要原因有以下三点：
• 内部类方法可以访问该类定义所在的作用域中的数据，包含私有的数据。
• 内部类可以对同一个包中的其他类隐藏起来
• 当想要定义一个回调函数且不想编写大量代码时，使用匿名（anonymous）内部类比较便捷。

.1使用内部类访问对象状态

• 内部类的语法比较复杂。一个特殊的例子，抽象出一个TalkingClock类，构造一个语音时钟需要提供两个参数：发布通告的间隔和开关铃声的标志。
  public class TalkingClock{
  private int interval;
  private boolean beep;

        public TalkingClock(int interval, boolean beep){...}
        public void start(){...}
  
        public class TimePrinter implements ActionListener{
        //an inner class
            public void actionPerformed(ActionEvent event){
                Date now = new Date();
                System.out.println("At the tone, time is "+now);
                if(beep){
                    Toolkit.getDefaultToolkit().beep();
                }
            }
        }
    }
  

TimePrinter对象是由TalkingClock类的方法构造。令人惊讶的事情发生了。TimePrinter类没有实例域或者名为beep的变量，取而代之的是beep引用了创建TimePrinter的TalkingClock对象的域。内部类既可以访问自身的数据域，也可以访问创建它的外部类对象的数据域。为了能够运行这个程序，内部类的对象总有一个隐式引用，它指向了创建它的外部类对象。这个引用在内部类的定义中是不可见的。

6_3.jpg

如果将外部类的对象称为outer。于是actionPerformed方法等价于下列形式：

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

• 外部类的引用在构造器中设置。编译器修改了所有的内部类的构造器，添加了一个外部类引用的参数。因为TimePrinter类没有定义构造器，所以编译器为这个类生成了一个默认的构造器，代码如下：
  public TimePrinter(TalkingClock clock){
  //automatically generated code
  outer = clock;
  }
  Tips：outer并不是Java的关键字，我们只是用其说明内部类中的机制
  当在start方法中创建了TimePrinter对象后，编译器就会将this引用传递给当前的语音时钟构造器：
  ActionListener listener = new TimePrinter(this);//automatically added
• TimePrinter类声明为私有的。这样一来，只有TalkingClock的方法才能够构造TimePrinter对象。只有内部类可以是私有类，而常规类只可以具有包可见性，或公有可见性。