抽象类（一）：
为何会出现抽象类这种类？
1、某些情况下，父类只知道子类需要哪些方法，但是不知道子类如何实现这些方法，或者每个子类对同一方法的实现都不同
2、所以允许父类定义方法时，只定义方法，但是不具体实现，定义的这种方法称为抽象方法，包含这种抽象方法的类，就被称为抽象类
3、抽象方法：只有方法签名，没有方法实现的方法，抽象方法用 abstract 修饰 ，如：
public abstract double getHeight();
4、上面的代码定义了一个 抽象方法：getHeight();只有方法签名，没有后面的方法体。
因此总结出抽象方法和抽象类的一些规则如下：
1、抽象类和抽象方法必须用 abstract 修饰符来修饰
2、抽象方法不能有方法体
3、抽象类不能被实例化，无法使用 new 关键字来调用抽象类的构造器来实现实例对象，即使抽象类里不包含抽象方法，这个类也不能被实例化
4、抽象类可以包含成员变量、方法（普通方法、抽象方法都可以）、构造器，初始化块，内部类（接口、枚举）5种成分
5、抽象类的构造器不能用于创建实例，只能用于被其子类调用
6、包含抽象方法的类，只能被定义为抽象类
7、抽象类里可以没有抽象方法
8、类包含抽象方法是指：
.8.1、直接定义了一个抽象方法
.8.2、继承了一个抽象父类，但没有完全实现父类的抽象方法
.8.3、实现了一个接口，但没有完全实现接口包含的抽象方法
9、归纳起来，抽象类可以用 “有得有失” 四个字来形容：
有得：抽象类多了一个能力，能包含抽象方法
有失：抽象类失去了一个能力，不能用于创建实例
10、使用 abstract 修饰的类必须被继承，使用 abstract 修饰的方法必须被重写
使用 final 修饰的类不能被继承，使用 final 修饰的方法不能被重写
所以 abstract 和 final 永远不能一起用
如下代码定义了一个抽象类，并被不同的子类继承实现：
import static java.lang.System.*;
//-定义一个抽象类，作为父类
abstract class Shape{
{
out.println("执行Shape类的普通初始化块！");
}
private String color;
//-定义两个抽象方法，让子类去重写实现
public abstract double getPerimeter();
public abstract String getType();
public Shape(){
}
public Shape(String color){
out.println("执行带参数的Shape类构造器！");
this.color=color;
}
public String getColor(){
return this.color;
}
public void setColor(String color){
this.color=color;
}
}
//-子类 继承抽象父类
class Triangle extends Shape{
private double a;
private double b;
private double c;
public Triangle(String color,double a,double b,double c){
//-super关键字 调用父类构造器
super(color);
setSides(a,b,c);
}
public void setSides(double a,double b,double c){
if(a>=b+c||b>=a+c||c>=a+b){
out.println("三角形的两边之和必须大于第三边！");
return;
}
this.a=a;
this.b=b;
this.c=c;
}
//-重写实现父类 getPerimeter() 方法
public double getPerimeter(){
return a+b+c;
}
//-重写实现父类 getType() 方法
public String getType(){
return "三角形";
}
}
//-子类 继承抽象父类
public class Circle extends Shape{
private double radius;
public Circle(String color,double radius){
//-super关键字 调用父类构造器
super(color);
this.radius=radius;
}
//-重写实现父类 getPerimeter() 方法
public double getPerimeter(){
return 2*Math.PI*radius;
}
//-重写实现父类 getType() 方法
public String getType(){
return "圆形";
}
public void setRadius(double radius){
this.radius=radius;
}
public double getRadius(){
return this.radius;
}
public static void main(String[] args){
//-分别调用两个子类中重写的 方法:
Shape s1=new Triangle("红色",3,4,5);
out.println("周长是："+s1.getPerimeter());
out.println("图形是："+s1.getType());
out.println();
Shape s2=new Circle("蓝色",5);
out.println("周长是："+s2.getPerimeter());
out.println("图形是："+s2.getType());
out.println();
//-改变一下写法：
Triangle s3=new Triangle("红色",3,4,5);
out.println("周长是："+s3.getPerimeter());
out.println("图形是："+s3.getType());
out.println();
Circle s4=new Circle("蓝色",5);
out.println("周长是："+s4.getPerimeter());
out.println("图形是："+s4.getType());
}
}
运行结果：
如上代码看到：利用抽象类和抽象方法，可以更好的发挥多态的优势，使程序可以更灵活，但是不用抽象类抽象方法，结果是一样的。
注：
1、abstract 不能修饰成员变量，不能修饰局部变量，即：没有抽象成员变量、抽象局部变量的说法
2、abstract 不能修饰构造器，也没有抽象构造器的说法，抽象类里定义的构造器只能是普通构造器
3、当使用 static 修饰方法时，表示这个方法属于类本身，即通过类就能调用该方法，但如果该方法被定义为抽象方法，当用该类来调用该方法时，就会出现错误，即调用了一个没有方法体的方法，因此： static 和 abstract 不能同时修饰一个方法，即没有所谓的类抽象方法
4、static 和 abstract 并不是绝对互斥的，他们可以同时修饰内部类
5、abstract 修饰的方法只有被子类重写才有意义，因此 abstract 方法不能定义为 private 访问权限，即：abstract 和 private 不能同时修饰方法
