抽象类和接口是相对于普通类的更高一层的抽象，抽象类用于扩展（extends），接口用于实现（implements，可以是多个）。

抽象类表示“是一个（IS-A）关系的抽象”，比如比尔是一个人；接口表示“能（CAN-DO）关系的抽象”（接口的英文名称通常以able为后缀，表示有某某能力的意思，如Comparable），比如比尔能编程。

语法：

abstract class Comparator{ private String datafiled; public abstract int compareTo(Object other); // }// an abstract method is called a pure virtual function and is tagged with a trailing = 0interface Comparable{ int compareTo(Object other); // All methods of an interface are automatically public. default int compareTo2(Object other) { return 0; } // By default, all elements are the same}

A class implements an interface by doing this:

class SomeClass extends SomeParent implements interfaceName{}

单根结构中的所有对象都有一个通用接口，所以它们最终都属于相同的类型。

A class extends just one parent, but may implement several interfaces.

class SomeClass extends SomeParent implements interfaceA, interfaceB, interfaceC{}1 抽象类

Abstract classes are used to organize programs. The same program could be organized in many ways. Our example program could be written without an abstract class. But a real-world application might have hundreds of classes. Grouping classes together is important in keeping a program organized and understandable.

抽象类用于组织程序。同一个项目可以通过多种方式组织。我们的示例程序可以在没有抽象类的情况下编写。但实际应用程序可能有数百个类。将类分组对于保持类的组织性和可理解性很重要。

The advantage of using an abstract class is that you can group several related classes together as siblings.

使用抽象类的优点是，可以将多个相关类作为兄弟类分组在一起。

abstract class Template { public final voidgetTime() { long start= System.currentTimeMillis(); code(); longend= System.currentTimeMillis(); System.out.println("执行时间是："+ (end-start)); } public abstract void code();}class SubTemplate extends Template { public void code() { for(int i= 0; i< 10000; i++) { System.out.println(i); } }}

无论继承还是合成，我们都可以在现有类型的基础上创建一个新类型。但在典型情况下，我们通过合成来实现现有类型的“再生”或“重复使用”，将其作为新类型基础实施过程的一部分使用。但如果想实现接口的“再生”，就应使用继承。由于衍生或派生出来的类拥有基础类的接口，所以能够将其“上溯造型”为基础类。

2 接口

“interface”（接口）关键字使抽象的概念更深入了一层。我们可将其想象为一个“纯”抽象类。它允许创建者规定一个类的基本形式：方法名、自变量列表以及返回类型，但不规定方法主体。接口也可以有基本数据类型的数据成员，但它们都默认为static 和final。接口只提供一种形式，并不提供实施的细节。接口这样描述自己：“对于实现我的所有类，都应该具有我的能力”。因此，采用了一个特定接口的所有代码都知道对于那个接口可能会调用什么方法。所以我们常把接口用于建立类和类之间的一个“协议”。有些面向对象的程序设计语言采用了一个名为“protocol”（协议）的关键字，它做的便是与接口相同的事情。

接口中定义的字段会自动具有static 和final 属性。它们不能是“空白final”，但可初始化成非常数表达式。

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要...则必须能...”的思想。继承是一个"是不是"的关系，而接口实现则是"能不能"的关系。

接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。

接口(interface)是抽象方法和常量值定义的集合。

Supplying instance fields and methods that operate on them is the job of the classes that implement the interface. being similar to an abstract class with no instance fields. Why can’t Comparable simply be an abstract class? A class can only extend a single class(not support multiple inheritance. But each class can implement as many interfaces.

提供实例字段和对其进行操作的方法是实现接口的类的工作。类似于没有实例字段的抽象类。为什么Compariable不能只是一个抽象类？一个类只能扩展一个类（不支持多重继承。但每个类可以实现尽可能多的接口）。

3 接口和抽象类的区别是什么？

Java提供和支持创建抽象类和接口，自然有各自用途和区别所在。

接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。

类可以实现（implements）很多个接口，但是只能扩展（extents）一个抽象类。

类如果要实现一个接口，它必须要实现接口声明的所有方法。但是，类可以不实现抽象类声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。

抽象类可以在不提供接口方法实现的情况下实现接口。

Java接口中声明的变量默认都是final的。抽象类可以包含非final的变量。

Java接口中的成员函数默认是public的。抽象类的成员函数可以是private，protected或者是public。

接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是，如果它包含main方法的话是可以被调用的。

Comparable和Comparator接口是干什么的？列出它们的区别。

Java提供了只包含一个compareTo()方法的Comparable接口。这个方法可以给两个对象排序。具体来说，它返回负数，0，正数来表明输入对象小于，等于，大于已经存在的对象。

Java提供了包含compare()和equals()两个方法的Comparator接口。compare()方法用来给两个输入参数排序，返回负数，0，正数表明第一个参数是小于，等于，大于第二个参数。equals()方法需要一个对象作为参数，它用来决定输入参数是否和comparator相等。只有当输入参数也是一个comparator并且输入参数和当前comparator的排序结果是相同的时候，这个方法才返回true。

Interfaces, is a way of describing what classes should do, without specifying how they should do it. A class can implement one or more interfaces. You can then use objects of these implementing classes whenever conformance to the interface is required.

接口它描述类应该做什么，而不指定它们应该如何做。一个类可以实现一个或多个接口。然后，只要需要符合接口，就可以使用这些实现类的对象。

In the Java programming language, an interface is not a class but a set of requirements for the classes that want to conform to the interface.

在Java编程语言中，接口不是一个类，而是希望符合接口的类的一组需求。

C++ has multiple inheritance, similar to a Java class with a single superclass and additional interfaces.

C++具有多重继承，类似于具有单个超类和附加接口的Java类。

You can use a proxy to create, at runtime, new classes that implement a given set of interfaces. Proxies are only necessary when you don’t yet know at compile time which interfaces you need to implement.

您可以使用代理在运行时创建实现给定接口集的新类。只有在编译时还不知道需要实现哪些接口时，才需要代理。

Suppose you want to construct an object of a class that implements one or more interfaces whose exact nature you may not know at compile time. This is a difficult problem. To construct an actual class, you can simply use the newInstance method or use reflection to find a constructor. But you can’t instantiate an interface. You need to define a new class in a running program.

假设您想要构造一个类的对象，该类实现一个或多个接口，这些接口的确切性质在编译时可能不知道。这是一个难题。要构造实际的类，只需使用newInstance方法或使用反射来查找构造函数。但不能实例化接口。您需要在正在运行的程序中定义一个新类。

To overcome this problem, some programs generate code, place it into a file, invoke the compiler, and then load the resulting class file. Naturally, this is slow, and it also requires deployment of the compiler together with the program. The proxy mechanism is a better solution. The proxy class can create brand-new classes at runtime. Such a proxy class implements the interfaces that you specify. In particular, the proxy class has the following methods:

为了克服这个问题，一些程序生成代码，将其放入文件中，调用编译器，然后加载生成的类文件。当然，这很慢，而且还需要将编译器与程序一起部署。代理机制是更好的解决方案。代理类可以在运行时创建全新的类。这样的代理类实现您指定的接口。具体而言，proxy类具有以下方法：

All methods required by the specified interfaces; and

规定接口所需的所有方法；和

All methods defined in the Object class (toString, equals, and so on).The application program interface (API), also known as library, contains predefined classes and interfaces for developing Java programs. The API is still expanding.

对象类中定义的所有方法（toString、equals等）。应用程序接口（API），也称为库，包含用于开发Java程序的预定义类和接口。API仍在扩展。

The Collections Framework is a sophisticated hierarchy of interfaces and classes that provide state-of-the-art technology for managing groups of objects.

集合框架是一个复杂的接口和类层次结构，为管理对象组提供了最先进的技术。

Normally, you can’t put any code inside an interface, but a nested class can be part of an interface. Any class you put inside an interface is automatically public and static. Since the class is static, it doesn’t violate the rules for interfaces-the nested class is only placed inside the namespace of the interface.

通常，您不能在接口中放置任何代码，但嵌套类可以是接口的一部分。在接口中放置的任何类都是自动公开和静态的。由于该类是静态的，因此不会违反接口的规则。嵌套类仅放置在接口的命名空间中。

Interfaces give Java some of the advantages of multiple inheritance without the disadvantages.

接口为Java提供了多重继承的一些优点，但没有缺点。

An interface is a list of constants and method headers. The methods are not implemented in the interface (there is no method body). A class that implements an interface must implement each of the methods listed in the interface.

接口是常量和方法头的列表。这些方法没有在接口中实现（没有方法体）。实现接口的类必须实现接口中列出的每个方法。

An interface includes only constants and method headers, not instance variables.

接口只包括常量和方法头，不包括实例变量。

A method in an interface is public by default. The constants in an interface are public static final by default. Recall that final means that the value cannot change as the program is running.

默认情况下，接口中的方法是公共的。默认情况下，接口中的常量是public static final。回想一下，final表示在程序运行时该值不能更改。

interface MyInterface{ int aConstant = 32; // a constant (public static final, by default) double pi = 3.14159; // a constant (public static final, by default) void methodA( int x ); // a method header (public, by default) double methodB(); // a method header (public, by default)}4 使用接口注意事项

A class that implements an interface must implement each method in the interface.

实现接口的类必须实现接口中的每个方法。

Methods from the interface must be declared public in the class.

接口中的方法必须在类中声明为public。

Constants from the interface can be used as if they had been defined in the class.

可以类中使用接口中的常量。

Constants should not be redefined in the class.

不应在类中重新定义常量。

An interface can be used as a data type for a reference variable.

接口可用作引用变量的数据类型。

An interface can be an extension of another interface (but not an extension of a class).

一个接口可以是另一个接口的扩展（但不能是类的扩展）。

To use sort() with a class that you define, Comparable interface must be implemented

要对定义的类使用sort()，必须实现可比较的接口

Several classes in the Java libraries implement the Iterator interface. Some of these classes are complicated, and a simple loop can't be used to access all their elements. For those classes, an iterator, which systematically accesses each element, is very useful.

Java库中的几个类实现了迭代器接口。其中一些类很复杂，不能使用简单的循环来访问它们的所有元素。对于这些类，系统地访问每个元素的迭代器非常有用。

Iterable interface -- a class that implements this can create an Iterator for itself.

Iterable接口——实现该接口的类可以为自己创建迭代器。

Iterator interface -- an Iterator implements methods to visit the elements of a list.

迭代器接口——迭代器实现访问列表元素的方法。

-End-