接口与实现

写在前面：本文章来自于在学习过程中的总结，供大家参考。因水平有限，博客中难免会有不足，恳请大佬们不吝赐教！

接口

接口声明

package Interface;

interface A{
    void eat();
    static int s=0;
}

interface B extends A {
    void work();
}

public class C implements B{

    public void eat(){
        System.out.println("eat");
    }

    public void work(){
        System.out.println("work");
    }

    public static void main(String[] args) {
        C c=new C();
        c.eat();
        c.work();
        System.out.println(A.s);
    }
}

结果：

eat
work
0

定义接口时使用关键字interface来声明一个接口

接口体

接口体中包含常量的声明（没有变量）和抽象方法两部分。接口体中的所有常量的访问权限都是public static，（允许省略public static final修饰符）。

实现接口

• 如果一个非抽象类实现了某个接口，那么这个类必须重写这个接口中的所有方法。
• 由于接口的方法一定是public stract方法，所以类在重写接口时一定要明显地使用public修饰（否则就降低了访问权限）。

如果一个类声明实现一个接口，但没有重写接口中地所有方法，那么这个类必须时抽象类。

interface A{
    void eat();
    static int s=0;
}

interface B extends A {
    void work();
}

abstract public class C implements B{
    public void work(){
        System.out.println("work");
    }

    public static void main(String[] args) {
//        C c=new C();//错误，没有重写接口中地所有方法，所以C为抽象类
//        c.eat();
//        c.work();
        System.out.println(A.s);
    }
}

结果：

0

• 定义接口是，如果在interface前面加上public，就成该接口为public接口。public接口可以被任何一个类实现。如果一个接口不加public修饰，那么它只能被同一包中的类实现。
• 如果父类实现了某个接口，那么子类也自然实现了这个接口，子类不必使用implements声明实现这个接口。

接口的UML图

第一层：名字层，接口的名字必须是斜体
第二层：常量层，列出接口中的常量及类型
第三层：方法层（操作层），列出方法名及返回类型

接口回调

在C语言中，接口回调表示一个变量的地址在某个时刻存放在一个指针变量中，那么指针变量就可以简介操作该变量存放的数据。

在Java语言中，接口回调是指：可以把实现某一接口的类创建的对象的引用赋值给该接口声明的接口变量。

interface A{
    void show();
}

class B implements A {
    public void show(){
        System.out.println("B");
    }
}

public class C implements A{
    public  void show(){
        System.out.println("C");
    }

    public static void main(String[] args) {
        A a=new B();
        a.show();
        a=new C();
        a.show();
    }
}

结果：

B
C

理解接口

abstract class vehicle{//基类：交通工具
    abstract void brake();//刹车,必须使用abstract修饰
}

interface A{
    void a();
}
interface B{
    void b();
}

class Bus extends vehicle implements A,B{
    @Override
    void brake() {
        System.out.println("公交车刹车了");
    }
    public void a(){
        System.out.println("公交车使用了a()");
    }
    public void b(){
        System.out.println("公交车使用了b()");
    }
}

class Taxi extends vehicle implements A,B{
    @Override
    void brake() {
        System.out.println("出租车刹车了");
    }
    public void a(){
        System.out.println("出租车使用了a()");
    }
    public void b(){
        System.out.println("出租车使用了b()");
    }
}
public class C{
    public static void main(String[] args) {
        Bus bus=new Bus();
        bus.brake();
        bus.a();
        bus.b();
        Taxi taxi=new Taxi();
        taxi.brake();
        taxi.a();
        taxi.b();
    }
}

结果：

公交车刹车了
公交车使用了a()
公交车使用了b()
出租车刹车了
出租车使用了a()
出租车使用了b()

理解接口：

• 接口可以抽象出重要的行为标准，该行为标准使用抽象方法来表示。
• 可以把实现接口的类的对象的引用赋值给接口变量，该接口变量可以调用被该类实现的接口方法。
• 接口的思想在于它可以要求某些类相同名称的方法，但方法的具体内容（方法体的内容）可以不同，即要求这些类实现接口，以保证这些类一定有接口中所声明的方法（即方法绑定）

接口与多态

即接口回调的使用,把实现接口的类的实例的引用赋值给接口变量后，该接口变量就可以回调重写的接口的方法。

interface A{
    void show();
}

class B implements A {
    public void show(){
        System.out.println("B");
    }
}

public class C implements A{
    public  void show(){
        System.out.println("C");
    }

    public static void main(String[] args) {
        A a=new B();
        a.show();
        a=new C();
        a.show();
    }
}

结果：

B
C

接口参数

如果一个方法的参数是接口类型，我们可以将任何实现接口的类的实例的引用传递给该接口参数。

interface SpeakHello{
    void speakHello();
}

class Chinese implements SpeakHello{
    @Override
    public void speakHello() {
        System.out.println("中国人习惯问候语：你好，吃饭了吗？");
    }
}
class English implements SpeakHello{
    @Override
    public void speakHello() {
        System.out.println("英国人习惯问候语：你好，天气不错 ");
    }
}

class kindHello{
    public void show(SpeakHello hello){
        hello.speakHello();
    }
}

public class C{
    public static void main(String[] args) {
        kindHello kindHello=new kindHello();
        kindHello.show(new Chinese());
        kindHello.show(new English());
    }
}

结果：

中国人习惯问候语：你好，吃饭了吗？
英国人习惯问候语：你好，天气不错 

面对接口编程

• 面对抽象编程：抽象类最本质的特性就是可以包含抽象方法，抽象类将其抽象方法的实现交给子类。
• 面对接口编程：只不过接口中只有抽象方法，接口将其抽象方法的实现交给实现该接口的类。

由于水平有限，博客难免会有不足，恳请大佬们不吝赐教！