Java中的“抽象”关键字

抽象关键字

“抽象”关键字用于将方法或类声明为抽象。

抽象类

在其声明中包含 abstract关键字的类称为抽象类。

• 抽象类可以包含也可以不包含抽象方法，即没有主体的方法（public void get();）

• 但是，如果一个类至少具有一个抽象方法，则必须将该类声明为抽象。

• 如果类被声明为抽象，则无法实例化。

• 要使用抽象类，您必须从另一个类继承它，并为其中的抽象方法提供实现。

• 如果继承抽象类，则必须为其中的所有抽象方法提供实现。

示例

本节为您提供了抽象类的示例。要创建抽象类，只需在类声明中的class关键字之前使用abstract关键字。

/* File name : Employee.java */
public abstract class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   public double computePay() {
      System.out.println("Inside Employee computePay");
      return 0.0;
   }
   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }
   public String toString() {
      return name + " " + address + " " + number;
   }
   public String getName() {
      return name;
   }
   public String getAddress() {
      return address;
   }
   public void setAddress(String newAddress) {
      address = newAddress;
   }
   public int getNumber() {
      return number;
   }
}

您可以观察到，除抽象方法外，Employee类与Java中的普通类相同。该类现在是抽象的，但它仍然具有三个字段，七个方法和一个构造函数。

现在，您可以尝试通过以下方式实例化Employee类-

/* File name : AbstractDemo.java */
public class AbstractDemo {

   public static void main(String [] args) {
      /* Following is not allowed and would raise error */
      Employee e = new Employee("乔治W.-", "Houston, TX", 43);
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

当您编译上面的类时，它给您以下错误-

Employee.java:46: Employee is abstract; cannot be instantiated
   Employee e = new Employee("乔治W.-", "Houston, TX", 43);                    
      ^
1 error

抽象方法

如果您希望一个类包含一个特定的方法，但希望该方法的实际实现由子类确定，则可以在父类中将该方法声明为一个抽象。

• 抽象关键字用来声明该方法为抽象。

• 您必须在方法声明中的方法名称之前放置abstract关键字。

• 抽象方法包含方法签名，但不包含方法主体。

• 代替花括号，抽象方法将在末尾使用分号（;）。

以下是抽象方法的示例。

示例

public abstract class Employee {
   private String name;
   private String address;
   private int number;

   public abstract double computePay();
   //剩余的类定义
}

将方法声明为抽象有两个结果-

• 包含它的类必须声明为抽象。

• 任何继承当前类的类都必须重写abstract方法或将其声明为abstract。

注–最终，后代类必须实现abstract方法；否则，您将拥有无法实例化的抽象类的层次结构。

假设Salary类继承了Employee类，那么它应该实现computePay()方法，如下所示-

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary;   // Annual salary

   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
   //剩余的类定义
}