翻译 2006年06月20日 13:16:00


In the Java programming language, an interface is not a class but a set of requirements for classes that want to conform to the interface(实现某个接口的类的需求集).

Typically, the supplier of some service states: "If your class conforms to a particular interface, then I'll perform the service." Let's look at a concrete example. The sort method of the Arrays class promises to sort an array of objects, but under one condition: The objects must belong to classes that implement the Comparable interface.

Here is what the Comparable interface looks like:

public interface Comparable


   int compareTo(Object other);



This means that any class that implements the Comparable interface is required to have a compareTo method, and the method must take an Object parameter and return an integer.


As of JDK 5.0, the Comparable interface has been enhanced to be a generic typeJDK5.0中,Comparable接口已经强化为泛型).

public interface Comparable<T>


   int compareTo(T other); // parameter has type T



For example, a class that implements Comparable<Employee> must supply a method

int compareTo(Employee other)

You can still use the "raw" Comparable type without a type parameter, but then you have to manually cast the parameter of the compareTo method to the desired type.

All methods of an interface are automatically public(接口中的方法自动是public的). For that reason, it is not necessary to supply the keyword public when declaring a method in an interface.

Of course, there is an additional requirement that the interface cannot spell out: When calling x.compareTo(y), the compareTo method must actually be able to compare two objects and return an indication whether x or y is larger. The method is supposed to return a negative number if x is smaller than y, zero if they are equal, and a positive number otherwise.

This particular interface has a single method. Some interfaces have more than one method. As you will see later, interfaces can also define constants(接口中可以定义常量). What is more important, however, is what interfaces cannot supply. Interfaces never have instance fields, and the methods are never implemented in the interface(接口中不能含有实例域,并且不能实现方法). Supplying instance fields and method implementations is the job of the classes that implement the interface(提供实例域和实现方法是实现某个接口的类的任务). You can think of an interface as being similar to an abstract class with no instance fields(可以将接口看作是不带实例域的抽象类). However, there are some differences between these two concepts-we look at them later in some detail.

Now suppose we want to use the sort method of the Arrays class to sort an array of Employee objects. Then the Employee class must implement the Comparable interface.

To make a class implement an interface, you carry out two steps:

1. You declare that your class intends to implement the given interface.

2. You supply definitions for all methods in the interface.

To declare that a class implements an interface, use the implements keyword:

class Employee implements Comparable

Of course, now the Employee class needs to supply the compareTo method. Let's suppose that we want to compare employees by their salary. Here is a compareTo method that returns -1 if the first employee's salary is less than the second employee's salary, 0 if they are equal, and 1 otherwise.

public int compareTo(Object otherObject)


   Employee other = (Employee) otherObject;

   if (salary < other.salary) return -1;

   if (salary > other.salary) return 1;

   return 0;




In the interface declaration, the compareTo method was not declared public because all methods in an interface are automatically public. However, when implementing the interface, you must declare the method as public(然而在实现某个接口时,必须声明方法为public. Otherwise, the compiler assumes that the method has package visibility-the default for a class. Then the compiler complains that you try to supply a weaker access privilege.

As of JDK 5.0, we can do a little better. We'll decide to implement the Comparable<Employee> interface type instead.

class Employee implements Comparable<Employee>


   public int compareTo(Employee other)


      if (salary < other.salary) return -1;

      if (salary > other.salary) return 1;

      return 0;


    . . .


Note that the unsightly cast of the Object parameter has gone away.


The compareTo method of the Comparable interface returns an integer. If the objects are not equal, it does not matter what negative or positive value you return. This flexibility can be useful when you are comparing integer fields. For example, suppose each employee has a unique integer id and you want to sort by employee ID number. Then you can simply return id - That value will be some negative value if the first ID number is less than the other, 0 if they are the same ID, and some positive value otherwise. However, there is one caveat: The range of the integers must be small enough that the subtraction does not overflow. If you know that the IDs are not negative or that their absolute value is at most (Integer.MAX_VALUE - 1) / 2, you are safe.

Of course, the subtraction trick doesn't work for floating-point numbers. The difference salary - other.salary can round to 0 if the salaries are close together but not identical.

Now you saw what a class must do to avail itself of the sorting service-it must implement a compareTo method. That's eminently reasonable. There needs to be some way for the sort method to compare objects. But why can't the Employee class simply provide a compareTo method without implementing the Comparable interface?

The reason for interfaces is that the Java programming language is strongly typed. When making a method call, the compiler needs to be able to check that the method actually exists.Java是强制类型的语言,在作方法调用时,编译器需要能够检查所有实际存在的方法。) Somewhere in the sort method will be statements like this:

