Java_接口

目录

1.接口的语法规则

2.接口使用

 3.接口特性

4.实现多个接口

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

2）另外再提供一组接口, 分别表示 "会跑的", "会飞的", "会游泳的"；

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

小狗，是会跑的：

小鱼，是会游泳的：

小鸭，是会跑，会游泳，会飞的：

现在实现几个方法walk()，swim()

5.接口间的继承

---

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

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

1.接口的语法规则

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

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

提示: 1）创建接口时, 接口的命名一般以大写字母 I 开头；2）接口的命名一般使用 "形容词" 词性的单词；3） 接口中的方法和属性尽量不要加任何修饰符号, 保持代码的简洁性。

2.接口使用

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

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

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

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

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

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

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

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

// USB接口
public interface IUSB {
    void openDevice();
    void closeDevice();
}
// 鼠标类，实现USB接口
public class Mouse implements IUSB{
 
    @Override
    public void openDevice() {
        System.out.println("打开鼠标服务！");
    }
 
    @Override
    public void closeDevice() {
        System.out.println("关闭鼠标服务！");
    }
    public void click() {
        System.out.println("点击鼠标！");
    }
}
// 键盘类，实现USB接口
public class KeyBoard implements IUSB{
 
    @Override
    public void openDevice() {
        System.out.println("打开键盘！");
    }
 
    @Override
    public void closeDevice() {
        System.out.println("关闭键盘！");
    }
    public void inPut() {
        System.out.println("敲击键盘！");
    }
}
// 笔记本类：使用USB设备
public class Computer {
    public void open() {
        System.out.println("开机!");
    }
    public void close() {
        System.out.println("关机！");
    }
    //所有的USB接口在电脑上都可以使用
    public void useDevice(IUSB usb) {
        usb.openDevice();
        if (usb instanceof Mouse) {
            Mouse mouse = (Mouse)usb;//向下转型
            mouse.click();//向下转型的原因是访问类Mouse中自己特有的方法click
        }else if (usb instanceof KeyBoard) {
            KeyBoard keyBoard = (KeyBoard)usb;
            keyBoard.inPut();
        }
        usb.closeDevice();
    }
}
// 测试类：
public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer();
        Mouse mouse = new Mouse();
        KeyBoard keyBoard = new KeyBoard();
        computer.useDevice(mouse);
        System.out.println("-----------");
        computer.useDevice(keyBoard);
    }
}

 3.接口特性

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

public class TestUSB {
    public static void main(String[] args) {
        USB usb = new USB();
    }
}
// Error:(10, 19) java: day20210915.USB是抽象的; 无法实例化

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

public interface USB {
    // Error:(4, 18) java: 此处不允许使用修饰符private
    private void openDevice();
    void closeDevice();
}

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

public interface USB {
    void openDevice();
    // 编译失败：因为接口中的方式默认为抽象方法
    // Error:(5, 23) java: 接口抽象方法不能带有主体
    void closeDevice(){
        System.out.println("关闭USB设备");
    }
}

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

public interface IUSB {
    void openDevice(); // 默认是public的
    void closeDevice(); // 默认是public的
}
public class Mouse implements USB {
    @Override
    //这里不加public，系统会默认这个方法为默认修饰符，这样写是错误的
    //因为重写的时候子类的访问权限一定要大于等于父类的访问权限
    //所以，这里的openDevice() 一定要加上public，写成public void openDevice()
    void openDevice() {
        System.out.println("打开鼠标");
    }
// ...
}
// 编译报错，重写USB中openDevice方法时，不能使用默认修饰符
// 正在尝试分配更低的访问权限; 以前为public

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

public interface USB {
    double brand = 3.0; // 默认被：final public static修饰
    void openDevice();
    void closeDevice();
}
public class TestUSB {
    public static void main(String[] args) {
        System.out.println(USB.brand); // 可以直接通过接口名访问，说明是静态的
// 编译报错：Error:(12, 12) java: 无法为最终变量brand分配值
        USB.brand = 2.0; // 说明brand具有final属性
    }
}

6）接口中不能有静态代码块和构造方法；

public interface USB {
    // 编译失败
    public USB(){
    }
    {} // 编译失败
    void openDevice();
    void closeDevice();
}

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

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

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

4.实现多个接口

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

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

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

2）另外再提供一组接口, 分别表示 "会跑的", "会飞的", "会游泳的"；

interface IRunning {
    void run();
}
interface ISwimming {
    void swim();
}
interface IFlying {
    void fly();
}

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

小狗，是会跑的：

class Dog extends Animal implements IRunning {
    public Dog(String name) {
        super(name);
    }
 
    @Override
    public void run() {
        System.out.println(name + "正在跑！");
    }
}

小鱼，是会游泳的：

class Fish extends Animal implements ISwimming{
    public Fish(String name) {
        super(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 run() {
        System.out.println(name + "正在跑！");
    }
 
    @Override
    public void swim() {
        System.out.println(name + "正在游泳！");
    }
 
    @Override
    public void fly() {
        System.out.println(name + "正在飞！");
    }
}

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

现在实现几个方法walk()，swim()

public class Test {
    public static void walk(IRunning iRunning) {
        iRunning.run();
    }
    public static void swim(ISwimming iSwimming) {
        iSwimming.swim();
    }
    public static void main(String[] args) {
        walk(new Dog("小狗"));
        walk(new Duck("小鸭"));
        System.out.println("-----------");
        swim(new Fish("小鱼"));
        swim(new Duck("小鸭2"));
    }
}

打印结果是：

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

狗是一种动物, 具有会跑的特性；

鱼是一种动物，具有会游泳的特性；

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

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

例如什么的实现方法 walk()，swim() 内部，我们并不关注到底是哪种动物，只要参数是会跑的, 就行，甚至参数可以不是 "动物"，只要会跑!

5.接口间的继承

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

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

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

interface A {
    void funcA();
}
interface B {
    void funcB();
}
//C这个接口，不仅仅具备funcC这个功能，还具备了A和B这两个接口的功能
//接口可以通过extends这个关键字来拓展多个接口的功能
interface C extends A, B {
    void funcC();
}
//所以类CC如果继承了接口C，要重写的不仅仅接口C的方法，还要重写接口A和接口B的方法
class CC implements C {
 
    @Override
    public void funcA() {
 
    }
 
    @Override
    public void funcB() {
 
    }
 
    @Override
    public void funcC() {
 
    }
}
public class Test2 {
    public static void main(String[] args) {
        
    }
}