java8之后接口跟抽象类有哪些区别，有哪些适用场景啊

Java 8 之后，接口和抽象类在定义、使用和特性上存在一些明显区别，各自适用于不同的场景，以下为你详细介绍：

区别

定义和结构

• 接口：接口使用 interface 关键字定义，主要用于定义一组规范或契约，接口中的方法默认是 public abstract 的，Java 8 之后允许接口中定义默认方法（使用 default 关键字）和静态方法。

java

public interface MyInterface {
    // 抽象方法
    void abstractMethod();
    // 默认方法
    default void defaultMethod() {
        System.out.println("This is a default method.");
    }
    // 静态方法
    static void staticMethod() {
        System.out.println("This is a static method.");
    }
}

• 抽象类：抽象类使用 abstract 关键字定义，它是一种特殊的类，可以包含抽象方法（使用 abstract 关键字修饰）和具体方法，也可以包含成员变量。

java

public abstract class MyAbstractClass {
    // 成员变量
    protected int value;
    // 抽象方法
    public abstract void abstractMethod();
    // 具体方法
    public void concreteMethod() {
        System.out.println("This is a concrete method.");
    }
}

继承和实现方式

• 接口：一个类可以实现多个接口，通过 implements 关键字，这使得 Java 具有了一定的多继承能力。

java

public class MyClass implements MyInterface {
    @Override
    public void abstractMethod() {
        System.out.println("Implementing abstract method from interface.");
    }
}

• 抽象类：一个类只能继承一个抽象类，通过 extends 关键字。

java

public class MySubClass extends MyAbstractClass {
    @Override
    public void abstractMethod() {
        System.out.println("Implementing abstract method from abstract class.");
    }
}

访问修饰符

• 接口：接口中的方法默认是 public 的，不允许使用其他访问修饰符（如 private、protected），成员变量默认是 public static final 的。
• 抽象类：抽象类中的方法和成员变量可以使用各种访问修饰符，如 private、protected、public 等。

设计目的

• 接口：主要用于定义行为的规范，强调 “是什么能做什么”，它是一种纯粹的契约，不关心具体的实现细节。
• 抽象类：更侧重于对一组相关类的共性进行抽象和封装，提供一些通用的实现和状态，是一种 “是一个” 的关系。

适用场景

接口的适用场景

• 多实现和多继承能力：当一个类需要实现多个不同的行为或功能时，可以使用接口。例如，一个类既可以是 Serializable （可序列化）的，又可以是 Cloneable （可克隆）的，通过实现多个接口来达到目的。

java

public class MyData implements Serializable, Cloneable {
    // 类的具体实现
}

• 定义回调机制：在事件驱动的编程中，接口常用于定义回调方法。例如，Java 的 GUI 编程中，通过实现 ActionListener 接口来处理按钮点击事件。

java

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;

public class ButtonExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Button Example");
        JButton button = new JButton("Click me");
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("Button clicked!");
            }
        });
        frame.add(button);
        frame.setSize(300, 200);
        frame.setVisible(true);
    }
}

• 插件化架构：在插件化的系统中，接口可以作为插件的规范，各个插件实现该接口来提供不同的功能。

抽象类的适用场景

• 代码复用：当多个类有一些共同的行为和状态时，可以将这些共性提取到抽象类中，实现代码复用。例如，java.io.InputStream 是一个抽象类，它定义了一些通用的输入流操作方法，具体的输入流类（如 FileInputStream、ByteArrayInputStream 等）继承自该抽象类并实现其抽象方法。
• 模板方法模式：抽象类可以定义一个算法的骨架，将一些步骤的具体实现留给子类。例如，在一个游戏开发中，抽象类可以定义游戏的基本流程，如初始化、游戏循环、结束等，具体的游戏逻辑由子类实现。

java

public abstract class Game {
    // 模板方法
    public final void play() {
        initialize();
        startGame();
        endGame();
    }
    protected abstract void initialize();
    protected abstract void startGame();
    protected abstract void endGame();
}

public class ChessGame extends Game {
    @Override
    protected void initialize() {
        System.out.println("Initializing chess game.");
    }
    @Override
    protected void startGame() {
        System.out.println("Starting chess game.");
    }
    @Override
    protected void endGame() {
        System.out.println("Ending chess game.");
    }
}