接口 interface

接口就是一组规范（就像我们法律一样）             ，所有实现类都要遵守
  
  
  
  
  
  
  。

面向对象的精髓  
 
  
 
  
 
  
 
  
 
  
 
  
 ，最能体现这一点的就是接口 
  
  
  
  
  
  
。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如 C++
  
  
  
  
  
  
  、Java 
  
  
  
  
  
  
、C#等）













，就是因为设计模式所研究的
  
  
  
  
  
  
 ，实际上就是如何合理的去抽象 


 


 


 


 


 


 

。

接口的作用

为什么需要接口?接口和抽象类的区别?

接口就是比“抽象类
  
  
  
  
  
  
  ”还“抽象 
  
  
  
  
  
  
”的“抽象类 


 


 


 


 


 


 

”  
  
  
  
  
  
  ，可以更加规范的对子类进行约束
 
 
 
 
 
 
 。全面地专业地实现了：规范和具体实现的分离  
   
   
   
   
   
   
。接口是两个模块之间通信的标准
 


 


 


 


 


 


 

，通信的规范 

 

 

 

 

 

 
。如果能把你要设计的模块之间的接口定义好
 
 
 
 
 
 
，就相当于完成了系统的设计大纲   
   
   
   
   
   
   ，剩下的就是添砖加瓦的具体实现了

 

 

 

 

 

 

 。大家在工作以后
 

 

 

 

 

 

 
，做系统时往往就是使用“面向接口
 
 
 
 
 
 
 ”的思想来设计系统             。

接口和实现类不是父子关系

 

 

 

 

 

 

，是实现规则的关系 
 

 
 

 
 

 
 

 
 

 
 

 
 
。比如：定义一个接口 Runnable              ，Car 实现它就能在地上跑
 
 

 
 

 
 

 
 

 
 

 
 

 
 ，Train 实现它也能在地上跑













，飞机实现它也能在地上跑













。就是说                    ，如果它是交通工具 
 
 
 
 
 
 
 
 
 
 
 
 
 ，就一定能跑




















，但是一定要实现 Runnable 接口                    。

[访问修饰符] interface 接口名 [extends 父接口 1             ，父接口 2…] {常量定义；方法定义；}

类实现接口用implements表示

[访问修饰符] class 类名 implements 接口名 {}

访问修饰符：只能是 public 或默认 
 
 
 
 
 
 
 
 
 
 
 
 
 
。

  接口名：和类名采用相同命名机制



















。

  extends：接口可以多继承              。

  常量：接口中的属性只能是常量  
 
  
 
  
 
  
 
  
 
  
 
  
 ，总是：public static final 修饰 
 
  
 
  
 
  
 
  
 
  
 
  
 
。不写也是












。

  方法：接口中的方法只能是：public abstract
  
  
  
  
  
  
  。 省略的话













，也是 public abstract 
  
  
  
  
  
  
。

要点

接口不能实例化

我们可以创建接口的实现类对象使用

接口的子类 implements

要么重写接口中的所有抽象方法

要么子类也是抽象类

  子类通过 implements 来实现接口中的规范 


 


 


 


 


 


 

。

  接口不能创建实例
  
  
  
  
  
  
 ，但是可用于声明引用变量类型
 
 
 
 
 
 
 。

  一个类实现了接口  
  
  
  
  
  
  ，必须实现接口中所有的方法
 


 


 


 


 


 


 

，并且这些方法只能是 public 的  
   
   
   
   
   
   
。

  JDK1.8（不含 8）之前
 
 
 
 
 
 
，接口中只能包含静态常量 


 


 


 


 


 


 

、抽象方法   
   
   
   
   
   
   ，不能有普通属性
 
 
 
 
 
 
 、构造方法  
   
   
   
   
   
   
、普通方法 

 

 

 

 

 

 
。

  JDK1.8（含 8）后
 

 

 

 

 

 

 
，接口中包含普通的静态方法 

 

 

 

 

 

 
、默认方法

 

 

 

 

 

 

 。

