Java语言 - 接口和抽象类有什么共同点和区别？

Cosolar
381 阅读3分钟

在 Java 语言中，接口和抽象类的区别如下：

  1. 定义方式不同：接口使用 interface 关键字定义，抽象类使用 abstract class 关键字定义。

  2. 实现方式不同：一个类可以实现多个接口，但只能继承一个抽象类。

  3. 成员变量不同：接口中只能定义常量，即使用 public static final 修饰的变量，抽象类可以定义普通变量。

  4. 成员方法不同：接口中只能定义抽象方法和默认方法（Java 8 引入的新特性），即使用 public abstract 或 default 关键字修饰的方法，抽象类可以定义抽象方法、普通方法和静态方法。

  5. 访问修饰符不同：接口中的方法和变量默认为 public，抽象类中的方法和变量可以使用任何访问修饰符。

  6. 构造方法不同：接口中不能定义构造方法，抽象类可以定义构造方法。

  7. 关系不同：接口和实现类之间的关系是实现关系，抽象类和子类之间的关系是继承关系。

总的来说，接口和抽象类都是用来实现多态的重要手段，但在具体的应用场景中需要根据具体情况选择使用哪种方式。

下面我用 Java 代码来解释一下接口和抽象类的区别。

  1. 定义方式不同：

接口的定义方式如下：

public interface MyInterface {
    // 常量
    public static final int MAX_COUNT = 10;

    // 抽象方法
    public abstract void myMethod();
}

抽象类的定义方式如下：

public abstract class MyAbstractClass {
    // 普通变量
    protected String name;

    // 抽象方法
    public abstract void myMethod();

    // 普通方法
    public void setName(String name) {
        this.name = name;
    }
}
  1. 实现方式不同：

一个类可以实现多个接口，如下所示：

public class MyClass implements MyInterface1, MyInterface2 {
    // 实现 MyInterface1 和 MyInterface2 中的抽象方法
    public void myMethod() {
        // TODO: 实现方法
    }
}

但一个类只能继承一个抽象类，如下所示：

public class MyClass extends MyAbstractClass {
    // 实现 MyAbstractClass 中的抽象方法
    public void myMethod() {
        // TODO: 实现方法
    }
}
  1. 成员变量不同：

接口中只能定义常量，如下所示：

public interface MyInterface {
    // 常量
    public static final int MAX_COUNT = 10;
}

抽象类可以定义普通变量，如下所示：

public abstract class MyAbstractClass {
    // 普通变量
    protected String name;
}
  1. 成员方法不同：

接口中只能定义抽象方法和默认方法，如下所示：

public interface MyInterface {
    // 抽象方法
    public abstract void myMethod();

    // 默认方法
    public default void myDefaultMethod() {
        // TODO: 实现方法
    }
}

抽象类可以定义抽象方法、普通方法和静态方法，如下所示：

public abstract class MyAbstractClass {
    // 抽象方法
    public abstract void myMethod();

    // 普通方法
    public void setName(String name) {
        this.name = name;
    }

    // 静态方法
    public static void myStaticMethod() {
        // TODO: 实现方法
    }
}
  1. 访问修饰符不同：

接口中的方法和变量默认为 public，如下所示：

public interface MyInterface {
    // 默认为 public
    int MAX_COUNT = 10;

    // 默认为 public
    void myMethod();
}

抽象类中的方法和变量可以使用任何访问修饰符，如下所示：

public abstract class MyAbstractClass {
    // 可以使用任何访问修饰符
    protected String name;

    // 可以使用任何访问修饰符
    public abstract void myMethod();
}
  1. 构造方法不同：

接口中不能定义构造方法，如下所示：

public interface MyInterface {
    // 接口中不能定义构造方法
}

抽象类可以定义构造方法，如下所示：

public abstract class MyAbstractClass {
    // 构造方法
    public MyAbstractClass(String name) {
        this.name = name;
    }

    // 抽象方法
    public abstract void myMethod();
}
  1. 关系不同：

接口和实现类之间的关系是实现关系，如下所示：

public class MyClass implements MyInterface {
    // 实现 MyInterface 中的抽象方法
    public void myMethod() {
        // TODO: 实现方法
    }
}

抽象类和子类之间的关系是继承关系，如下所示：

public class MySubClass extends MyAbstractClass {
    // 实现 MyAbstractClass 中的抽象方法
    public void myMethod() {
        // TODO: 实现方法
    }
}

以上就是 Java 中接口和抽象类的区别的一些例子。

avatar
文章
阅读
粉丝