一：基本介绍

接口就是给出一些没有实现的方法,封装到一起,到某个类要使用的时候,在根据具体情况把这些方法写出来。语法：

  1. interface 接口名{
  2.     //属性
  3.     //抽象方法
  4. }

:::danger 接口是更加抽象的抽象的类，抽象类里的方法可以有方法体。
接口里的所有方法都没有方法体。【JDK7.0】__接口体现了程序设计的多态和高内聚低耦合的设计思想
特别说明：JDK8。0后接口类可以有静静态方法，默认方法，也就是接口可以有方法的具体实现 :::

二：深入理解

  1. 说现在要制造战斗机,武装直升机.专家只需把飞机需要的功能/规格定下来即可,然后让别的人具体实现就可。
  2. 说现在有一个项目经理(段玉),管理三个程序员,功能开发一个软件.为了控制和管理软件,项目经理可以定义一些接口，然后由程序员具体实现。(1.项目质量2.项目进度3.项目奖)参加工作

模拟一个数据库连接操作

  2. public interface InterfaceTest {
  4.     //数据库链接操作
  5.     public void connection();
  7.     public void close();
  9. }
  11. public class Test {
  12.     public static void main(String[] args) {
  13.         Mysql mysql = new Mysql();
  14.         Orcle orcle = new Orcle();
  16.         //通过传入的参数来判断执行的数据库连接操作
  17.         to(mysql);
  18.         to(orcle);
  20.     }
  22.     public static void to(InterfaceTest interfaceTest){
  23.         interfaceTest.connection();
  24.         interfaceTest.close();
  25.     }
  26. }
  29. public class Orcle implements InterfaceTest{
  31.     @Override//继承接口来实现接口的方法，来完成对应的操作
  32.     public void connection() {
  33.         System.out.println("Orcle数据库连接成功");
  34.     }
  36.     @Override
  37.     public void close() {
  38.         System.out.println("Oecle数据库连接结束");
  39.     }
  40. }
  43. public class Mysql implements InterfaceTest{
  45.     @Override
  46.     public void connection() {
  47.         System.out.println("Mysql数据库连接成功");
  48.     }
  50.     @Override
  51.     public void close() {
  52.         System.out.println("Mysql数据库连接关闭");
  53.     }
  54. }

三：注意事项和细节

  • 接口不能被实例化，只能被实现 ```java public interface InterfaceTest { public void connection();

    public void close();

} public class connect implements InterfaceTest{

}

  2. - 接口中所有的方法是public 方法，口中抽象方法，可以不用abstract修饰
  3. ```java
  4. public interface InterfaceTest {
  5.     public void close();
  6.     //实际上是abtract void close();
  8. }

  • 一个普通类实现接口，就必须将该接口的所有方法实现 ```java public interface InterfaceTest { public void connection();

    public void close();

} public class Mysql implements InterfaceTest{ //必须实现所有接口的方法 @Override public void connection() { System.out.println(“Mysql数据库连接成功”); }

  1. @Override
  2. public void close() {
  3.     System.out.println("Mysql数据库连接关闭");
  4. }

}

  2. - 抽象类实现接口，可以不用实现接口的方法
  3. ```java
  4. abstract public class Test01 implements InterfaceTest {
  5.     //抽象了可以不用全部实现接口
  6.     @Override
  7.     public void close() {
  9.     }
  10. }
  11. public interface InterfaceTest {
  13.     public void connection();
  15.     public void close();
  17. }

  • 一个类可以同时实现多个接口【单继承，多接口】 ```java public class InteranceTest00 implements InterfaceTest,TestInterface{

    @Override public void connection() {

    }

    @Override public void close() {

    } }

  2. - 接口中的属性,只能是final的，而且是 public static final修饰符。比如：int a=1;实际上是public static final int a=1;(必须初始化)
  3.    - 接口中属性的访问形式：接口名.属性名
  4. ```java
  5. public class Test {
  6.     public static void main(String[] args) {
  7.         System.out.println(AA.NUM); //可以通过接口接口名调用
  8.         AA.NUM = 20; //且不能修改，也这也说明是final的
  9.     }
  10. }
  12. interface AA{
  13.     int NUM =1;
  14. }
  • 接口不能继承其他的类，但是可以继承多个别的接口 ```java //接口可以继承接口 interface AA{ int NUM =1;

} interface BB extends AA{

}

  2. - 接口的修饰符只能是public 和默认 ，这点和类的修饰符是一样的
  3. ```java
  4.  public interface AA{
  5.     int NUM =1;
  8. }
  9. interface BB extends AA{
  11. }

