【JAVA】抽象类与接口

╰+攻爆jí腚メ 2023-10-15 14:11 13阅读 0赞

> **作者主页：[paper jie\_的博客][paper jie]**
> 
> **本文作者：大家好，我是paper jie，感谢你阅读本文，欢迎一建三连哦。**
> 
> **本文录入于《JAVASE语法系列》专栏，本专栏是针对于大学生，编程小白精心打造的。笔者用重金(时间和精力)打造，将javaSE基础知识一网打尽，希望可以帮到读者们哦。**
> 
> **其他专栏：《JAVA》《算法详解》《C语言》等**
> 
> **内容分享：本期将会对JAVA中的抽象类与接口进行讲解**

# 抽象类 #

## 抽象类的概念 ##

在面对对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描述对象的，如果一个类中没有包含足够的信息来描述一个具体的对象，这样的类就是抽象类。

![7eba29c4de0a4b6c8219f022159bad68.png][]

我们可以发现，Shape类中的draw方法好像没有什么实际的工作，主要的绘图都是由Shape的子类的draw方法来完成的，像这种没有实际的方法，我们可以把它设计为一个抽象类，包含抽象方法的类我们叫做抽象类。

## 抽象类的语法 ##

在java中，一个类被abstract修饰叫做抽象类，抽象类中的方法被abstract修饰的方法叫做抽象方法。注意：抽象方法是不可以给出具体的实现的。

举个栗子：

abstract class Shape {
        // 抽象方法：被abstract修饰的方法，没有方法体
        abstract public void draw();
        abstract void calcArea();
        // 抽象类也是类，也可以增加普通方法和属性
        public double getArea(){
            return area;
        }
        protected double area; // 面积
    }

**这里要注意：**

**抽象类也是类，内部也可以有普通方法和属性，构造方法**

![bffa7ccd955441ce9e4ecc6f90e6c6cc.png][]

## 抽象类的特点 ##

**抽象类不可以直接实例化对象**

Shape shape = new Shape();
        // 编译出错
        Error:(30, 23) java: Shape是抽象的; 无法实例化

**抽象方法不可以是private修饰**

abstract class Shape {
        abstract private void draw();
    } // 编译出错 Error:(4, 27) java: 非法的修饰符组合: abstract和private

**抽象方法不可以被final和static修饰，因为抽象方法要被重写**

public abstract class Shape {
    abstract final void methodA();
    abstract public static void methodB();
    } // 编译报错：
    // Error:(20, 25) java: 非法的修饰符组合: abstract和final
    // Error:(21, 33) java: 非法的修饰符组合: abstract和static

**抽象类必须被继承，继承后的子类必须重写父类中的抽象方法，否则子类也是抽象类，必须要使用abstract修饰**

// 矩形类
    class Rect extends Shape {
        private double length;
        private double width;
        Rect(double length, double width){
            this.length = length;
            this.width = width;
        }
        public void draw(){
            System.out.println("矩形: length= "+length+" width= " + width);
        }
        public void calcArea(){
            area = length * width;
        }
    } // 圆类：
    class Circle extends Shape{
        private double r;
        final private static double PI = 3.14;
        public Circle(double r){
            this.r = r;
        }
        public void draw(){
            System.out.println("圆：r = "+r);
        }
        public void calcArea(){
            area = PI * r * r;
        }
    } // 三角形类：
    abstract class Triangle extends Shape {
        private double a;
        private double b;
        private double c;
        @Override
        public void draw() {
            System.out.println("三角形：a = "+a + " b = "+b+" c = "+c);
        } // 三角形：直角三角形、等腰三角形等，还可以继续细化
    //@Override
    //double calcArea(); // 编译失败：要么实现该抽象方法，要么将三角形设计为抽象类
    }

**抽象类中不一定有抽象方法，但抽象方法一定有抽象类**

**抽象类中可以有构造方法，供子类创建对象的时候，初始化父类的成员变量。**

抽象类的作用

抽象类本身是不可以被实例化的，要想使用，只能创建该抽象类的子类，由子类重写父类中的抽象类。

使用继承抽象类的代码比继承普通类的好处就在于：**实际工作不应该由父类完成, 而应由子类完成. 那么此时如果不小心误用成父类了, 使用普通类编译器是不会报错的. 但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题**

很多语法存在的意义都是为了 "预防出错", 例如我们曾经用过的 final 也是类似. 创建的变量用户不去修改, 不就相当于常量嘛? 但是加上 final 能够在不小心误修改的时候, 让编译器及时提醒我们.  
充分利用编译器的校验, 在实际开发中是非常有意义的.

# 接口 #

## 接口的概念 ##

接口就是公共的行为规范标准，在实现的时候，只要符合规范标准，就可以通用。在java中，接口可以看成为：**多个类的规范，是一种引用数据类型。**

## 接口的语法 ##

将class关键字换成interface就等于定义了一个接口了，和定义类的格式差不多

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

**书写规范：**

**创建接口时，接口名一般用大写字母I开头**

**接口一般以形容词命名**

**阿里编码规范中约定，接口中的方法和属性不要加任何的修饰符号，这样以便保持代码的简洁（方法和属性是默认修饰符的）**

