JavaSE：抽象类和接口

目录

一、前言

大家好啊，蜡笔小欣前面和大家分享了Java中的类与对象、继承和多态等内容，相信大家也能感受到 Java的魅力所在，今天小欣将给大家分享Java中的抽象类和接口。在Java中，抽象类和接口是两个重要的概念，用于创建可重用和可扩展的代码。它们允许我们在不同类之间建立契约，同时保持实现代码的灵活性。

二、抽象类

（一）抽象类概念

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

 说明：

1.矩形、三角形、圆形都是图形，因此和Shape类的惯性应该是继承关系，

2.虽然图形图Shape中也存在draw方法，但由于Shape类并不是具体的图形，因此其内部的draw方法实际是没有办法实现的，

3.由于Shape类没有办法描述一个具体的图形，导致其draw()方法无法具体实现，因此可以将Shape类设计为“抽象类”。

class Shape {
    public void draw() {
        System.out.println("Shape::draw()");
    }
}

class Rect extends Shape {
    public void draw() {
        System.out.println("菱形");
    }
}

class Triangle extends Shape {
    @Override
    public void draw() {
        System.out.println("三角形");
    }
}

class Cycle extends Shape {
    @Override
    public void draw() {
        System.out.println("圆形");
    }
}

public class Test {
    public static void main(String[] args) {
        Rect rect = new Rect();
        Triangle triangle = new Triangle();
        Cycle cycle = new Cycle();
        Shape[] shapes = {triangle, rect, cycle};
        for (Shape s : shapes) {
            s.draw();
        }
    }
}

在打印图形例子中，父类 Shape 中的 draw 方法好像并没有什么实际工作, 主要的绘制图形都是由 Shape 的各种子类的 draw 方法来完成的. 像这种没有实际工作的方法, 我们可以把它设计成一个 抽象方法, 包含抽象方法的类我们称为抽象类。

abstract class Shape{
    public abstract void draw();
}

在 draw 方法前面加上 abstract 关键字就变成了抽象方法，但是包含抽象方法的类，必须用 abstract 修饰。

（二）使用抽象类的注意事项

1. 抽象类不能直接实例化对象

public class Test {
    public static void main(String[] args) {
        Shape shape = new Shape();
    }
}

报错如下图所示：

2.抽象方法是不能用 private 修饰的

abstract class Shape{
    private abstract void draw();
}

报错如下图所示： 

3.抽象方法不能被final和static修饰，因为抽象方法要被子类重写

抽象类中可以包含其他的非抽象方法，也可以包含字段，这里的非抽象方法和普通方法的挥着都是一样的，可以被重写，也可以被子类直接调用，但是一个普通类要继承抽象类，那么必须重写抽象类当中的所有抽象方法。

abstract class Shape {
    abstract final void methodA();
    abstract public static void methodB();
    public void draw() {
        System.out.println("Shape::draw()");
    }
}

报错如下：

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

5.抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类。

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

（三）抽象类的作用

 抽象类存在的最大意义就是为了被继承，抽象类本身并不能被实例化，要想使用，只能创建该抽象类的子类，然后让子类重写抽象类中的抽象方法。在使用的时候，会多一重编译器的校验。因为直接使用父类的时候就会报错误。

三、接口

（一）接口概念

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

（二）接口语法规则

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

public interface 接口名称{
// 抽象方法
//接口中的4中写法
public abstract void method1(); // public abstract 是固定搭配，可以不写
public void method2();
abstract void method3();
void method4();
}

Tips：

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

（三）接口的使用 

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

public class 类名称 implements 接口名称{  … }

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

让我们看看下面这个代码：

interface IShape {
    void draw();
}

class Cycle implements IShape {
    @Override
    public void draw() {
        System.out.println("圆形");
    }
}

public class Test {
    public static void main(String[] args) {
        IShape shape = new Cycle();
        shape.draw();
    }
}

运行结果如下：

（四）接口特性

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

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

3.接口中的方法是不能在接口中实现的，只能由实现接口的类来实现

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

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

 6.接口中不能有静态代码块构造方法

7.接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class

8. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

9. jdk8中：接口中还可以包含default方法

