JAVA系列小白入门参考资料接口

接口

接口的概念

语法

接口使用

接口实现用例

接口特性

实现多个接口和实现用例

接口间的继承

接口

接口的概念

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

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

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

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

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

语法

接口在语法上和类相似

public interface 接口名称 {

......

}

提示: 创建接口时, 接口的命名一般以大写字母 I 开头

接口使用

接口不能直接使用，必须要有一个"实现类"来"实现"该接口，并实现接口中的所有抽象方法。

public class 类名称 implements 接口名称 {

...

}

注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。

接口实现用例

以笔记本电脑使用 USB 鼠标、 USB 键盘为例

USB接口笔记本类鼠标类键盘类

//USB接口
public interface USB {
    //方法，打开设备，关闭设备
    void openEquipment();
    void stopEquipment();
}

//定义鼠标类，使用接口
class Mouse implements USB {

    //使用接口，就要重写USB接口的抽象方法
    @Override
    public void openEquipment() {
        System.out.println("使用鼠标");
    }

    //自定义一个鼠标点击的功能
    public void click(){
        System.out.println("鼠标点击");
    }

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

//定义键盘类，使用接口
class Keyboard implements USB{

    @Override
    public void openEquipment() {
        System.out.println("使用键盘");
    }

    //自定义一个键盘输入的方法
    public void inPut() {
        System.out.println("键盘输入");
    }

    @Override
    public void stopEquipment() {
        System.out.println("关闭键盘");
    }
}
//定义电脑类,使用设备
class Computer{
        public void powerOn(){
            System.out.println("打开电源");
        }

        public void useEquipment(USB usb){
            //这里使用USB usb的原因是：为了传参并发生向上转型

            usb.openEquipment();//这里会发生动态绑定

            //这里，我们调用了使用设备的方法，但我们有鼠标和键盘，他们都要各自特有的方法click和inPut
            //但usb是接口类型，直接用usb去调用他们的特有方法，不可行

            //区分 引用的是谁的对象
            if(usb instanceof Mouse){
                Mouse mouse = (Mouse) usb;
                mouse.click();
            }else if(usb instanceof Keyboard){
                Keyboard keyboard = (Keyboard) usb;
                keyboard.inPut();
            }

            usb.stopEquipment();

        }

        public void powerOff(){
            System.out.println("关闭电源");
        }
        
}

class Test{
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.powerOn();
        System.out.println();
        computer.useEquipment(new Keyboard());
        System.out.println();
        computer.useEquipment(new Mouse());
        System.out.println();
        computer.powerOff();

    }
}

接口特性

接口类型是一种引用类型，不能直接 new 接口的对象
接口中的每一个方法都是默认被 public private 修饰
接口中的方法不能在接口中实现(因为抽象方法不能有具体的实现)，只能由实现接口的类来实现
重写接口中的方法时，不能使用默认的访问权限（因为接口的方法默认是public）
接口中可以拥有变量，但接口中的变量会默认被public static final 修饰
接口中不能有静态代码块和构造方法
接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

实现多个接口和实现用例

在 Java 中，类和类之间是单继承的，一个类只能有一个父类，即 Java 中不支持多继承 ，但是 一个类可以实现多个接 口。

下面通过类来表示一组动物

创一个动物类

//动物类
class Animals{
    private String name;

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

创几个接口

//吃 接口
interface EAT{
    void eat();
}

//跑 接口
interface RUN{
    void run();
}

//飞 接口
interface FLY{
    void fly();
}

//游泳 接口
interface SWIM{
    void swim();
}

创几个具体的动物类

小狗，可以吃和跑

class Dog extends Animals implements EAT,RUN{

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

    @Override
    public void eat() {
        System.out.println(this.name + "在吃");
    }

    @Override
    public void run() {
        System.out.println(this.name + "在跑");
    }
}

小鱼，可以吃和游

class Fish extends Animals implements EAT,SWIM{

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

    @Override
    public void eat() {
        System.out.println(this.name + "在吃");
    }

    @Override
    public void swim() {
        System.out.println(this.name + "在游");
    }
}

小鸭子，可以吃，飞，跑和游

class Duck extends Animals implements EAT,RUN,FLY,SWIM{

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

    @Override
    public void eat() {
        System.out.println(this.name + "在吃");
    }

    @Override
    public void run() {
        System.out.println(this.name + "在跑");
    }

    @Override
    public void fly() {
        System.out.println(this.name + "在飞");
    }

    @Override
    public void swim() {
        
    }
}

上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口

继承表达的含义是 is - a 语义, 而接口表达的含义是具有 xxx 特性

以下是完整代码和执行结果

class Animals{
    public String name;

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

//吃 接口
interface EAT{
    void eat();
}

//跑 接口
interface RUN{
    void run();
}

//飞 接口
interface FLY{
    void fly();
}

//游泳 接口
interface SWIM{
    void swim();
}

class Dog extends Animals implements EAT,RUN{

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

    @Override
    public void eat() {
        System.out.println(this.name + "在吃");
    }

    @Override
    public void run() {
        System.out.println(this.name + "在跑");
    }
}

class Fish extends Animals implements EAT,SWIM{

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

    @Override
    public void eat() {
        System.out.println(this.name + "在吃");
    }

    @Override
    public void swim() {
        System.out.println(this.name + "在游");
    }
}

class Duck extends Animals implements EAT,RUN,FLY,SWIM{

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

    @Override
    public void eat() {
        System.out.println(this.name + "在吃");
    }

    @Override
    public void run() {
        System.out.println(this.name + "在跑");
    }

    @Override
    public void fly() {
        System.out.println(this.name + "在飞");
    }

    @Override
    public void swim() {

    }
}

public class Blog {
    public static void main(String[] args) {
        Dog dog = new Dog("小狗");
        dog.eat();
        dog.run();
        
        Fish fish = new Fish("小鱼");
        fish.eat();
        fish.swim();
        
        Duck duck = new Duck("小鸭子");
        duck.eat();
        duck.fly();
        duck.run();
        duck.swim();
    }

}

接口间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。

接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字

interface RUN{
    void run();
}

//游泳 接口
interface SWIM{
    void swim();
}

interface ICanDo extends RUN, SWIM {
}

class Frog implements ICanDo {
    ...
}

通过接口继承创建一个新的接口 ICanDo 表示 "两栖的". 此时实现接口创建的 Frog 类, 就继续要实现 run 方法, 也需要实现 swim 方法.