Java接口的使用

接口

接口就是一种公共的规范标准，只要符合规范标准，就可以通用。

接口是多个类的公共规范
接口是一种引用数据类型，最重要的内容就是其中的抽象方法

定义接口的格式

public interface 接口名称{
		//接口内容
}

接口的使用步骤

接口使用步骤：

1. 接口不能直接使用，必须有一个实现类来实现该接口

public class 实现类名称 implements 接口名称{

}

2. 接口的实现类必须覆盖重写接口中所有的抽象方法
3. 创建实现类的对象，进行使用

接口包含的内容有
常量
抽象方法
默认方法
静态方法
私有方法

接口中的抽象方法

定义

注意事项：
接口中的抽象方法，修饰符必须是两个固定的关键字public abstract
这两个关键字修饰符，可以选择性的忽略
方法的三要素可以随意定义

定义抽象方法的格式：
public abstract 返回值类型 名称方法(参数列表)

//public和abstract两个关键词都不使用也可
public interface interfaceAbstract {
    public abstract void methodAbs();
    void methodabs();
}

抽象方法的使用

//接口本身使用需要进行“继承”

public class interfaceAbstractimpl implements interfaceAbstract{
    @Override
    public void methodAbs() {
        System.out.println("抽象方法一");
    }

    @Override
    public void methodabs() {
        System.out.println("抽象方法二");
    }
}
//抽象类的使用
    public static void main(String[] args) {
        interfaceAbstractimpl impl=new interfaceAbstractimpl();
        impl.methodAbs();
        impl.methodabs();
    }

如果实现类并没有覆盖重写接口中的所有抽象方法，那么这个实现类自己就是抽象类，不能直接使用

接口中默认方法

从java8开始，接口里允许定义默认方法
接口当中的默认方法，可以解决接口升级的问题。
比如对于接口A有抽象方法1，那么产生的类A，类B对抽象方法1覆盖重写；接口A又新添加了一个抽象方法，如果不添加其他措施，那么类A和类B会报错

接口中默认方法的定义

public default 返回值类型 方法名称(参数列表){
}

接口中默认方法

public interface InterfaceDefault {
    //抽象方法
    public abstract void methodAbs();
    //新添加的抽象方法
//    public abstract void methodAbs2();
    //新添加的方法，改成默认方法
    public default void methoddefault(){
        System.out.println("这是新添加的默认方法");
    }
}

接口中默认方法的使用

接口实现类A，B，实现类B覆盖重写了接口的默认方法

public class InterfaceDefaultA implements  InterfaceDefault{
    @Override
    public void methodAbs() {
        System.out.println("实现了抽象方法A");
    }
}
public class InterfaceDefaultB implements InterfaceDefault{
    @Override
    public void methodAbs() {
        System.out.println("实现了抽象方法B");
    }
    @Override
    public void methoddefault() {
        System.out.println("抽象方法B覆盖重写了接口的默认方法");
    }
}
//默认类的使用，实现类B覆盖重写了默认方法
        InterfaceDefaultA a=new InterfaceDefaultA();
        a.methodAbs();
        a.methoddefault();
        System.out.println("==============");

        InterfaceDefaultB b=new InterfaceDefaultB();
        b.methodAbs();
        b.methoddefault();
        System.out.println("==============");

接口中的静态方法

从Java 8开始，接口当中允许定义静态方法

静态方法的定义

提示：就是将abstract或者default换成static即可，带上方法体

public static 返回值类型 方法名称(参数列表)
{
方法体
}

public interface InterfaceStatic {
    public static void methodstatic(){
        System.out.println("静态方法执行");
    }
}

接口静态方法的使用

不通过接口实现类的对象来调用接口当中的静态方法。
正确用法：通过接口名称，直接调用其中的静态方法
格式：
接口名称.静态方法(参数)

        //直接通过方法体调用静态方法
        InterfaceStatic.methodstatic();

接口私有方法

我们需要抽取一个共有方法，用来解决两个方法之间重复代码的问题，但是这个共有方法不应该让实现类使用，应该是私有化的

从java9 开始，接口当中允许定义私有方法

私有方法的定义

//普通私有方法，解决多个默认值之间重复代码问题
private 返回值类型 方法名称(参数列表){
方法体
}
//静态私有方法，解决多个静态方法之间重复代码问题
private static 返回值类型 方法名称(参数列表){
方法体
}

