1. 定义抽象类与抽象方法

抽象类相较普通类需要用到abstract关键字来定义，在其内部可定义抽象方法，同样采用abstract关键字，但是没有抽象变量。
抽象方法只定义了方法名，不给出具体的方法实现，即没有后面花括号的内容。定义抽象方法只需要在普通方法前面加上abstract关键字，并将后边花括号及里面内容（方法体）删掉，最后在后边加上分号即可：

//定义一个抽象test方法
abstract void test();

抽象类的类成员种类相较普通类多了抽象方法，且由于抽象类里面的抽象方法没有方法体，故其构造器无法创建抽象类的实例，主要用于被子类所调用。以下代码创建了一个Shape抽象类，其具有calPerimeter()与type()两个抽象方法。

/**
 * @author Liu XueZheng
 * @version 1.0
 * 这是一个抽象类
 */
public abstract class Shape {
    static{
        System.out.println("执行Shape的初始化块");
    }
    //定义一个成员变量
    private String color;
    //定义其setter方法
    public void setColor(String color){
        this.color = color;
    }
    //定义其getter方法
    public String getColor(){
        return color;
    }
    //定义一个计算周长的抽象方法
    public abstract double calPerimeter();
    //定义一个返回形状类型的抽象方法
    public abstract String type();
    //定义构造器
    public Shape(){
    }
    //重载构造器
    public Shape(String color){
        System.out.println("执行Shape的构造器");
        this.color = color;
    }
  }
}

2. 抽象类的作用

抽象类实际上实现了模板模式的设计模式，即将抽象类作为多个子类的模板，子类对其抽象方法进行实现，虽然具体方法可能不同，但都保留了父类的行为模式。例如下面两个子类Triangle和Circle，都继承自Shape类，对其两个抽象方法进行了实现：

/**
 * @author Liu XueZheng
 * @version 1.0
 * 这是一个三角形类，继承自Shape抽象类
 */
public class Triangle extends Shape{
    //定义边长变量a,b,c
    private double a;
    private double b;
    private double c;
    //定义构造器对边长和color进行初始化
    public Triangle(String color, double a, double b, double c){
        //继承父类的有参构造器
        super(color);
        this.setSides(a,b,c);
    }
    public void setSides(double a, double b, double c){
        //判断三角形三边是否满足基本要求
        if((a+b)>c && (a+c)>b && (b+c)>a){
            this.a = a;
            this.b = b;
            this.c = c;
        }
        else{
            System.out.println("三角形两边之和必须大于第三边");
            return;
        }
    }
    //重写返回计算周长的方法
    public double calPerimeter(){
        return (a+b+c);
    }
    //重写返回类型的方法
    public String type(){
        return "三角形";
    }
    public static void main(String[] args){
        //创建Triangle实例
        Shape t = new Triangle("red", 1.0, 1.0, 1.5);
        System.out.println("t的周长是：" + t.calPerimeter());
        System.out.println("t的形状是：" + t.type());
    }
}

/**
 * @author Liu XueZheng
 * @version 1.0
 */
public class Circle extends Shape{
    //定义半径成员变量
    private double radius;
    //定义其setter方法
    public void setRadius(double radius){
        this.radius = radius;
    }
    //定义其getter方法
    public double getRadius(){
        return this.radius;
    }
    //实现父类的calPerimeter方法
    public double calPerimeter(){
        return this.radius * 2 * Math.PI;
    }
    //重写构造器
    public Circle(double radius, String color){
        super(color);
        this.radius = radius;
    }
    //实现父类的type方法
    public String type(){
        return "圆形";
    }
    public static void main(String[] args){
        //定义Circle实例
        Shape c = new Circle(2.0, "green");
        c.type();
        System.out.println("c的周长是：" + c.calPerimeter());
    }
}

运行效果如下：

执行Shape的初始化块
执行Shape的构造器
t的周长是：3.5
t的形状是：三角形

执行Shape的初始化块
执行Shape的构造器
c的形状是：圆形
c的周长是：12.566370614359172

3. 接口

接口可以理解为一种更为“抽象”的抽象类。下次再更。