接口interface

基本介绍

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

语法：

interface 接口名{
	// 属性
	// 方法（1.抽象方法 2.默认实现方法 3.静态方法）
}

public interface AInterface {
    // 写属性
    public int n1 = 10;
    // 写方法
    // 在接口中，抽象方法可以省略abstract关键字
    public void hi();

    // 在jdk8后，可以有默认实现方法，需要使用default关键字修饰
    default public void ok(){
        System.out.println("ok...");
    }

    // 在jdk8后，可以有静态方法
    public static void cry(){
        System.out.println("cry...");
    }
}

   

class 类名 implements 接口{
	// 自己属性
	// 自己方法
	// 必须实现的接口的抽象方法
}

小结：
   1） 在Jdk7.0前接口里的所有方法都没有方法体；
   2） Jdk8.0后接口类可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现。

接口使用细节

   1） 接口不能被实例化；

   2） 接口中所有的方法是public方法，接口中抽象方法，可以不用abstract 修饰；

void aaa();
// 实际上是
abstract void aaa();

   3） 一个普通类实现接口，就必须将该接口的所有方法都实现，可以使用CTRL + i来解决；

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

   5） 一个类同时可以实现多个接口；

   6） 接口中的属性，只能是final的，而且是public static final修饰符。比如：

int a = 1;	// 实际上是 public static final int a = 1;(必须初始化)

   7） 接口中属性的访问形式：接口名.属性名；

   8） 一个接口不能继承其它的类,但是可以继承多个别的接口；

interface A extends B,C{}

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

public class Interface03 {
    public static void main(String[] args) {
        B b = new B();
        System.out.println(b.a);	// 23
        System.out.println(A.a);	// 23
        System.out.println(B.a);	// 23
    }
}

interface A{
    int a = 23;
}

class B implements A{}

接口 vs 继承

   当子类继承了父类，就自动的拥有父类的功能；

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

   可以理解实现接口是对java单继承机制的一种补充。

// 例子
public class ExtendsVsInterface {
    public static void main(String[] args) {
        LittleMonkey wuKong = new LittleMonkey("悟空");
        wuKong.climbing();
        wuKong.swimming();
        wuKong.flying();
    }
}

// 猴子
class Monkey{
    private String name;

    public String getName() {
        return name;
    }

    public Monkey(String name) {
        this.name = name;
    }

    public void climbing(){
        System.out.println(name + " 会爬树...");
    }
}
// 接口 鱼
interface Fish{
    void swimming();
}

// 接口 鸟
interface Bird{
    void flying();
}

// 继承
class LittleMonkey extends Monkey implements Fish,Bird{
    public LittleMonkey(String name) {
        super(name);
    }

    @Override
    public void swimming() {
        System.out.println(getName() + " 通过学习，可以像鱼儿一样游泳...");
    }

    @Override
    public void flying() {
        System.out.println(getName() + " 通过学习，可以像鸟儿一样飞翔...");
    }
}

接口和继承解决的问题不同：
   继承的价值主要在于：解决代码的复用性和可维护性。
   接口的价值主要在于：设计，设计好各种规范(方法)，让其它类去实现这些方法，即更加灵活。

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

接口在一定程度上实现代码解耦【即：接口规范性 + 动态绑定】

接口多态特性

   1） 多态参数，接口引用可以指向实现了接口的类的对象；

   2） 多态数组；

public class InterfacePolyArr {
    public static void main(String[] args) {
    
        // 多态数组 -> 接口类型数组
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera_();
    }
}

interface Usb{}

class Phone_ implements Usb{}

class Camera_ implements Usb{}

   3） 接口存在多态传递现象。

public class InterfacePolyPass {
    public static void main(String[] args) {
        // 接口类型的变量可以指向，实现了该接口的类的对象实例
        C c = new C();
        // 如果 B 继承了 A 接口，而 C类 实现了 B接口
        // 那么，实际上就相当于 C类也实现了 A接口
        // 这就是所谓的 接口多态传递现象
        A a = new C();
    }
}

interface A{
    void hi();
}
interface B extends A{}
class C implements B{
    @Override
    public void hi() {
        
    }
}