Java - 抽象

根据字典,抽象是处理想法而不是事件的质量.例如,当您考虑电子邮件的情况,复杂的详细信息(例如发送电子邮件时会发生的情况),您的电子邮件服务器使用的协议对用户是隐藏的.因此,要发送电子邮件,您只需要输入内容,提及接收者的地址,然后单击发送.

同样在面向对象的编程中,抽象是一个过程隐藏用户的实现细节,只有功能将提供给用户.换句话说,用户将获得有关对象的作用而不是对象的信息.

在Java中,使用抽象类和接口实现抽象.

抽象类

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

  • 抽象类可能包含也可能不包含抽象方法,即没有body的方法(public void get();)

  • 但是,如果一个类至少有一个抽象方法,那么类必须被声明为abstract.

  • 如果一个类被声明为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

继承抽象类

我们可以继承属性员工类就像具体类一样,按以下方式减去;

示例

/* 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 Class,并使用这个实例你可以访问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 keyword用于将方法声明为抽象.

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

  • 摘要method包含一个方法签名,但没有方法体.

  • 抽象方法最后会有一个semoi冒号(;)而不是花括号./p>

以下是抽象方法的示例.

示例

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
}