抽象类
当编写一个类时，常常会为该类定义一些方法，这些方法用以描述该类的行为方式，那么这些方法都有具体的方法体。但在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确地知道这些子类如何实现这些方法。例如定义了一个Shape类，这个类应该提供一个计算周长的方法callPerimeter（），但不同Shape子类对周长的计算方法是不一样的，即Shape类无法准确地知道其子类计算周长的方法。
如何既能让Shape类里包含calPerimeter()方法，又无须提供其方法实现呢？使用抽象方法即可满足该要求：抽象方法是只有方法签名，没有方法实现的方法。
抽象方法和抽象类
抽象方法和抽象类必须使用abstract修饰符来定义，有抽象方法的类只能被定义成抽象类，抽象类里可以没有抽象方法。
抽象方法和抽象类的规则如下：
- 抽象类必须使用abstract修饰符来修饰，抽象方法也必须使用abstract修饰符来修饰，抽象方法不能有方法体。
- 抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器创建抽象类的实例。即使抽象类里不包含抽象方法，这个抽象类也不能创建实例。
- 抽象类可以包含Field、方法（普通方法和抽象方法都可以）、构造器、初始化块、内部类、枚举类6种成分。抽象类的构造器不能用于创建实例，主要是用于被其子类调用。
- 含有抽象方法的类（包括直接定义了一个抽象方法；继承了一个抽象父类，但没有完全实现父类包含的抽象方法，以及实现了一个接口，但没有完全实现接口包含的抽象方法3种情况）只能被定义成抽象类。
定义抽象方法只需在普通方法上增加abstract修饰符，并把普通方法的方法体（也就是方法后花括号括起来的部分）全部去掉，并在方法后增加分号即可。
==抽象方法和空方法体的方法不是同一个概念。例如，public abstract void test();是一个抽象方法，它根本没有方法体，即方法定义后面没有一对花括号；但public void test(){}方法是一个普通方法，它已经定义了方法体，只是方法体为空，即它的方法体什么也不做，因此这个方法不可使用abstract来修饰。
定义抽象类只需在普通类上增加abstract修饰符即可。甚至一个普通类（没有包含抽象方法的类）增加abstract修饰符后也将变成抽象类。下面定义一个Shape抽象类：
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;
}
//省略color属性的setter和getter
public void serColor(String color){
this.color=color;
}
public String getColor(){
return this.color;
}
}
上面的Shape类里包含了两个抽象方法：calPerimeter()和getType()，所以这个Shape类只能被定义成抽象类。Shape类里既包含了初始化块，也包含了构造器，这些都不是在创建Shape对象时被调用的，而是在创建其子类的实例时被调用。
抽象类不能用于创建实例，只能当作父类被其他子类继承。
下面定义一个三角形类，三角形类被定义成普通类，因此必须实现Shape类里的所有抽象方法:
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 "三角形";
}
}
上面的Triangle类继承了Shape抽象类，并实现了Shape类中两个抽象方法，是一个普通类，因此可以创建Triangle类的实例，可以让一个Shape类型的引用变量指向Triangle对象。
下面再定义一个Circle普通类，Circle类也是Shape类的一个子类。
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());
}
}
上面主方法中定义了两个Shape类型的应用变量，他们分别指向Triangle对象和Circle对象。由于在Shape类中定义了calPerimeter()方法和getType（）方法，所以程序可以直接调用s1变量和s2变量的calPerimeter()方法和getType()方法，无需强制类型转换为其子类类型。
利用抽象类和抽象方法的优势，我们可以更好地放回多态的优势，是的程序更加灵活。
当使用abstract修饰类时，表明这个类只能被继承；但使用abstract修饰方法时，表明这个方法必须由子类提供实现（即重写）。而final修饰的类不能被继承，final修饰的方法不能被重写。因此final和abstract永远不能同时使用。
除此之外，当使用static修饰一个方法时，表明这个方法属于该类本身，即通过类就可调用该方法，但如果该方法被定义成抽象方法，则将导致通过该类来调用该方法是出现错误（因为是没有方法体）。因此static和abstract不能同时修饰某个方法，即没有所谓的类抽象方法。
抽象类作用
从前面的示例程序可以看出，抽象类不能创建实例，只能当成父类来被继承。从语义的角度来看，抽象类是从多个具体类中抽象出来的父类，它具有更高层次的抽象。从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为其子类的模板，从而避免了子类设计的随意性。
抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会大致保留抽象类的行为方式。
如果编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，这就是一种模板模式，模板模式也是十分常见且简单的设计模式之一。例如前面介绍的Shape、Circle和Triangle三个类，已经使用了模板模式。下面再介绍一个模板模式的范例，在这个范例的抽象父类中，父类的普通方法依赖于一个抽象方法，而抽象方法则推迟到子类中提供实现。
public abstract class SpeedMeter
{
//转速
private double turnRate;
public SpeedMeter()
{
}
//把返回车轮半径的方法定义成抽象方法
public abstract double getRadius();
public void setTurnRate(double turnRate)
{
this.turnRate=turnRate;
}
//定义计算速度的通用算法
public double getSpeed()
{
//速度等于 车轮半径 * 2 * PI * 转速
return java.lang.Math.PI * 2 * getRadius() * turnRate;
}
}
上面程序定义了一个抽象的SpeedMeter类（车速表），该表里定义了一个getSpeed方法，该方法用于返回当前车速，getSpeed方法依赖于getRadius方法的返回值，因此getRadius方法必须推迟到其子类中实现。
下面是其子类CarSpeedMeter的代码，该类实现了其抽象父类的getRadius（）方法，即可创建CarSpeedMeter类的对象，也可通过该对象来去的当前速度。
public class CarSpeedMeter extends SpeedMeter
{
public double getRadius(){
return 0.28;
}
public static void main(String[] args)
{
CarSpeedMeter csm=new CarSpeedMeter();
csm.setTurnRate(15);
System.out.println(csm.getSpeed());
}
}
SpeedMeter类里提供了速度表的通用算法，但一些具体的实现细节则推迟到其子类CarSpeedMeter类中实现。这也是一种典型的模板模式。
模板模式在面向对象的软件中很常用，其原理简单，实现也很简单。下面是使用模板模式的一些简单规则。
- 抽象父类可以只定义需要使用的某种方法，把不能实现的部分抽象成抽象方法，留个其子类去实现。
- 父类中可能包含需要调用的其他锡类方法的方法，这些被调用法既可以有父类实现，也可以有其子类实现。父类里提供的方法只是定义了一个通用算法，其实现也许并不完全有自身实现，而必须依赖于其子类的辅助。
java实例练习
猴子选大王
我们来看一个有关数组的古典游戏。n只猴子要选大王，选举方法是：参选猴子按1，2，…， n编号并按照顺序围成一圈，从第k只猴子起，由1开始报数，报到m时，该猴子就跳出圈外，下一只猴子再次由1开始报数，如此循环，直到圈内剩下一只猴子时，这只猴子就是大王。其实就是约瑟夫问题的变体：
1.
新建项目MonkeyKing，并在其中创建一个MonkeyKing.java文件。在该类的主方法中创建3个输入流的扫描器对象，分别接收用户输入的猴子总数、起始报数号，以及出局号。然后将所有报此号的猴子排除，最后剩下的就是猴王。核心代码如下所示：
package MonkeyKing;
import javax.swing.JOptionPane;
public class MonkeyKing {
public static void main(String[] args){
String s;
int n,k,m,n1;
s=JOptionPane.showInputDialog("输入猴子总数：");
n=Integer.parseInt(s);
n1=n+1;
s=JOptionPane.showInputDialog("请输入起始报数猴子编号：");
k=Integer.parseInt(s);
s=JOptionPane.showInputDialog("请输入出局数字：");
m=Integer.parseInt(s);
int a[]=new int[n+1];
a[0]=0;
System.out.println("出局的猴子编号：");
for (int i=0;i<a.length;i++)
a[i]=1;
for (int i=1;i<=m;i++){
if(n==1) break;
else if(i==m){
n--;
i=0;
a[k]=0;
System.out.print(k+" ");
}
do {
k++;
k=k%n1;
}while (a[k]!=1);
}
System.out.println("\n猴王编号为："+k);
}
}
根据问题描述可知，该问题中n只猴子围坐在一起形成首尾相接的环，因此可用循环链表解决。从第k只猴子开始出列相当于从链表中删除一个结点。该程序主要有三个模块组成，建立单链表，报数，利用do-while循环实现猴子的出列，最终剩下的猴子即猴王。具体步骤如下：
- 首先创建循环链表。向单链表中填入猴子的编号。
- 找第一个开始报数的猴子。
- 数到n让这个猴子出列。
- 接着开始报数，重复第三步。
然后在使用for循环将出局的猴子依次找出，就可以确定猴王是谁了。