Java基础语法69-接口

Java基础语法69-接口

一、接口的使用

1. 接口使用interface来定义
2. 在java中接口和类是并列的结构
3. 如何定义接口：定义接口中的成员

​ 3.1 JDK7及以前：只能定义全局常量和抽象方法

​ 全局常量：public static final的，但是书写时可以省略不写

​ 抽象方法：public abstract的

​ 3.2 JDK8：除了定义全局常量和抽象以外，还可以定义静态方法、默认方法

4. 接口中不能定义构造器！意味着这个接口不能实例化
5. java开发中，让类去实现（implements）来使用。如果实现类覆盖了接口中的抽象方法，则此实现类就可以实例化，如果没有覆盖所有的抽象方法，则此实现类为抽象类
6. Java类可以实现多个接口 -->弥补了单继承性的局限性

​ 格式：class AA extends BB implements CC,DD,EE

7. 接口与接口之间可以继承，而且可以多继承

package com.java11;

public class InterfaceTest {
    public static void main(String[] args) {
        System.out.println(Flyable.MAX_SPEED);
        System.out.println(Flyable.MIN_SPEED);
    }
}

interface Attackable{
    public abstract void attack();
}

interface Flyable{
    //全局常量
    public static final int MAX_SPEED = 7900;
    public static final int MIN_SPEED = 1;

    //抽象方法
    public abstract void  fly();
    //省略了public abstract
    void stop();

}

class Plane implements Flyable{

    @Override
    public void fly() {
        System.out.println("通过引擎起飞！");
    }

    @Override
    public void stop() {

    }
}

abstract class Kite implements Flyable{

}

class Bullet extends Object implements Flyable,Attackable,CC{

    @Override
    public void attack() {

    }

    @Override
    public void fly() {

    }

    @Override
    public void stop() {

    }

    @Override
    public void AA() {
        
    }

    @Override
    public void BB() {

    }
}

interface AA{
    public abstract void AA();
}

interface BB{
    public abstract void BB();
}

interface CC extends AA,BB{

}

7. 接口的使用体现了多态性
8. 接口，实际上可以看做是一种使用规范

package com.java11;

public class USBTest {
    public static void main(String[] args) {
        Computer computer = new Computer();
        Flash flash = new Flash();
        computer.transferData(flash);
    }
}

class Computer{
    public void transferData(USB usb){
        usb.start();
        System.out.println("具体传输细节");
        usb.stop();
    }
}

interface USB{
    void start();
    void stop();

}

class Flash implements USB{

    @Override
    public void start() {
        System.out.println("U盘开启工作");
    }

    @Override
    public void stop() {
        System.out.println("U盘结束工作");
    }
}

class Printer implements USB{
    @Override
    public void start() {
        System.out.println("打印机开启工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机结束工作");
    }
}

二、接口的应用：代理模式

package com.java11;

public class NetWorkTest {
    public static void main(String[] args) {
        Sever sever = new Sever();
        ProxySever proxySever = new ProxySever(sever);
        proxySever.browse();
    }
}

interface NetWork {
    public void browse();
}

//被代理类
class Sever implements NetWork {

    @Override
    public void browse() {
        System.out.println("真实的服务器来访问网络");
    }
}

//代理类
class ProxySever implements NetWork {

    public NetWork work;

    public ProxySever(NetWork work) {
        this.work = work;
    }

    public void check() {
        System.out.println("互联网之前的检查工作");
    }

    @Override
    public void browse() {
        check();
        work.browse();
    }
}

三、Java8接口的新特性

JDK8：除了定义全局常量和抽象以外，还可以定义静态方法、默认方法

知识点1：接口中定义的静态方法，只能通过接口来调用。

知识点2：通过实现类的对象，可以调用接口中默认的方法。如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法。–类优先原则

知识点3：如果子类或实现类，继承的父类和实现的接口中，声明了同名同参数的方法，那么子类在没有重写此方法的情况下，默认调用的是父类中同名同参数的方法

知识点4：如果实现类中实现了多个接口，接口定义了同名同参数的方法，在没有重写方法的情况下，报错 —接口冲突

这就让我们必须重写接口中的方法

知识点5：如何在子类或者实现类的方法中调用父类、接口中被重写的方法

package com.java11;

public interface CompareA {
    public static void method1(){
        System.out.println("CompareA: 北京");
    }

    public default void menthod2(){
        System.out.println("CompareA:上海");
    }

    default void method3(){
        System.out.println("CompareA:上海");

    }

}

package com.java11;

public interface CompareB {
    default void method3(){
        System.out.println("CompareB:上海");

    }
}

package com.java11;

public class SuperClass {
    public void method3(){
        System.out.println("SuperClass:北京");
    }
}

package com.java11;

public class SubClassTest {
    public static void main(String[] args) {
        SubClass subClass = new SubClass();
        subClass.method3();
        //知识点1：接口中定义的静态方法，只能通过接口来调用。
        CompareA.method1();
        //知识点3：如果子类或实现类，继承的父类和实现的接口中，声明了同名同参数的方法，
        // 那么子类在没有重写此方法的情况下，默认调用的是父类中同名同参数的方法
        //知识点4：如果实现类中实现了多个接口，接口定义了同名同参数的方法，在没有重写方法的情况下，报错  ---接口冲突
        //这就让我们必须重写接口中的方法
        subClass.method3();
        //知识点2：通过实现类的对象，可以调用接口中默认的方法。
        // 如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法。--类优先原则
        subClass.menthod2();
    }
}

class SubClass extends SuperClass implements CompareA,CompareB {

    public void method2() {
        System.out.println("SuperClass:上海");
    }

    public void method3() {
        System.out.println("SuperClass:深圳");
    }

    //知识点5：如何在子类或者实现类的方法中调用父类、接口中被重写的方法
    public void myMethod(){
        method3();//调用自己重写的方法
        super.method3();//调用父类中的方法
        CompareA.super.method3();//调用接口中默认的方法
    }
}