JavaSE语法之十一：接口（超全！！！）

文章目录

- - 1. 概念
  - 2. 语法规则
  - 3. 接口使用
  - 4. 接口特性
  - 5. 实现多个接口
  - 6. 接口间的继承
  - 7. 接口使用实例
  - 8. Clonable 接口和深拷贝
  - 9. 抽象类和接口的区别（重要！）

1. 概念

在现实生活中的接口比比皆是，如：笔记本上的USB接口、电源插座等。
电脑的USB口上，可以插：U盘、鼠标、键盘…所有符合USB协议的设备；
电源插座插孔上，可以插：电脑、电视机、电饭煲…所有符合规范的设备。
通过上述例子可以看出：接口就是公共的行为规范标准，我们在实现时，只要符合规范标准，就可以通用。在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

抽象类时对一个事物在抽象；
接口是对一个行为或者规范在设定标准。

2. 语法规则

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

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

注意：

创建接口时，接口的命名一般以大写字母I开头母；
接口的命名一般使用“形容词”词性的单词；
阿里编码规范中约定，接口中的方法和属性不要加任何修饰符号，保持代码的简洁性。

3. 接口使用

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

public class 类名称 implements 接口名称{
……
}

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

如实现笔记本电脑使用USB鼠标、USB键盘的例子：
① USB接口：包含打开设备、关闭设备功能；
② 笔记本类：包含开机功能、关机功能、使用USB设备功能；
③ 鼠标类：实现USB接口，并具备点击功能；
④ 键盘类：实现USB接口，并具备输入功能。

//USB接口
public interface IUSB {void openDevice();void closeDevice();
}//鼠标类，实现USB接口
public class Mouse implements IUSB {@Overridepublic void openDevice() {System.out.println("打开鼠标");}@Overridepublic void closeDevice() {System.out.println("关闭鼠标");}public void click() {System.out.println("鼠标点击");}
}//键盘类
public class KeyBoard implements IUSB {@Overridepublic void openDevice() {System.out.println("打开键盘");}@Overridepublic 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设备，在电脑上都可以使用，只要实现了这个接口就可以使用，不关注你是键盘还是鼠标了。public void useDevice(IUSB usb) {usb.openDevice();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 Test2 {public static void main(String[] args) {Computer computer = new Computer();computer.powerOn();//使用鼠标设备computer.useDevice(new Mouse());//使用键盘设备computer.useDevice(new KeyBoard());computer.powerOff();}
}//输出结果：
打开笔记本电脑
打开鼠标
鼠标点击
关闭鼠标
打开键盘
键盘输入
关闭键盘
关闭笔记本电脑

4. 接口特性

接口是一种引用类型，不能实例化对象；
接口中的成员，默认是 public static final 静态常量；

//不管怎么定义默认前面都有public static final
public String name = "1";
public static String name2 = "1";
public static final String name3 = "1";

接口中的方法都是public抽象方法，不写也默认为public abstract；
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现，但是从JDK8开始，可以写一个default修饰的方法可以实现；

public void func(){ //报错，不能有具体实现的方法，只能有抽象方法System.out.println("hahah");
}//JDK8中
default public void func1(){ //可以System.out.println("hahah");
}

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

public interface IUSB {void openDevice(); //这里默认是public abstract void openDevice();void closeDevice();
}public class Mouse implements IUSB {@Overridevoid openDevice() { //此时会报错，重写的时候，子类的修饰权限一定要大于等于父类的访问权限//此时这里是什么都没写，是包访问权限，比public小，所以报错!System.out.println("打开鼠标");}//正确写法@Overridepublic void closeDevice() {System.out.println("关闭鼠标");}
}

接口中不能有静态代码块；
接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class；
如果类没有实现接口中的所有抽象方法，则类必须设置为抽象类；

public interface IUSB {void closeDevice();
}//如果实现类没有重写接口中的抽象方法，此时会报错
public class Mouse implements IUSB { //报错}//正确写法，不想重写接口中的抽象方法
public abstract class Mouse implements IUSB { }

接口当中，可以有 static修饰的方法。

5. 实现多个接口

在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);
}@Overridepublic void run() {System.out.println(this.name + "正在用四条腿跑");
}
}

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

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

public class Test {//只要实现了 IRunning接口的，都可以接收
//此时和动物没关系了，只是看谁实现了这个规范public static void walk(IRunning running) {System.out.println("我带着伙伴去散步");running.run();
}public static void swima(ISwimming swimming) {swimming.swim();}public static void main(String[] args) {walk(new Cat("咪咪"));walk(new Frog("蛙小侠"));swima(new Frog("蛙蛙"));}
}//输出结果
我带着伙伴去散步
咪咪正在用四条腿跑
我带着伙伴去散步
蛙小侠正在往前跳
蛙蛙正在蹬腿游泳

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

上述代码展示了Java 面向对象编程中最常见的用法：一个类继承一个父类, 同时实现多种接口。
继承表达的含义是 is - a语义，而接口表达的含义是具有XXX特性。
① 猫是一种动物，具有会跑的特性；
② 青蛙是一种动物，既能跑，也能游泳。
这样设计的好处是，能让程序员忘记类型。有了接口后，类的使用者就不必须关注具体类型，而只关注某个类具备某种能力。

6. 接口间的继承

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

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

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

接口间的继承，相当于把多个接口合并在一起。
通过接口继承创建一个新的接口 IAmphibious 表示 “两栖的”。此时实现接口创建的 Frog 类，就继续要实现 run 方法，也需要实现 swim 方法。

7. 接口使用实例

给对象数组排序。

首先，当我们给一组整型数组排时，直接调用Arrays.sort();方法就可以完成数组的排序。

