抽象类和抽象方法

抽象方法和抽象类必须使用abstract修饰符来定义，有抽象方法的类只能被定义成抽象类，抽象类里可以没有抽象方法。

抽象方法和抽象类的规则如下:
1、抽象类，抽象方法必须使用修饰符abstract修饰，抽象方法不能有方法体。
2、抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器创建抽象类实例。
3、抽象类可以包含Feild，方法（普通方法和抽象方法都可以），构造器，初始化块，内部类，枚举类6种成分。抽象类的构造器不能用于创建实例，主要是用于被其子类调用。
4、含有抽象方法的类只能被定义为抽象类。

public abstract class Shape {
    {
        System.out.println("执行Shape的初始化块！");
    }
    private String color;
    public abstract double calPerimeter();
    public abstract String getType();
    public Shape(){}
    public Shape(String color){
        System.out.println("执行Shape的构造器....");
        this.color = color;
    }
}

抽象类不能用于创建实例，只能当作父类被其他子类继承。

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;
	}

	@Override
	public double calPerimeter() {
		return a + b + c;
	}

	@Override
	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 setRaius(double radius) {
		this.radius = radius;
	}

	@Override
	public double calPerimeter() {
		return 2 * Math.PI * radius;
	}

	@Override
	public String getType() {
		return "圆形";
	}
	
	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());
	}
}

console:

执行Shape的初始化块！
执行Shape的构造器....
执行Shape的初始化块！
执行Shape的构造器....
三角形
12.0
圆形
18.84955592153876

当使用abstract修饰符时，表明这个类只能被继承；当使用abstract修饰方法时，表明这个方法必须由子类提供实现（即重写）。
而final修饰的类不能被继承，final修饰的方法不能被重写。因此final和abstract永远不能同时使用。

static和abstract不能同时修饰某个方法。

抽象父类可以只定义需要使用的某些方法把不能实现的部分抽象成抽象方法，留给其子类去实现。

父类中可能包含需要调用的其他系列方法的方法，这些被调方法即可以由父类实现，也可以由子类实现。父类里提供的方法之是定义一个通用的算法，其实现也许并不完全由自身实现。而必须依赖于其子类的辅助。