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 {
@Override
public void openDevice() {
System.out.println("打开鼠标");
}
@Override
public void closeDevice() {
System.out.println("关闭鼠标");
}
public void click() {
System.out.println("鼠标点击");
}
}
//键盘类
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 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 {
@Override
void openDevice() { //此时会报错，重写的时候，子类的修饰权限一定要大于等于父类的访问权限
//此时这里是什么都没写，是包访问权限，比public小，所以报错!
System.out.println("打开鼠标");
}
//正确写法
@Override
public 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);
}
@Override
public void run() {
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 + "正在蹬腿游泳");
}
}
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;
}
@Override
public String toString() {
return "[" + this.name + ":" + this.score + "]";
}
//重写compareTo方法
//这里不灵活，因为写死了，只能用分数来进行排序
@Override
public 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 类型的对象，然后比较当前对象和参数对象的大小关系（按分数来算）。
@Override
public 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;
@Override
public String toString() {
return "Student1{" +
"name='" + name + '\'' +
'}';
}
//重写Object中的克隆方法
@Override
protected 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(); //这里存储的是对象的地址
@Override
public String toString() {
return "Student1{" +
"name='" + name + '\'' +
'}';
}
//重写Object中的克隆方法
@Override
protected 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;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class Student1 implements Cloneable {
public String name;
public Money m = new Money(); //这里存储的是对象的地址
@Override
public String toString() {
return "Student1{" +
"name='" + name + '\'' +
'}';
}
//重写Object中的克隆方法
@Override
protected 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
9. 抽象类和接口的区别（重要！）
抽象类和接口都是Java中多态的常见使用方法。
【核心区别】
抽象类中可以包含普通方法和普通字段，这样的普通方法和字段可以被子类直接使用（不必重写）；
接口中不能包含普通方法，子类必须重写所有的抽象方法。
