java学习日记20230325-接口

接口基本介绍

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

如果一个类implements，需要将该接口的所有抽象方法都实现

在jdk8以后可以默认实现方法，需要使用default关键字

在jdk8以后，可以有静态方法

在jdk7前接口里的所有方法都没有方法体，即都是抽象方法；

在jdk8后接口可以有静态方法，默认方法（default/static public void hi(){}），也就是说接口中可以有方法的具体实现

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

interface inf{
    //属性
    //方法（抽象方法，默认方法，静态方法）
}

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

public interface UsbInterface {
    public void start();
    public void stop();
}

public class Phone implements UsbInterface {
    @Override
    public void start() {
        System.out.println("手机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("手机停止工作");
    }
}

public class Computer {
    public void work(UsbInterface usbInterface){
        //通过接口调用方法
        usbInterface.start();
        usbInterface.stop();
    }
}

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

接口的注意事项和使用细节：

　　1.接口不能被实例化；

　　2.接口中所有的方法时public方法，接口中的抽象方法可以省略abstract

　　3. 一个普通类实现该接口，必须实现接口所有的抽象方法

　　4.抽象类去实现接口时，可以不实现所有接口抽象方法

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

interface IB{
    void hi();
}

interface IC{
    void say();
}

class Pig implements IB,IC{
    @Override
    public void hi() {
        
    }

    @Override
    public void say() {

    }
}

　　6.接口中的属性只能是final的，而且是public static final 修饰符

int a = 1；//实际上是 public static final int a = 1；

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

　　8.一个接口不能继承其他的类，但是可以继承多个别的接口

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

接口和继承

　　
　　　实现接口在某种意义上，是java对单继承机制的补充；

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

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

public class ExtendsVsImplements {
    public static void main(String[] args) {
        LittleMonkey wk = new LittleMonkey("悟空");
        wk.climbing();
        wk.swimming();
    }
}

class Monkey{
    private String name;
    public void climbing(){
        System.out.println(name+"会爬树");
    }

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

    public String getName() {
        return name;
    }
}

class LittleMonkey extends Monkey implements Fishable{
    public LittleMonkey(String name) {
        super(name);
    }

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

interface Fishable{
    void swimming();
}

继承的价值在于解决代码的复用性和可维护性；

接口的价值在于设计，设计好各种规范方法，让其他类去实现这些方法，即更加灵活；

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

接口在一定程度上实现代码解耦（接口的规范性和动态绑定机制）

接口和多态

　　　　1.多态参数：实现了接口的类的对象的实例　　（方法形参是接口implement）

public class InterfacePolyParameter {
    public static void main(String[] args) {
        IF if01 =  new Moster();
        //接口类型的变量if01可以指向实现了IF接口的对象实例
        if01 = new Car();
    }
}

interface IF{}
class Moster implements IF{}

class Car implements IF{}

　　　　2.多态数组：

public class InterfacePolyArr {
    public static void main(String[] args) {
        Usb[] usbs = new Usb[2];
        usbs[0]=new Phone01();
        usbs[1]=new Camera01();

        for (int i = 0; i < usbs.length; i++) {
            usbs[i].work();
            //判断运行类型是Phone01，向下转型
            if(usbs[i] instanceof Phone01){
                ((Phone01) usbs[i]).call();
            }
        }
    }
}

interface Usb{
    void work();
}

class Phone01 implements Usb{
    public void call(){
        System.out.println("手机可以打电话");
    }

    @Override
    public void work() {
        System.out.println("手机工作中");
    }
}
class Camera01 implements Usb{
    @Override
    public void work() {
        System.out.println("相机工作中");
    }
}

　　3.接口存在多态传递现象

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

interface IH{}
interface IG extends IH {}
class Teacher implements IG{

}