if (a[i].compareTo(a[j]) > 0)


   // rearrange a[i] and a[j]

   . . .


The compiler must know that a[i] actually has a compareTo method. If a is an array of Comparable objects, then the existence of the method is assured because every class that implements the Comparable interface must supply the method.


You would expect that the sort method in the Arrays class is defined to accept a Comparable[] array so that the compiler can complain if anyone ever calls sort with an array whose element type doesn't implement the Comparable interface. Sadly, that is not the case. Instead, the sort method accepts an Object[] array and uses a clumsy cast:

// from the standard library--not recommended

if (((Comparable) a[i]).compareTo(a[j]) > 0)


   // rearrange a[i] and a[j]

   . . .


If a[i] does not belong to a class that implements the Comparable interface, then the virtual machine throws an exception.


Example 6-1 presents the full code for sorting an employee array.

Example 6-1.

 1. import java.util.*;


 3. public class EmployeeSortTest

 4. {

 5.    public static void main(String[] args)

 6.    {

 7.       Employee[] staff = new Employee[3];


 9.       staff[0] = new Employee("Harry Hacker", 35000);

10.       staff[1] = new Employee("Carl Cracker", 75000);

11.       staff[2] = new Employee("Tony Tester", 38000);


13.       Arrays.sort(staff);


15.       // print out information about all Employee objects

16.       for (Employee e : staff)

17.          System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());

18.    }

19. }


21. class Employee implements Comparable<Employee>

22. {

23.    public Employee(String n, double s)

24.    {

25.       name = n;

26.       salary = s;

27.    }


29.    public String getName()

30.    {

31.       return name;

32.    }


34.    public double getSalary()

35.    {

36.       return salary;

37.    }


39.    public void raiseSalary(double byPercent)

40.    {

41.       double raise = salary * byPercent / 100;

42.       salary += raise;

43.    }


45.    /**

46.       Compares employees by salary

47.       @param other another Employee object

48.       @return a negative value if this employee has a lower

49.       salary than otherObject, 0 if the salaries are the same,

50.       a positive value otherwise

51.    */

52.    public int compareTo(Employee other)

53.    {

54.       if (salary < other.salary) return -1;

55.       if (salary > other.salary) return 1;

56.       return 0;

57.    }


59.    private String name;

60.    private double salary;

61. }




java.lang.Comparable 1.0

"   int compareTo(Object otherObject)

compares this object with otherObject and returns a negative integer if this object is less than otherObject, zero if they are equal, and a positive integer otherwise.

java.lang.Comparable<T> 5.0

"   int compareTo(T other)

compares this object with other and returns a negative integer if this object is less than other, zero if they are equal, and a positive integer otherwise.

java.util.Arrays 1.2

"   static void sort(Object[] a)

sorts the elements in the array a, using a tuned mergesort algorithm(使用归并排序算法). All elements in the array must belong to classes that implement the Comparable interface, and they must all be comparable to each other.


According to the language standard: "The implementor must ensure sgn(x.compareTo(y)) = -sgn(y.compareTo(x)) for all x and y. (This implies that x.compareTo(y) must throw an exception if y.compareTo(x) tHRows an exception.)" Here, "sgn" is the sign of a number: sgn(n) is -1 if n is negative, 0 if n equals 0, and 1 if n is positive. In plain English, if you flip the parameters of compareTo, the sign (but not necessarily the actual value) of the result must also flip.

As with the equals method, problems can arise when inheritance comes into play.

Because Manager extends Employee, it implements Comparable<Employee> and not Comparable<Manager>. If Manager chooses to override compareTo, it must be prepared to compare managers to employees. It can't simply cast the employee to a manager:

