接口(Interface)

接口

基本介绍

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

class 类名 implements 接口{
    自己属性;
    自己方法;
    必须实现的接口的抽象方法;  // 只需要重写抽象方法即可
}

接口中的方法使用：

1、抽象方法： 在接口中，可省略 abstract 关键字

2、默认实现方法, default修饰符只能在修饰接口方法时使用。在普通类的方法中不能使用。

3、静态方法

interface 接口名{
    // 属性
    // 方法 1、抽象方法 2、默认实现方法  3、静态方法
    // 1、抽象方法： 在接口中，省略了 abstract 关键字
    public void say();  // public abstract void say();
    
    // 2、默认实现方法, default修饰符只能在修饰接口方法时使用。在普通类的方法中不能使用。
    default void speak(){
        System.out.println("speak ...");
    }
    
    //3、静态方法
    static void cry(){
        System.out.println("cry ...");
    }
}

注意：

1、在jdk7前，接口中的所有方法都没有方法体。

2、jdk8之后，接口类中可以写静态方法、默认方法【默认修饰符】，也就是说接口中可以有方法的具体实现。

接口的使用

1、接口不能被实例化。

2、接口中的所有方法都是public方法，接口中的所有方法，默认被 abstract 修饰，即为抽象方法。

public修饰符证明方法：实现类的重写中，重写方法的修饰符只能比父类权限大。

3、一个普通类实现接口类，就必须将该接口中的所有抽象方法都实现。

4、抽象类实现接口，可以不用实现接口的方法。

5、一个类可以同时实现多个接口。

class A implements Week, Enumeration01{
    // Override 接口中的方法。
 }

6、一个接口不能继承其他的类，但是可以继承[extends]多个别的接口。

interface A extends B, C{}

7、接口中的属性，只能是final的，而且是public static final 修饰符。

interface A{
    int n1 = 10;  // 等价于 public static final int n1;
}

8、接口中属性的方法形式为：接口名.属性名

9、接口的修饰符，只能是 public 和 默认，这点和类的修饰符一致。

interface 接口名{
    // 属性
    // 方法 1、抽象方法 2、默认实现方法  3、静态方法
    // 1、抽象方法： 在接口中，可省略 abstract 关键字
    public void say();

    // 2、默认实现方法, default修饰符只能在修饰接口方法时使用。在普通类的方法中不能使用。
    default void speak(){
        System.out.println("speak ...");
    }

    //3、静态方法
    public static void cry(){
        System.out.println("cry ...");
    }
}

实现接口和继承类的比较

实现接口机制 是对 单继承 缺陷的补充。

如果子类需要扩展功能，可以通过实现接口的方式去进行扩展

class LittleMonkey extends Monkey implements Fly, Swimming

接口和继承解决的问题不同

1、继承的价值主要在于：解决问题的复用性和可维护性

2、接口的价值在于：设计，设计好各种规范(方法)，让其他类去实现这些方法

接口比继承更加灵活

接口比继承更加灵活，继承是满足 is - a的关系，而接口只需满足 like - a的关系

接口在一定程度上实现代码的解藕

接口规范性 + 动态绑定 在讲解集合的时候，会具体讲解。

接口的多态

1、接口引用可以指向实现了接口的类的对象

2、接口多态数组。

3、接口的多态传递。

package com.interfac_;

public class Test {
    public static void main(String[] args) {
         C a = new A();
    }
}


interface B extends C{
    int b = 20;
}

interface C{
    void speak();
}
class A implements B{
    @Override
    public void speak() {
        System.out.println("speak ...");
    }
}
package com.interfac_;

public class Test extends A implements B{
    public void speak(){
        //接口中的x值是，public static final int x,为静态属性，则直接用类名进行调用。        
        System.out.println("x的父类值为：" + super.x + "接口的x值为：" +  B.x);
    }
    public static void main(String[] args) {
        Test test = new Test();
        test.speak();
    }
}


class A{
    int x = 1;
}

interface B{
    int x = 2;
}