| ① 定义 在 Java 程序设计语言中，接口不是类，而是对希望符合这个接口的类的一组需求。 接口就是多个类的公共规范。 接口是一种引用数据类型，最重要的内容就是其中的抽象方法。 |
| ② 方法是 public 方法 接口中的所有方法都自动是 public 方法。因此，在接口中声明方法时，不必提供关键字 public。 |
| ③ 让类实现一个接口 为了让类实现一个接口，通常需要下面两个步骤： （1）将类声明为实现给定的接口。 （2）对接口中的所有方法进行定义。 要将类声明为实现某个接口，需要使用关键字 implements: public class Employee implements Comparable 换成了关键字 interface 后，编译生成的字节码文件仍然是：.java --> .class |
| ④ 警告 在接口声明中，没有将 compareTo 方法声明为 public，这是因为在接口中的所有方法都自动是 public。不过，在实现接口时，必须把方法声明为 public；否则，编译器将认为这个方法的访问属性是包可见性，这是类的默认访问属性，之后编译器就会报错，指出你试图提供更严格的访问权限。 接口是没有静态代码块或者构造方法的。 |
| ⑤ 接口发展概述 如果是 Java 7，那么接口中可以包含的内容有： （1）常量 （2）抽象方法 如果是 Java 8，还可以额外包含有： （3）默认方法 （4）静态方法 如果是 Java 9，还可以额外包含有： （5）私有方法 |
| ① 接口不是类 接口不是类。具体来说，不能使用 new 运算符实例化一个接口： x = new Comparable(. . .); // ERROR 然而，尽管不能构造接口的对象，却能声明接口的变量： Comparable x; // OK 接口变量必须引用实现了这个接口的类对象： x = new Employee(. . .); // OK provided Employee implements Comparable |
| ② 使用 instanceof 检查一个对象是否属于某个特定类 接下来，如同使用 instanceof 检查一个对象是否属于某个特定类一样，也可以使用 instance 检查一个对象是否实现了某个特定的接口： if (anObject instanceof Comparable) { . . . } |
| ③ 接口扩展接口 与可以建立类的继承关系一样，接口也可以被扩展。这里允许存在多条从具有较高通用性的接口到较高专用性的接口的链。例如，假设有一个名为 Moveable 的接口： public interface Moveable { void move(double x, double y); } 然后，可以假设一个名为 Powered 的接口扩展了以上 Moveable 接口： public interface Powered extends Moveable { double milesPerGallon(); } 虽然在接口中不能包含实例字段，但却可以包含常量。例如： public interface Powered extends Moveable { double milesPerGallon(); double SPEED_LIMIT = 95; // a public static final constant } 与接口中的方法都自动地被设置为 public —样，接口中的字段总是 public static final。 |
| ④ 注释 可以将接口方法标记为 public，将字段标记为 public static final。有些程序员出于习惯或提高清晰度的考虑，可能会这样做。但 Java 语言规范却建议不要提供多余的关键字。 |
| ① Java 不支持多重继承 有些程序设计语言允许一个类有多个超类，例如 C++。我们将此特性称为多重继承。而 Java 的设计者选择了不支持多继承，其主要原因是多继承会让语言本身变得非常复杂（如同 C++)，效率也会降低（如同 Eiffel)。 实际上，接口可以提供多重继承的大多数好处，同时还能避免多重继承的复杂性和低效性。 |
| ② C++ 注释 C++ 具有多重继承特性，随之带来了一些诸如虚基类、控制规则和横向指针类型转换等复杂特性 ，很少有 C++ 程序员使用多继承，甚至有些人说：就不应该使用多继承。也有些程序员建议只对 “混合” 风格的继承使用多继承。在“ 混合” 风格中，一个主要的基类描述父对象，其他的基类（因此称为混合）扮演辅助的角色这种风格类似于 Java 类中从一个基类派生，然后实现若干个辅助接口。 |
| ③ 定义抽象方法 （1）在任何版本的 Java 中，接口都能定义抽象方法。 （2）格式： public abstract 返回值类型 方法名称(参数列表); （3）注意事项： 接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract，这两个固定的关键字可以省略不写。 |
| ④ 使用规则 （1）接口不能直接使用，必须有一个”实现类“来”实现“该接口。 格式： public class 实现类名称 implements 接口名称 { . . . } （2）接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。 实现：去掉 abstract 关键字，加上方法体大括号。 （3）创建实现类的对象，进行使用。 （4）注意事项： 如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。 如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。 |
| ① 在接口中增加静态方法 在 Java SE 8 中，允许在接口中增加静态方法。 格式： public static 返回值类型 方法名称(参数列表){ 方法体 } 提示：就是将 abstract 或者 default 换成 static 即可，带上方法体。 理论上讲，没有任何理由认为这是不合法的。只是这有违于将接口作为抽象规范的初衷。目前为止，通常的做法都是将静态方法放在伴随类中。 |
| ② 接口的方法可以是 private 在 Java 9 中，接口的方法可以是 private。private 方法可以是静态方法或实例方法。由于私有方法只能在接口本身的方法中使用，所以它们的用法很有限，只能作为接口中其他方法的辅助方法。 |
| ① 使用 default 修饰符 可以为接口方法提供一个默认实现。必须用 default 修饰符标记这样一个方法。 public interface Comparable default int compareTo(T other) { return 0; } // By default, all elements are the same } |
| ② 接口的默认方法 接口的默认方法，可以通过接口实现类对象，直接调用。 接口的默认方法，可以被接口实现类进行覆盖重写。 |
| ① 出现的问题 如果先在一个接口中将一个方法定义为默认方法，然后又在超类或另一个接口中定义同样的方法，会发生什么情况？诸如 Scala 和 C++ 等语言对于解决这种二义性有一些复杂的规则。幸运的是，Java 的相应规则要简单得多。 |
| ② Java 规则 （1）超类优先。如果超类提供了一个具体方法，同名而且有相同参数类型的默认方法会被忽略。 （2）接口冲突。如果一个超接口提供了一个默认方法，另一个接口提供了一个同名而且参数类型（不论是否是默认参数）相同的方法，必须覆盖这个方法来解决冲突。 （3）接口与接口之间是多继承的。 （4）多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，【而且带着 default 关键字】。 |
public class Interface {
public static void main(String[] args) {
// 创建实现类的对象使用
MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
impl.methodAbs1();
impl.methodAbs2();
impl.methodAbs3();
impl.methodAbs4();
}
}
public interface MyInterfaceAbstract {
// 定义抽象方法，省略了 public abstract
void methodAbs1();
void methodAbs2();
void methodAbs3();
void methodAbs4();
}
public class MyInterfaceAbstractImpl implements MyInterfaceAbstract{
@Override
public void methodAbs1() {
System.out.println("这是第一个方法！");
}
@Override
public void methodAbs2() {
System.out.println("这是第二个方法！");
}
@Override
public void methodAbs3() {
System.out.println("这是第三个方法！");
}
@Override
public void methodAbs4() {
System.out.println("这是第四个方法！");
}
}
========================================================================================
public class Interface2 {
public static void main(String[] args) {
// 创建了实现对象
MyInterfaceDefaultA a= new MyInterfaceDefaultA();
a.methodAbs(); // 调用抽象方法，实际运行的是右侧实现类。
// 调用默认方法，如果实现类当中没有，会向上找接口。
a.methodDefault();
System.out.println("=======================");
MyInterfaceDefaultB b= new MyInterfaceDefaultB();
b.methodAbs();
b.methodDefault();
}
}
public interface MyInterfaceDefault {
// 抽象方法
void methodAbs();
// 新添加的方法，改成默认方法
default void methodDefault(){
System.out.println("这是新添加的默认方法！");
}
}
public class MyInterfaceDefaultA implements MyInterfaceDefault{
@Override
public void methodAbs() {
System.out.println("实现了抽象方法，AAA");
}
}
public class MyInterfaceDefaultB implements MyInterfaceDefault{
@Override
public void methodAbs() {
System.out.println("实现了抽象方法，BBB");
}
@Override
public void methodDefault() {
System.out.println("实现类B覆盖重写了接口的默认方法！");
}
}
=======================================================================================
public class Interface3 {
public static void main(String[] args) {
// 创建了实现类对象
MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();
// 直接通过接口调用静态方法
MyInterfaceStatic.methodStatic();
}
}
public interface MyInterfaceStatic {
static void methodStatic(){ // 前面省略了 public
System.out.println("这是接口的静态方法！");
}
}
public class MyInterfaceStaticImpl implements MyInterfaceStatic {
}
=======================================================================================
public class Interface4 {
public static void main(String[] args) {
MyInterfacePrivateB.methodStatic1();
MyInterfacePrivateB.methodStatic2();
}
}
public interface MyInterfacePrivateB {
static void methodStatic1(){
System.out.println("静态方法1");
methodCommon();
}
static void methodStatic2(){
System.out.println("静态方法2");
methodCommon();
}
private static void methodCommon(){
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");
}
}
======================================================================================
public class Interface5 {
public static void main(String[] args) {
// 访问接口当中的常量
System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS);
}
}
public interface MyInterfaceConst {
// 这其实就是一个常量，一旦赋值，不可以修改
int NUM_OF_MY_CLASS=12;
}
========================================================================================
public interface MyInterfacePrivateA {
default void methodDefault1(){
System.out.println("默认方法1");
methodCommon();
}
default void methodDefault2(){
System.out.println("默认方法2");
methodCommon();
}
private void methodCommon(){
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");
}
}