class Manager extends Employee


   public int compareTo(Employee other)


      Manager otherManager = (Manager) other; // NO

      . . .


   . . .



That violates the "antisymmetry" rule(“反对称性”原则). If x is an Employee and y is a Manager, then the call x.compareTo(y) doesn't throw an exception-it simply compares x and y as employees. But the reverse, y.compareTo(x), throws a ClassCastException.

This is the same situation as with the equals method that we discussed in Chapter 5, and the remedy is the same. There are two distinct scenarios.

If subclasses have different notions of comparison, then you should outlaw comparison of objects that belong to different classes. Each compareTo method should start out with the test

if (getClass() != other.getClass()) throw new ClassCastException();


If there is a common algorithm for comparing subclass objects, simply provide a single compareTo method in the superclass and declare it as final.

For example, suppose that you want managers to be better than regular employees, regardless of the salary. What about other subclasses such as Executive and Secretary? If you need to establish a pecking order, supply a method such as rank in the Employee class. Have each subclass override rank, and implement a single compareTo method that takes the rank values into account.


Properties of Interfaces

Interfaces are not classes. In particular, you can never use the new operator to instantiate an interface(不能使用new来初始化某个接口):

x = new Comparable(. . .); // ERROR

However, even though you can't construct interface objects, you can still declare interface variables(尽管不能构造接口对象,但可以声明接口变量).

Comparable x; // OK

An interface variable must refer to an object of a class that implements the interface(接口变量必须指向实现该接口的类的一个对象):

x = new Employee(. . .); // OK provided Employee implements Comparable

Next, just as you use instanceof to check whether an object is of a specific class, you can use instanceof to check whether an object implements an interface(可以用instanceof运算符来检查对象是否实现了某个接口):

if (anObject instanceof Comparable) { . . . }

Just as you can build hierarchies of classes, you can extend interfaces(接口可以继承). This allows for multiple chains of interfaces that go from a greater degree of generality to a greater degree of specialization. For example, suppose you had an interface called Moveable.

public interface Moveable


   void move(double x, double y);


Then, you could imagine an interface called Powered that extends it:

public interface Powered extends Moveable


   double milesPerGallon();


Although you cannot put instance fields or static methods in an interface, you can supply constants in them(尽管接口中不存在实例域或静态方法,却可以提供常量). For example:

public interface Powered extends Moveable


   double milesPerGallon();

   double SPEED_LIMIT = 95; // a public static final constant


Just as methods in an interface are automatically public, fields are always public static final(接口中的域总是public static final的).


It is legal to tag interface methods as public, and fields as public static final. Some programmers do that, either out of habit or for greater clarity. However, the Java Language Specification recommends that the redundant keywords not be suppliedJava语言规范推荐不使用这些多余的关键字), and we follow that recommendation.


Some interfaces define just constants and no methods(某些接口只定义常量而没有方法). For example, the standard library contains an interface SwingConstants that defines constants NORTH, SOUTH, HORIZONTAL, and so on. Any class that chooses to implement the SwingConstants interface automatically inherits these constants. Its methods can simply refer to NORTH rather than the more cumbersome SwingConstants.NORTH. However, this use of interfaces seems rather degenerate, and we do not recommend it(接口的这种使用方法似乎与接口的本质相偏离,我们不推荐使用).

While each class can have only one superclass, classes can implement multiple interfaces. This gives you the maximum amount of flexibility in defining a class's behavior(每个类只能有一个超类,但却可以实现多个接口。这使得在定义类的行为时有最大的灵活性). For example, the Java programming language has an important interface built into it, called Cloneable. (We discuss this interface in detail in the next section.) If your class implements Cloneable, the clone method in the Object class will make an exact copy of your class's objects. Suppose, therefore, you want cloneability and comparability. Then you simply implement both interfaces.

class Employee implements Cloneable, Comparable

Use commas to separate the interfaces that describe the characteristics that you want to supply(逗号隔开).

Interfaces and Abstract Classes