## 接口的使用 ##

接口和抽象类很像，不可以直接使用，必须要有一个实现类来实现这个接口，实现接口中的所有抽象方法。**子类与接口是用implement来实现之间的关系**

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

举个USB接口的栗子：

// USB接口
    public interface USB {
        void openDevice();
        void closeDevice();
    } // 鼠标类，实现USB接口
    public class Mouse implements USB {
        @Override
        public void openDevice() {
            System.out.println("打开鼠标");
        }
        @Override
        public void closeDevice() {
            System.out.println("关闭鼠标");
        }
        public void click(){
            System.out.println("鼠标点击");
        }
    } // 键盘类，实现USB接口
    public class KeyBoard implements USB {
        @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("关闭笔记本电脑");
        }
        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 class TestUSB {
        public static void main(String[] args) {
            Computer computer = new Computer();
            computer.powerOn();
    // 使用鼠标设备
            computer.useDevice(new Mouse());
    // 使用键盘设备
            computer.useDevice(new KeyBoard());
            computer.powerOff();
        }
    }

## 接口特性 ##

**接口是一种引用类型，但它并不可以new出一个对象**

public class TestUSB {
        public static void main(String[] args) {
            USB usb = new USB();
        }
    } // Error:(10, 19) java: day20210915.USB是抽象的; 无法实例化

**接口中每个抽象方法都是public修饰的，被默认的隐式的指定为public abstract且只能是public abstract**

public interface USB {
        // Error:(4, 18) java: 此处不允许使用修饰符private
        private void openDevice();
        void closeDevice();
    }

**接口中的方法是不可以在接口中实现的，只能由实现接口的类来实现**

public interface USB {
    void openDevice();
    // 编译失败：因为接口中的方式默认为抽象方法
    // Error:(5, 23) java: 接口抽象方法不能带有主体
    void closeDevice(){
    System.out.println("关闭USB设备");
    }
    }

**重写接口方法时，不能使用默认的访问权限**

public interface USB {
        void openDevice(); // 默认是public的
        void closeDevice(); // 默认是public的
    }
    public class Mouse implements USB {
        @Override
        void openDevice() {
            System.out.println("打开鼠标");
        } // ...
    } // 编译报错，重写USB中openDevice方法时，不能使用默认修饰符
    // 正在尝试分配更低的访问权限; 以前为public

**接口中可以有变量，但是接口的变量会被隐式的指定为public static final 变量**

public interface USB {
        double brand = 3.0; // 默认被：final public static修饰
        void openDevice();
        void closeDevice();
    }
    public class TestUSB {
        public static void main(String[] args) {
            System.out.println(USB.brand); // 可以直接通过接口名访问，说明是静态的
    // 编译报错：Error:(12, 12) java: 无法为最终变量brand分配值
            USB.brand = 2.0; // 说明brand具有final属性
        }
    }

**接口中不能含有静态代码块和构造方法**

interface USB {
        // 编译失败
        public USB(){
        } 
        static{
        } // 编译失败
        void openDevice();
        void closeDevice();
    }

**接口不是类，但接口编译完后的字节码文件后缀也是.class**

**如果类没有实现接口中的所有抽象方法，这个类就必须设置为抽象类**

![2fce1631a06843778161b23bece37149.png][]

## 实现多个接口 ##

在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 Fish extends Animal implements ISwimming {
        public Fish(String name) {
            super(name);
        } @Override
        public void swim() {
            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 + "正在蹬腿游泳");
        }
    }

可以飞，游，跑的小鸭子类：

class Duck extends Animal implements IRunning, ISwimming, IFlying {
        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 + "正在漂在水上");
        }
    }

通过这个栗子，我们可以了解了接口在java中的基本用法：就是一个类继承父类，且实现多个类。

继承的含义可以理解为is-a，接口可以理解为has-a。

这个设计后有一个很大的好处，就是让程序员忘记类型，有了接口后，类的使用者就不用关心具体类型。而只具备某种能力。

这就很好解释：

假设我们有一个walk方法,接着上面的代码。这个walk方法内部，我们根本就不需要知道是什么动物，知道它会跑就可以了。

public static void walk(IRunning running) {
        System.out.println("我带着伙伴去散步");
        running.run();
    }

Cat cat = new Cat("小猫");
            walk(cat);
            Frog frog = new Frog("小青蛙");
            walk(frog);
    /* 执行结果
           我带着伙伴去散步
            小猫正在用四条腿跑
            我带着伙伴去散步
            小青蛙正在往前跳 */

而且这个类型可以不是动物，只要它可以跑就行：

class Robot implements IRunning {
        private String name;
        public Robot(String name) {
            this.name = name;
        } @Override
        public void run() {
            System.out.println(this.name + "正在用轮子跑");
        }
    } 
    Robot robot = new Robot("机器人");
            walk(robot);
    // 执行结果
            机器人正在用轮子跑

![8f528723dc3d4b39886400ca888a59d8.png][]

## 接口之间的继承 ##

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

接口继承接口也是用extends：

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

接口的继承就是相当于将多个接口合并起来了。

