抽象类(abstract class)和接口(interface)的区别总结

抽象类和接口是Java中实现多态性的两种方式，它们有以下区别：

一、修饰符：

抽象类：可以使用abstract和public等修饰符。
接口：可以使用public和default等修饰符。

🎡在JDK 9中，接口还可以使用private和private static修饰符。🎡

二、默认方法和静态方法：

抽象类：可以包含普通方法、抽象方法和静态方法，没有默认方法的概念。
接口：JDK 8引入了默认方法和静态方法的概念，接口可以包含抽象方法、默认方法、静态方法和私有方法。

三、final变量：

抽象类：可以包含final变量。
接口：接口中的变量默认是public static final类型的，因此必须被初始化，并且不能被修改。

四、多实现：

抽象类：一个类只能继承一个抽象类。
接口：一个类可以实现多个接口。

五、设计层面：

抽象类：用于表示一种"是什么"的关系，即某个类是某个抽象概念的一种实现。
接口：用于表示一种"有什么能力"的关系，即某个类具有某个接口所定义的能力。

六、JDK不同版本特性对比：

在不同的Java版本中，抽象类和接口的功能有所变化：

1. JDK 7：抽象类和接口的功能与之前版本相同，没有任何新增的特性。

在JDK 7或更早版本中，接口只能包含常量变量和抽象方法。下面是一个示例代码：

public interface MyInterface {
    // 常量变量
    public static final int MY_CONSTANT = 10;
    
    // 抽象方法
    public abstract void myMethod();
}

然后，我们可以创建一个类来实现这个接口并实现其中的抽象方法：

public class MyClass implements MyInterface {
    @Override
    public void myMethod() {
        System.out.println("MyClass implementing MyInterface");
    }
}

在这个示例中，接口MyInterface只包含常量变量MY_CONSTANT和抽象方法myMethod()。类MyClass实现了接口MyInterface并实现了抽象方法myMethod()。

我们可以在主程序中创建MyClass的实例，并调用myMethod()方法：

public class Main {
    public static void main(String[] args) {
        MyClass myObj = new MyClass();
        myObj.myMethod();
    }
}

输出结果将是：

MyClass implementing MyInterface

请注意，这个示例只适用于JDK 7或更早版本。在JDK 8及更高版本中，接口可以包含默认方法和静态方法。

2. JDK 8：接口可以包含默认方法和静态方法，从而使接口具有更多的灵活性。同时，引入了default和static关键字来定义默认方法和静态方法。

当JDK 8引入了默认方法和静态方法功能后，接口不再是纯粹的抽象方法的集合，而是可以包含具体实现的方法。

以下是一个简单的示例：

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.");
    }
}

class MyClass implements MyInterface {
    @Override
    public void abstractMethod() {
        System.out.println("This is the implementation of abstractMethod.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.abstractMethod(); // 调用抽象方法
        myClass.defaultMethod(); // 调用默认方法
        MyInterface.staticMethod(); // 调用静态方法
    }
}

运行上述代码，将会输出以下结果：

This is the implementation of abstractMethod.
This is a default method.
This is a static method.

可以看到，接口MyInterface包含了一个抽象方法abstractMethod、一个默认方法defaultMethod和一个静态方法staticMethod。在MyClass类中，实现了抽象方法abstractMethod，并继承了默认方法和静态方法。

通过调用实现类的方法和接口的静态方法，我们可以验证接口中的默认方法和静态方法的功能。

3. JDK 9：接口可以使用private和private static修饰符，从而可以定义私有方法和私有静态方法。私有方法可以用于默认方法和静态方法的内部实现，提高了代码的可维护性和重用性。

在JDK 9中，接口可以引入私有方法和私有静态方法。

下面是一个示例代码：

public interface MyInterface {
    // 私有方法
    private void privateMethod() {
        System.out.println("This is a private method");
    }
    
    // 私有静态方法
    private static void privateStaticMethod() {
        System.out.println("This is a private static method");
    }
    
    // 抽象方法
    public abstract void myMethod();
    
    // 默认方法
    public default void defaultMethod() {
        System.out.println("This is a default method");
        privateMethod(); // 在接口中调用私有方法
    }
    
    // 静态方法
    public static void staticMethod() {
        System.out.println("This is a static method");
        privateStaticMethod(); // 在接口中调用私有静态方法
    }
}

然后，我们可以创建一个类来实现这个接口并实现其中的抽象方法：

public class MyClass implements MyInterface {
    @Override
    public void myMethod() {
        System.out.println("MyClass implementing MyInterface");
        defaultMethod(); // 在类中调用接口的默认方法
    }
}

在这个示例中，接口MyInterface引入了私有方法privateMethod()和私有静态方法privateStaticMethod()。

类MyClass实现了接口MyInterface并实现了抽象方法myMethod()。

我们可以在主程序中创建MyClass的实例，并调用myMethod()方法：

public class Main {
    public static void main(String[] args) {
        MyClass myObj = new MyClass();
        myObj.myMethod();
        
        MyInterface.staticMethod(); // 调用接口的静态方法
    }
}

输出结果将是：

MyClass implementing MyInterface
This is a default method
This is a private method
This is a static method
This is a private static method

请注意，这个示例是在JDK 9中使用私有方法和私有静态方法的示例。在JDK 8及更低版本中，接口不支持私有方法和私有静态方法。