四：实现接口vs接口类

  • 接口和继承解决的问题不同
    • 继承的价值主要在于：解决点的复用性和可维护性
    • 接口的价值主要在于：设计，设计好各种规范，让其他类去实现这些方法，即更加的灵活。。
  • 接口比继承更加的灵活
    • 继承满足is-a的关系
    • 接口满足like－a 的关系

  • 接口在一定程度上实现代码解耦[即:接口规范性+动态绑定机制] ```java public class Test { public static void main(String[] args) {

    1.   LitterMoney litterMoney = new LitterMoney();
    2.   litterMoney.fly();
    3.   litterMoney.walk();

    } } interface Fly{ public void fly(); } class Monkey{ private String name;

    public void walk(){

    1.   System.out.println("猴子走路");

    } }

class LitterMoney extends Monkey implements Fly{ @Override public void walk() { super.walk(); } @Override public void fly() { System.out.println(“猴子通过接口学会飞了”); } }

  1. <a name="shKDR"></a>
  2. ### 五：接口的多态属性
  3. **_接口引用可以指向实现了接口的类的对象_**
  4. <a name="aXMP9"></a>
  5. #### 1：多态接口数组
  6. ```java
  7. public class Test00 {
  8.     public static void main(String[] args) {
  10.         USB[] usb = new USB[2];
  12.         //接口类型的变量可以指向实现了该接口的类的对象实例
  13.         usb[0] = new Camera("索尼单反");
  14.         usb[1] = new Phone("华为");
  16.         for (int i = 0; i < usb.length; i++) {
  17.             if (usb[i] instanceof Phone){
  18.                 usb[i].Use();
  19.                 ((Phone)usb[i]).work();
  20.             }
  21.         }
  23.     }
  24. }
  26. public interface USB {
  27.     void Use();
  29. }
  31. public class Phone implements USB{
  32.     private String name;
  33.     public void work(){
  34.         System.out.println("手机工作中");
  35.     }
  37.     public Phone(String name) {
  38.         this.name = name;
  39.     }
  41.     public String getName() {
  42.         return name;
  43.     }
  45.     public void setName(String name) {
  46.         this.name = name;
  47.     }
  49.     @Override
  50.     public void Use() {
  51.         System.out.println("用" +getName()+"打电话");
  52.     }
  53. }
  55. public class Camera implements USB{
  56.     private String name;
  58.     public Camera(String name) {
  59.         this.name = name;
  60.     }
  63.     public String getName() {
  64.         return name;
  65.     }
  67.     public void setName(String name) {
  68.         this.name = name;
  69.     }
  71.     @Override
  72.     public void Use() {
  73.         System.out.println("用"+getName()+"照相");
  74.     }
  75. }

2：多态传递现象

  1. public class Test01 {
  2.     public static void main(String[] args) {
  4.         //接口类型的变量可以指向，实现了该接口的类的对象实例
  5.         BB bb  =new Person();
  6.         //如果BB继承了AA接口
  7.         //那么就相当于Person类也实现了AA接口
  8.         //这就是接口的多态传递
  9.         AA aa = new Person();
  11.     }
  12. }
  14. interface  AA{
  15.     void wolk();
  16. }
  17. interface BB extends AA{
  20. }
  22. class Person implements BB{
  24.     @Override
  25.     public void wolk() {
  27.     }
  28. }

六：练习

1：

  1. interface A{
  2.     int a=23;//等价public static final int a = 23;
  3. }
  4. class B implements A{ //正确
  5. }
  6. public static void main(String[] args) {
  7.     B b=new BO;//ok
  8.     System.out.println(b.a); //23
  9.     System.out.println(A.a); //23
  10.     System.out.println(B.a);  //23
  11. }

2：

image.png

  1. interface A { 
  2.     int x = 0;  //想到 等价 public static final int x = 0;
  3. } 
  4. class B { 
  5.     int x = 1;
  6. } 
  7. //普通属性
  8. class C extends B implements A { 
  9.     public void pX() {
  10.         //
  11.         System.out.println(x); //错误，会报错，因为有两个x不知道调用的是哪一个
  12.         //访问接口的x就用接口名.属性
  13.         System.out.println(A.x);
  14.         //访问父类的属性就用super
  15.         System.out.println(super.x);
  17.     }
  18. }
  19. public static void main(String[] args) { 
  20.     new C().pX();
  21. }

:::danger 访问接口的属性用：接口名.属性
访问父类的属性用：super(属性名) :::