Java 抽象类和抽象方法

Java 抽象类

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

// create an abstract class
abstract class Language {
  // fields and methods
}
...

// try to create an object Language
// throws an error
Language obj = new Language(); 

抽象类可以同时拥有常规方法和抽象方法。例如，

abstract class Language {

  // abstract method
  abstract void method1();

  // regular method
  void method2() {
    System.out.println("This is regular method");
  }
}

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

Java 抽象方法

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

abstract void display();

这里，display() 是一个抽象方法。display() 的方法体被 ; 替换了。

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

// error
// class should be abstract
class Language {

  // abstract method
  abstract void method1();
}

示例：Java 抽象类和方法

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

abstract class Language {

  // method of abstract class
  public void display() {
    System.out.println("This is Java Programming");
  }
}

class Main extends Language {

  public static void main(String[] args) {
    
    // create an object of Main
    Main obj = new Main();

    // access method of abstract class
    // using object of Main class
    obj.display();
  }
}

输出

This is Java programming

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

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

obj.display();

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

实现抽象方法

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

abstract class Animal {
  abstract void makeSound();

  public void eat() {
    System.out.println("I can eat.");
  }
}

class Dog extends Animal {

  // provide implementation of abstract method
  public void makeSound() {
    System.out.println("Bark bark");
  }
}

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

    // create an object of Dog class
    Dog d1 = new Dog();

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

输出

Bark bark
I can eat.

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

我们继承了一个子类 Dog，它继承自超类 Animal。在这里，子类 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 {
    
  // implementation of abstract method
  public void brake() {
    System.out.println("SportsBike Brake");
  }
}

class MountainBike extends MotorBike {
    
  // implementation of abstract method
  public void brake() {
    System.out.println("MountainBike Brake");
  }
}

class Main {
  public static void main(String[] args) {
    MountainBike m1 = new MountainBike();
    m1.brake();
    SportsBike s1 = new SportsBike();
    s1.brake();
  }
}

输出:

MountainBike Brake
SportsBike Brake

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

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

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

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

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

要记住的要点

• 我们使用 abstract 关键字来创建抽象类和方法。
• 抽象方法没有任何实现（方法体）。
• 包含抽象方法的类也应该是抽象的。
• 我们不能创建抽象类的对象。
• 要实现抽象类的功能，我们从它继承子类，并创建子类的对象。
• 子类必须覆盖抽象类的所有抽象方法。但是，如果子类被声明为抽象的，则不必覆盖抽象方法。
• 我们可以使用抽象类的引用来访问抽象类的静态属性和方法。例如，

  Animal.staticMethod();

另请阅读

• Java 类和对象