	int[] array = {2,5,6,3,8,4,1}; Arrays.sort(array);System.out.println(Arrays.toString(array));//输出结果
[1, 2, 3, 4, 5, 6, 8]

但当我们是对象数组时，该怎么排序呢？

class Student {public String name;public int score;public Student(String name, int score) {this.name = name;this.score = score;
}@Override
public String toString() {
return "[" + this.name + ":" + this.score + "]";
}
}public class Test {public static void main(String[] args) {Student[] students = new Student[] {new Student("张三", 90),new Student("李四", 96),new Student("王五", 97),new Student("赵六", 92),
};//直接用Arrays.sort();方法Arrays.sort(students);System.out.println(Arrays.toString(students));}
}// 运行出错, 抛出异常.
Exception in thread "main" java.lang.ClassCastException: Student cannot be cast to java.lang.Comparable

此时要进行排序，系统根本不知道要按照什么来排序。
我们想要用成绩来进行排序；
让我们的Student类实现现 Comparable 接口, 并重写其中的 compareTo 方法。

class Student implements Comparable<Student>{public String name;public int score;public Student(String name, int score) {this.name = name;this.score = score;}@Overridepublic String toString() {return "[" + this.name + ":" + this.score + "]";}
//重写compareTo方法
//这里不灵活，因为写死了，只能用分数来进行排序@Overridepublic int compareTo(Student o) {//比较规则/*if (this.score > o.score) {return -1;}else if (this.score < o.score) {return 1;}else {return 0;*/
//也可以直接返回this.age - o.age进行比较return this.age - o.age; }}
}public class Test4 {public static void main(String[] args) {Student[] students = new Student[] {new Student("张三", 90),new Student("李四", 96),new Student("王五", 97),new Student("赵六", 92),};Arrays.sort(students);System.out.println(Arrays.toString(students));}
}//输出结果
[[王五:97], [李四:96], [赵六:92], [张三:90]]

【分析】
在sort方法中会自动调用compareTo 方法.。compareTo 的参数是Student 类型的对象，然后比较当前对象和参数对象的大小关系（按分数来算）。

   @Overridepublic int compareTo(Student o) {//比较规则if (this.score > o.score) {return -1;}else if (this.score < o.score) {return 1;}else {return 0;}}

如果当前对象应排在参数对象之前，返回小于 0 的数字；
如果当前对象应排在参数对象之后，返回大于 0 的数字；
如果当前对象和参数对象不分先后，返回 0。
这样结果就符合预期了。

8. Clonable 接口和深拷贝

Java中内置了一些很有用的接口，Clonable就是其中之一。
Object类中存在一个clone方法，调用这个方法可以创建一个对象的“拷贝”。但是要想合法调用clone方法，必须要先实现Clonable接口，否则就会抛出CloneNotSupportedException 异常.

【方式一】
通过访问Cloneable接口，可以对自定义类型进行拷贝。

class Student1 implements Cloneable {public String name;@Overridepublic String toString() {return "Student1{" +"name='" + name + '\'' +'}';}
//重写Object中的克隆方法@Overrideprotected Object clone() throws CloneNotSupportedException { //这里是编译异常return super.clone(); //通过super访问的}
}
public class Test5 {public static void main(String[] args) throws CloneNotSupportedException {//如何拷贝这个对象Student1 student1 = new Student1();student1.name = "张三";Student1 student2 = (Student1) student1.clone(); //向下转型System.out.println(student1);System.out.println(student2);}
}//输出结果
Student1{name='张三'}
Student1{name='张三'}

其中：
我们看源码可知，public interface Cloneable {} 这个接口里面什么都没有，是个空接口，也叫标记接口。
空接口的作用：表示当前对象是可以被克隆的。

【方法二】
浅拷贝：原来的A和拷贝的B，当修改其中一个，另一个也会被修改。
深拷贝：原来的A和拷贝的B，当修改其中一个，另一个不会受影响。

【浅拷贝】

class Money {public double money = 12.25;
}
class Student1 implements Cloneable {public String name;public Money m = new Money(); //这里存储的是对象的地址@Overridepublic String toString() {return "Student1{" +"name='" + name + '\'' +'}';}
//重写Object中的克隆方法@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}
public class Test5 {public static void main(String[] args) throws CloneNotSupportedException {//如何拷贝这个对象Student1 student1 = new Student1();Student1 student2 = (Student1) student1.clone(); //向下转型System.out.println(student1.m.money);System.out.println(student2.m.money);System.out.println("======================");student2.m.money = 99;System.out.println(student1.m.money);System.out.println(student2.m.money);}
}//输出结果
12.25
12.25
======================
99.0
99.0
此时受影响了，是浅拷贝。

此时的内存图：
在这里插入图片描述

【深拷贝】

class Money implements Cloneable{public double money = 12.25;@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}class Student1 implements Cloneable {public String name;public Money m = new Money(); //这里存储的是对象的地址@Overridepublic String toString() {return "Student1{" +"name='" + name + '\'' +'}';}
//重写Object中的克隆方法@Overrideprotected Object clone() throws CloneNotSupportedException {//只是克隆了Student对象Student1 student = (Student1)super.clone();//克隆了Student对象 里面的Money对象student.m = (Money) this.m.clone();return student;//return super.clone();}
}
public class Test5 {public static void main(String[] args) throws CloneNotSupportedException {//如何拷贝这个对象Student1 student1 = new Student1();Student1 student2 = (Student1) student1.clone(); //向下转型System.out.println(student1.m.money);System.out.println(student2.m.money);System.out.println("======================");student2.m.money = 99;System.out.println(student1.m.money);System.out.println(student2.m.money);}
}//输出结果
12.25
12.25
======================
12.25
99.0