Java当中的接口

一.接口的概念

在我们的现实生活中，接口的例子比比皆是，比如笔记本电脑上的USB接口，电源插座等---

电脑的 USB 口上，可以插： U 盘、鼠标、键盘 ... 所有符合 USB 协议的设备

电源插座插孔上，可以插：电脑、电视机、电饭煲 ... 所有符合规范的设备

通过上述例子可以看出： 接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用 。

在 Java 中，接口可以看成是： 多个类的公共规范，是一种引用数据类型。

二.语法规则

接口的定义格式与定义类的格式基本相同，将 class 关键字换成 interface 关键字，就定义了一个接口。

public interface 接口名称{
// 抽象方法
public abstract void method1(); // public abstract 是固定搭配，可以不写
public void method2();
abstract void method3();
void method4();
// 注意：在接口中上述写法都是抽象方法，跟推荐方式4，代码更简洁
}

语法注意事项:

1.创建接口时，接口的命名一般以大写字母I开头

2.接口中的成员方法默认是:public abstract  修饰

3.接口中的成员变量默认是:public static final 修饰

4.接口不能被实例化，其方法不能有具体实现

三.接口的使用 

下面先来看一个例子

package NewOOP.prot;

public interface USB {             //USB接口代码
    void openDevice(); //打开的服务可能是打开鼠标  键盘
    void closeDevice();//关闭的服务可能是 关闭鼠标 和 键盘
}



package NewOOP.prot;

public class KeyBoard implements USB{    //键盘具有USB的特性，可以使用USB接口
    @Override
    public void openDevice() {
        System.out.println("键盘打开");
    }

    @Override
    public void closeDevice() {
        System.out.println("键盘关闭");
    }

    public void input(){
        System.out.println("键盘输入东西");
    }
}


package NewOOP.prot;

public class Mouse implements USB{      //鼠标也具有其相关特性

    @Override
    public void openDevice() {
        System.out.println("打开鼠标");
    }

    @Override
    public void closeDevice() {
        System.out.println("关闭鼠标");
    }

    public void click(){
        System.out.println("点击鼠标");
    }
}

//下面写一个computer类，来模拟进行电脑的开关机，以及USB接口的使用
package NewOOP.prot;

public class Computer {
    public void powerOn(){
        System.out.println("打开笔记本电脑");
    }
    public void powerOff(){
        System.out.println("关闭笔记本电脑");
    }

    public void useUSB(USB usb){
        //此类来使用服务
        usb.openDevice();

        if(usb instanceof Mouse){
            ((Mouse) usb).click();  //把usb转为Mouse类型来使用Mouse里特有的方法
        } else if (usb instanceof KeyBoard) {
            ((KeyBoard) usb).input(); //把usb转为KeyBoard类型来使用Mouse里特有的方法
        }
        usb.closeDevice();

    }
}

//测试代码
package NewOOP.prot;

public class TsetUSB {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.powerOn();

        //鼠标使用USB接口
        computer.useUSB(new Mouse());

        //键盘使用USB接口
        computer.useUSB(new KeyBoard());


        computer.powerOff();
    }
}

我们在测试类里面进行代码测试，发现鼠标和键盘分别调用useUSB方法时，出现的结果不一样。

这是因为如果在useUSB方法中传入的是Mouse的话，那么useUSB方法接收的就是我的Mouse对象，而方法的形参是USB接口引用类型（意思是符合USB接口规范的都可以使用次此方法），那么USB接口就接收到了Mouse对象，此时就发生了向下转型 ，然后在使用usb.openDevice服务时，会发生动态绑定，编译器在运行阶段，会跳转到Mouse中的特有的openDevice方法，从而实现接口。

简而言之，接口使用的就是多态的思想

四.接口的特性

1.接口时一种引用类型，但是不能直接实例化

2.接口中每一个方法都是public的抽象方法，会被指定为public abstract 类型

3.接口中的方法是不能在接口中实现的，只能由实现接口的类来实现

4.重写接口方法时，不能使用默认的访问权限（因为权限被缩小了）

5.接口中可以含有变量，但是都被指定为public static final来修饰

6.如何看一个类是否符合接口的规范：看这个类有没有implement接口，并且有没有重写接口中所有的抽象方法

 四.实现多个接口

在 Java 中，类和类之间是单继承的，一个类只能有一个父类，即 Java 中不支持多继承 ，但是 一个类可以实现多个接 口 。下面通过类来表示一组动物

package NewOOP.prot.many;

public class Animal {
    //实现多个接口
    String name;

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

//另外我们再提供一组接口, 分别表示 "会飞的", "会跑的", "会游泳的"

interface IFlying {
void fly();
}

interface IRunning {
void run();
}

interface ISwimming {
void swim();
}

//接下来我们创建几个具体的动物


//猫是会跑的
package NewOOP.prot.many;

public class Cat extends Animal implements IRunning{

    public Cat(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println("猫正在跑");
    }
}

//鱼是会游的
package NewOOP.prot.many;

public class Fish extends Animal implements ISwimming{

    public Fish(String name) {
        super(name);
    }

    @Override
    public void swimming() {
        System.out.println("鱼正在游泳");
    }
}


//鸭子既可以跑，也可以游泳，也可以低空飞行
package NewOOP.prot.many;

public class Duck extends Animal implements IRunning,IFlying,ISwimming{
    public Duck(String name) {
        super(name);
    }

    @Override
    public void fly() {
        System.out.println("鸭子在飞");
    }

    @Override
    public void run() {
        System.out.println("鸭子在跑");
    }

    @Override
    public void swimming() {
        System.out.println("鸭子在游泳");
    }
}

再写一个测试类:

package NewOOP.prot.many;

public class TestAnimal {

    public static void walk(IRunning running){  //只关心是否是IRunning标准
        running.run();
    }
    public static void swim(ISwimming swimming) {
        swimming.swimming();
    }
    public static void fly(IFlying flying) {  //只关心是否是IFlying标准
        flying.fly();
    }
    public static void main(String[] args) {
        walk(new Cat("小猫"));//walk

        walk(new Duck("唐老鸭"));
        fly(new Duck("唐老鸭二号"));





        



    }
}

我们可以发现，Duck类，可以使用多个接口，原因就是他符合多个接口的使用规范，并且重写了每个接口中的抽象方法。

以下是运行结果:

总结:Java当中接口的使用非常广泛，下篇博客中我回使用接口来重写comparable方法，来进行对数组排序。