1.抽象类

在继承的层次结构中，每个新的子类都使类变得更加明确和具体。如果从一个子类向父类追溯，类就会变得更通用、更加不明确。类的设计应该确保父类包含它的子类的共同特征。有时候，一个父类设计得非常抽象，以至于它都没有任何具体的实例。这样的类称为抽象类（abstract class）。

抽象方法，在方法头中使用 abstract 修饰符表示。如果类中有抽象方法，那么类就是抽象类。在类的头部使用 abstract 修饰符表示该类为抽象类。

• 一个包含抽象方法的类必须声明为抽象类。然而，可以定义一个不包含抽象方法的抽象类。这个抽象类用于作为定义新子类的基类
• 抽象类和常规类很像，但是不能使用 new 操作符创建它的实例。
• 抽象方法只有定义而没有实现。它的实现由子类提供。子类必须重写所有的抽象方法，否则子类也成为抽象类。
• 抽象方法是非静态的。
• 抽象类的构造方法定义为 protected, 因为它只被子类使用。创建一个具体子类的实例时，其父类的构造方法被调用以初始化父类中定义的数据域。
• 子类可以重写父类的方法并将它定义为抽象的。这很少见，但是它在当父类的方法实现在子类中变得无效时是很有用的。在这种情况下，子类必须定义为抽象的
• 不能使用 new 操作符从一个抽象类创建一个实例，但是抽象类可以用作一种数据类型。可以创建一个抽象类对象的数组，并用抽象类对象为数组元素赋值。

2.常见的抽象类

2.1 Number类

Number 类是数值包装类以及 Biginteger 和 BigDecimal 类的抽象父类。

2.2 Calendar 和GregorianCalendar

3.接口

接口是一种与类相似的结构，用于为对象定义共同的操作。接口在许多方面都与抽象类很相似，但是它的目的是指明相关或者不相关类的对象的共同行为。
类和接口之间的关系称为接口继承 ( interface inheritance)。因为接口继承和类继承本质上是相同的，所以我们将它们都简称为继承。

接口中所有的方法隐含的都是抽象的，抽象类中的方法可以是抽象的也可以是非抽象的。
类可以实现多个接口，但只能继承一个父类。
类可以选择在不全部实现抽象类和接口中抽象方法，但该类必须为抽象类。
接口中声明的变量都是（且默认）public static final修饰的，而抽象类的成员变量可以是各种类型的。
接口中方法的访问修饰符默认是public，而抽象类可以是private，protected或者是public。
接口和抽象类都不可实例化，接口是绝对抽象的。
子类可以通过构造方法链调用抽象类的构造方法
法，但接口没有构造方法
（原文链接：https://blog.csdn.net/m0_43405679/article/details/108410256）

public interface T{int k = 1; // public static final int k =1;void p(); // public abstract void p();
}abstract class F{abstract void f();
}class A extends F implements T{@overridevoid p(){...}@overridevoid f(){...}
}

Java 8 引入了使用关键字 default 的默认接口方法。一个默认接口方法为接口中的方法提供了一个默认实现。
原本接口类全部都是抽象方法，没有函数体，现在可以用default后，拥有函数体，作为一个子类不实现仍可以用的默认版本。

Java 8 还允许接口中存在公有的静态方法。接口中的公有静态方法和类中的公有静态方法一样使用。

public interface A{public default void f(){...}public static int m(){...}
}

Java 只允许为类的继承做单一继承，但是允许使用接口做多重继承。

public class NewClass extends BaseClassimplements Interface1,Interface2,...,InterfaceN{}

利用关键字 extends, 接口可以继承其他接口。这样的接口称为子接口 (subinterface)。

public interface NewInterface extends Interface1,Interface2,...,InterfaceN{}

接口可以继承其他接口但不能继承类。
一个类可以继承它的父类同时实现多个接口。
所有的类共享同一个根类 Object, 但是接口没有共同的根。
与类相似，接口也可以定义一种类型。一个接口类型的变量可以引用任何实现该接口的类的实例。如果一个类实
现了一个接口，那么这个接口就类似于该类的一个父类。可以将接口当作一种数据类型使用，将接口类型的变量转换为它的子类，反过来也可以。

