抽象是指能够使一个抽象类在面向对象编程的能力。抽象类是不能被实例化。该类别的所有其他功能仍然存在，及其字段，方法和构造函数以相同的方式被访问的。不能创建抽象类的实例。
如果一个类是抽象的，不能被实例化，类没有多大用处，除非它是子类。这通常是在设计阶段的抽象类是怎么来的。父类包含子类的集合的通用功能，但父类本身是过于抽象而被单独使用。
抽象类：
使用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 EmployeeConstructing an EmployeeCall mailCheck using Salary reference --Within mailCheck of Salary classMailing check to Mohd Mohtashim with salary 3600.0
Call mailCheck using Employee reference--Within mailCheck of Salary classMailing 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}
|
|
收藏
淘帖
踩
