Java 抽象

根据字典的定义，抽象是指处理思想而非事件的品质。例如，在考虑电子邮件的情况下，复杂的细节例如当你发送电子邮件时会发生什么以及你的电子邮件服务器使用的协议对用户是隐藏的。因此，要发送电子邮件，你只需要输入内容，提及收件人的地址，并点击发送。

同样，在面向对象编程中，抽象是一种从用户隐藏实现细节的过程，只向用户提供功能。换句话说，用户将获得对象做什么的信息而不是如何做到的信息。

在Java中，抽象是通过使用抽象类和接口来实现的。

抽象类

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

抽象类可以包含也可以不包含没有实体的方法（例如：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("George 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("George W.", "Houston, TX", 43);
                   ^
1 error

继承抽象类

我们可以像继承具体类一样继承Employee类的属性，具体做法如下：

示例

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

   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }

   public void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Mailing check to " + getName() + " with salary " + salary);
   }

   public double getSalary() {
      return salary;
   }

   public void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }

   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

在这里，你不能实例化Employee类，但你可以实例化Salary类，并使用该实例访问Employee类的三个字段和七个方法，如下所示。

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

   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

这将产生下面的结果 –

输出

Constructing an Employee
Constructing an Employee
Call mailCheck using Salary reference --
Within mailCheck of Salary class 
Mailing check to Mohd Mohtashim with salary 3600.0

 Call mailCheck using Employee reference--
Within mailCheck of Salary class 
Mailing check to John Adams with salary 2400.0

抽象方法

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

abstract 关键字用于声明该方法为抽象方法。
你必须将 abstract 关键字放在方法声明中方法名前面。
抽象方法包含方法签名但不包含方法体。
与花括号不同，抽象方法以分号（;）结尾。

以下是抽象方法的示例。

示例

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

   public abstract double computePay();
   // Remainder of class definition
}

将一个方法声明为抽象方法会有两个影响：

包含它的类必须被声明为抽象类。
继承当前类的任何类都必须要么覆盖抽象方法，要么将自己声明为抽象类。

注意 - 最终，子类必须实现抽象方法；否则，你将会有一系列无法实例化的抽象类。

假设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;
   }
   // Remainder of class definition
}