docker rootless模式和基于kind的k8s测试环境-CFANZ编程社区

1.接口的概念

2.语法规则

1.接口的概念

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

2.语法规则

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

interface USB{
    public abstract void methodA();
    public void methodB();
    abstract void methodC();
    void methodD();
}

以上接口中的四个方法的类型都是public abstract抽象方法，但是实际上更推荐methodD的写法，这样代码会更简洁。

3.接口使用

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

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

语法：

public class 类名称 implements 接口名称{ 
// ...
}

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

class Mouse implements USB{
    @Override
    public void openDevice() {
        System.out.println("启动鼠标");
    }

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

class KeyBoard implements USB{
    @Override
    public void openDevice() {
        System.out.println("启动键盘");
    }

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

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

class Computer{
    public void powerOn(){
        System.out.println("开机...");
    }

    public void powerOff(){
        System.out.println("关机...");
    }

    public void useDevice(USB usb){
        if(usb instanceof Mouse){
            Mouse mouse=(Mouse) usb;
            mouse.click();
        } else if (usb instanceof KeyBoard) {
            KeyBoard keyBoard=(KeyBoard) usb;
            keyBoard.input();
        }else{
            System.out.println("Error...");
        }
    }
}

public class Demo1 {
    public static void main(String[] args) {
        Computer computer=new Computer();
        //打开电源
        computer.powerOn();
        //使用鼠标
        computer.useDevice(new Mouse());
        //使用键盘
        computer.useDevice(new KeyBoard());
        //关闭电源
        computer.powerOff();
    }
}

4.接口特性

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

报错：USB类是抽象的，无法实例化。

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

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

报错：抽象方法不能有主体。

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

编译报错：正在尝试分配更低的访问权限; 以前为public

原因：接口中的方法都默认为public static，而实现接口时重写的方法的访问权限必须大于等于被重写的方法，也就是说，重写的方法的访问权限必须大于等于public。

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

interface USB{
    void openDevice();
    void closeDevice();
    int A=2;
}

给USB添加一个成员变量A。

①可以直接通过接口名访问，说明该成员变量是静态的。

修改A的值，编译报错：不能修改被final修饰的变量'A'

②说明成员变量A被final修饰..

6. 接口中不能有代码块和构造方法

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

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

9. jdk8中：接口中还可以包含default方法。

5.实现多个接口

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

现有一个动物类（作为父类），还有三个接口：IRunning、ISwimming、IFlying：

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

interface ISwimming{
    void swim();
}

interface IRunning{
    void run();
}

interface IFlying{
    void fly();
}

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

猫 , 是会跑的 .

class Cat extends Animal implements IRunning{

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

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

鱼 , 是会游的 .

class Fish extends Animal implements ISwimming{

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

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

青蛙 , 既能跑 , 又能游（两栖动物）

class Frog extends Animal implements IRunning,ISwimming{

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

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

    @Override
    public void swim() {
        System.out.println(name+"正在蹬腿游泳...");
    }
}

还有一种神奇的动物 , 水陆空三栖 , 叫做 " 鸭子 "

class duck extends Animal implements IRunning,ISwimming,IFlying{

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

    @Override
    public void swim() {
        System.out.println(name+"正在水上漂...");
    }

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

    @Override
    public void fly() {
        System.out.println(name+"正在扑腾翅膀飞...");
    }
}

注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类 。

【提示】 IDEA 中使用 ctrl + i 快速实现接口

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

6.接口间的继承

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

即：用接口可以达到多继承的目的。

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

案例：

interface ISwimming{
    void swim();
}

interface IRunning{
    void run();
}
//两栖类的
interface IAmphibious extends IRunning,ISwimming{
    
}

class Frog extends Animal implements IAmphibious{

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

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

    @Override
    public void swim() {
        System.out.println(name+"正在蹬腿游泳...");
    }
}

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