接口

1.1   什么是接口

接口是一种引用数据类型。使用interface声明接口，形式

public interface 接口名称{ }

 

1.1.1     接口的特性

[1] 接口中可以声明属性(C)。接口中定义的所有变量都是static final类型的。

public interface MyInterface {     public static final String version = "1.0";     public int count = 10; // 默认是static final类型 }

 

一般很少在接口中声明属性。

 

[2] (C)接口中的方法都是公共抽象方法。

public interface MyInterface {      public abstract void showInfo();      void showInfo3();           // 推荐写法      public void showInfo2(); }

 

[3] (C)接口不能拥有构造方法，不能用于创建对象,也就没有方法体

 

[4] 接口可以多继承。一个接口可以继承多个其他接口(B)

public interface CInterface extends AInterface, BInterface {   }

CInterface接口就具备了A、B接口中定义的抽象方法。

 

[5] (A) 一个类可以实现一个或者多个接口，该类称为接口的实现类(implement class).

实现类必须实现接口中的所有(抽象)方法

public class ImplClassA implements AInterface,BInterface{       @Override     public void showInfoA() {         System.out.println("实现接口中的showInfoA");     }       @Override     public void showInfoB() {         System.out.println("实现接口中的showInfoB");     } }

 

一个类只能继承一个父类，同时实现多个接口。继承在前，实现在后。

public class ImplClass3 extends AbsClass implements AInterface,BInterface{        @Override      public void showInfoA() {          // TODO Auto-generated method stub               }        @Override      public void showInfoB() {          // TODO Auto-generated method stub               }        @Override      public void showInfoC() {          // TODO Auto-generated method stub               }   }

 

特殊情况:

如果一个抽象父类定义了和接口同名的抽象方法，实现类实现的是抽象父类的抽象方法。

package cn.interface02;   public class ImplClass4 extends AbsClass implements CInterface{       @Override     public void showInfoA() {         // TODO Auto-generated method stub             }       @Override     public void showInfoB() {         // TODO Auto-generated method stub             }       @Override     public void showInfoC() {         // TODO Auto-generated method stub             }   }

 

总结:

实现类实现接口，必须实现接口中定义的抽象方法。

→  方法即行为，表示一种功能

→  接口定义了一套功能，实现类必须实现这些功能 –> 实现类的能力得到拓展。

 

1.2   接口的应用

1.2.1     [1]接口表示一种能力(B)

接口中定义的一些系列方法表示的是一种能力。接口让实现类实现这些能力，实现类的能力得到拓展和升级。

实现类根据自身特性实现接口中定义的方法。

 

package cn.sxt.interface03;   /**  * 驾驶接口  */ public interface DriveInterface {      /**       * 驾驶的方法       */      public void drive(); }

package cn.sxt.interface03;   public class Student implements DriveInterface{     …     public void learn(String cName) {         System.out.println(this.name+"正在学习"+cName);     }       @Override     public void drive() {         System.out.println(this.name+"正在驾驶...");     }   }

package cn.sxt.interface03;   public class Teacher implements DriveInterface{     /// …       @Override     public void drive() {         System.out.println(this.name+"正在学习驾驶技术...");         System.out.println(this.name+"很快学会了飙车...");     }     }

 

实现类Student具备了驾驶能力，实现类Teacher也具备了驾驶能力，原因是都实现了DriveInterface，两个实现类的能力得到了增强。

 

1.2.2     [2]接口实现多态(B)

package cn.sxt.interface4;   public class Test01 {     public static void main(String[] args) {                 // 同一引用类型         USBInterface usbInterface = null;                 // 实例不同         usbInterface = new USBFan();         // 对同一方法的执行结果不同         usbInterface.connect();           usbInterface = new USBMouse();         usbInterface.connect();                 usbInterface = new USBDisk();         usbInterface.connect();     } }

 

接口实现多态: 接口类型 引用 实现类对象

继承实现多态: 父类类型 引用 子类对象

接口定义的方法被实现类实现，通过接口引用实现类时，调用接口中的方法时，执行的是实现类实现的方法。

 

实现类对象具备接口中定义的能力 是一种has a 关系

子类对象是一种父类类型 是一种is a 关系

 

1.2.3     [3] 面向接口编程(A)

接口表示一种约定(协议),约定(规范)了实现类应该具备(has a)的能力。

 

理解:

=>实现类必须实现接口中所有的方法，所以接口规范了实现类的行为

=> 接口约定了实现类应该具备的行为。

 

面向接口编程

所谓面向接口编程，在程序设计时，只关心实现类具备什么能力，而不关心实现类如何实现这个能力。面向接口编程时，面向接口的约定而不考虑接口的具体实现。

 

也就是说，面向接口编程时，接口的定义方只关系实现类是否具备接口所定义的能力，而实现类如何被的该能力接口定义方一点都不关心。

 

package cn.sxt.interface06;   public class Writer {        // 预留墨盒接口      private InkBoxInterface inkBoxInterface;        // 预留纸张接口      private PaperInterface paperInterface;        public InkBoxInterface getInkBoxInterface() {          return inkBoxInterface;      }        public void setInkBoxInterface(InkBoxInterface inkBoxInterface) {          this.inkBoxInterface = inkBoxInterface;      }        public PaperInterface getPaperInterface() {          return paperInterface;      }        public void setPaperInterface(PaperInterface paperInterface) {          this.paperInterface = paperInterface;      }        public Writer(InkBoxInterface inkBoxInterface, PaperInterface paperInterface) {          super();          this.inkBoxInterface = inkBoxInterface;          this.paperInterface = paperInterface;      }        public Writer() {          super();      }        public void print(String content) {          System.out.println("打印机正在使用"+this.inkBoxInterface.getColor()+"颜色打印"+this.paperInterface.getSize()+"打印"+content);      } }

 

 

1.2.3.1  抽象类和接口的异同比较

• 抽象类和接口都是引用数据类型，他们都不能创建对象。
• 他们都可以定义抽象方法，都可以实现多态。但是抽象类可以定义非抽象方法，而接口中定义的都是抽象方法。
• 抽象类和接口都具有传递性。抽象类是单根性（单继承），而接口是多继承。
• 在概念上，都可以重写抽象方法。子类重写抽象类，实现类实现接口
• 抽象类和子类解决的是模块内的问题（代码重用,重写,多态）而接口解决的是模块间的问题 => 高内聚，低耦合。接口可以用解耦模块。

转载于:https://www.cnblogs.com/l3344/p/10771071.html