父类中定义了相关子类中的共同行为。 接口可以用于定义类的共同行为（包括 非相关的类）。

类的设计应该确保父类包含它的子类的共同特征。有时候，一个父类设计得非常抽象，以至于它都没有任何具体的实例。这样的类称为抽 象类(abstract class)。

Circle 类和 Rectangle 类分别包含计算圆和矩形的面积和周长的方法 getArea() getPerimeter()。因为可以计算所有几何对象的面积和周长，所以最好在 GeometricObject 类中定义 getAreaO getPerimeterO 方法。但是， 些方法不能在 GeometricObject类中实现，因为它们的实现取决于几何对象的具体类型。 这样的方法称为抽象方法(abstract method ), 在方法头中使用 abstract 修饰符表示。GeometricObject 类中定义了这些方法后，GeometricObject 就成为一个抽象类。在类头使用 abstract 修饰符表示该类为抽象类。

抽象类和常规类很像，但是不能使用 new 操作符创建它的实例。抽象方法只有定义而没有实现。它的实现由子类提供。一个包含抽象方法的类必须声明为抽象类。 抽象类的构造方法定义为protected, 因为它只被子类使用。创建一个具体子类的实例 ，它的父类的构造方法被调用以初始化父类中定义的数据域。

使用抽象类的好处：

如果在某个函数(方法)中，传入了父类对象，却要使用子类中有的方法，则应该将父类定义为抽象类，同时在父类中定义该方法(无须实现)。

关于抽象类值得注意的几点：

抽象的Number类

Number 类是数值包装类、Biglnteger 以及 BigDecimal 的抽象父类。

由于intValue()、longValue()、floatValue() 以及 doubleValue() 等方法不能在 Number 类中给出实现，它们在 Number 类中被定义为抽象方法。

接口在许多方面都与抽象类很相似，但是它的目的是指明相关或者不相关类的多个对象的共同行为。

为了区分接口和类，Java 采用下面的语法来定义接口：

修饰符 interface 接口名

