抽象类(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及更低版本中，接口不支持私有方法和私有静态方法。