本人在这篇博文中要讲解的知识点，和本人之前的一篇博文有所关联。因为，“抽象类” 是按照 “自下而上” 的顺序来编写所需的类，而在本人之前的博文《详解 继承(上)—— 工具的抽象与分层》中讲到的 继承 则与之相反，按照 “自上而下” 的顺序来编写所需类，那么，话不多说，现在本人就开始讲解这篇博文的主题

抽象类的基本概念：

首先，本人来介绍下什么是抽象类：

定义：

在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类

那么，抽象类具有如下特点：

特点：

抽象类 和 抽象方法 必须用abstract关键字修饰：

抽象类格式:abstract class 类名 {}

抽象方法格式:public abstract void eat();

抽象类 不一定有抽象方法，有抽象方法的类 一定是抽象类

抽象类中可以有构造方法,抽象类不能进行实例化：

问：那么要构造方法有什么作用呢?

答曰：用于子类访问父类数据时的初始化

抽象类不能直接实例化

问：那么，抽象类如何实例化呢?

答曰：按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。

抽象类的子类 ：

要么是抽象类

要么重写抽象类中的所有抽象方法

本人来通过两个例子，来展示这个知识点的应用:

一、图形类：

假设现在要求编写几个类可以分别根据图形的属性求出图形的 周长 及 面积。

那么，若我们将几个图形的共性拿出来，做一个基类，之后我们再根据基类派生出各图形的方法。

首先，我们来编写 基本图形类(BaseShape类)：

BaseShape.java:

package com.mec.about_abstruct;

public abstract class BaseShape {//只要含抽象方法，就是抽象类，就要加上“abstract”修饰符

protected String name;

protected String type;

protected BaseShape() {

}

protected BaseShape(String name) {

this.name = name;

}

//这两行代码，就是“抽象方法”，不在本类中实现，是专门用来给子类实现的

public abstract double area();

public abstract double rounder();

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getType() {

return type;

}

public void setType(String type) {

this.type = type;

}

@Override

public String toString() {

return name + "的" + type;

}

}

现在本人来通过这个类编写一个 确定图形类 ——“Circle类”：

Circle.java:

package com.mec.about_abstruct;

public class Circle extends BaseShape {

private double radius;

public Circle() {

}

public Circle(String name) {

super(name);

this.type = "圆";

}

public Circle(String name, double radius) {

this(name);

this.radius = radius;

}

@Override

public double area() {

return Math.PI * radius * radius;

}

@Override

public double rounder() {

return 2 * Math.PI * radius;

}

}

现在同学们可能就对抽象类有了进一步了解：

抽象类：将类似的东西的共同部分(toString() 及 name 和 type)实现，将不同的、但必须要完成的(area()、rounder() 及 各图形特有尺度)表现出来，但不实现。

现在本人来对 Test类 进行一些改动：

Test类：

package com.mec.about_abstruct.test;

import com.mec.about_abstruct.BaseShape;

import com.mec.about_abstruct.Circle;

public class Test {

public static void main(String[] args) {

circleOne = new Circle("地球", 6371000.0);

System.out.println(circleOne.toString() + "周长= " + circleOne.rounder());

System.out.println(circleOne.toString() + "面积= " + circleOne.area());

}

}

我们现在来看看运行结果：

现在，本人来总结下抽象类的注意点：

注意点：

只要含抽象方法，就是抽象类，就要加上“abstract”修饰符；

抽象类不能存在对象，因为它存在未实现的方法；

抽象类中不能存在private类成员及方法，所有抽象方法不能用static修饰；

抽象类派生的所有非抽象类，那么，

派生出来的非抽象类必须实现这个抽象类中的所有抽象方法；

若未实现，则子类也为抽象类，必须加上“abstract”修饰符；

我们能够发现，无论是 “继承” 还是 “抽象类” ，都是为了 “代码复用”。而本人在本专栏第一篇博文中就讲过，Java最主要的特点就是“面向对象”，也就是“面向工具”，我们现在来实现下一个有趣的问题——计算房价：

我们只需改动一下上面的代码：

BaseShape.java:

package com.mec.about_abstruct.shape;

public abstract class BaseShape {//只要含抽象方法，就是抽象类，就要加上“abstract”修饰符

protected String name;

protected String type;

//据了解：深圳近3年房价一平最低100

protected double price = 100;

protected BaseShape() {

}

protected BaseShape(String name) {

this.name = name;

}

public double getPrice() {

//所有的抽象方法，都可以在本类中被非静态方法调用

return price * area();

}

//这两行代码，就是“抽象方法”，不在本类中实现，是专门用来给子类实现的

public abstract double area();

public abstract double rounder();

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getType() {

return type;

}

public void setType(String type) {

this.type = type;

}

@Override

public String toString() {

return name;

}

}

