【JavaSE】接口的语法知识和使用方法总结

目录

1. 接口的概念

2. 语法规则

3. 接口特性

4. 接口使用

5. 实现多个接口

6. 接口间的继承

---

1. 接口的概念

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

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

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

通过上述例子可以看出：接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。 在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

2. 语法规则

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

 提示:

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

2. 接口的命名一般使用 "形容词" 词性的单词.

3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性.

3. 接口特性

1. 接口类型是一种引用类型，但是不能直接new接口的对象

---

2. 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错)

---

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

 但是，有两种方法例外，一个是被static修饰的方法，另一个是被default修饰的方法；

  如何访问这两种方法呢？

 输出结果：

static修饰的方法可以直接通过接口名进行访问，default修饰的方法需要实例化出对象来进行访问。

如果重写了default修饰的方法，则访问的是重写的方法：

  输出结果：

---

4. 重写接口中方法时，不能使用默认的访问权限

 

---

5. 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量

 

---

6. 接口中不能有静态代码块，实例代码块和构造方法 

---

 7. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class

   接口的字节码文件：

---

 8. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

---

4. 接口使用

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

以画图形为例：

interface Shape {
    void draw();
}
class Rect implements Shape {
    @Override
    public void draw() {
        System.out.println("🔶🔶🔶");
    }
}
class Flower implements Shape {
    @Override
    public void draw() {
        System.out.println("❀❀❀");
    }
}
public class Test {
    public static void drawMap(Shape shape) {
        shape.draw();
    }
    public static void main(String[] args) {
        Shape shape1 = new Rect();
        Shape shape2 = new Flower();
        drawMap(shape1);
        drawMap(shape2);
    }
}

输出结果：

 也可以使用Shape数组来存储创建的对象：

public class Test {
    public static void drawMap(Shape shape) {
        shape.draw();
    }
    public static void main(String[] args) {
        Shape[] shapes = {new Rect(), new Flower(), new Rect(), new Flower()};
        for (Shape shape : shapes) {
            shape.draw();
        }
    }
}

 输出结果：

请实现笔记本电脑使用USB鼠标、USB键盘的例子

1. USB接口：包含打开设备、关闭设备功能

2. 笔记本类：包含开机功能、关机功能、使用USB设备功能 

3. 鼠标类：实现USB接口，并具备点击功能

4. 键盘类：实现USB接口，并具备输入功能

 我们在一个包中写接口和各种类：

 USB接口：

package demo1;

public interface USB {
    void openDevice();
    void closeDevice();
}

Mouse类：

package demo1;

public class Mouse implements USB {
    public void openDevice() {
        System.out.println("鼠标开始工作！");
    }
    public void click() {
        System.out.println("鼠标点击！");
    }
    public void closeDevice() {
        System.out.println("鼠标结束工作！");
    }
}

Keyboard类：

package demo1;

public class KeyBoard implements USB {
    public void openDevice() {
        System.out.println("键盘开始工作！");
    }
    public void input() {
        System.out.println("敲击键盘");
    }
    public void closeDevice() {
        System.out.println("键盘结束工作！");
    }
}

Computer类：

package demo1;

public class Computer {
    public void powerOn() {
        System.out.println("电脑开机！");
    }
    public void powerOff() {
        System.out.println("电脑关机! ");
    }
    
    public void useService(USB usb) {
        usb.openDevice();
        if(usb instanceof Mouse) {
            ((Mouse) usb).click();
        } else if(usb instanceof KeyBoard) {
            ((KeyBoard) usb).input();
        }
        usb.closeDevice();
    }
}

Main方法类:

package demo1;

public class Main {
    public static void main(String[] args) {
        Computer computer = new Computer();
        Mouse mouse = new Mouse();
        KeyBoard keyBoard = new KeyBoard();
        computer.powerOn();
        //使用鼠标设备
        computer.useService(mouse);
        //使用键盘设备
        computer.useService(keyBoard);
        computer.powerOff();
    }
}

当程序运行起来的结果:

5. 实现多个接口

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

class Animal {
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
//接口
interface IRun {
    void run();
}
interface IFly {
    void fly();
}
interface ISwim {
    void swim();
}

class Dog extends Animal implements IRun {
    public Dog(String name, int age) {
        super(name, age);
    }
    public void run() {
        System.out.println(this.name + " 这条狗正在跑！");
    }
}

class Duck extends Animal implements IRun, ISwim, IFly {
    public Duck(String name, int age) {
        super(name, age);
    }
    public void run() {
        System.out.println(this.name + " 这只鸭正在跑！");
    }
    public void fly() {
        System.out.println(this.name + " 这只鸭正在飞！");
    }
    public void swim() {
        System.out.println(this.name + " 这只鸭正在游泳！");
    }
}

class Frog extends Animal implements IRun, ISwim {
    @Override
    public void run() {
        System.out.println(this.name + " 这只蛙正在跑！");
    }
    @Override
    public void swim() {
        System.out.println(this.name + " 这只蛙正在游泳！");
    }
    public Frog(String name, int age) {
        super(name, age);
    }
}

public class Test {
    public static void Running(IRun iRun) {
        iRun.run();
    }
    public static void Flying(IFly iFly) {
        iFly.fly();
    }
    public static void Swiming(ISwim iSwim) {
        iSwim.swim();
    }

    public static void main(String[] args) {
        Running(new Dog("二狗子", 2));
        Running(new Duck("唐老鸭", 3));
        Running(new Frog("青蛙", 1));
        Swiming(new Duck("唐老鸭", 3));
        Swiming(new Frog("青蛙", 1));
        Flying(new Duck("唐老鸭", 3));
    }
}

上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口. 继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性 .

猫是一种动物, 具有会跑的特性.

青蛙也是一种动物, 既能跑, 也能游泳

鸭子也是一种动物, 既能跑, 也能游, 还能飞

这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型, 而只关注某个类是否具备某种能力. 

例如, 现在实现一个方法, 叫 "散步"

在这个 walk 方法内部, 我们并不关注到底是哪种动物, 只要参数是会跑的, 就行

6. 接口间的继承

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

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

interface A {
    void testA();
}
interface B extends A {
    void testB();
}
class TestDome implements B {
    @Override
    public void testA() {
        
    }
    @Override
    public void testB() {

    }
}

接口间的继承相当于把多个接口合并在一起.

这篇文章到这里就结束了，下篇文章继续写接口的使用场景。