//默认方法定义私有方法
public interface InterfacePrivateA {
    public default void methodDefault1(){
        System.out.println("默认方法1");
    }
    public default void methodDefault2(){
        System.out.println("默认方法2");
    }
    private void methodCommon(){
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}

//静态方法定义私有方法
public interface InterfacePrivateB {
    public static void methodStatic1(){
        System.out.println("静态方法1");
    }
    public static void methodStatic2(){
        System.out.println("静态方法2");
    }
    private void staticCommon(){
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}

私有方法的使用

私有方法只能为接口中的方法使用

        //私有方法
        //默认方法
        InterfacePrivateAimpl p1=new InterfacePrivateAimpl();
        p1.methodDefault1();
        p1.methodDefault2();
        //不能调用p1.methodCommon();
        System.out.println("================");
        //静态方法
        InterfacePrivateB.methodStatic2();
        InterfacePrivateB.methodStatic2();
        //不能调用InterfacePrivateB.staticCommon();

常量

接口当中可以定义”成员变量“，但是必须使用public static final三个关键字进行修饰
从效果上看，就是接口的常量

格式
public static final 数据类型 常量名称=数据值；

一旦使用final关键字进行修饰，说明不可变
注意事项：

1. 接口当中的常量，可以省略public static final
2. 接口当中的常量，一定要进行赋值
3. 接口当中常量的名称，使用完全大写的字母，用下划线进行分隔

public interface InterfaceConst {
    //这就是一个常量，一旦赋值，不可能修改
    public static final int NUM=12;
}

//访问接口中的常量
        System.out.println(InterfaceConst.NUM);

接口的注意事项

1. 接口没有静态代码块或者构造方法
2. 一个类的直接父类是唯一的，但是一个类可以是多

public class InterfaceImpl implements InterfaceA,InterfaceB{
//覆盖重写所有的抽象方法
}

3. 如果实现类所实现的多个接口中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
4. 如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类是抽象类
5. 如果实现类实现的多个接口当中，存在重复的默认方法，那么实现类必须要对默认方法进行覆盖重写
6. 一个类如果直接父类当中的方法和接口当中的默认方法冲突，那么优先使用父类方法。（Java中，继承是优先于接口的）

类和接口相关的关系

1. 类于类之间单继承，直接父类只有一个
2. 类与接口之间是多实现的，一个类可以实现多个接口
3. 接口与接口之间是多继承的

public interface Interface extends InterfaceA,InterfaceB{
}

多个父接口中的抽象方法冲突没事，但是多个父接口中的默认方法重复会出bug，需要对默认方法进行默认方法的覆盖重写

接口的实例

进行描述笔记本类，实现笔记本使用USB鼠标，USB键盘

USB接口，包含打开设备功能，关闭设备功能
笔记本类：包含开机功能，关机功能，使用USB设备功能
鼠标类：要实现USB接口，并具备点击的方法
键盘类：要实现USB接口，具备敲击的方法

public interface USB {
    public abstract void open();//打开设备

    public abstract void close();//关闭设备
}

//鼠标就是一种USB设备
public class Mouse implements USB {
    @Override
    public void open() {
        System.out.println("鼠标打开");
    }

    @Override
    public void close() {
        System.out.println("鼠标关闭");
    }
    public void click(){
        System.out.println("点击鼠标");
    }
}

public class Keyboard implements USB {
    @Override
    public void open() {
        System.out.println("键盘打开");
    }

    @Override
    public void close() {
        System.out.println("键盘关闭");
    }
    public void type(){
        System.out.println("键盘输入");
    }
}

public class Computer {
    public void powerOn(){
        System.out.println("Power on");
    }
    public void powerOff(){
        System.out.println("Power off");
    }
    //使用USB设备的方法，使用接口作为方法的参数
    public void useDevice(USB usb){
        usb.open();//打开设备
        if(usb instanceof Mouse ){
            Mouse mouse=(Mouse)usb;
            mouse.click();
        }
        else if(usb instanceof Keyboard)
        {
            Keyboard keyboard=(Keyboard)usb;
            keyboard.type();
        }
        usb.close();//关闭设备
    }
}