因为一般租的房子是投影式长方形的，所以本人现在来编写一个 长方形类：

Rectangle.java：

package com.mec.about_abstruct.shape;

public class Rectangle extends BaseShape {

private double width;

private double height;

public Rectangle() {

}

public Rectangle(String name) {

super(name);

this.type = "长方形";

}

public Rectangle(String name,double width, double height) {

this(name);

this.height = height;

this.width = width;

}

public double getWidth() {

return width;

}

public void setWidth(double width) {

this.width = width;

}

public double getHeight() {

return height;

}

public void setHeight(double height) {

this.height = height;

}

@Override

public double area() {

return width * height;

}

@Override

public double rounder() {

return 2 * (width + height);

}

}

Test.java:

package com.mec.about_abstruct.test;

import com.mec.about_abstruct.shape.BaseShape;

import com.mec.about_abstruct.shape.Rectangle;

public class Test {

public static void main(String[] args) {

BaseShape rectangleOne = new Rectangle("深圳一间小房间", 6, 6);

System.out.println(rectangleOne.toString() + "周长= " + rectangleOne.rounder());

System.out.println(rectangleOne.toString() + "面积= " + rectangleOne.area());

System.out.println(rectangleOne.toString() + "房价/月 约= " + rectangleOne.getPrice( ));

}

}

二、货币类：

因为本人在上文中已经将“抽象类”的基本知识点都已讲解完毕，那么，在这个例子中，本人就不会再做过多解释，以展示使用方法为目的，为同学们加深这个知识点的印象。

Currency类(抽象类)：

package com.mec.about_abstruct.currency;

public abstract class Currency {

protected String goodsName;

protected double weight;

//以下是人民币分别对应其他货币的汇率

public static double RMB = 1.0;

public static double DOLLAR = 0.1459;

public static double EURO = 0.1250;

public static double POUND = 0.1110;

public static double YEN = 16.3797;

public static double WON = 163.8141;

public Currency(String goodsName, double weight) {

this.goodsName = goodsName;

this.weight = weight;

}

public double getWeight() {

return weight;

}

public abstract double price();

public void setWeight(double weight) {

this.weight = weight;

}

public double value(double currencyType) {

return price() * currencyType;

}

//这个方法调用了抽象方法，并将其返回值作为货币转换的基础数据

public String getValueString(double currencyType) {

return weight + "克" + goodsName + "价格为："

+ value(currencyType)

+ currencyName(currencyType);

}

public String currencyName(double currencyType) {

if(Math.abs(currencyType - DOLLAR) < 1e-6) {

return "美元";

}

if(Math.abs(currencyType - EURO) < 1e-6) {

return "欧元";

}

if(Math.abs(currencyType - YEN) < 1e-6) {

return "日元";

}

if(Math.abs(currencyType - WON) < 1e-6) {

return "韩元";

}

if(Math.abs(currencyType - POUND) < 1e-6) {

return "英镑";

}

return "人民币";

}

}

Silver 类：

package com.mec.about_abstruct.currency;

public class Silver extends Currency{

public Silver(double weight) {

super("白银", weight);

}

@Override

public double price() {

return 3.12 * weight;

}

}

Gold 类：

package com.mec.about_abstruct.currency;

public class Gold extends Currency {

public Gold(double weight) {

super("黄金", weight);

}

@Override

public double price() {

return 264.5 * weight;

}

}

测试类(Demo 类)：

package com.mec.about_abstruct.currency;

public class Demo {

public static void main(String[] args) {

Gold gold = new Gold(1.47);

System.out.println(gold.getValueString(Currency.RMB));

System.out.println(gold.getValueString(Currency.DOLLAR));

System.out.println(gold.getValueString(Currency.POUND));

System.out.println("下面演示白银兑换率：");

Silver silver = new Silver(132.0);

System.out.println(silver.getValueString(Currency.EURO));

System.out.println(silver.getValueString(Currency.WON));

System.out.println(silver.getValueString(Currency.YEN));

}

}

下面本人来展示下运行结果：

由以上代码运行结果的展示，我们大致能够看出：

抽象类的成员具有如下特点：

抽象类的成员特点：

成员变量：

既可以是变量，也可以是常量。

构造方法：

必须有，因为 要用于子类访问父类数据的初始化。

成员方法：

既可以是抽象的，也可以是非抽象的。

抽象类的成员方法具有如下特性：

抽象类的成员方法特性：

抽象方法

强制要求子类做的事情

非抽象方法

子类继承的事情，提高代码复用性

抽象类和继承的逻辑顺序是相反的。

并且，抽象类 与 本人下一篇博文—— 《内部类 与 匿名内部类》 还有很深的关系，能够看出，这个知识点还是蛮重要的，所以，希望同学们能够加以重视。