在某些情况下，某个父类只是知道其子类应该包含怎么样的方法，但不能准确地知道这些子类如何实现这些方法，因为抽象类的特性，它非常好的支撑了这种情，并且有了模板模式
抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会大致保留抽象类的行为方式。
如果编写了一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，这就是模板模式（一种常见的且简单的设计模式之一）
抽象方法和抽象类
抽象方法和抽象类必须使用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());
}
}模板模式规则
- 抽象父类可以只定义需要使用的某些方法，把不能实现的部分抽象成抽象方法留给其子类去实现
- 父类中可能包含需要调用其它系列方法的方法，这些被调方法可以由其父类实现，也可以由其子类实现
- 父类里提供的方法只是定义了一个通用算法，其实可以不完全由自身完成，而可以依赖于其子类辅助
