java中的抽象类

当编写一个类时，常常会为该类定义一些方法，这些方法用以描述该类的行为方式，那么这些方法都有具体的方法体。但在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确地知道这些子类如何实现这些方法。
1.抽象方法和抽象类
抽象方法和抽象类的规则如下:
1.抽象类必须使用abstract修饰符来修饰，抽象方法也必须使用abstract修饰符来修饰，抽象方法不能有方法体。
2.抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器创建抽象类的实例。即使抽象类里不包含抽象方法，这个抽象类也不能创建实例。
3.抽象类可以包含成员变量、方法(普通方法和抽象方法都可以)、构造器、初始化块、内部类(接口、枚举)5种成分。抽象类的构造器不能用于创建实例，主要是用于被其子类调用。
4.含有抽象方法的类(包括直接定义了一个抽象方法；或继承了一个抽象父类，但没有完全实现父类包含的抽象方法；或实现了一个接口，但没有完全实现接口包含的抽象方法三种情况)只能被定义成抽象类。
注意1 抽象类可用“有得有失”4个字来描述。“得”指的是抽象类多了一个能力：抽象类可以包含抽象方法；“失”指的是抽象类失去了一个能力：抽象类不能用于创建实例。
注意2 抽象方法和空方法体的方法不是同一个概念。例如，public abstract void test()；是一个抽象方法，它根本没有方法体，即方法定义后面没有一对花括号；但public void test(){}方法是一个普通方法，它已经定义了方法体，只是方法体为空，即它的方法体什么也不做，因此这个方法不可以使用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方法
    ...
}

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

下面定义一个三角形类，三角形类被定义成普通类，因此必须实现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());
    }   

}

上面main()方法中定义了两个Shape类型的引用变量，它们分别指向Triangle对象和Circle对象。
由于在Shape类中定义了calPerimeter()方法和getType()方法，所以程序可以直接调用s1变量和
s2变量的calPerimeter()方法和getType()方法，无须强制类型转换为其子类类型。

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

注意５　当static修饰一个方法时，表明这个方法属于该类本身，即通过类就可以调用该方法，但如果该方法被定义成抽象方法，则将导致通过该类来调用该方法时出现错误(调用了一个没有方法体的方法肯定会引起错误)。因此static和abstract不能同时修饰某个方法，即没有所谓的类抽象方法。
static和abstract并不是绝对互斥的，static和abstract虽然不能同时修饰某个方法，但它们可以同时修饰内部类。

注意６　abstract关键字修饰的方法必须被其子类重写才有意义，否则这个方法将永远不会有方法体，因此abstract方法不能定义为private访问权限，即private和abstract不能同时修饰方法。

２.抽象类的作用
说一些规则：
１.抽象父类可以只定义需要使用的某些方法，把不能实现的部分抽象成抽象方法，留给其子类去实现。
２.父类中可能包含需要调用其它系列方法的方法，这些被调方法既可以由父类实现，也可以由其子类实现。父类里提供的方法只是定义了一个通用算法，其实现也许并不完全由自身实现，而必须依赖于其子类的辅助。