1、抽象类和接口都不能直接实例化:

// 抽象类无法实例化
abstract class AbstractClass {
    abstract void abstractMethod();
}
// AbstractClass obj = new AbstractClass(); // 编译错误

// 接口无法实例化
interface MyInterface {
    void interfaceMethod();
}
// MyInterface obj = new MyInterface(); // 编译错误

2、抽象类要被子类继承,接口要被类实现:

// 继承抽象类
abstract class AbstractClass {
    abstract void abstractMethod();
}

class ConcreteClass extends AbstractClass {
    @Override
    void abstractMethod() {
        // 实现抽象方法
    }
}

// 实现接口
interface MyInterface {
    void interfaceMethod();
}

class ImplementingClass implements MyInterface {
    @Override
    public void interfaceMethod() {
        // 实现接口方法
    }
}

3、接口只能做方法申明,抽象类中可以做方法申明和实现:

// 接口只能声明方法
interface MyInterface {
    void interfaceMethod(); // 只能声明
    //void implementedMethod() {} // 编译错误,不能有方法体
}

// 抽象类可以声明和实现方法
abstract class AbstractClass {
    abstract void abstractMethod(); // 声明抽象方法

    void implementedMethod() { // 实现普通方法
        // 方法体
    }
}

4、接口里定义的变量只能是公共的静态的常量,抽象类中的变量是普通变量:

// 接口中的变量是公共静态常量
interface MyInterface {
    int CONSTANT = 10; // 隐式public static final
    //int variable; // 编译错误
}

// 抽象类中的变量是普通变量
abstract class AbstractClass {
    int variable = 10; // 普通变量
    static final int CONSTANT = 20; // 静态常量
}

5、子类必须实现父类的所有抽象方法,否则子类也必须是抽象类。实现接口时,如果无法实现所有方法,该类也必须是抽象类:

// 子类必须实现父类的所有抽象方法
abstract class AbstractClass {
    abstract void abstractMethod1();
    abstract void abstractMethod2();
}

class ConcreteClass extends AbstractClass {
    @Override
    void abstractMethod1() {
        // 实现方法
    }

    // 如果没有实现abstractMethod2(),那么ConcreteClass也必须是抽象类
}

// 实现接口时,如果无法实现所有方法,该类也必须是抽象类
interface MyInterface {
    void interfaceMethod1();
    void interfaceMethod2();
}

abstract class ImplementingClass implements MyInterface {
    @Override
    public void interfaceMethod1() {
        // 实现方法
    }
    
    // 没有实现interfaceMethod2(),所以ImplementingClass必须是抽象类
}

6、抽象方法只能申明,不能实现。接口是设计的结果,抽象类是重构的结果:

// 抽象方法只能申明,不能实现
abstract class AbstractClass {
    abstract void abstractMethod(); // 只能申明
    //abstract void abstractMethod() {} // 编译错误,不能有方法体
}

// 接口是设计的结果,定义行为规范
interface MyInterface {
    void interfaceMethod(); // 定义行为规范
}

// 抽象类是重构的结果,提取共同的代码和行为
abstract class AbstractClass {
    void commonMethod() {
        // 实现共同的方法
    }
    abstract void abstractMethod(); // 抽象出需要子类实现的方法
}

7、抽象类里可以没有抽象方法:

// 抽象类可以没有抽象方法
abstract class AbstractClass {
    void nonAbstractMethod() {
        // 普通方法实现
    }
}

8、如果一个类里有抽象方法,那么这个类只能是抽象类:

// 如果类中有抽象方法,那么这个类必须是抽象类
abstract class AbstractClass {
    abstract void abstractMethod(); // 抽象方法
}

//class ConcreteClass { // 编译错误,不能有抽象方法
//    abstract void abstractMethod();
//}

9、抽象方法要被实现,所以不能是静态的,也不能是私有的:

// 抽象方法不能是静态的或私有的
abstract class AbstractClass {
    //static abstract void staticAbstractMethod(); // 编译错误
    //private abstract void privateAbstractMethod(); // 编译错误

    abstract void abstractMethod(); // 正确
}

10、接口可继承接口,并可多继承接口,但类只能单根继承:

// 接口可继承接口,并可多继承接口
interface BaseInterface {
    void baseMethod();
}

interface ExtendedInterface extends BaseInterface {
    void extendedMethod();
}

interface MultipleInterface extends BaseInterface, AnotherInterface {
    void multipleMethod();
}

// 类只能单根继承
class BaseClass {
    void baseMethod() {
        // 方法实现
    }
}

class DerivedClass extends BaseClass {
    // 只能继承自一个类
}

//class MultipleInheritanceClass extends BaseClass, AnotherClass { // 编译错误
//    // 类不能多继承
//}