抽象类和接口有什么区别？

参考回答

抽象类和接口是 Java 中用来定义抽象行为的两种机制，它们的主要区别如下：

详细讲解与拓展

1. 抽象类

• 抽象类是用 abstract 修饰的类，可以包含抽象方法（没有方法体）和非抽象方法（有方法体）。
• 主要用来定义一组共有的行为和属性，子类继承后可以重写这些行为。

示例：

abstract class Animal {
    // 抽象方法
    public abstract void makeSound();

    // 普通方法
    public void eat() {
        System.out.println("This animal eats food.");
    }
}

1. 继承抽象类

• 子类必须实现抽象类中的所有抽象方法，否则子类也必须声明为抽象类。

  class Dog extends Animal {
     @Override
     public void makeSound() {
         System.out.println("Woof Woof");
     }
  }
  
  public class Test {
     public static void main(String[] args) {
         Animal animal = new Dog();
         animal.makeSound(); // 输出：Woof Woof
         animal.eat();       // 输出：This animal eats food.
     }
  }
  

2. 关键点：

• 抽象类可以包含普通方法和普通成员变量。
• 不能直接实例化抽象类，但可以通过子类实例化。

2. 接口

• 接口是用 interface 修饰的抽象类型，用来定义一组规范或能力，它强调实现的契约而非继承。
• 接口中的成员默认是 public，方法默认是 public abstract，从 Java 8 开始，可以包含默认方法和静态方法。

示例：

interface Animal {
    void makeSound(); // 抽象方法
}

class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof Woof");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.makeSound(); // 输出：Woof Woof
    }
}

3. 详细对比

1. 继承与实现

• 抽象类：使用 extends 继承，且 Java 是单继承语言，一个类只能继承一个抽象类。
• 接口：使用 implements 实现，一个类可以实现多个接口。

示例：

abstract class A {}
class B extends A {} // 正确
class C extends B {} // 正确，但只能继承一个类

interface X {}
interface Y {}
class Z implements X, Y {} // 正确，可以实现多个接口

1. 成员变量

• 抽象类：可以有普通成员变量，支持各种访问修饰符（private、protected、public）。
• 接口：只能有 public static final 常量，不能有普通变量。

示例：

abstract class AbstractExample {
    protected int x = 10; // 普通变量
    public static final int Y = 20; // 常量
}

interface InterfaceExample {
    int X = 10; // 等价于 public static final int X = 10;
}

1. 方法

• 抽象类：可以有抽象方法和普通方法。

• 接口：

  • Java 8 之前：只能有抽象方法。

  • Java 8 引入：

  • 默认方法（default）：可以有方法体。

  • 静态方法（static）：可以直接通过接口调用。

  • Java 9 引入：允许有私有方法。

示例：

interface Example {
    void abstractMethod(); // 抽象方法

    default void defaultMethod() {
        System.out.println("Default method in interface");
    }

    static void staticMethod() {
        System.out.println("Static method in interface");
    }
}

1. 构造方法

• 抽象类：可以有构造方法，用于初始化成员变量。
• 接口：不能有构造方法，因为接口不能直接实例化。

示例：

abstract class AbstractExample {
    protected int x;

    public AbstractExample(int x) {
        this.x = x;
    }
}

1. 多继承

• 抽象类：不支持多继承，但可以通过继承一个类并实现多个接口来间接实现多继承。
• 接口：支持多实现，一个类可以实现多个接口。

示例：

interface A {}
interface B {}
class C implements A, B {} // 支持多实现

4. 使用场景对比

5. 拓展知识

1. 抽象类与接口的结合

• 一个类可以继承抽象类并实现多个接口，结合两者的特性。

  abstract class Animal {
     public abstract void eat();
  }
  
  interface Flyable {
     void fly();
  }
  
  class Bird extends Animal implements Flyable {
     @Override
     public void eat() {
         System.out.println("Bird eats");
     }
  
     @Override
     public void fly() {
         System.out.println("Bird flies");
     }
  }
  

2. 默认方法冲突

• 如果一个类实现了多个接口，且这些接口有相同签名的默认方法，必须重写该方法。

  interface A {
     default void show() {
         System.out.println("A");
     }
  }
  
  interface B {
     default void show() {
         System.out.println("B");
     }
  }
  
  class C implements A, B {
     @Override
     public void show() {
         A.super.show(); // 调用接口 A 的默认方法
         B.super.show(); // 调用接口 B 的默认方法
     }
  }
  

3. JDK 演化

• Java 8：引入默认方法和静态方法，使接口更灵活。
• Java 9：支持私有方法，增强代码复用能力。

6. 总结

• 抽象类：用来描述类之间的继承关系，强调“is-a”。
• 接口：用来描述类的行为规范，强调“can-do”。
• 在设计中，优先使用接口，当需要定义一组通用的属性和行为时，再考虑使用抽象类。

shuaidi永久会员

收藏 海报挣佣金 推广链接