4.16Java接口的作用

4.16Java接口的作用

本章内容

• 为什么需要接口？

• 接口和抽象类的区别

---

为什么需要接口？

接口的定义：A

接口就是比"抽象类"还"抽象"的"抽象类"

接口的作用：

• 可以更加规范的对子类进行约束

• 全面地专业地实现了：规范和具体实现地分离

接口和抽象类地区别

抽象类

特点：

抽象类还提供了某些具体实现---某些普通的方法

接口

特点：

• 不提供任何实现---不提供任何普通方法

• 接口中所有方法都是抽象方法

• 接口是完全面向规范的，规定了一批类具有的公共方法规范

从接口的实现者角度看

接口定义了可以向外部提供的服务

从接口的调用者角度看

接口定义了实现者能提供那些服务

接口的作用

两个模块之间通信的标准

做系统时就是使用"面向接口"的思想来设计系统

接口和实现类不是父子关系，是实现规则的关系

举例:

定义一个接口Runnable，Car实现它能在地上跑，Train实现它也能在地上跑，任何东西实现了Runnable接口都能在地上跑

浅谈接口的本质

接口的本质是契约

就像法律意义，制定好了以后大家都遵守

面向对象的精髓是对对象抽象，最能体现抽象这一点的就是接口

设计模式只针对具备了抽象能力的语言(C++、Java、C#等)，因为设计模式所研究的实际上就是如何合理的去抽象

区别

1. 普通类：具体实现

2. 抽象类：具体实现，规范(抽象方法)

3. 接口：规范!

转到项目中就是

• 项目分层

• 层与层之间通过接口进行调用，而不是在通过类的调用

• 接口提供也是提供一层接口，因为接口只有抽象方法，比较稳定。不管具体的实现。随时可以改具体的实现

接口的声明格式:

[访问修饰符] interface 接口名 [extends 父接口1, 父接口2...]{
    常量定义;
    方法定义;
}

接口实例：

package com.cxl;
​
/**
 * 测试接口和实现类
 * @author Lucifer
 */
public class TestInterface {
    public static void main(String[] args) {
​
        /*找一个飞行器，方法是创建对象，但是接口不能实例化，所以要实例化实现了接口的类*/
        Volant v = new Angel(); //把子类实现了接口的对象赋予一个类型，需要实现哪个接口就赋给哪个接口
        /*
        写了Volant意味着编译器把他识别成了Volant
        会使用Volant里面的方法
        虽然Angle里面有其他方法但是不能被调用---编译器只认识接口类型
         */
        v.fly();
​
        Honest h = new GoodMan();
        h.helpOther();
    }
}
​
/**
 * 飞行接口，只要实现了这个接口的都是飞行器
 * @author Lucifer
 */
interface Volant{
​
    /*定义飞行方法*/
    public abstract void fly();
​
    /*定义飞行高度*/
    public static final int FLY_HEIGHT = 1000;
}
​
/**
 * 善良接口，实现了这个接口的都是天使
 * @author Lucifer
 */
interface Honest{
​
    /*定义善良的方法*/
    public abstract void helpOther();
}
​
/**
 * 定义实现类，用于实现接口
 * @author Lucifer
 */
class Angel implements Volant,Honest{
    /*
    实现类可以实现一个接口也可以实现多个接口---多继承
    由于接口当中的所有都是规范的---抽象的
    所以实现的时候全部都需要重写
     */
​
    /*重写fly方法*/
    @Override
    public void fly(){
        System.out.println("Fly Man!");
    }
​
    /*实现helpOther方法*/
​
    @Override
    public void helpOther() {
        System.out.println("I can help you!");
    }
}
​
/**
 * 在实现一个类,实现帮助别人的接口
 * @author Lucifer
 */
class GoodMan implements Honest{
    /*
    重写Honest里面的方法
     */
​
    /*重写helpOther方法*/
    @Override
    public void helpOther(){
        System.out.println("GoodMan will help each other!");
    }
}
​
/**
 * 在实现一个类，鸟人类，会飞，实现飞行接口
 * @author Lucifer
 */
class BirdMan implements Volant{
    /*
    重写Volant里面的方法---因为接口里面的全部是抽象的方法和常量
     */
​
    /*重写fly方法*/
    @Override
    public void fly(){
        System.out.println("BirdMan can fly");
    }
}

 

定义接口的详细说明：

1. 访问修饰符：只能是public或default

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

3. extends：接口可以多继承---不止有一个父接口

4. 常量：接口中的属性只能是常量，总是：public static final修饰，不声明也是这样

5. 方法：接口中的方法只能是：public abstract，省略的画也是public abstract

要点

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

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

3. 一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的

4. JDK7之前，接口中只能包含静态常量、抽象方法，不能有普通属性、构造方法、普通方法

5. 接口是稳定的，不能定义变量，只能定义不变的

6. 接口中不存在私有

接口的多继承

接口完全支持多继承，和类的继承类似

子接口扩展某个父接口，将会获得父接口中所定义的一切 Java的类只有单继承没有多继承，Java的接口有多继承

实例：

package com.cxl;
​
/**
 * 接口可以多继承，测试接口的多继承
 * @author Lucifer
 */
public class TestInterface2 {
}
​
/*定义一个接口A*/
interface A{
​
    /*接口当中的方法都是抽象的方法*/
    public abstract void testA();
​
}
​
/*定义一个接口B*/
interface B{
​
    /*接口当中的方法*/
    public abstract void testB();
​
}
​
/**
 * 接口的多继承，接口C继承接口A和B---注意这里是继承(extends)不是工具(implements)
 * @author Lucifer
 */
interface C extends A,B{
​
    /*
    接口C继承了A和B不需要重写A,B中的方法
    C拥有A,B当中的全部的方法
    实现类在实现了接口C的同时也可以实现接口A,B
    */
​
    /*接口C自己的方法*/
    public abstract void testC();
​
}
​
/**
 * 定义实现类，实现接口C的方法同时也实现了接口A,B当中的方法，因为接口C继承了接口A和B
 * @author Lucifer
 */
class Mysubclass implements C{
    /*
    因为接口C继承了接口A,B
    所以在重写接口方法的时候只需要重写需要使用的方法即可
     */
​
    /*重写接口C当中的方法*/
    @Override
    public void testC(){
    }
​
    /*重写接口A的方法*/
    @Override
    public void testA() {
    }
​
    /*重写接口B的方法*/
    @Override
    public void testB() {
    }
}

面向接口编程

面向接口编程是面向对象编程的一部分

为什么需要面向接口编程？

因为软件设计需求的复杂变化更多的体现在具体实现上，我们必须围绕某种稳定的东西开展达到以静制动

接口就是规范，是最稳定的。面向接口编程可以让我们把握真正核心的东西

通过面向接口编程而不是面向实现类编程可以大大降低程序模块间的耦合性，提高整个系统的可扩展性和可维护性

接口语法简单但是如何使用才是难点。多运用才能深刻体会

接口里面是不变的，不变是最稳定的