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

田雨晴Tipper

已于 2024-02-03 22:11:37 修改

阅读量2.2k

点赞数 62

分类专栏： JavaSE 文章标签：电脑 java-ee python java 学习方法 intellij idea

于 2023-12-29 15:08:23 首次发布

本文链接：https://blog.csdn.net/T2283380276/article/details/135241705

版权

JavaSE 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

文章目录

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