面向对象之经典讲解(抽象类)

public **abstract** class GeometricObject {    
    private String color="white";
    private boolean filled;
    private java.util.Date dateCreated;

    **protected** GeometricObject()
    {       
    }

    **protected** GeometricObject(String color,boolean filled)
    {
        dateCreated=new java.util.Date();
        this.color=color;
        this.filled=filled;
    }

    public String color()
    {
        return this.color;
    }

    public void setColor(String color)
    {
        this.color=color;
    }

    public boolean isFilled()
    {
        return this.filled;
    }

    public void setFilled(boolean filled)
    {
        this.filled=filled;
    }

   public java.util.Date getDateCreated()
   {
       return dateCreated;
   }

   public String toString()
   {
       return "created on "+dateCreated+"\ncolor: "+color+
               " and filled: "+filled;
   }

   **public abstract double getArea();**

   **public abstract double getPerimeter();**
}

抽象类不能用new操作符创建它的实例。抽象方法只有定义而没有实现，它的实现由子类提供。一个包含抽象方法的类必须声明为抽象类。

抽象类的构造方法定义为protected，因为它只能被子类使用。

public class Circle extends GeometricObject{
    private double radius;

    public Circle()
    {
    }

    public Circle(double radius)
    {
        this.radius=radius;
    }

    public Circle(double radius,String color,boolean filled)
    {
        super(color, filled);
        this.radius=radius;
    }

    public double getRadius()
    {
        return this.radius;
    }

    public void setRadius(double radius)
    {
        this.radius=radius;
    }

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

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


}

public class Rectangle extends  GeometricObject{
    private double width;
    private double height;

    public Rectangle()
    {
    }

    public Rectangle(double width,double height)
    {
        this.width=width;
        this.height=height;
    }

    public Rectangle(double width,double height,String color,boolean filled)
    {
        super(color, filled);
        this.width=width;
        this.height=height;
    }

    public double getWidth()
    {
        return this.width;
    }

    public void setWidth(double width)
    {
        this.width=width;
    }


    public double getHeight()
    {
        return this.height;
    }

    public void setHeight(double height)
    {
        this.height=height;
    }

    @Override
    public double getArea()
    {
        return this.width*this.height;
    }

    @Override
    public double getPerimeter()
    {
        return 2*(this.width+this.height);
    }

}

public class TestGeometricObject {
    public static void main(String[] args) {
        GeometricObject geoObject1=new Circle(5);
        GeometricObject geoObject2=new Rectangle(5,3);

        System.out.println("The two objects have the same area? "+
                equalArea(geoObject1, geoObject2));

        displayGeometricObject(geoObject1);
        displayGeometricObject(geoObject2);
   }

    public static boolean equalArea(GeometricObject object1,
            GeometricObject object2)
    {
        return object1.getArea()==object2.getArea();
    }

    public static void displayGeometricObject(GeometricObject object)
    {
        System.out.println("");
        System.out.println("The area is "+object.getArea());
        System.out.println("The perimeter is "+object.getPerimeter());
    }

}

【运行结果】:
The two objects have the same area? false

The area is 78.53981633974483
The perimeter is 31.41592653589793

The area is 15.0
The perimeter is 16.0

抽象类的几点说明：
(1)抽象方法不能包含在非抽象类中。 如果抽象父类的子类不能实现所有的抽象方法，那么子类也必须定义为抽象的。换句话说，在抽象类扩展的非抽象子类中，必须实现所有的抽象方法。还要注意到，抽象方法是非静态的。
(2)抽象类是不能用new操作符来初始化的。但是，仍然可以定义它的构造方法，这个构造方法在它的子类的构造方法中调用。例如，GeometriObject类的构造方法在Circle类和Rectangle类中调用。
(3)包含抽象方法的类必须是抽象的。 但是，可以定义一个不包含抽象方法的抽象类。在这种情况下，不能使用new操作符创建该类的实例。这种类是用来定义新子类的基类的。
(4)子类可以覆盖父类的方法并将它定义为abstract。这是很少见的，但是它在当父类的方法实现在子类中变得无效时是很有用的。在这种情况下，子类必须定义为abstract。
(5)即使子类的父类是具体的，这个子类也可以是抽象的。例如Object类是具体的，但是它的子类如GeometricObject可以是抽象的。
(6)不能使用new操作符从一个抽象类创建一个实例。