接口（interface）

1.接口

       宏观上来讲，接口是一种标准。例如，我们生活中常见的 USB 接口。电脑通过 USB 接口连接各种外设的设备，每一个接口不用关心连接的外设设备是什么，只要这个外设的设备实现了USB 的标

准，就可以连接到电脑上。

       从程序上来讲，接口代表了某种能力，类似于生活中的合同。而在接口中定义的各个方法，表

示这个能力的具体要求，类似于合同中的条款。

1.1接口的定义

       定义接口，需要使用到关键字 interface

public interface MyInterface {
    public static final String INTERFACE_FIELD = "value";    // 接口中的属性定义
    public abstract void method();     // 接口中的方法定义 
}

接口中可以定义 :

• 属性

接口中的属性，默认都是静态常量，访问权限都是 public 。

• 方法

接口中的方法，默认都是抽象方法，访问权限都是 public 。

 

注意 :

一般接口中不写成员变量 , 只写方法 , 相当于制定规则 , 所以又将接口称为方法列表

 

接口的作用

让 java 从单继承间接的实现了多继承 , 扩充了原来的功能 , 我们可以认为接口是类的补充 .

 

1.2接口和抽象类的异同

相同点

• 都可以编译成字节码文件。
• 都不能创建对象。
• 都可以声明引用。
• 都具备Object类中所定义的方法。
• 都可以写抽象方法。

不同点

• 接口中所有的属性，都是公开静态常量，缺省使用 public static fifinal 修饰。
• 接口中所有的方法，都是公开抽象方法，缺省使用 public abstract 修饰。
• 接口中没有构造方法、构造代码段、静态代码段

1.3接口的实现

       接口，需要让类实现，表示这个类具有了这个接口定义的能力。因为接口中有很多的抽象方

法，因此类在实现接口的时候，如果不是抽象类，必须要重写实现接口中所有的抽象方法。

 

public interface MyInterface {
    public static final String INTERFACE_FIELD = "value"; // 接口中的属性定义
    public abstract void method();     // 接口中的方法定义
 }                                 // 非抽象类实现接口，必须重写实现接口中所有的抽象方法 
class MyInterfaceImpl implements MyInterface {
 @Override
    public void method() {} }  // 抽象类实现接口，接口中的抽象方法，可以实现，也可以不实现
    abstract class MyInterfaceAbstractImpl implements MyInterface {
}

一个类可以实现多个接口

我们使用接口进行行为的约束，规则的制定。接口表示一组能力，那么一个类可以接受多种

能力的约束。类比于合同来说，一个人是可以签订多份合同的。因此，一个类可以实现多个

接口。实现多个接口的时候，必须要把每一个接口中的方法都实现了。

注意：如果一个类实现的多个接口中，有相同的方法，实现类只需要实现一次即可。

 

interface CookService {
   void cook();
 }
interface NursemaidService {
    void cook();
    void wash();
 }
class Nurse implements NursemaidService, CookService {
      // 这个cook方法，在这两个接口中都定义了，那么只需要实现一次即可
 @Override public void cook() {
    System.out.println("做饭");
 }
@Override public void wash() {
    System.out.println("洗衣服");
   }
}

需要注意的是：

       如果两个接口中定义了两个同名、同参数的方法，但是返回值不同。那么类是没有办法

同时实现这两个接口的。因为在同时实现的时候，无法最终确定这个方法的返回值类

型。就好比一个人签订了两份合同， A 合同要求性别男， B 合同要求性别女。这是有冲突

的条件。因此类无法同时实现。

 

1.4接口的继承

       接口之间也是存在继承关系的，与类的继承相似，子接口可以继承到父接口中所有的成员

的。

       与类的继承不同，接口之间的继承是多继承。也就是说，一个接口是可以有多个父接口的。

       子接口可以继承到所有的父接口中的成员。

 

interface SuperInterface1 {
    void method1(); 
}
interface SupeInterface2 {
    void method2(); 
} // 此时，在这个接口中，继承到了所有的父接口中的方法，同时定义了自己独有的方法 
  // 实现类在实现这个接口的时候，需要实现 method1、method2、method3 三个方法
interface SubInterface extends SuperInterface1, SuperInterface2 {
    void method3();
}

注意：

上述，一个类实现多个接口的时候，多个接口中不能存在有冲突的方法。接口在继承父接口

的时候，也不允许同时继承两个有方法冲突的接口。

 

父类与接口的功能如何分配 ?

一般父类中放的是主要功能 , 接口中放的是额外的功能 , 接口作为父类的补充 .

 

当一个类实现的接口中出现了相同的方法 , 子类中实现方法的时候会不会混淆 ?

不会,接口中的方法都是抽象的,要通过子类写具体的实现.我们在调用方法时,最终看的功能,
而功能只有子类中的一份.

1.5接口的多态

接口的引用，可以指向实现类的对象。与类的多态相似，同样存在向上转型和向下转型。

• 向上转型：实现类类型转型为接口类型。

是一个隐式转换，不需要任何的修饰。
向上转型后的接口引用，只能访问接口中的成员。

• 向下转型：接口类型转型为实现类类型。

是一个显式转换，需要强制类型转换。
向下转型后的实现类引用，将可以访问实现类中的成员。

interface CanWalk {
void walk();
}
abstract class Animal {
public abstract void eat();
}
class Dog extends Animal implements CanWalk {
@Override
public void eat() {}
@Override
public void walk() {}
}
class Test {
public static void main(String[] args) {
// 1. 实例化一个Dog对象
Dog dog = new Dog(); // 将狗看成狗看待
// 2. 将Dog对象转型为Animal类型
Animal animal = dog; // 将狗看成动物看待
// 3. 将Dog对象转型为CanWalk类型
CanWalk walk = dog; // 将狗看成会走的东西看待
}
}

多态体现
       与类相同，向上转型后的接口的引用，调用接口中的方法的时候，实际调用的是实现类中的
重写实现。

1.6接口的新特性

在Java8中，为接口添加了两个新特性：

• static方法：可以在接口中定义静态方法，静态方法不是抽象方法，是有实现部分的。同

时，这个静态方法，只能由当前的接口名字调用，接口的引用和实现类都是不能使用
的。

interface MyInterface {
public static void method1() {
System.out.println("接口中的静态方法实现");
}
}
class Person implements MyInterface{
//这里不可以重写method1方法
}
public class Demo8 {
public static void main(String[] args) {
MyInterface.method1(); //正确
MyInterface m = new Person();
m.method1(); //错误
Person.method1();//错误
}
}

• default方法：修饰接口中的方法，default修饰的方法可以添加默认的实现部分。此时，

实现类在实现接口的时候，对于这些方法可以重写，也可以不重写。

interface MyInterface {
public default void method2() {
System.out.println("接口中的方法默认实现");
}
}
class Person implements MyInterface{
//可以重写method2方法
}
public class Demo8 {
public static void main(String[] args) {
MyInterface m = new Person();
m.method2(); //正确
Person.method2();//错误
}
}