Java 简明教程

Java - Abstraction

如同字典所述，abstraction 是处理思想而非事件的质量。例如，在考虑电子邮件时，一些复杂的细节会对用户隐藏，例如发送电子邮件会发生什么、电子邮件服务器使用什么协议。因此，要发送电子邮件，您只需要键入内容、指出收件人的地址并单击发送。

Java Abstraction

抽象是向用户隐藏实现细节的过程，只向用户提供功能。换句话说，用户将了解对象的功能，而不是了解它如何执行此操作。在 Java 编程中，使用 Abstract classes 和 interfaces 实现抽象。

Java Abstract Classes

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

Java 抽象类可能包含或不包含抽象方法，即没有主体的方法（public void get();）。
但是，如果一个类至少有一个抽象方法，那么该类 must 被声明为抽象类。
如果一个类被声明为抽象类，那么它就不能被实例化。
要使用抽象类，您必须从另一个类继承它，为其中的抽象方法提供实现。
如果您继承一个抽象类，您必须为其中的所有抽象方法提供实现。

Example: Java Abstract Class

本节向您提供有关 Java 抽象类的示例。要在 Java 中创建一个抽象类，只需在类声明中将 abstract 关键字放在 class 关键字前面。

/* 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();
   }
}

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:46: Employee is abstract; cannot be instantiated
      Employee e = new Employee("George W.", "Houston, TX", 43);
                   ^
1 error

Inheriting the Java Abstract Class

我们可以按照具体类中一样继承 Employee 类的属性，按照以下方法操作 −

Example: Inheriting the Abstract Class in Java

/* 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();
   }
}
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;
   }
}
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;
   }
}

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

Java Abstract Methods

如果你想要一个类包含特定的 method，但你想让该方法的实际实现由子类来确定，则可以在父类中将该方法声明为抽象。

abstract 关键字用于将方法声明为抽象方法。
您必须在方法声明的方法名称之前放置 abstract 关键字。
抽象方法包含方法签名，但没有方法体。
抽象方法的结尾处会用分号 (;) 而不是大括号。

Example 1: Implementing Abstract Method in Java

以下是抽象方法示例。

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

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

将方法声明为抽象方法会产生两个后果 −

包含它的类必须声明为抽象类。
任何类 inheriting 当前类要么 override 抽象方法，要么把自己声明为抽象。

− 最终，派生类必须实现抽象方法；否则，您将拥有一个无法实例化的抽象类的层次结构。

假设 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
}

Example 2: Implementing Abstract Method in Java

以下示例展示了抽象方法的概念。

/* File name : AbstractDemo.java */
public class AbstractDemo {
   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      System.out.println("salary: " + s.computePay());
   }
}
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 abstract double computePay();
      // Remainder of class definition

   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }

   public String getAddress() {
      return address;
   }

   public void setAddress(String address) {
      this.address = address;
   }

   public int getNumber() {
      return number;
   }

   public void setNumber(int number) {
      this.number = number;
   }
}
class Salary extends Employee {
   private double salary;   // Annual salary

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

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

Constructing an Employee
Computing salary pay for Mohd Mohtashim
salary: 69.23076923076923