abstraction java,Java 抽象

Java 抽象

Abstraction 是指在 OOP 中让一个类抽象的能力。一个抽象类是不能被实例化的。类的功能仍然存在，它的字段，方法和构造函数都以相同的方式进行访问。你只是不能创建一个抽象类的实例。

如果一个类是抽象的，即不能被实例化，这个类如果不是子类它将没有什么作用。这体现了在设计过程中抽象类是如何被提出的。一个父类包含子类的基本功能集合，但是父类是抽象的，不能自己去使用功能。

抽象类

使用关键字 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("\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 对象，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.

抽象方法

如果你想一个提供特定方法的类，但是你想要在他的子类中实际实现这个方法，你可以在父类中声明这个方法为抽象的。

abstract 关键字也被用来定义抽象方法。一个抽象方法是有方法签名的但没有方法实体。

抽象方法无需定义，并且它的签名以分号结束，不需要花括号。

public abstract class Employee

{

private String name;

private String address;

private int number;

public abstract double computePay();

//Remainder of class definition

}

声明一个抽象方法有两个结果:

如果一个类中含有一个抽象方法，类必须也是抽象的。

任何一个子类必须覆盖这个抽象方法，或者继续将它声明为抽象方法。

子类继承一个抽象方法，必须要去覆盖他。如果不这样做的话，它们必须将其继续声明为抽象，或在它们的子类中去覆盖它们。

最终，后代类不得不去实现抽象方法；否则你会一直有一个不能被实例化的抽象类。

如果 Salary 继承 Employee 类，则他必须如下要去实现 computerPay() 方法：

/* 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

}