“接口”公共规范的遵守者

👨‍💻作者简介：👨🏻‍🎓告别，今天

📔高质量专栏：☕java趣味之旅

欢迎🙏点赞🗣️评论📥收藏💓关注

💖衷心的希望我的📙作品能给大家带来收获。

🎊前言：

让我们如大自然般🌱悠然自在😊地生活一天吧，
别因为有坚果外壳或者蚊子翅膀落在铁轨上🛤️而翻了车🚆。让我们该起床时🛏️就赶紧起床🛏️，
该休息🛏️时就安心休息🛏️，
保持安宁而没有烦扰的心态;身边的人要来就让他来，要去就让他去，
让钟声🕰️回荡，让孩子👼哭喊—
下定决心好好地过一天。

🙏希望大家都可以过好每一天。也🙏希望我的博客，能给大家带来💯收获。

1. 接口

为什么说“接口”公共规范的遵守者？这要从接口的概念说起。

1.1 接口的概念

在 Java 程序设计语言中，接口不是类，而是对类的一组需求描述，这些类要遵从接口描

述的统一格式进行定义。

在现实生活中，接口到处都是，如电脑的USB口，还有随处可见的电源插座等。

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

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

通过上述例子可以看出：

接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。

在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

1.2 语法规则

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

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

提示:

1. 创建接口时, 接口的命名一般以大写字母 I 开头.(如果不是会报警告)

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

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

（因为接口当中的成员方法和成员变量默认是public abstract 和public static final接口的特性会讲。）

1.3 接口的使用

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

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

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

请实现电脑使用IUSB鼠标、IUSB键盘的例子

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

2. 电脑类：包含开机功能、关机功能、使用IUSB设备功能

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

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

// IUSB接口
public interface IUSB {
void openDevice();//打开服务
void closeDevice();//关闭服务
}
// 鼠标类，实现IUSB接口
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("鼠标点击");
}
}
// 键盘类，实现IUSB接口
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("键盘输入");
}
}
// 电脑类：使用IUSB设备
public class Computer {
public void powerOn(){
System.out.println("打开电脑");
}
public void powerOff(){
System.out.println("关闭电脑");
}
public void useDevice(IUSB iusb){
usb.openDevice();
if(usb instanceof Mouse){
Mouse mouse = (Mouse)iusb;i
mouse.click();i
}else if(iusb instanceof KeyBoard){
KeyBoard keyBoard = (KeyBoard)iusb;i
keyBoard.inPut();
}
usb.closeDevice();
}
}
// 测试类：
public class TestIUSB {
public static void main(String[] args) {
Computer computer = new Computer();
computer.powerOn();
// 使用鼠标设备
computer.useDevice(new Mouse());
// 使用键盘设备
computer.useDevice(new KeyBoard());
computer.powerOff();
}
}

这个多练几遍就熟了.

1.4 接口的特性

1. 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract

接口当中不可以有普通变量,接口当中的成员变量默认是public static final。

（成员方法只能是public abstract，而成员变量只能是public static final其他修饰符都会报警告）

通过三个成员变量的比较,我们可以看出接口当中的成员变量,默认是不被修饰的静态常量。

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

public class TestUSB {
public static void main(String[] args) {
IUSB iusb = new IUSB();
}
}

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

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

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

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

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

7. 接口中如果是static,是可以具体实现的。

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

public interface USB {
void openDevice(); // 默认是public的
void closeDevice(); // 默认是public的
}
public class Mouse implements USB {
@Override
void openDevice() {
System.out.println("打开鼠标");
}
// ...
}
// 编译报错，重写USB中openDevice方法时，不能使用默认修饰符
// 正在尝试分配更低的访问权限; 以前为public

9. 接口中不能有静态代码块和构造方法，可以有静态方法。

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

10. 类和接口之间可以通过关键字implements来实现接口。

11. 接口也可以发生向上转型和动态绑定。

1.5 实现多个接口

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

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

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

interface IFlying {
void fly();
}
interface IJump {
void jump();
}
interface ISwimming {
void swim();
}

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

兔子🐇, 是会跳的.

class Rabbit extends Animal implements IJump {
public Rabbit(String name) {
super(name);
}
@Override
public void jump() {
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 IJump, ISwimming {
public Frog(String name) {
super(name);
}
@Override
public void jump() {
System.out.println(this.name + "正在往前跳");
}
@Override
public void swim() {
System.out.println(this.name + "正在蹬腿游泳");
}
}

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

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

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

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

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

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

兔子是一种动物, 具有会跳的特性.

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

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

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

而只关注某个类是否具备某种能力.

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

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

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

Cat cat = new Cat("小猫");
walk(cat);
Frog frog = new Frog("小青蛙");
walk(frog);
// 执行结果
我带着伙伴去散步
小猫正在用四条腿跑
我带着伙伴去散步
小青蛙正在往前跳

甚至参数可以不是 "动物", 只要会跑!

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);
// 执行结果
机器人正在用轮子跑

1.6 接口间的继承

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

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

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

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

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

1.7 抽象类和接口的区别

抽象类和接口都是 Java 中多态的常见使用方式. 都需要重点掌握. 同时又要认清两者的区别(重要!!! 常见面试题).

核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法.

如之前写的 Animal 例子. 此处的 Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此此处的 Animal 只能作为一个抽象类, 而不应该成为一个接口

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

再次提醒:

抽象类存在的意义是为了让编译器更好的校验, 像 Animal 这样的类我们并不会直接使用, 而是使用它的子类.

万一不小心创建了 Animal 的实例, 编译器会及时提醒我们.

🎊总结

以下是对接口简单的了解，下一篇文章我们会对，接口加深理解。具体内容有：接口的使用实例，以及Clonable接口和深拷贝。还有object类.