位置:首页 > Java技术 > Java在线教程 > 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类没有什么不同。这个类是抽象的现在,但它仍然有三个字段,七种方法,和一个构造函数。

现在,如果想尝试如下:

/* 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("
 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 对象,Salary 对象将继承这三个字段,并从员工七种方法。

/* 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("
 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.

抽象方法:

如果你想有一个类包含一个特定的方法,但是希望该方法由子类来决定的实际执行情况,可以在父类中声明的抽象方法。

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
}