五分钟“手撕”Java中的接口（上）

Tracy-22

已于 2024-05-01 22:05:13 修改

阅读量692

点赞数 35

文章标签： java 开发语言

于 2024-04-30 20:49:44 首次发布

本文链接：https://blog.csdn.net/2301_80958683/article/details/138355289

版权

4. 重写接口中方法时，不能使用默认的访问权限（分不清大小王了）

5.变量被public static final 修饰

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

7. 接口编译完成后字节码文件的后缀格式也是.class

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

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

一、什么是接口

接口其实算一种特殊的抽象类，比抽象类还要抽象的东西。

在日常生活中，随处可见都有接口：笔记本上的USB口，电源接口等....

耳机接口，只要你是符合耳机规范（市面上的耳机一样规格的）就能接入；

电源接口，只要你符合电源接口的规范，就能接入。

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

二、接口的语法

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

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

提示:

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

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

3. 接口中的方法和属性尽量不要加任何修饰符号, 保持代码的简洁性.

三、接口的简单使用

那怎么使用一个接口呢?

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

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

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

那我们现在来实现一个小代码：

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

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

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

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

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

// USB接口
public interface USB {
    void openDevice();
    void closeDevice();
}
// 鼠标类，实现USB接口
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("鼠标点击");
}
}
// 键盘类，实现USB接口
public class KeyBoard implements USB {
@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 powerOn(){
    System.out.println("打开笔记本电脑");
}
public void powerOff(){
    System.out.println("关闭笔记本电脑");
}
//这里传值给usb接口相当于
//USB usb=new Mouse();
//USB usb=new KeyBoard();
public void useDevice(USB usb){
    usb.openDevice();
//这里是判断传的值到底是Mouse还是Keyboard，
//才能使用对应的方法，这时需要发生向下转型
//不发生向下转型则无法通过usb调用子类特有的方法
if(usb instanceof Mouse){
    Mouse mouse = (Mouse)usb;
    mouse.click();
}else if(usb instanceof KeyBoard){
    KeyBoard keyBoard = (KeyBoard)usb;
    keyBoard.inPut();
}
    usb.closeDevice();
}
}
// 测试类：
public class TestUSB {
public static void main(String[] args) {
    Computer computer = new Computer();
    computer.powerOn();
// 使用鼠标设备
    computer.useDevice(new Mouse());
// 使用键盘设备
    computer.useDevice(new KeyBoard());
    computer.powerOff();
}
}

上面思想：就是利用接口发生多态

四、接口的特性

1.不能实例化对象

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

2.被public abstract修饰

public interface USB {
    private void openDevice();
    void closeDevice();
}
 Error:(4, 18) java: 此处不允许使用修饰符private
（只能是 public abstract，其他修饰符都会报错)

3.只能在类中实现接口的方法

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

4. 重写接口中方法时，不能使用默认的访问权限（分不清大小王了）

public interface USB {
    void openDevice(); // 默认是public的
    void closeDevice(); // 默认是public的
}
public class Mouse implements USB {
@Override
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); // 可以直接通过接口名访问，说明是静态的
    USB.brand = 2.0; // 说明brand具有final属性
}
}
编译报错：Error:(12, 12) java: 无法为最终变量brand分配值

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

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

7. 接口编译完成后字节码文件的后缀格式也是.class

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

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

public interface Interfacepratice {
    void method1();
//default修饰的方法
    default void method2(){
        System.out.println("default");
    }
//还可以是static修饰的方法
    static void method3(){
        System.out.println("static");
    }
}

五、接口的好处

1.解决不能多继承的问题，实现多接口

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

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

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

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

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

猫, 是会跑的

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(this.name + "正在用尾巴游泳");
}
}

青蛙, 既能跑, 又能游(两栖动物)

class Frog extends Animal implements IRunning, ISwimming {
public Frog(String name) {
    super(name);
}
@Override
public void run() {
    System.out.println(this.name + "正在往前跳");
}
@Override
public void swim() {
    System.out.println(this.name + "正在蹬腿游泳");
}
}

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

class Duck extends Animal implements IRunning, ISwimming, IFlying {
public Duck(String name) {
    super(name);
}
@Override
public void fly() {
    System.out.println(this.name + "正在用翅膀飞");
}
@Override
public void run() {
    System.out.println(this.name + "正在用两条腿跑");
}
@Override
public void swim() {
    System.out.println(this.name + "正在漂在水上");
}
}

上面的代码展示了 Java 面向对象编程中最常见的用法：

一个类继承一个父类, 同时实现多种接口。

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

2.不必关注具体是某种类型

这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿忘记类型.。

有了接口之后, 类的使用者就不必关注具体类型, 而只关注某个类是否具备某种能力。

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

public static void walk(IRunning running) {
    System.out.println("我带着伙伴去散步");
    running.run();
}

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

class Robot implements IRunning {
    private String name;
public Robot(String name) {
    this.name = name;
}
@Override
public void run() {
    System.out.println(this.name + "正在用轮子跑");
}
}
Robot robot = new Robot("机器人");
walk(robot);
// 执行结果
机器人正在用轮子跑

3.接口与接口也可以多继承

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

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

interface IRunning {
    void run();
}
interface ISwimming {
    void swim();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
}
    class Frog implements IAmphibious {
    ...
}

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

六、接口与抽象类的区别

Tracy-22

关注

35
点赞
踩
22

收藏

觉得还不错? 一键收藏
11
评论
五分钟“手撕”Java中的接口（上）

接口其实算一种特殊的抽象类，比抽象类还要抽象的东西。在日常生活中，随处可见都有接口：笔记本上的USB口，电源接口等....耳机接口，只要你是符合耳机规范（市面上的耳机一样规格的）就能接入；电源接口，只要你符合电源接口的规范，就能接入。接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。
复制链接

扫一扫