（五）实现多个接口

 有些时候我们需要让一个类同时继承多个父类，但是 Java 实现不了多继承。不过可以通过同时实现多个接口来达到多继承类似的效果。通过类来表示一组动物（通过接口来调用就不用关心引用是谁了）

class Animal {
    protected String name;

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

}
interface IFlying {
    void fly();
}
interface IRunning{
    void run();
}
interface ISwimming{
    void swimming();
}
class Bird extends Animal implements IFlying{
    public Bird(String name) {
        super(name);
    }
    @Override
    public void fly() {
        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 swimming() {
        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 swimming() {
        System.out.println(this.name+"在游泳");
    }
}
class Roobot implements IRunning{
    @Override
    public void run() {
        System.out.println("机器人在跑");
    }
}
public class Test {
    public static void runFunc(IRunning iRunning){
        iRunning.run();
    }
    public static void swimmingFunc(ISwimming iSwimming){
        iSwimming.swimming();
    }
    public static void flyingFunc(IFlying iFlying){
        iFlying.fly();
    }

    public static void main(String[] args) {
        runFunc(new Duck("鸭子"));
        runFunc(new Frog("青蛙"));
        runFunc(new Roobot());
    }
}

运行结果如下：

通过实现多个接口，可以利用接口来完成需要的功能，通过同时实现多个接口来完成功能。 

（六）接口间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。 接口可以继承一个接口（也叫扩展）
, 达到复用的效果. 使用 extends 关键字。

interface IA {
    void funcA();
}
interface IB extends IA {
    void funcB();
}
//拓展接口的功能 需要对有A和B这俩的方法进行重写
class C implements IB {
    @Override
    public void funcB() {
    }
    @Override
    public void funcA() {
    }
}

 （七）使用接口给对象数组排序

我们通过一个例子来加深理解，通过接口对学生年龄进行排序，

学生类代码如下：

package demo4_8;

public class Student implements Comparable<Student> {
    //Comparable接口有局限性，只能进行默认的比较
    public String name;
    public int age;

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

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

    //根据年龄比较大小
    @Override
    public int compareTo(Student o) {
        //if(this.age>o.age) {
        //return 1;
        //}else if(this.age == o.age) {
        //return 0;
        //}else {
        //return -1;
        //}
        return this.age - o.age;
    }

    //根据姓名比较大小
   /* @Override
    public int compareTo(Student o) {
        if (this.name.compareTo(o.name) > 0) {
            return 1;
        } else if (this.name.compareTo(o.name) == 0) {
            return 0;
        } else {
            return -1;
        }
    }*/
}

Test代码如下：

package demo4_8;

import java.util.Arrays;

public class Test {
    //Comparable接口的实使用
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("zhangsan", 10);
        students[1] = new Student("lisi", 15);
        students[2] = new Student("wangwu", 11);

        System.out.println(Arrays.toString(students));
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }

    public static void main1(String[] args) {
        Student student1 = new Student("zhangsan", 18);
        Student student2 = new Student("lisi", 20);
        //比较student1和student2
        /*
        1.如果student1>student2 返回大于0
        2.如果student1<student2 返回小于0
        3否则返回0相等
        * */
        if (student1.compareTo(student2) > 0) {
            System.out.println("student1 > student2");
        } else {
            System.out.println("student1 <= student2");
        }
    }
}

运行结果如下：

 （八）Clonable 接口和深拷贝

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

class Person implements Cloneable {
    public int age;

    public void eat() {
        System.out.println("正在吃东西！");
    }

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

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

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

运行结果如下：

上面在使用 clone 方法的时候，通过抛出异常，重写异常达到接口的使用。

内存分布如下：

如果把 age 改为 99， 因为 person1 是克隆 person 的，所以person1 的 age 也变成 99 。

因此后面继续对 person1 进行修改，也会改变 age 的值 。

这里就是发生了浅拷贝。

 四、抽象类与接口的区别

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

五、总结

抽象类和接口是 Java 中强大的工具，用于实现抽象和多态性。我们通过了解它们之间的区别和选择条件，为我们后期编写代码提供更多的便利性。以上就是本期的内容，希望小伙伴能收获满满，感谢大家的支持，我们下次再见！