在某些情况下，某个父类只是知道其子类应该包含怎么样的方法，但不能准确地知道这些子类如何实现这些方法，因为抽象类的特性，它非常好的支撑了这种情，并且有了模板模式

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会大致保留抽象类的行为方式。

如果编写了一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，这就是模板模式（一种常见的且简单的设计模式之一）

抽象方法和抽象类

抽象方法和抽象类必须使用abstract修饰符来定义，有抽象方法的类只能被定义成抽象类，抽象类中可以没有抽象方法，规则如下

• • 
    
• 抽象类和抽象方法必须使用abstract修饰符来修饰，抽象方法不能有方法体
• 抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器，即便抽象类中没有抽象方法，这个抽象类也不能创建实例
• 抽象类可以包含成员变量、方法（普通方法和抽象方法均可）、构造器、初始化块、内部类（接口及枚举）5种成分，抽象类的构造器不能用于创建实例，主要是用于被其子类调用
• 含有抽象方法的类（包括直接定义了抽象方法或继承了一个抽象父类，但没有完全实现父类包含的抽象方法或实现了一个接口，但没有完全实现接口包含的抽象方法三种情况）只能被定义成抽象类
  • 
    

抽象方法和空方法不是一回事，例如抽象方法这样的：public abstract void test();而空方法是这样的public void test(){};，抽象方法根本没有方法体，即那对花括号，而空方法就是个普通方法只是方法体内啥也没有。

定义抽象类

定义抽象类只需要在普通类上增加abstract修饰符即可，甚至一个普通类（没有包含抽象方法的类）增加abstract修饰符后也变成了抽象类

public abstract class Shape
{
    {
        System.out.println("执行Shape的初始化块...");
    }
    private String color;
    // 定义一个计算周长的抽象方法
    public abstract double calPerimeter();
    // 定义一个返回形状的抽象方法
    public abstract String getType();
    // 定义Shape的构造器，该构造器并不是用于创建Shape对象，
    // 而是用于被子类调用
    public Shape(){}
    public Shape(String color)
    {
        System.out.println("执行Shape的构造器...");
        this.color = color;
    }
    public void setColor(String color)
    {
        this.color = color;
    }
    public String getColor()
    {
        return this.color;
    }
}

定义一个三角类型，继承于Shape类，因为三角类是普通类，因此它必须实现Shape类里的所有抽象方法

三角类是个普通类，因此可以实例化，可以让一个Shape类型的引用变量指向Triangle对象

public class Triangle extends Shape
{
    // 定义三角形的三边
    private double a;
    private double b;
    private double c;
    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 || b >= a + c || c >= a + b)
        {
            System.out.println("三角形两边之和必须大于第三边");
            return;
        }
        this.a = a;
        this.b = b;
        this.c = c;
    }
    // 重写Shape类的的计算周长的抽象方法
    public double calPerimeter()
    {
        return a + b + c;
    }
    // 重写Shape类的的返回形状的抽象方法
    public String getType()
    {
        return "三角形";
    }
}

public class Circle extends Shape
{
    private double radius;
    public Circle(String color, double radius)
    {
        super(color);
        this.radius = radius;
    }
    public void setRadius(double radius)
    {
        this.radius = radius;
    }
    // 重写Shape类的的计算周长的抽象方法
    public double calPerimeter()
    {
        return 2 * Math.PI * radius;
    }
    // 重写Shape类的的返回形状的抽象方法
    public String getType()
    {
        return getColor() + "圆形";
    }
    public static void main(String[] args)
    {
        Shape s1 = new Triangle("黑色", 3, 4, 5);
        Shape s2 = new Circle("黄色", 3);
        System.out.println(s1.getType());
        System.out.println(s1.calPerimeter());
        System.out.println(s2.getType());
        System.out.println(s2.calPerimeter());
    }
}

main()方法中定义了两个Shape类型的引用变量，他们分别指向了Triangle对象和Circle对象，由于Shape类中应以了calPerimeter()方法和getType()方法，所以程序可以直接调用s1变量和s2变量的calPerimeter()方法和getType()方法，无需强制类型 转换为其子类类型

• • 
    
• 利用抽象类和抽象方法的优势，可以更好的发挥多态的优势
• 抽象类只能被继承，抽象方法必须由子类实现（即重写），而final修饰的类不能被继承，final修饰的方法不能被重写，final和abstract永远不能同时使用
• abstract不能修饰成员变量，不能修饰局部变量，即没有抽象变量没有抽象成员变量等，abstract不能修饰构造器，没有抽象构造器，抽象类里定义的构造器只能是普通构造器
• static和abstract不能同时修饰某个方法，即没有所谓的类抽象方法
• static和abstract并不是绝对的互斥，虽然不能 同时修饰某个方法，但可以同时修饰内部类
• private和abstract不能同时出现，abstract修饰的方法必须被子类重写才有意义，因此它就不能再用private修饰了，否则子类不能访问到他也就无从重写了。
  • 
    

实现模版模式

抽象类不能被实例化只能被继承，从某种角度来看抽象类是从多个具体类中抽象出来的父类，它具有更高层次的抽象，从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为其子类的模板，从而避免了子类的随意设计

public abstract class SpeedMeter
{
    // 转速
    private double turnRate;
    public SpeedMeter(){}
    // 把计算车轮周长的方法定义成抽象方法
    public abstract double calGirth();
    public void setTurnRate(double turnRate)
    {
        this.turnRate = turnRate;
    }
    // 定义计算速度的通用算法
    public double getSpeed()
    {
        // 速度等于 周长 * 转速
        return calGirth() * turnRate;
    }
}

类中定义了一个getSpeed()方法，该方法用于返回当前车速，而getSpeed()方法依赖于calGirth()方法的返回值，对于一个抽象的SpeedMeter类而言它无法确定车轮的周长，因此calGirth()方法要到子类中实现

public class CarSpeedMeter extends SpeedMeter
{
    private double radius;
    public CarSpeedMeter(double radius)
    {
        this.radius = radius;
    }
    public double calGirth()
    {
        return radius * 2 * Math.PI;
    }
    public static void main(String[] args)
    {
        var csm = new CarSpeedMeter(0.34);
        csm.setTurnRate(15);
        System.out.println(csm.getSpeed());
    }
}

模板模式规则

• • 
    
• 抽象父类可以只定义需要使用的某些方法，把不能实现的部分抽象成抽象方法留给其子类去实现
• 父类中可能包含需要调用其它系列方法的方法，这些被调方法可以由其父类实现，也可以由其子类实现
• 父类里提供的方法只是定义了一个通用算法，其实可以不完全由自身完成，而可以依赖于其子类辅助
  •