Java基础(5) 接口(Java核心技术卷笔记)

接口的基本知识

接口的定义

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

接口的形态

intrface 接口名{

//属性

//方法

//1抽象方法，可以省略abstract

//2默认实现方法，抽象方法内有方法体，要加default

//3静态方法static

}

类如何使用接口

implements：实现

class 类名 implements 接口{

//可以有自己属性，自己方法

//必须实现的接口的全部抽象方法

}

细节

jdk7以前，接口里的所有方法都没有方法体，都是抽象方法。

jdk8以后，接口可以有静态方法；默认方法，也就是说接口中可以有方法的具体实现。

无方法体：void test();

有方法体：void test(){...(可写可不写)};

一个样例（设备实现接口）

接口、设备实现接口、使用设备

接口：Usb

Camera、Phone实现了接口的方法

在Computer内有个方法，可以通过接口统一调用设备的方法；

在类里创建三者的对象，可以在computer上使用两个设备。

package interfaceTest;

public class Main {
    public static void main(String[] args) {
        Camera camera = new Camera();
        Phone phone = new Phone();
        Computer computer = new Computer();
        computer.work(camera);
    }
}

interface Usb {
    //规定接口相关方法，也就是一些规范
    void start();

    void stop();

}

class Camera implements Usb {
    @Override
    public void start() {
        System.out.println("camera start");
    }

    @Override
    public void stop() {
        System.out.println("camera stop");
    }
}

class Phone implements Usb {
    //实现接口，把接口的方法完成

    @Override
    public void start() {
        System.out.println("start phone here");
    }

    @Override
    public void stop() {
        System.out.println("stop phone here");
    }
}

class Computer {
    public void work(Usb usb) {
        usb.start();
        usb.stop();
    }
}

一个重要样例（不同数据库连接）

接口要求连接、关闭数据库，类实现这个方法来连接不同数据库，可以统一调用

public class connectDB {
    public static void main(String[] args) {
        Postgresql postgresql = new Postgresql();
        Mysql mysql = new Mysql();
        connect(postgresql);
        connect(mysql);
    }

    public static void connect(requirementDB requirement){
        requirement.connect();
        requirement.close();
    }
}
interface requirementDB{
    void connect();
    void close();
}
class Postgresql implements requirementDB{
    @Override
    public void connect() {
        System.out.println("write connect postgresql here");
    }

    @Override
    public void close() {
        System.out.println("write close postgresql here");
    }
}
class Mysql implements requirementDB{
    @Override
    public void connect() {
        System.out.println("write connect mysql here");
    }

    @Override
    public void close() {
        System.out.println("write close mysql here");
    }
}

使用接口的细节

接口不能被实例化（接口本身就是抽象的概念）

接口中的所有方法是public方法（默认，public可以不写）（所以子类实现必须是public）

一个普通类实现接口，必须将该接口方法全部实现；抽象类实现接口，可以不实现接口的抽象方法

一个类可以同时实现多个接口，但只能继承一个类

接口中的属性只能是public static final的（虽然可以隐藏这几个关键词）

接口不能继承类，但可以继承多个别的接口（接口不能实现接口）

接口的修饰符只能是默认或public，和类是一样的

实现接口vs继承类

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

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

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

继承：is-a的关系；接口：like-a的关系（像一个什么什么）

接口在一定程度上实现代码解耦（接口规范性+动态绑定）（需要学习集合看代码理解）

例子：猴子会爬树，小猴子继承猴子类，自动学会爬树；

但是不会飞、游泳，通过实现鸟、鱼接口内的方法， 学会游泳和飞

public class ExtendsVsInterface {
    public static void main(String[] args) {
        littleMonkey WuKong = new littleMonkey("wukong");
        WuKong.climbing();
        WuKong.swim();
        WuKong.fly();
    }
}

class Monkey{
    private String name;
    public String getName() {
        return name;
    }
    public Monkey(String name) {
        this.name = name;
    }
    public void climbing(){
        System.out.println("monkey can climb");
    }
}

class littleMonkey extends Monkey implements FishAbility,BirdAbility{
    public littleMonkey(String name) {
        super(name);
    }
    @Override
    public void swim() {
        System.out.println(getName()+" can swim now by learning");
    }
    @Override
    public void fly() {
        System.out.println(getName()+" can fly now by learning");
    }
}

interface FishAbility{
    void swim();
}
interface BirdAbility{
    void fly();
}

接口的多态特性

多态参数

通过接口来调用方法，接收 实现了接口的类 的对象实例

上面的camera，phone，computer代码；

连接数据库，创建接口的对象变量，引用具体实现数据库的对象

多态数组

public class InterfacePolyParameter {
    public static void main(String[] args) {
        //接口多态体现：
        //接口类型的变量 interface01 可以引用实现了I接口的对象实例
        I interface01 = new A();
        interface01 = new B();
        
        //继承多态体现：
        //父类类型的变量     item    可以引用继承了父类的子类的对象实例（父类AA，子类BB、CC）
        AA item = new BB();
        item = new CC();
       
        //多态数组
        I[] Interfaces = new I[2];
        Interfaces[0] = new A();
        Interfaces[1] = new B();
    }
}
interface I{}
class A implements I{}
class B implements I{}

class AA{}
class BB extends AA{}
class CC extends AA{}

多态传递

public class InterfacePolyParameter {
    public static void main(String[] args) {
        I1 x1 = new A();
        I2 x2 = new A();
    }
}

interface I1 { }
interface I2 extends I1 { }
class A implements I2 { }

类的五大成员：

字段，方法，构造器，代码块，内部类