【Java 学习】接口的意义：程序世界的规则与多态性，学会接口、驭见多态是Java初学者的必经之路
💬 欢迎讨论：如对文章内容有疑问或见解，欢迎在评论区留言，我需要您的帮助！
👍 点赞、收藏与分享：如果这篇文章对您有所帮助，请不吝点赞、收藏或分享，谢谢您的支持！
🚀 传播技术之美：期待您将这篇文章推荐给更多对需要学习Java语言、低代码开发感兴趣的朋友，让我们共同学习、成长！
1. 什么是接口？
1.1 引入接口
在生活中，接口属于一个标准，如：手机的充电口，电脑的USB盘接口。一般情况下，所做的东西都要符合这个接口（标准）。
大家设置的产品都按着这个标准来做，设计出的产品都是 \" 通用 \" 的。
电脑的USB口上，可以插：U盘、鼠标、键盘…所有符合USB协议的设备
在Java中也规定的有标准，为了设置的方法符合标准，就需要实现接口。
1.2 接口的定义
在Java中，接口是一个用来定义方法的集合，但这些方法没有具体实现（即只有方法的声明，没有方法体）。接口可以看作是一种契约，规定了实现这个接口的类必须提供这些方法的具体实现。
定义接口的语法：
public interface 接口名 { // 抽象方法（没有方法体） void 方法名();}2. 接口的语法和使用
2.1 接口的语法
接口的定义格式与定义类的格式基本相同，将class关键字换成interface关键字，就定义了一个接口。
// interface 是定义接口垫的关键字public interface 接口名称{double a = 3.0; // 默认被：final public static修饰 // 抽象方法public abstract void method1(); // public abstract 是接口中函数的默认形式，可以不写public void method2(); // 相当于省略了 abstract, 隐士存在sbatractabstract void method3(); // 相当于省略了 public, 隐士存在public void method4(); // 省略了 public abstract, 隐士存在public abstract }提示:
- 创建接口时, 接口的命名一般以大写字母 I 开头.
- 接口的命名一般使用 “形容词” 词性的单词.
- 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性.
2.2 使用接口
接口不能直接使用，必须要有一个\"实现类\"来\"实现\"该接口，实现接口中的所有抽象方法
public class 类名称 implements 接口名称{ // ... } 注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。
示例：
在同一个包中，下面代码文件的结构：
Usb接口类：
声明两个方法。
public interface Usb { // 连接 void connect(); // 断开连接 void disconnect();}Mouse类：
实现接口Usb
public class Mouse implements Usb{ public void connect() { System.out.println(\"连接鼠标\"); } public void disconnect(){ System.out.println(\"断开鼠标\"); }}Keyboard类：
实现接口Usb
public class Keyboard implements Usb{ public void connect(){ System.out.println(\"连接键盘\"); } public void disconnect(){ System.out.println(\"断开键盘\"); }}Service 服务类（类似于电脑工作）：
public void useService(Usb usb) 函数模拟电脑的工作流程
public class Servise { // 打开电脑 private void openService(){ System.out.println(\"打开电脑\"); } // 关闭电脑 private void closeService(){ System.out.println(\"关闭电脑\"); } // 工作流程 public void useService(Usb usb){ //向上转型 openService(); // 检查时什么硬件插入 if( usb instanceof Keyboard){ // 键盘插入 // 向下转型 Keyboard k = (Keyboard) usb; // 转换成键盘对象 k.connect(); System.out.println(\"操作。。。。。。。。。。。。。。。。\"); k.disconnect(); } else if( usb instanceof Mouse){ // 鼠标插入 // 向下转型 Mouse m = (Mouse) usb; // 转换成鼠标对象 m.connect(); System.out.println(\"操作。。。。。。。。。。。。。\"); m.disconnect(); } else { // 不支持的硬件 System.out.println(\"不支持该设备\"); } closeService(); }}Main类，运行程序
public class Main { public static void main(String[] args){ // 创建鼠标对象 Mouse m = new Mouse(); // 创建键盘对象 Keyboard k = new Keyboard(); // 创建电脑对象 Servise s = new Servise(); // 电脑接入键盘 s.useService(m); System.out.println(\"========================\"); // 电脑接入鼠标 s.useService(k); }}3. 接口的特性
3.1 特性
接口是一种引用数据类型：
- 接口 是使用interface方法 来修饰的
- 接口当中 不能有 被实现的方法 ，意味着只能有抽象方方，但是两个方法除外:一个是static修饰的方法 一个是被 default 修饰的方法
- 接口当中的 抽象方法 默认都是public abstract 修饰的
- 接口当中 的成员变量 默认都是 public static final修饰
- 接口 不能进行实例化
- 类 和 接口 之间 的关系 ，可以使用implements来进行关联
- 接口 也是有 对应的 字节码文件的
3.2 举例
-
接口类型是一种引用类型，但是不能直接new接口的对象
public class Main { public static void main(String[] args) { Usb usb = new Usb; // 会报错，因为接口不能被实例化 } } -
接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是
public abstract，其他修饰符都会报错)public interface Usb { // 报错 此处不允许使用修饰符private private void openDevice(); void closeDevice(); } -
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现
public interface USB { void connect(); // 编译失败：因为接口中的方式默认为抽象方法 // 接口抽象方法不能带有主体 void disconnect(){ System.out.println(\"断开USB设备\"); } } -
重写接口中方法时，不能使用默认的访问权限
public interface Usb { void connect(); // 默认是public abstract的 void disconnect(); // 默认是public abstract的}public class Mouse implements Usb {// 默认的位default void connect() { System.out.println(\"连接鼠标\"); } // ... } // 编译报错，重写Usb中connect方法时，不能使用默认修饰符// Mouse正在尝试分配更低的访问权限， 接口的为public -
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量
public interface Usb { double brand = 3.0; // 默认被：final public static修饰 void connect(); // 默认是public abstract的 void disconnect(); // 默认是public abstract的 } public class TestUsb { public static void main(String[] args) { System.out.println(USB.brand); // 可以直接通过接口名访问，说明是静态的 // 编译报错；无法为最终变量brand分配值 USB.brand = 2.0; // 说明brand具有final属性 } } -
接口中不能有静态代码块和构造方法
public interface USB { // 编译失败 public USB(){ } {} // 编译失败 void connect(); // 默认是public abstract的 void disconnect(); // 默认是public abstract的 } -
接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
// 抽象方法public abstract class MaxUsb implements Usb{// 不实现方法 public abstract void connect(); public abstract void disconnect();} -
接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
-
jdk8中：接口中还可以包含default方法。
4. 实现多个接口
背景：要求实现三个类：猫（名字，会跑）、鱼（名字，会游泳）、青蛙（名字，会跑、游泳）鸭子（名字，会跑，会游泳，会飞）。
思考：
先设计一个Animal抽象类，每个动物的方法是不同的，怎么设计呢？
Animal设置所有的方法，这是不行的，因为猫只能跑，不会游泳
Animal中只设置跑的方法，把动物特有的方法写在自己的类中，这样是不好的，因为没有了 “通用” 的功能。
每个功能可以单独写在一个抽象类中，但是，一个类继承一个Aniaml类后就不能再继承了。
在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); } public void run() { System.out.println(this.name + \"正在用四条腿跑\"); } }鱼，会游泳
class Fish extends Animal implements ISwimming { public Fish(String name) { super(name); } public void swim() { System.out.println(this.name + \"正在用尾巴游泳\"); } }青蛙，能跑、能游泳
class Frog extends Animal implements IRunning, ISwimming { public Frog(String name) { super(name); } public void run() { System.out.println(this.name + \"正在往前跳\"); } public void swim() { System.out.println(this.name + \"正在蹬腿游泳\"); } }注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。
提示：IDEA 中使用 ctrl + i 快速实现接口
还有一种神奇的动物, 水陆空三栖, 叫做 “鸭子”
class Duck extends Animal implements IRunning, ISwimming, IFlying { public Duck(String name) { super(name); } public void fly() { System.out.println(this.name + \"正在用翅膀飞\"); } public void run() { System.out.println(this.name + \"正在用两条腿跑\"); public void swim() { System.out.println(this.name + \"正在漂在水上\"); } }上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口。
继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性 。
猫是一种动物, 具有会跑的特性.
青蛙也是一种动物, 既能跑, 也能游泳
鸭子也是一种动物, 既能跑, 也能游, 还能飞
这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型,而只关注某个类是否具备某种能力.
例如, 现在实现一个方法, 叫 “散步”
public static void walk(IRunning running) { System.out.println(\"我带着伙伴去散步\"); running.run(); }在这个 walk 方法内部, 我们并不关注到底是哪种动物, 只要参数是会跑的, 就行
public class Main { public static void walk(IRunning running) { System.out.println(\"我带着伙伴去散步\"); running.run(); } public static void seeSwim(ISwimming swimming) { System.out.println(\"我看着伙伴去游泳\"); swmming.swimming(); } public static void main(String[] args){ Cat cat = new Cat(\"小猫\"); walk(cat);// // 如果我们这样写// seeSwim(cat);// // seeSwim()括号中的引用会有红线，表示ISwimming没有被Cat实现 Frog frog = new Frog(\"小青蛙\"); walk(frog); }}// 执行结果
我带着伙伴去散步
小猫正在用四条腿跑
我带着伙伴去散步
小青蛙正在往前跳
5. 接口间的继承
在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。
接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字
可以让IAmphibious继承IRunning和ISwimming，这样，IAmphibious表示两栖动物，而且还可以使用public static void walk(IRunning running)函数。
interface IRunning { void run(); } interface ISwimming { void swim(); } // 两栖的动物, 既能跑, 也能游interface IAmphibious extends IRunning, ISwimming { } class Frog implements IAmphibious { ... }通过接口继承创建一个新的接口 IAmphibious 表示 “两栖的”. 此时实现接口创建的 Frog 类, 就继续要实现 run 方法, 也需要实现 swim 方法.
还可以使用public static void walk(IRunning running)函数，保证代码的 “通用性”。
接口间的继承相当于把多个接口合并在一起.
