• java 抽象类与接口——接口

    文章目录

    1. 接口

    1.1 接口的概念


    在现实生活中，接口的例子比比皆是，比如：笔记本上的USB口，手机的Type—c接口等。

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

    手机Type—c接口上，可以插：耳机、充电线…所有符合规范的设备。


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

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

    1.2 语法规则

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

    
interface IShape{
    public abstract void draw();
}

public class Test {

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    这里定义了一个draw方法（抽象方法），因为被abstract修饰所以不需要写出是怎样实现的。

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


    可以实现一个静态方法

    interface IShape{
    public abstract void draw();
    default public void func() {
        System.out.println("YYDS！");
    }
    public static  void func1() {
        System.out.println("java!");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9


    接口不能实例化，那该怎么使用？


    类与接口之间使用implements来实现多个接口。

    class A implements IShape {
    @Override
    public void draw() {
        System.out.println("*******");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    1.3 接口的使用


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

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

    • 1
    • 2
    • 3


    【注意】

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

    interface USB {
    public void openDevice();//打开
    public void closeDevice();//关闭
}

class KeyBoard implements USB{
    @Override
    public void openDevice() {
        System.out.println("打开键盘~");
    }

    @Override
    public void closeDevice() {
        System.out.println("关闭键盘~");
    }
    public void inPut(){
        System.out.println("键盘输入~");
    }
}

class Mouse implements USB{
    @Override
    public void openDevice() {
        System.out.println("打开鼠标~");
    }

    @Override
    public void closeDevice() {
        System.out.println("关闭鼠标~");
    }
    public void click() {
        System.out.println("鼠标点击~");
    }
}

public class Computer {
    public void powerOn(){
        System.out.println("打开笔记本电脑");
    }
    public void powerOff(){
        System.out.println("关闭笔记本电脑");
    }
    public void useDevice(USB 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 static void main(String[] args) {
        Computer computer = new Computer();
        computer.powerOn();
        //使用鼠标设备
        computer.useDevice(new Mouse());
        // 使用键盘设备
        computer.useDevice(new KeyBoard());
        computer.powerOff();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64


    1.4 接口的特性

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

    编译器报错

    1. 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是public abstract，其他修饰符都会报错）。

    可见编译器报错。

    1. 接口中不能有方法的具体实现。

    可见编译器报错。

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

    编译器报错。
    在这里插入图片描述

    1. 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量。
    interface USB {
    public void openDevice();//打开
    public void closeDevice();//关闭
    
    public static final int brand = 1;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    1. 接口中不能有静态代码块和构造方法

    报错

    1. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
    2. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
    3. jdk8中：接口中还可以包含default方法

    1. 5 实现多个接口

    Java中不支持多继承，但是一个类可以实现多个接口。


    用implements来实现，每个接口之间用逗号来连接。

    interface A1 {
    public void func1();
}

interface B1 {
    public void func2();
}

class C1 implements A1,B1 {
    @Override
    public void func1() {

    }
    @Override
    public void func2() {

    }
}

public class Test {
    
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22


    下面来看一个例子。

    interface IFlying {
    public void fly();
}

interface IRunning {
    public void run();
}

interface ISwimming {
    public void swim();
}

class Animals {
    protected String name;

    public void eat() {
        System.out.println("吃食物~");
    }

    public Animals(String name) {
        this.name = name;
    }
}

class Dog extends Animals implements IRunning, ISwimming{
    public Dog(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在跑~");
    }
    @Override
    public void swim() {
        System.out.println(this.name + "正在游泳~");
    }
}

class Bird extends Animals implements IFlying{
    public Bird(String name) {
        super(name);
    }
    @Override
    public void fly() {
        System.out.println(this.name + "正在飞~");
    }
}

class Frog extends Animals 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 + "正在游泳~");
    }
}

class Duck extends Animals implements IFlying, IRunning, ISwimming{
    public Duck(String name) {
        super(name);
    }
    @Override
    public void fly() {
        System.out.println(this.name + "正在飞~");
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在跑~");
    }
    @Override
    public void swim() {
        System.out.println(this.name + "正在游泳~");
    }
}

class Robot implements IRunning {
    private String name;
    public Robot(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在用轮子跑");
    }
}

public class Test1 {
    public static void walk(IRunning iRunning) {
       iRunning.run();
    }

    public static void main(String[] args) {
        walk(new Dog("小狗"));
        walk(new Duck("鸭子"));
        walk(new Frog("青蛙"));
        walk(new Robot("机器人"));
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103


    狗是一种动物, 具有会跑、游泳的特性。
    鸟是一种动物，具有会飞的特性。
    青蛙也是一种动物, 既能跑, 也能游泳。
    鸭子也是一种动物, 既能跑, 也能游, 还能飞。

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

    有了接口之后，类的使用者就不必关注具体类型，而只关注某个类是否具备某种能力。

    1.6 接口间的继承

    接口与接口之间可以多继承。即：用接口可以达到多继承的目的。

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

    interface Iflying {
    public void fly();
}

interface Iswimming {
    public void swim();
}

interface Ifunc extends Iflying, ISwimming {
    public void func();
}

interface Ifunc1 extends Ifunc {
    public void func1();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15


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

    1.7 接口使用实例

    class Student {
    public String name;
    public int age;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Test {
    public static void main(String[] args) {
        Student[] student = new Student[3];
        student[0] = new Student("zhangsan", 19);
        student[1] = new Student("lisi", 17);
        student[2] = new Student("wangwu", 20);
        Arrays.sort(student);
        System.out.println(Arrays.toString(student));

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29


    上面代码是按照学生的姓名比较的？还是按照学生的年龄比价的？


    我们要让Student类可支持比较大小。


    现在分别写出按照年龄和姓名排序的方法：

    import java.util.Arrays;
import java.util.Comparator;

class StudentSort implements Comparable<StudentSort>{
    public String name;
    public int age;

    public StudentSort(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(StudentSort o) {
        if(this.age - o.age > 0) {
            return 1;
        }else if(this.age - o.age < 0) {
            return -1;
        }else {
            return 0;
        }
        //return 0;
    }
}

class AgeComparator implements Comparator<StudentSort> {
    @Override
    public int compare(StudentSort o1, StudentSort o2) {
        return o1.age - o2.age;
    }
}

class NameComparator implements Comparator<StudentSort> {
    @Override
    public int compare(StudentSort o1, StudentSort o2) {
        return o1.name.compareTo(o2.name);
    }
}

public class TestSort {
    public static void main(String[] args) {
        StudentSort[] students = new StudentSort[3];
        students[0] = new StudentSort("zhangsan", 10);
        students[1] = new StudentSort("lisi", 40);
        students[2] = new StudentSort("wangwu", 5);

        AgeComparator ageComparator = new AgeComparator();//按照年龄排序
        Arrays.sort(students, ageComparator);
        System.out.println(Arrays.toString(students));

        NameComparator nameComparator = new NameComparator();//按照姓名排序
        Arrays.sort(students, nameComparator);
        System.out.println(Arrays.toString(students));
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63



    输出的第一行是年龄有小到排序的，第二行是姓名有小到大排序的。

    1.8 Clonable 接口和深拷贝

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

    class Person1 implements Cloneable{
    public int id;

    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                '}';
    }
}

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person1 person = new Person1();
        person.id = 99;
        Person1 person1 = (Person1)person.clone();
        person1.id = 100;
        System.out.println(person);
        System.out.println(person1);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25



    浅拷贝：

    先来看一段代码

    class Money {
    public double  money = 12.5;
}

class Person implements Cloneable{
    public int id;
    public Money money = new Money();
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                '}';
    }
}

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person();
        Person person1 = (Person)person.clone();
        System.out.println("person:" + person.money.money);
        System.out.println("person1:" + person.money.money);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27




    如果将person1中的money的值改变会发生什么呢？

    public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person();
        Person person1 = (Person)person.clone();
        person1.money.money = 199;
        System.out.println("person:" + person.money.money);
        System.out.println("person1:" + person.money.money);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9




    根据运行结果会发现，person1的值修改后。person的值也跟着一起修改了。
    这种情况就叫做浅拷贝。


    很明显这并不是想要得到的结果，那该怎么做呢？

    深拷贝：

    class Money implements Cloneable{
    public double m = 12.5;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

}

class Person implements Cloneable{
    public int id;
    public Money money = new Money();

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person tmp = (Person) super.clone();
        tmp.money = (Money) this.money.clone();
        return tmp;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                '}';
    }
}

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person();

        Person person2 = (Person)person.clone();
        person2.money.m = 1999;

        System.out.println("person："+person.money.m);
        System.out.println("person2："+person2.money.m);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41


    1.9 抽象类和接口的区别

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


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

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    抽象类存在的意义是为了让编译器更好的校验，像 Animal 这样的类我们并不会直接使用，而是使用它的子类。万一不小心创建了 Animal 的实例，编译器会及时提醒我们。

    2. Object类

    Object是Java默认提供的一个类，所有类的对象都可以使用Object的引用进行接收。

    class Person {
  
}

class Student {
   
}

public class Test {
    public static void func(Object object) {
        System.out.println(object);
    }

    public static void main(String[] args) {
        func(new Person());
        func(new Student());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18



    对于整个Object类中的方法需要实现全部掌握。
    本小节当中，我们主要来熟悉这几个方法：toString()方法，equals()方法，hashcode()方法。

    2.1 获取实例对象

    如果要打印对象中的内容，可以直接重写Object类中的toString()方法，之前已经讲过了，此处不再赘述。

    // Object类中的toString()方法实现：
public String toString() {
    return getClass().getName() + "@" Integer.toHexString(hashCode());
}

    • 1
    • 2
    • 3
    • 4

    2.2 对象比较equals方法

    在Java中，== 进行比较时：

    • a.如果 == 左右两侧是基本类型变量，比较的是变量中值是否相同
    • b.如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同
    • c.如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的：
    // Object类中的equals方法
public boolean equals(Object obj) {
    return (this == obj); // 使用引用中的地址直接来进行比较
}

    • 1
    • 2
    • 3
    • 4


    因为是按照地址进行比较的，是两块不同的空间，所以比较出来的结果不相等。

    class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

}

class Student {

}

public class Test {

    public static void main(String[] args) {
        Person person1 = new Person("张三", 19);
        Person person2 = new Person("张三", 19);
        System.out.println(person1.equals(person2));
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23





    调试后可见person1和person2所在的位置不一样。



    要换一种比较的方法。

    按照自己的逻辑重写一下。

    class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public boolean equals(Object obj) {
        Person person = (Person) obj;
        if (this.name.equals(person.name) && this.age == person.age) {
            return true;
        }else {
            return false;
        }
    }
}

class Student {

}

public class Test {

    public static void main(String[] args) {
        Person person1 = new Person("张三", 19);
        Person person2 = new Person("张三", 19);
        System.out.println(person1.equals(person2));
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    2.3 hashcode方法

    hashCode()这个方法，他帮我算了一个具体的对象位置。由于这里面涉及数据结构，现在只是简单的认识一下。


    两个名字相同，年龄相同的对象，将存储在同一个位置，如果不重写hashcode()方法。

    我们可以来看示例代码：

    class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

class Student {

}

public class Test {
    public static void main(String[] args) {
        Person per1 = new Person("zhangsan", 20) ;
        Person per2 = new Person("zhangsan", 20) ;
        System.out.println(per1.hashCode());
        System.out.println(per2.hashCode());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    在这里插入图片描述


    可以看到两个值不一样大。


    这里和equals一样需要重写一下。

    import java.util.Objects;

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

class Student {

}

public class Test {
    public static void main(String[] args) {
        Person per1 = new Person("zhangsan", 20) ;
        Person per2 = new Person("zhangsan", 20) ;
        System.out.println(per1.hashCode());
        System.out.println(per2.hashCode());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29


    可以发现两个值一样大了。

    • hashcode方法用来确定对象在内存中存储的位置是否相同
    • 事实上hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置
  • 相关阅读:
    laravel框架介绍(一) 开发环境配置
    (十)C++中的左值lvalue&右值rvaue
    【电路基础1】电阻
    10 关联模型《ThinkPHP6 入门到电商实战》
    HCNP Routing&Switching之RSTP
    机器学习笔记之粒子滤波(二)基于序列重要性采样的重采样
    Python绘制三维立体图详解
    《学术小白学习之路》论文常见方法：Doc2vec-句向量模型实现
    VUE3+Cesium+Three项目源码
    【附源码】计算机毕业设计SSM网上开发商售楼及管理信息系统
  • 原文地址：https://blog.csdn.net/m0_63033419/article/details/126547508