{//常量声明

//方法签名

在Java中，接口被看作是一种特殊的类。就像常规类一样，每个接口都被编译为独立的字节码文件。使用接口或多或少有点像使用抽象类。例如，可以使用接口作为引用变量的数据类型或类型转换的结果等。与抽象类相似，不能使用 new 操作符创建接口的实例。

类和接口之间的关系称为接口继承(interface inheritance)。因为接口继承和类继承本质上是相同的，所以我们将它们都简称为继承。使用inplements关键字让对象的类实现这个接口。

由于接口中所有的數据域都是 public static final 而且所有的方法都是 public abstract, 所以 Java 允许忽略这些修饰符。

Comparable接口

Java提供了Comparable 接口，用来对两个可比较的对象(譬如，可以是是两个学 、两个日期、两个圆、 两个矩形或者两个正方形)提供比较大小。接口的定义如下所示:

package java.lang;
public interface Comparable<E> {
    public int compareTo(E o);
compareTo 方法判断这个对象相对于给定对象 o 的顺序，并且当这个对象小于、等于或 大于给定对象o ，分别返回负整数、0或正整数。
Comparable 接口是一个泛型接口。在实现该接口时，泛型类型 E 被替换成一种具体的类型。Java 类库中的许多类实现了 Comparable 接口以定义对象的自然顺序。Byte、Short、 Integer、Long、Float、Double、Character、Biglnteger、BigDecimal、Calendar、String 以及Date类都 实现了 Comparable 接口。
可以定义一个新的 Rectangle 类来实现 Comparable。
public class ComparableRectangle extends Rectangle implements 
    Comparable<ComparableRectangle> {
    public ComparableRectangle(double width, double height) {super(width, height)}
    @Override
    public int compareTo(ComparableRectangle o) {
        if (getArea() > o.getArea())
            return 1;
        else if (getArea() < o.getArea())
            return 0;
            return 0;
    @Override
    public String toString() {
        return super.toString() + " Area: " + getArea();
强烈建议(尽管不要求) compareTo 应该与 equals 保持一致。也就是说，对于两个对象 o1和o2, 应该确保当且仅当 o1.equals(o2)为 true时，o1.compareTo(o2) == 0 成立。
Cloneable接口
经常会出现需要创建一个对象拷贝的情况。为了实现这个目的，需要使用 clone 方法并理解Cloneable 接口。接口包括常量和抽象方法，但是 Cloneable 接口是一个特殊情况。 java.lang包中的 Cloneable 接口的定义如下所示：
public java.lang;
public interface Cloneable {}
这个接口是空的。一个带空体的接口称为标记接口(marker interface)。一个标记接口既不包括常量也不包括方法。它用来表示一个类拥有某些特定的属性。
实现 Cloneable 接口的类标记为可克隆的，而且它的对象可以使用在 Object 类中定义的 clone() 方法克隆。Java 库中的很多类(例如，Date、Calendar ArrayList) 实现 Cloneable。
为了定义一个自定义类来实现 Cloneable 接口，这个类必须覆盖 Object 类中的 cloneO 方法。
public class House implements Cloneable, Comparable<House> {
    private int id;
    private double area;
    private java.util.Date whenBuilt;
    public House(int id, double area) {
        this.id = id;
        this.area = area;
        whenBuilt = new java.util.Date();
    public int getId() {
        return id;
    public double getArea() {
        return area;
    public java.util.Date getWhenBuilt() {
        return whenBuilt;
    @Override /**Override the protected clone method defined in
              the Object class, and strengthen its accessibility**/
    public Object clone() throws CloneNotSupportedException {return super.clone();}
    @Override
    public int compareTo(House o) {
        if (area > o.area)
            return 1;
        else if (area < o.area)
            return -1;
            return 0;
// 以创建一个 House 类的对象，然后从这个对象创建一个完全一样的拷贝:
House house1 = new House(1, 1750.50);
House house2 = (House)house1.clone();
House 类实现在 Object 类中定义的 clone 方法，方法头是:
protected native Object clone() throws CloneNotSupportedException;
关键字 native 表明这个方法不是用 Java 写的，但它是 JVM 针对自身平台实现的。 关键字 protected限定方法只能在同一个包内或在其子类中访问。由于这个原因，House 必须覆盖该方法并将它的可见性修饰符改为 public, 这样，该方法就可以在任何一个包中使用。
Object 类中的 clone 方法将原始对象的每个数据域复制给目标对象。如果一个数据域是基本类型，复制的就是它的值。如果一个数据域是对象，复制的就是该域的引用。这意味着浅复制。
接口和抽象类
Java 只允许为类的扩展做单一继承，但是允许使用接口做多重扩展。利用关键字 extends, 接口可以继承其他接口。这样的接口称为子接口(subinterface)。
所有的类共享同一个根类 Object, 但是接口没有共同的根。与类相似，接口也可以定义一种类型。一个接口类型的变量可以引用任何实现该接口的类的实例。
抽象类和接口都是用来明确多个对象的共同特征的。那么该如何确定在什么情况下应该使用接口，什么情况下应该使用类呢？
一般来说，清晰描述父子关系的强的 “是一种” 的关系(strong is-a relationship) 应该用类建模。例如，因为公历是一种日历， 所以，java.util .GregorianCalendar 和java.util.Calendar 是用类继承建模的。弱的“是一种” 的关系(weak is-a relationship) 也称为类属关系（is-kind-of relationship), 表明对象拥有某种属性，可以用接口来建模。例如，所有的字符串都是可比较的，因此，String 类实现 Comparable 接口。
通常，推荐使用接口而非抽象类，因为接口可以定义非相关类共有的父类型。
类设计的原则
内聚性  类应该描述一个单一的实体，而所有的类操作应该在逻辑上相互配合，支持一个一致的目的。
一致性  遵循标准 Java 程序设计风格和命名习惯。为类、数据域和方法选取具有信息的名字。 通常的风格是将数据声明置于构造方法之前，并且将构造方法置于方法之前。一般来说，应该具有一致性地提供一个公共无参构造方法，用于构建默认实例。如果一 个类不支持无参的构造方法，要用文档写出原因。如果没有显式定义构造方法，即假定有一 个空方法体的公共默认无参构造方法。如果不想让用户创建类的对象，可以在类中声明一个私有的构造方法，Math 类就是如此。
封装性  类应该使用 private 修饰符隐藏其数据，以免用户直接访问它。这使得类更易于维护。只在希望数据域可读的情况下，才提供 get 方法；也只在希望数据域可更新的情况下， 才提供 set 方法。
清晰性  方法应在不产生混淆的情况下进行直观定义。
实例和静态  依赖于类的具体实例的变量或方法必须是一个实例变量或方法。如果一个变量 被类的所有实例所共享，那就应该将它声明为静态的。应该总是使用类名（而不是引用变量）引用静态变量和方法，以增强可读性并避免错误。不要从构造方法中传人参数来初始化静态数据域。最好使用 set 方法改变静态数据域
继承与聚合  继承和聚合之间的差异，就是 is-a (是一种） has-a (具有）之间的关系。
接口和抽象类  接口比抽象类更加灵活，因为一个子类只能继承一个父类，但是却可以实现任意个数的 接口。然而，接口不能具有具体的方法。
2. 泛型
泛型(generic)可以参数化类型，这个能力让我们可以定义带泛型类型的类或方法，随后编译器会用具体的类型来替换它。
泛型可以让我们在编译时而不是运行时检测出错误。
java.lang.Comparable接口被定义如下：
package java.lang;
public interface Comparable<T> {
    public int compareTo(T o)
表示形式泛型类型，随后可以用一个实际具体类型来替换它。替换泛型类型称为泛型实例化。
例如，下面的语句创建一个字符串线性表：
ArrayList<String> list = new ArrayList<>();
现在就只能向该线性表中添加字符串，试图添加非字符串就会产生编译错误。
泛型类型必须是引用类型，不能用基本类型来替换泛型类型，例如，为给Int值创建一个ArrayList对象，必须使用
ArrayList<Integer> intList = new ArrayList<>();
无须类型转换就可以从一个元素类型已指定的线性表中获取一个值，因为编译器已经知道这个元素类型。
定义泛型类和接口
public class GenericStack<E> {
    private java.util.ArrayList<E> list = new java.util.ArrayList<>();
    public int getSize() {return list.size();}
    public void push(E o) {list.add(o);}
    public E peek() {return list.get(getSize() - 1);}
    public E pop() {
        E o = list.get(getSize() - 1);
        list.remove(getSize() - 1);
        return o;
    public boolean isEmpty() {return list.isEmpty();}
    @Override
    public String toString() {return "stack: " + list.toString();}
// 使用方法
GenericStack<String> stack0 = new GenericStack<>();
stack0.push("London");
stack0.push("Hongkong");
可以不使用泛型，而将元素类型设置为Object，也可以容纳任何对象类型，但是，使用泛型能提高软件的可靠性和可读性，因为某些错误能在编译时而不是运行时被检测到。
注意，GenericStack的构造方法被定义为 public GenericStack()。
有时候，泛型类可能会有多个参数，此时，应该将所有参数放在尖括号中，并以逗号隔开，比如：<E1, E2, E3>。
可以定义一个类或接口作为泛型类或泛型接口的子类型，例如，在Java API中，java.lang.String类被定义为实现Comarable接口：
public class String implements Comarable<String>
可以使用泛型类型来定义泛型方法：
public class GenericMethodDemo {
    public static void main(String[] args) {
        Integer[] intergers = {1,2,3,4};
        String[] strings = {"London", "Paris", "New York", "Austin"};
        GenericMethodDemo.<Integer>print(integers);
        GenericMethodDemo.<String>print(strings);
    public static <E> void print(E[] list) {
        for (int i = 0; i < list.length; i++)
            System.out.print(list[i] + " ");
        System.out.println();
泛型方法声明如下：
public static <E> void print(E[] list)
调用泛型方法：
GenericMethodDemo.<Integer>print(integers); 或简单地调用：
print(integers);这种情形，实际类型没有明确指定，编译器自动发现实际类型。
可以将泛型指定为另外一种类型的子类型，这样的泛型称为受限的，受限的泛型类型 <E extends GeometricObject> 将 E 指定为GeometricObject的子类型。
非受限泛型类型 <E>等同于 <E extends Object>。
public static double max(GenericStack<Number> stack) {
    double max = stack.pop().doubleValue();
    while (!stack.isEmpty()) {
        double value = stack.pop().doubleValue();
        if (value > max)
            max = value;
    return max;
试想如果对一个元素为Integer型的intStack调用上面的max方法，能运行成功吗？
不能。因为intStack不是GenericStack<Number>的实例，不能调用max方法，尽管Integer是Number的子类型，但是，GenericStack<Integer>并不是 GenericStack<Number>的子类型。
为避免这个问题，可以使用通配泛型类型。
? 称为非受限通配，和? extends Object一样
? extends T称为受限通配，表示T或T的一个子类型
? super T称为下限通配，表示T或T的一个父类型
可以使用下面的定义方式修复上面的调用错误：
public static double max(Generic<? extends Number> stack)
消除泛型和对泛型的限制
泛型是使用一种称为类型消除的方法来实现的，编译器使用泛型类型信息来编译代码，但是随后会消除它。泛型存在于编译时，一旦编译器确认泛型类型是安全使用的，就会将它转换为原始类型。
需要注意的是，不管实际类型是什么，泛型类是被它的所有实例共享的，假如创建了两个列表对象：
ArrayList<String> list1 = new ArrayList<>();
ArrayList<Integer> list2 = new ArrayList<>();
尽管在编译时，ArrayList<String>和 ArrayList<Integer>是两种类型，但是，在运行时只有一个ArrayList类会被加载到JVM中，list1和list2都是ArrayList的实例，因此，一下两条语句都为true：
list1 instanceof ArrayList
list2 instanceof ArrayList
然而，表达式 list1 instaceof ArrayList<String>是错误的，由于ArrayList<String>并没有在JVM中存储为单独一个类，所以在运行时使用它毫无意义。
由于泛型类型在运行时被消除，因此，对于如何使用泛型类型是有一些限制的。
不能使用new E()
不能使用new E[]
在静态上下文中，不允许类的参数是泛型类型；由于泛型类的所有实例都有相同的运行时类，所以泛型类型的静态变量和方法是被它的所有实例共享的。因此，在静态方法，数据域中或初始化语句中，为类引用泛型类型的参数是非法的；
public class Test<E> {
    public static void m(E o1) { // illegal
    public static E o1; // illegal
    static { E o2;  // illegal}
异常类不能是泛型的