![77ee53d53d0641fd8ed6d8406c4237dc.png][]

## 两个常用的比较接口 ##

**给对象数组排序：**

我们发现用常规的sort排序来实现是不行的，会报异常：

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

这是因为它是一个对象，和普通的整数不同，可以直接比较。这我们就需要使用上我们的comparable接口，且重写它里面的compareTo方法：

class Student implements Comparable {
        private String name;
        private int score;
        public Student(String name, int score) {
            this.name = name;
            this.score = score;
        } @Override
        public String toString() {
            return "[" + this.name + ":" + this.score + "]";
        } @Override
        public int compareTo(Object o) {
            Student s = (Student)o;
            if (this.score > s.score) {
                return -1;
            } else if (this.score < s.score) {
                return 1;
            } else {
                return 0;
            }
        }
    }

在sort方法中，会自动调用compareTo方法，compareTo的参数是Object，其实传入的是它的子类Student类型的对象。然后比教当前对象和参数对象的大小关系：

如果当前对象应排在参数对象之前, 返回小于 0 的数字;  
如果当前对象应排在参数对象之后, 返回大于 0 的数字;  
如果当前对象和参数对象不分先后, 返回 0;

对于 sort 方法来说, 需要传入的数组的每个对象都是 "可比较" 的, 需要具备 compareTo 这样的能力. 通过重写 compareTo 方法的方式, 就可以定义比较规则.

![09849f0e316d488d9e9c0168a9d51439.png][]

## Cloneable ##

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

![9ff1bfbd87db48dcb3a54a28fa5d7b48.png][]

我们发现结果是flase

class Animal implements Cloneable {
        private String name;
        @Override
        public Animal clone() {
            Animal o = null;
            try {
                o = (Animal)super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            } return o;
        }
    }
    public class Test {
        public static void main(String[] args) {
            Animal animal = new Animal();
            Animal animal2 = animal.clone();
            System.out.println(animal == animal2);
        }
    }

## 浅拷贝和深拷贝 ##

Cloneable它克隆出来的就是一份浅拷贝：

class Money {
        public double m = 99.99;
    }
    class Person implements Cloneable{
        public Money money = new Money();
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }
    public class TestDemo3 {
        public static void main(String[] args) throws CloneNotSupportedException {
            Person person1 = new Person();
            Person person2 = (Person) person.clone();
            System.out.println("通过person2修改前的结果");
            System.out.println(person1.money.m);
            System.out.println(person2.money.m);
            person2.money.m = 13.6;
            System.out.println("通过person2修改后的结果");
            System.out.println(person1.money.m);
            System.out.println(person2.money.m);
        }
    } // 执行结果
            通过person2修改前的结果
            99.99
            99.99
            通过person2修改后的结果
            13.6
            13.6

![c481549aebdb44f183471954ec2dda3a.png][]

深拷贝就是我们也要把深层次的也拷贝：

![058a25aa3b8949fe88552b79d0473a59.png][]

## 抽象类和接口的区别 ##

抽象类和接口都是 Java 中多态的常见使用方式都需要重点掌握. 同时又要认清两者的区别(重要!!!)  
核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法.  
如之前写的 Animal 例子. 此处的 Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此此处的 Animal 只能作为一个抽象类, 而不应该成为一个接口.

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

注意：

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

![98caaf20cc31447298ed9e2f2e46e2dd.png][]

[paper jie]: https://blog.csdn.net/paperjie?type=blog
[7eba29c4de0a4b6c8219f022159bad68.png]: https://img-blog.csdnimg.cn/7eba29c4de0a4b6c8219f022159bad68.png
[bffa7ccd955441ce9e4ecc6f90e6c6cc.png]: https://img-blog.csdnimg.cn/bffa7ccd955441ce9e4ecc6f90e6c6cc.png
[2fce1631a06843778161b23bece37149.png]: https://img-blog.csdnimg.cn/2fce1631a06843778161b23bece37149.png
[8f528723dc3d4b39886400ca888a59d8.png]: https://img-blog.csdnimg.cn/8f528723dc3d4b39886400ca888a59d8.png
[77ee53d53d0641fd8ed6d8406c4237dc.png]: https://img-blog.csdnimg.cn/77ee53d53d0641fd8ed6d8406c4237dc.png
[09849f0e316d488d9e9c0168a9d51439.png]: https://img-blog.csdnimg.cn/09849f0e316d488d9e9c0168a9d51439.png
[9ff1bfbd87db48dcb3a54a28fa5d7b48.png]: https://img-blog.csdnimg.cn/9ff1bfbd87db48dcb3a54a28fa5d7b48.png
[c481549aebdb44f183471954ec2dda3a.png]: https://img-blog.csdnimg.cn/c481549aebdb44f183471954ec2dda3a.png
[058a25aa3b8949fe88552b79d0473a59.png]: https://img-blog.csdnimg.cn/058a25aa3b8949fe88552b79d0473a59.png
[98caaf20cc31447298ed9e2f2e46e2dd.png]: https://img-blog.csdnimg.cn/98caaf20cc31447298ed9e2f2e46e2dd.png