跳到主要内容

Java 抽象类和抽象方法

提示
  1. 抽象类的基本概念：Java 中的抽象类不能被实例化，使用 abstract 关键字声明。抽象类可以包含抽象方法（没有具体实现的方法）和非抽象方法。
  2. 实现抽象方法：从抽象类继承的子类必须提供抽象方法的具体实现，除非子类也被声明为抽象类。
  3. 抽象类的用途和访问方式：抽象类用于实现面向对象编程中的抽象概念，隐藏不必要的细节。虽然不能直接创建抽象类的对象，但可以通过子类对象访问其成员，或直接访问抽象类的静态属性和方法。

Java 抽象类​

Java 中的抽象类不能被实例化（我们不能创建抽象类的对象）。我们使用 abstract 关键字来声明一个抽象类。例如，

// 创建一个抽象类
abstract class Language {
  // 字段和方法
}
...

// 尝试创建一个 Language 对象
// 抛出错误
Language obj = new Language();

一个抽象类可以有普通方法和抽象方法。例如，

abstract class Language {

  // 抽象方法
  abstract void method1();

  // 普通方法
  void method2() {
    System.out.println("这是一个普通方法");
  }
}

要了解非抽象方法，请访问 Java 方法。在这里，我们将学习抽象方法。

Java 抽象方法​

没有具体实现的方法被称为抽象方法。我们使用同样的 abstract 关键字来创建抽象方法。例如，

abstract void display();

这里，display() 是一个抽象方法。display() 的实现体被 ; 替代。

如果一个类包含抽象方法，那么这个类应该被声明为抽象类。否则，它将产生错误。例如，

// 错误
// 类应该是抽象的
class Language {

  // 抽象方法
  abstract void method1();
}

示例：Java 抽象类和方法​

尽管抽象类不能被实例化，我们可以从中创建子类。然后我们可以使用子类的对象访问抽象类的成员。例如，

abstract class Language {

  // 抽象类的方法
  public void display() {
    System.out.println("这是 Java 编程");
  }
}

class Main extends Language {

  public static void main(String[] args) {

    // 创建 Main 的对象
    Main obj = new Main();

    // 使用 Main 类的对象
    // 访问抽象类的方法
    obj.display();
  }
}

输出

这是 Java 编程

在上面的示例中，我们创建了一个名为 Language 的抽象类。该类包含一个普通方法 display()。

我们创建了继承抽象类的 Main 类。注意这个语句，

obj.display();

这里，obj 是子类 Main 的对象。我们使用对象 obj 调用抽象类的方法。

实现抽象方法​

如果抽象类包含任何抽象方法，那么从抽象超类继承的所有子类必须提供抽象方法的实现。例如，

abstract class Animal {
  abstract void makeSound();

  public void eat() {
    System.out.println("我可以吃。");
  }
}

class Dog extends Animal {

  // 提供抽象方法的实现
  public void makeSound() {
    System.out.println("汪汪");
  }
}

class Main {
  public static void main(String[] args) {

    // 创建 Dog 类的对象
    Dog d1 = new Dog();

    d1.makeSound();
    d1.eat();
  }
}

输出

汪汪
我可以吃。

在上面的示例中，我们创建了一个名为 Animal 的抽象类。该类包含一个抽象方法 makeSound() 和一个非抽象方法 eat()。

我们从超类 Animal 继承了一个子类 Dog。在这里，子类 Dog 提供了抽象方法 makeSound() 的实现。

然后我们使用 Dog 类的对象 d1 来调用方法 makeSound() 和 eat()。

注意：如果 Dog 类不提供抽象方法 makeSound() 的实现，Dog 也应该被声明为抽象的。这是因为子类 Dog 继承了 Animal 的 makeSound()。

访问抽象类的构造函数​

抽象类可以像普通类一样拥有构造函数。我们可以使用 super 关键字在子类中访问抽象类的构造函数。例如，

abstract class Animal {
   Animal() {
      ….
   }
}

class Dog extends Animal {
   Dog() {
      super();
      ...
   }
}

在这里，我们在 Dog 的构造函数中使用了 super() 来访问 Animal 的构造函数。

注意 super 应该始终是子类构造函数的第一个语句。访问 Java super 关键字 了解更多。

Java 抽象​

抽象类和方法的主要用途是在 Java 中实现抽象。

抽象是面向对象编程的一个重要概念，它允许我们隐藏不必要的细节，只显示所需的信息。

这使我们能够通过省略或隐藏细节，用一个更简单、更高级别的思想来管理复杂性。

抽象的一个实际例子是摩托车刹车。我们知道刹车的作用。当我们使用刹车时，摩托车将停止。但是，刹车的工作方式对我们来说是隐藏的。

隐藏刹车的工作原理的主要优势在于，现在制造商可以为不同的摩托车以不同的方式实现刹车，但刹车的功能将是相同的。

让我们通过一个例子更好地理解 Java 抽象。

示例 3：Java 抽象​

abstract class MotorBike {
  abstract void brake();
}

class SportsBike extends MotorBike {

  // 抽象方法的实现
  public void brake() {
    System.out.println("SportsBike 刹车");
  }
}

class MountainBike extends MotorBike {

  // 抽象方法的实现
  public void brake() {
    System.out.println("MountainBike 刹车");
  }
}

class Main {
  public static void main(String[] args) {


    MountainBike m1 = new MountainBike();
    m1.brake();
    SportsBike s1 = new SportsBike();
    s1.brake();
  }
}

输出:

MountainBike 刹车
SportsBike 刹车

在上面的示例中，我们创建了一个名为 MotorBike 的抽象超类。超类 MotorBike 有一个抽象方法 brake()。

brake() 方法不能在 MotorBike 中实现。这是因为每辆自行车都有不同的刹车实现方式。因此，MotorBike 的所有子类都会有不同的 brake() 实现。

因此，MotorBike 中的 brake() 实现被隐藏了。

在这里，MountainBike 实现了自己的 brake()，而 SportsBike 实现了自己的 brake()。

注意：我们也可以使用接口来实现 Java 中的抽象。要了解更多，请访问 Java 接口。

记住的关键点​

  • 我们使用 abstract 关键字来创建抽象类和方法。
  • 抽象方法没有任何实现（方法体）。
  • 包含抽象方法的类也应该是抽象的。
  • 我们不能创建抽象类的对象。
  • 为了实现抽象类的功能，我们继承子类并创建子类的对象。
  • 子类必须重写抽象类的所有抽象方法。然而，如果子类被声明为抽象，那么重写抽象方法就不是强制性的。
  • 我们可以使用抽象类的引用来访问抽象类的静态属性和方法。例如，
Animal.staticMethod();
最后于 更新