接口（Interface）和抽象类（Abstract Class）的区别和用法

KingDol_MIni

已于 2024-01-08 11:47:45 修改

阅读量616

点赞数 13

文章标签：后端 java

于 2024-01-08 11:46:40 首次发布

本文链接：https://blog.csdn.net/m0_68856746/article/details/135453328

版权

接口（Interface）和抽象类（Abstract Class）是面向对象编程中的两个概念，用于实现多态性和封装性。它们有一些相似之处，但也有一些关键的区别。

区别：

实现方式：接口是一种完全抽象的类，它只定义了方法的签名而没有具体实现；而抽象类是一个可以包含具体方法实现的类，它可以定义方法的默认实现。
继承关系：类只能继承一个抽象类，但可以实现多个接口。一个类可以通过实现多个接口来达到多继承的效果。
构造函数：抽象类可以有构造函数，而接口不能有构造函数。
字段：抽象类可以包含字段（成员变量），而接口只能包含常量（final变量）。
设计目的：接口主要用于定义一组相关的操作，而抽象类则是为了提供一种通用的基类，可以作为其他类的父类。

具体的使用案例：

使用接口：

// 定义接口
public interface Drawable {
    void draw();
}

// 实现接口
public class Circle implements Drawable {
    public void draw() {
        System.out.println("Drawing a circle...");
    }
}

public class Rectangle implements Drawable {
    public void draw() {
        System.out.println("Drawing a rectangle...");
    }
}

public class Main {
    public static void main(String[] args) {
        Drawable circle = new Circle();
        Drawable rectangle = new Rectangle();

        circle.draw();     // 输出："Drawing a circle..."
        rectangle.draw();  // 输出："Drawing a rectangle..."
    }
}

在这个例子中，接口Drawable定义了一个draw方法，Circle和Rectangle类分别实现了这个接口，并提供了各自的draw方法的具体实现。在Main类中，我们可以创建Circle和Rectangle对象，并调用它们的draw方法。

使用抽象类：

// 定义抽象类
public abstract class Shape {
    public abstract void draw();

    public void printDescription() {
        System.out.println("This is a shape.");
    }
}

// 继承抽象类
public class Circle extends Shape {
    public void draw() {
        System.out.println("Drawing a circle...");
    }
}

public class Rectangle extends Shape {
    public void draw() {
        System.out.println("Drawing a rectangle...");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle();
        Shape rectangle = new Rectangle();

        circle.draw();          // 输出："Drawing a circle..."
        rectangle.draw();       // 输出："Drawing a rectangle..."
        circle.printDescription();   // 输出："This is a shape."
        rectangle.printDescription();  // 输出："This is a shape."
    }
}

在这个例子中，抽象类Shape定义了一个抽象的draw方法和一个具体的printDescription方法。Circle和Rectangle类继承了Shape类，并提供了draw方法的具体实现。在Main类中，我们可以创建Circle和Rectangle对象，并调用它们的draw方法和printDescription方法。

更高级得使用

接口的多重继承：
接口可以通过实现多个接口来继承多个行为。这种多重继承的特性使得接口更加灵活，可以在一个类中实现多个相关的功能。

public interface Drawable {
    void draw();
}

public interface Colorable {
    void setColor(String color);
}

public class Circle implements Drawable, Colorable {
    private String color;

    public void draw() {
        System.out.println("Drawing a circle...");
    }

    public void setColor(String color) {
        this.color = color;
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle();
        circle.draw();      // 输出："Drawing a circle..."
        circle.setColor("Red");
    }
}

在这个例子中，我们定义了两个接口Drawable和Colorable，并在Circle类中实现了这两个接口。Circle类具有draw和setColor方法，可以绘制圆形并设置颜色。

抽象类的模板方法模式：
抽象类可以定义一个模板方法，该方法定义了一系列的操作步骤，具体的实现由子类提供。这种模板方法模式允许在不改变算法结构的情况下，通过子类来定制部分步骤的实现。

public abstract class AbstractClass {
    public void templateMethod() {
        stepOne();
        stepTwo();
        stepThree();
    }

    protected abstract void stepOne();
    protected abstract void stepTwo();

    protected void stepThree() {
        System.out.println("AbstractClass: Step Three");
    }
}

public class ConcreteClass extends AbstractClass {
    protected void stepOne() {
        System.out.println("ConcreteClass: Step One");
    }

    protected void stepTwo() {
        System.out.println("ConcreteClass: Step Two");
    }
}

public class Main {
    public static void main(String[] args) {
        AbstractClass abstractClass = new ConcreteClass();
        abstractClass.templateMethod();
    }
}

在这个例子中，AbstractClass是一个抽象类，定义了一个模板方法templateMethod，其中包含了一系列的操作步骤，包括stepOne、stepTwo和stepThree。stepOne和stepTwo是抽象方法，由子类提供具体的实现。stepThree是一个默认的实现，子类可以选择是否重写它。ConcreteClass是AbstractClass的子类，提供了stepOne和stepTwo的具体实现。