接口

# 接口概述

一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。

另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有is-a的关系，仅仅是具有相同的行为特征而已。

例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等都支持USB连接。

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要...则必须能...”的思想。继承是一个"是不是"的关系，而接口实现则是"能不能"的关系。

接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。

# 接口`interface`定义

接口(interface)是抽象方法和常量值定义的集合。

接口的特点：

用interface来定义。
接口中的所有成员变量都默认是由public static final修饰的。
接口中的所有抽象方法都默认是由public abstract修饰的。
**接口中没有构造器。**当你试图编写构造器，编译不通过。意味着接口不能实例化。
接口采用多继承机制。

接口定义举例

public interface Runner{
    int ID = 1;
    void start();
    public void run();
    void stop();
}

1
2
3
4
5
6

等同于

public interface Runner{
    public static final int ID = 1;
    public abstract void start();
    public abstract void run();
    public abstract void stop();
}

1
2
3
4
5
6

# 实现接口`implements`

在Java开发当中，都是用类去实现implements接口的方式来使用。。

定义Java类的语法格式：先写extends，后写implements：

class SubClass extends SuperClass implements InterfaceA{
    
}

1
2
3

一个类可以实现多个接口，接口也可以继承其它接口。
实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。
接口的主要用途就是被实现类实现。（面向接口编程）
与继承关系类似，接口与实现类之间存在多态性
接口和类是并列关系，或者可以理解为一种特殊的类。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义(JDK7.0及之前)，而没有变量和方法的实现。

# 应用举例

interface Runner{
    public void start();
    public void run();
    public void stop();
}

class Person implements Runner{
    public void start(){
        code...
    }
    
    public void run(){
        code...
    }
    
    public void stop(){
        code...
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

一个类可以实现多个无关的接口

interface Runner{
    public void run();
}

interface Swimmer{
    public double swim();
}

class Creator{
    public int eat(){
        ...
    }
}

class Man extends Creator implements Runner,Swimmer{
    public void run(){
        ...
    }
    
    public double swim(){
        ...
    }
    
    public int eat(){
        ...
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

与继承关系类似，接口与实现类之间存在多态性

public class Test{
    public static void main(String[] args){
       Man m = new Man();
       Test.m1(m);
       Test.m2(m);
       Test.m3(m);      
    }
    
    public static String m1(Runner r){
        r.run();
    }
    
    public static void m2(Swimmer s){
        s.swim();
    }
    
    public static void m3(Creator c){
        c.eat();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

继承类和实现接口也可以分开写

interface MyInterface{
    String s = "MyInterface";
    public void absM1();
}

interface SubInterface extends MyInterface{
    public void absM2();
}

public class SubAdapter implements SubInterface{
    public void absM1(){
        System.out.println("absM1");
    }
    
    public void absM2(){
        System.out.println("absM2");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

实现类SubAdapter必须给出接口SubInterface以及父接口MyInterface中所有方法的实现。否则，SubAdapter仍需声明为abstract的。

# 接口的应用：代理模式(`Proxy`)

概述：

代理模式是Java开发中使用较多的一种设计模式。代理设计就是为其他对象提供一种代理以控制对这个对象的访问。

interface Network {
    public void browse();
}

//被代理类
class RealServer implements Network{
    @overrride
    public void browse(){
        System.out.println("真实服务器上网浏览信息");
    }
}

//代理类
class ProxyServer implements Network{
    private Network network;
    
    public ProxyServer(Network network){
        this.network = network;
    }
    
    public void check(){
        System.out.println("检查网络连接等操作");
    }
    
    public void browse(){
        check();
        network.browse();
    }
}

public class ProxyDemo{
    public static void main(String[] args){
        Network net = new ProxyServer(new RealServer());
        net.browse();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

接口可以理解为明星的责任，要做什么。

被代理类可以理解为真正的明星，具体要怎么做。

代理类可以理解为经纪人，要接触明星之前，先要跟经纪人讲。

应用场景：

安全代理：屏蔽对真实角色的直接访问。

远程代理：通过代理类处理远程方法调用（RMI）

延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时，不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。

分类

静态代理（静态定义代理类）

动态代理（动态生成代理类），JDK自带的动态代理，需要反射等知识。

# 接口的应用：工厂模式

以后拓展。

# 接口和抽象类之间的对比

#	区别点	抽象类	接口
1	定义	包含抽象方法的类	主要是抽象方法和全局常量的集合
2	组成	构造方法、抽象方法、普通方法、常量、变量	常量、抽象方法、(jdk8.0:默认方法、静态方法)
3	使用	子类继承抽象类(`extends`)	子类实现接口(`implements`)
4	关系	抽象类可以实现多个接口	接口不能继承抽象类，但允许继承多个接口
5	常见设计模式	模板方法	简单工厂、工厂方法、代理模式
6	对象	通过对象的多态性产生实例化对象	通过对象的多态性产生实例化对象
7	局限	抽象类有单继承的局限	接口没有此局限
8	实际	作为一个模板	是作为一个标准或是表示一种能力
9	选择	如果抽象类和接口都可以使用的话，优先使用接口，因为避免单继承的局限	如果抽象类和接口都可以使用的话，优先使用接口，因为避免单继承的局限

接口和抽象类之间的对比在开发中，常看到一个类不是去继承一个已经实现好的类，而是要么继承抽象类，要么实现接口。

# 面试题

排错

这里x编译不通过，编译器不明确要使用哪个x。

可以这样访问：

System.out.println(A.x);
SYstem.out.println(super.x);

1
2

如果它们2个变量名不一样，可以直接访问，A接口的变量是x1，B类的变量名是x2，那么可以这样访问：

Sysmte.out.println(x1);
Sysmte.out.println(x2);

1
2

排错

多个接口都是重名，那么只要重写一次，就可以把两个接口都重写。

ball是final修饰的全局常量，不能再次赋值。接口中的所有成员变量都默认是由public static final修饰的。

# Java 8中关于接口的改进

Java 8中，你可以为接口添加静态方法和默认方法。从技术角度来说，这是完全合法的，只是它看起来违反了接口作为一个抽象定义的理念。

接口中的静态方法

静态方法：使用static关键字修饰。可以通过接口直接调用静态方法，并执行其方法体。我们经常在相互一起使用的类中使用静态方法。你可以在标准库中找到像Collection/Collections或者Path/Paths这样成对的接口和类。

接口中的默认方法

默认方法：默认方法使用default关键字修饰。可以通过实现类对象来调用。我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。比如：java 8 API中对Collection、List、Comparator等接口提供了丰富的默认方法。

若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同参数的方法（不管此方法是否是默认方法），在实现类同时实现了这两个接口时，会出现：接口冲突。

解决办法：实现类必须覆盖接口中同名同参数的方法，来解决冲突。

若一个接口中定义了一个默认方法，而父类中也定义了一个同名同参数的非抽象方法，则不会出现冲突问题。因为此时遵守：类优先原则。接口中具有相同名称和参数的默认方法会被忽略。

如何在子类(或实现类)的方法中调用父类、接口中被重写的方法

接口.super.方法名();

帮我改善此页面

#接口 #interface #implements #extends

上次更新: 2020/12/18, 12:50:58

← 抽象类与抽象方法类的成员-内部类→

接口