一般来说，清晰描述父子关系的强的 “是…的 一种” 关系 ( strong is-a relationship) 应该用类建模。
弱的 “是…的一种” 关系 ( weak is-a relationship) 也称为类属关系 ( is-kind-of relationship), 它表明对象拥有某种属性，可以用接口来建模。
通常，推荐使用接口而非抽象类，因为接口可以为不相关类定义共同的父类型。接口比类更加灵活。

4.常见接口

4.1 Comparable 接口

Comparable 接口定义了 compareTo 方法，用于比较对象。

package java.langpublic interface Comparable<E>{public int compareTo(E o);
}

Comparable 接口是一个泛型接口。在实现该接口时, 泛型类型 E 被替换成一种具体的类型。Java 类库中的许多类实现了 Comparable 接口以定义对象的自然顺序。
BigDecimal 、 String、Integer等以及 Date 类都 实现了 Comparable 接口。

public final class Integer extends Number implements Compareble<Integer>{@overridepublic int compareTo(Integer o){...}
}

由于所有 Comparable 对象都有 compareTo 方法，如果对象是 Comparable 接口类型的实例的话, Java API中的 java.util.Arrays.sort(Object[]) 方法就可以使用 compareTo 方法来对数组中的对象进行比较和排序。
没有实现Comparable的话，就用不了java.util.Arrays.sort(Object[])。对于自定义的类，可以手动实现Comparable。

public class NewCircle extends Circleimplements Compareble<NewCircle>{public NewCircle(double radius){super(radius);}@overridepublic int compareTo(NewCircle o){if(this.getRadius()>o.getRadius())return 1;else if(this.getRadius()>o.getRadius())return -1;else return 0;}
}

4.2 Cloneable 接口

经常 希望创 建一个 对象的拷贝。为了实 现这个目的，需要使用 clone 方法并理解Cloneable 接口。
这个接口是空的。一个方法体为空的接口称为标记接口 ( marker interface)。一个标记接口既不包括常量也不包括方法。它用来表示一个类拥有某些希望具有的特征。
实现Cloneable 接口的类标记为可克隆的，而且它的对象可以使用在 Object 类中定义的 clone()方法克隆。

Calendar calendar = new GregorianCalendar(2013, 2, 1) ;
Calendar calendar1 = calendar;
Calendar calendar2 = (Calendar)calendar.clone();

为了定义一个实现 Cloneable 接口的自定义类，这个类必须重写 Object 类中的 clone()方法。

public class A implements Cloneable{@overridepublic Object clone(){try{return super.clone();catch(CloneNotSupportedexception ex)return null;}}
}

因为 Object 类中针对自身平台实现的 clone 方法完成了克隆对象的任务，所以，在A类中的 clone 方法只要简单调用 super.clone()即可。

Object 类中的 clone 方法将原始对象的每个数据域复制给目标对象。如果一个数据域是基本类型，复制的就是它的值。如果一个数据域是对象，复制的就是该域的引用。
这称为浅复制 ( shallow copy) 而不是深复制 ( deep copy), 这意味着如果数据域是对象类型，那
么复制的是对象的引用。

4.3 深浅拷贝

接口和抽象类的区别是什么？（清晰易懂）

5.类的设计原则

内聚性：类应该描述一个单一的实体，而所有的类操作应该在逻辑上相互契合来支持一个一致的目的。
—致性：遵循标准 Java 程序设计风格和命名习惯。为类、数据域和方法选取传递信息的名字。通常的风格是将数据声明置于构造方法之前，并且将构造方法置于普通方法之前。
封装性：一个类应该使用private 修饰符隐藏其数据，以免用户直接访问它。这使得类更易于维护。只在希望数据域可读的情况下，才提供获取方法；也只在希望数据域可更新的情况下，才提供设置方法。
清晰性：为使设计清晰，内聚性、一致性和封装性都是很好的设计原则。除此之外，类应该有一个很清晰的合约，从而易于解释和易于理解。
完整性：类是为许多不同用户的使用而设计的。为了能在大范围的应用中使用，一个类应该通过属性和方法提供各种自定义功能的实现方式。
实例和静态：依赖于类的具体实例的变量或方法必须是一个实例变量或方法。如果一个变量被类的所有实例所共享，那就应该将它声明为静态的。
继承和聚合：继承和聚合之间的差异，就是 is-a（是一种）和 has-a（具有）之间的关系。
接口和抽象类：接口和抽象类都可以用于为对象指定共同的行为。