花图问答
您的当前位置：首页正文

6接口与内部类

来源：花图问答

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。

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

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

    • 1）让类声明为实现给定的接口
    • 2）对接口中的所有方法进行定义
    • Warning：在接口的声明中，没有将compareTo方法声明为public，这是因为在接口中的所有方法都自动地市public。不过，在实现接口时，必须把方法声明为public；否则编译器将认为这个方法的访问属性是包可见性，即默认的访问属性，之后编译器就会给出试图提供更严格的访问权限的警告信息。
    • Tips：comparable接口中的compareTo方法返回一个整型数值。这中方法在比较两个整数域时非常有用，通常返回两个参数的差值就可以。但是，在比较浮点值时，由于精度问题，差值在四舍五入后很可能变为0。所以不适用。
    • Tips：有人认为，将Arrays类中的中的sort方法定义为接收一个Comparable[]数组就可以在使用元素类型没有实现Comparable接口的数组作为参数调用sort时，由编译器给出错误报告。但事实并非如此。在这种情况下，sort方法可以接收一个Object[]数组，并对其进行笨拙的类型转换：
      //Approach used in the standard library--not recommended
      if > 0){
      //rearrange a[i] and a[j]
      ...
      }
      如果a[i]不属于实现了Comparable接口的类，那么虚拟机就会抛出一个异常。
    • 。。）这里的“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
      ...
      }
      ...
      }
      这不符合“反对称”的规则。。。
      有两种不同的办法解决：如果子类之间的比较含义不一样，那就属于不同对象的非法比较。每个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对象。只有内部类可以是私有类，而常规类只可以具有包可见性，或公有可见性。

Copyright © 2019- huatuowenda.com 版权所有
湘ICP备2023022495号-1

Top