抽象类与抽象方法

抽象类与抽象方法必须使用abstract定义；
有抽象方法的类只能被定义成抽象类，抽象类里面可以没有抽象方法；
抽象方法没有方法体；
抽象类不能被实例化（即使抽象类中没有抽象方法也不能被实例化），因为无法使用new关键字调用抽象类中的构造器方法来创建抽象类的实例；
抽象类不能用于创建实例，只能当作父类被子类继承；
含有抽象方法的类（直接定义一个抽象方法、继承一个抽象父类，但未完全实现抽象父类包含的抽象方法、实现一个接口，但没有完全实现接口包含的抽象方法）必须定义成抽象类；
抽象方法没有方法体，只需在定义方法前加abstract修饰，在方法后面加逗号；
抽象方法（没有方法体即方法定义后面没有一对花括号；）：public abstract void Test();
空方法体：public void Test(){}
eg:

public abstract class Shape{
	{
		System.out.println("初始化块");
	}
	//定义抽象方法
	public abstract double calPerimeter();
	//定义构造器，用于被子类调用
	public Shape(){}
	public Shape(String color){
		System.out.println("构造器");
	}
}

eg1:

public class Circle extendes Shape{
	private double radius;
	public Circle(String color,double radius){
		super(color);
		this.radius = radius;
	}
	//重写calPerimeter抽象方法
	public double calPerimeter(){
		return 2*Math.PI*radius;
	}
	//重写getType抽象方法
	public String getType(){
		return getColor();
	}
	public static void main(String[] args){
		Shape s1 = new Circle("黄色",3);
		System.out.println(s1.getType());
		System.out.println(s1.calPerimeter());
	}
}

抽象方法必须由子类重写，final修饰的类不能被继承，final修饰的方法不能被重写，所以final与abstract不能同时使用。
当static修饰方法时可以用类调用，但是由abstract修饰时该方法为抽象方法没有方法体，所以调用时出现错误。
abstract关键字修饰的方法只有当子类重写时才有意义；
抽象类作用：
抽象类是由多个具有相同特征的类中抽象出来的一个抽象类，作为其子类的模板；
eg2:在此范例中，父类的普通方法依赖于一个抽象方法，抽象方法推迟到子类中实现

public abstract class SpeedMeter{
	private double turnRate;
	public SpeedMeter(){}
	//定义抽象方法
	public abstract double calGirth();
	public void setTurnable(bouble turnRate){
		this.turnRate = turnRate;
	}
	public void getSpeed(){
		return calGirth()*turnRate; //普通方法结果需要calGirth()抽象方法实现
	}
}

通过子类实现其抽象方法的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){
		CarSpeedMeter cs = new CarSpeedMeter(0.34);
		cs.setTurnable();
		System.out.println(cs.getSpeed());
	}
}

注：抽象父类可以指定需要使用的方法，将不能实现的部分抽象成抽象方法，交给子类去实现，父类中提供的方法只定义一个通用算法，实现可以由自身完成，也可以部分由自身完成，其余依赖子类完成。

以上内容整理自李刚老师的《疯狂Java讲义》