If you read the section about abstract classes in Chapter 5, you may wonder why the designers of the Java programming language bothered with introducing the concept of interfaces. Why can't Comparable simply be an abstract class:

abstract class Comparable // why not?


   public abstract int compareTo(Object other);


The Employee class would then simply extend this abstract class and supply the compareTo method:

class Employee extends Comparable // why not?


   public int compareTo(Object other) { . . . }



There is, unfortunately, a major problem with using an abstract base class to express a generic property. A class can only extend a single class. Suppose that the Employee class already extends a different class, say, Person. Then it can't extend a second class.

class Employee extends Person, Comparable // ERROR

But each class can implement as many interfaces as it likes:

class Employee extends Person implements Comparable // OK


Other programming languages, in particular C++, allow a class to have more than one superclass. This feature is called multiple inheritance(多重继承). The designers of Java chose not to support multiple inheritance, because it makes the language either very complex (as in C++) or less efficient (as in Eiffel).

Instead, interfaces afford most of the benefits of multiple inheritance while avoiding the complexities and inefficiencies.


C++ has multiple inheritance and all the complications that come with it, such as virtual base classes, dominance rules, and transverse pointer casts. Few C++ programmers use multiple inheritance, and some say it should never be used. Other programmers recommend using multiple inheritance only for "mix in" style inheritance. In the mix-in style, a primary base class describes the parent object, and additional base classes (the so-called mix-ins) may supply auxiliary characteristics. That style is similar to a Java class with a single base class and additional interfaces. However, in C++, mix-ins can add default behavior, whereas Java interfaces cannot.


示例源码      通过继承,可以很容易地在接口中添加新的方法声明,还可以通过继承在新接口中组合数个接口。这两种情况都可以获得新的接口,就像在下例中看到的: package com.mufen...
  • u013693649
  • u013693649
  • 2016年07月20日 15:57
  • 1658

java 接口用法(通俗易懂)

以前我一直没有搞懂接口的工作流程,直到看了下面这篇文章: 很形象的接口的使用——针对初学者  里氏代换原则是什么?听起来很高深,不过我们也不是什么学院派,就不讲大道理了,直接拿个例子来说一下。...
  • frdde
  • frdde
  • 2012年08月17日 10:54
  • 1943

Java接口 详解(二)

上一篇Java接口 详解(一)讲到了接口的基本概念、接口的使用和接口的实际应用(标准定义)。我们接着来讲。一、接口的应用—工厂设计模式(Factory)我们先看一个范例:package com.wz....
  • wei_zhi
  • wei_zhi
  • 2016年10月06日 12:16
  • 2179

什么是java 接口,用处是什么

关于学习到java ,很多人可能接触到接口,但并不理解接口的用处,其实接口很简单,其作用有两个 1 泛化      下面请看代码   public void  feed(Chicken chike...
  • huangjunjie1991
  • huangjunjie1991
  • 2017年05月02日 13:39
  • 2603


Computer 类为模板类,里面包含USB接口的相应流程,USB.java为接口,usbkeyborad与usbMouse为USB接口的实现。 main函数: packa...
  • xiaoleiacm
  • xiaoleiacm
  • 2015年10月27日 11:41
  • 969


1.修改web.xml文件 TestHTTPServer com.atoz.http.SmsHTTPServer T...
  • yang_ai
  • yang_ai
  • 2017年04月26日 09:41
  • 1949

Java接口 详解(一)

  • wei_zhi
  • wei_zhi
  • 2016年10月06日 00:46
  • 29490


此代码一共包括4个类,在一个包下面: 例子1: 分别是,,,,从别人网页上学习,自己心得。 ...
  • Clarissatt
  • Clarissatt
  • 2016年04月27日 19:18
  • 6213

从头认识java-7.4 实现多重接口

这一章节我们来说一下接口另一个特性:多重接口。在平常,使用继承,我们只是继承某一类,只能够一种向上转型,但是在接口的使用方面,可以实现多个接口,然后实现多种的向上转型。 我们先上代码:package ...
  • raylee2007
  • raylee2007
  • 2015年11月08日 23:16
  • 3524

  • 2017年06月12日 22:47
  • 321