public class test { public static void main(String[] args) { Volant volant = new Angel(); volant.fly(); System.out.println(Volant.FLY_HIGHT); Honest honest = new GoodMan(); honest.helpOther(); } } /** 飞行接口 */ interface Volant { int FLY_HIGHT = 100; // 总是：public static final 类型的； void fly(); // 总是：public abstract void fly(); } /** 善良接口 */ interface Honest { void helpOther(); } /** Angel 类实现飞行接口和善良接口 */ class Angel implements Volant, Honest { public void fly() { System.out.println("我是angel!!

 

 

 

 

 

 

，飞起来啦！"); } public void helpOther() { System.out.println("帮助需要帮助的人"); } } class GoodMan implements Honest { public void helpOther() { System.out.println("帮助需要帮助的人"); } } class BirdMan implements Volant { public void fly() { System.out.println("我是鸟人              ，正在飞！"); } }

接口中定义静态方法和默认方法(JDK8)

JAVA8 之前
 
 

 
 

 
 

 
 

 
 

 
 

 
 ，接口里的方法要求全部是抽象方法             。

JAVA8（含 8）之后













，以后允许在接口里定义默认方法和静态方法 
 

 
 

 
 

 
 

 
 

 
 

 
 
。

JDK8 新特性_默认方法

  Java 8 及以上新版本                    ，允许给接口添加一个非抽象的方法实现 
 
 
 
 
 
 
 
 
 
 
 
 
 ，只需要使用 default 关键字即可




















，这个特征又叫做默认方法（也称为扩展方法）













。

  默认方法和抽象方法的区别是抽象方法必须要被实现             ，默认方法不是                    。作为替代方式  
 
  
 
  
 
  
 
  
 
  
 
  
 ，接口可以提供默认方法的实现













，所有这个接口的实现类都可以得到默认方法 
 
 
 
 
 
 
 
 
 
 
 
 
 
。

public class test { public static void main(String[] args) { A a = new Test_A(); a.moren(); } } interface A { default void moren() { System.out.println("我是接口 A 中的默认方法！"); } } class Test_A implements A { @Override public void moren() { System.out.println("Test_A.moren"); } }

静态方法和默认方法

本接口的默认方法中可以调用静态方法



















。

public class test { public static void main(String[] args) { A a = new Test_A(); a.moren(); } } interface A { public static void staticMethod() { System.out.println("A.staticMethod"); } public default void moren() { staticMethod(); System.out.println("A.moren"); } } class Test_A implements A { public static void staticMethod() { System.out.println("Test_A.staticMethod"); } }

接口的多继承

接口支持多继承              。和类的继承类似
  
  
  
  
  
  
 ，子接口 extends 父接口  
  
  
  
  
  
  ，会获得父接口中的一切 
 
  
 
  
 
  
 
  
 
  
 
  
 
。

interface A { void testa(); } interface B { void testb(); } /** 接口可以多继承：接口 C 继承接口 A 和 B */ interface C extends A, B { void testc(); } public class test implements C { public void testc() { } public void testa() { } public void testb() { } }

接口语法本身非常简单
 


 


 


 


 


 


 

，但是如何真正使用？这才是大学问












。我们需要后面在项目中反复使用
 
 
 
 
 
 
，才能体会到

类和接口的关系

类与类的关系

继承关系   
   
   
   
   
   
   ，只能单继承
 

 

 

 

 

 

 
，但是可以多层继承

类与接口的关系

实现关系

 

 

 

 

 

 

，可以单实现              ，也可以多实现
 
 

 
 

 
 

 
 

 
 

 
 

 
 ，还可以在继承一个类的同时实现多个接口

接口与接口的关系

继承关系













，可以单继承                    ，也可以多继承

接口中私有方法

私有方法产生原因

Java 9中新增了带方法体的私有方法 
 
 
 
 
 
 
 
 
 
 
 
 
 ，这其实在Java 8中就埋下了伏笔：Java 8允许在接口中定义带方法体的默认方法和静态方法
  
  
  
  
  
  
  。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时




















，程序必然考虑将这段实现代码抽取成一个共性方法             ，而这个共性方法是不需要让别人使用的  
 
  
 
  
 
  
 
  
 
  
 
  
 ，因此用私有给隐藏起来













，这就是Java 9增加私有方法的必然性

定义格式

格式1

private 返回值类型 方法名(参数列表) { }

      【每天5分钟轻松学java第四弹之【接口】来啦！】

每天一个技术点】一个接口的诞生之路