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,代码更简洁
}

注意:

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

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. 接口特性

  1. 接口是一种引用类型,不能实例化对象;
  2. 接口中的成员,默认是 public static final 静态常量;
//不管怎么定义默认前面都有public static final
public String name = "1";
public static String name2 = "1";
public static final String name3 = "1";
  1. 接口中的方法都是public抽象方法,不写也默认为public abstract
  2. 接口中的方法是不能在接口中实现的,只能由实现接口的类来实现,但是从JDK8开始,可以写一个default修饰的方法可以实现;
public void func(){ //报错,不能有具体实现的方法,只能有抽象方法
	System.out.println("hahah");
}

//JDK8中
default public void func1(){ //可以
	System.out.println("hahah");
}
  1. 接口中不能有构造方法;
  2. 重写接口中方法时,不能使用默认的访问权限;
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("关闭鼠标");
    }
}
  1. 接口中不能有静态代码块;
  2. 接口虽然不是类,但是接口编译完成后字节码文件的后缀格式也是.class;
  3. 如果类没有实现接口中的所有抽象方法,则类必须设置为抽象类;
public interface IUSB {
    void closeDevice();
}

//如果实现类没有重写接口中的抽象方法,此时会报错
public class Mouse implements IUSB { //报错
    }

//正确写法,不想重写接口中的抽象方法
public abstract class Mouse implements IUSB { 
    }
  1. 接口当中,可以有 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
此时受影响了,是浅拷贝。

此时的内存图:
JavaSE语法之十一:接口(超全!!!)_第1张图片

【深拷贝】

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

JavaSE语法之十一:接口(超全!!!)_第2张图片

9. 抽象类和接口的区别(重要!)

抽象类和接口都是Java中多态的常见使用方法。
【核心区别】
抽象类中可以包含普通方法和普通字段,这样的普通方法和字段可以被子类直接使用(不必重写);
接口中不能包含普通方法,子类必须重写所有的抽象方法。
JavaSE语法之十一:接口(超全!!!)_第3张图片

你可能感兴趣的:(JavaSE,电脑,java-ee,python,java,学习方法,intellij,idea)