Java 抽象类和抽象方法

在本教程中，我们将借助示例了解 Java 抽象类和方法。我们还将学习 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() 的实现 .

然后我们使用对象 d1 狗 类调用方法makeSound() 和 eat() .

注意 :如果狗 类不提供抽象方法 makeSound() 的实现 , 狗 也应该被声明为抽象的。这是因为子类 Dog 继承 makeSound() 来自动物 .

访问抽象类的构造函数

抽象类可以有像普通类一样的构造函数。而且，我们可以使用 super 从子类访问抽象类的构造函数关键词。例如，

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

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

在这里，我们使用了 super() Dog 的构造函数内部访问 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() 实现 .

所以，brake()的实现在 摩托车 一直隐藏。

在这里，MountainBike 自己实现 brake() 和 SportsBike 自己实现 brake() .

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

要记住的关键点

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

Java超级 Java 接口

java