JAVA程序设计--抽象类和接口（一）

为什么要使用抽象类？

所谓的抽象，就是这个东西会改变~~~根据面向对象的思想，要封装好变化的部分

这里引入一个抽象类的规矩，抽象类包含抽象方法，而这些方法则在具体的子类中实现。

也就是说，抽象类里定义抽象方法是为了方便子类去实现多个子类里的”本质上相同，具体操作不同”的方法。

抽象类和常规类很像，但不能使用new操作符创建实例。

抽象类只有定义，没有实现！实现由子类提供。

综上，体现了抽象类的作用之一：模板模式的设计！

把一些父类写成抽象类，别人看到你的代码，或你看到别人的代码，你就会注意抽象方法（关键字abstract），而知道这个方法是在子类中实现的，所以，也 有个提示作用。

别人的理解：

抽象类的作用之一：java中抽象类更利于代码的维护和重用。

1.因为抽象类不能实例化对象，所以必须要有子类来实现它之后才能使用。这样就可以把一些具有相同属性和方法的组件进行抽象，这样更有利于代码和程序的维护。
比如本科和研究生可以抽象成学生，他们有相同的属性和方法。这样当你 对其中某个类进行修改时 会受到父类的限制，这样就会提醒开发人员有些东西不能进行随意修改，这样可以对比较重要的东西进行统一的限制，也算是一种保护，对维护会有很大的帮助。
2.当又有一个具有相似的组件产生时，只需要实现该抽象类就可以获得该抽象类的那些属性和方法。
比如学校又新产生了专科生这类学生，那么专科生直接继承学生，然后对自己特有的属性和方法进行补充即可。这样对于代码的重用也是很好的体现。

所以，Java中抽象类对于代码的维护和重用有很好的帮助，也是Java面向对象的一个重要体现。

抽象方法：实现取决于具体类型，方法头加上abstract修饰符。UML图中，抽象类和抽象方法的名字使用斜体表示。

贴个代码，更好理解上面的解释：

package chapter13;
//父类
public abstract class GeometricObject {
  private String color = "white";
  private boolean filled;
  private java.util.Date dateCreated;

  /** Construct a default geometric object */
  protected GeometricObject() {
    dateCreated = new java.util.Date();
  }

  /** Construct a geometric object with color and filled value */
  protected GeometricObject(String color, boolean filled) {
    dateCreated = new java.util.Date();
    this.color = color;
    this.filled = filled;
  }

  /** Return color */
  public String getColor() {
    return color;
  }

  /** Set a new color */
  public void setColor(String color) {
    this.color = color;
  }

  /** Return filled. Since filled is boolean,
   *  the get method is named isFilled */
  public boolean isFilled() {
    return filled;
  }

  /** Set a new filled */
  public void setFilled(boolean filled) {
    this.filled = filled;
  }

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

  /** Return a string representation of this object */
  public String toString() {
    return "created on " + dateCreated + "\ncolor: " + color +
      " and filled: " + filled;
  }

  /** Abstract method getArea */
  public abstract double getArea();

  /** Abstract method getPerimeter */
  public abstract double getPerimeter();
}

package chapter13;
//测试类
public class TestGeometricObject {
  /** Main method */
  public static void main(String[] args) {
    // Declare and initialize two geometric objects
    GeometricObject geoObject1 = new Circle(5);
    GeometricObject geoObject2 = new Rectangle(5, 3);

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

    // Display circle
    displayGeometricObject(geoObject1);

    // Display rectangle
    displayGeometricObject(geoObject2);
  }

  /** A method for comparing the areas of two geometric objects */
  public static boolean equalArea(GeometricObject object1,
      GeometricObject object2) {
    return object1.getArea() == object2.getArea();
  }

  /** A method for displaying a geometric object */
  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());
  }
}

所以，其实比较面积的方法equalArea()的参数是geoObject1和geoObject2，结果是return 各自参数调用的getArea()方法。

如果在这两个父类里，定义了抽象方法getArea()，让各自类去重写，不就方便子类的运算了呢（因为子类们都要用到这个方法）？两个子类就不用再重新创建一个新方法了，也相当于告诉子类们这是你们需要完成的方法（具体操作不同，本质一样）。

这就是所谓代码的重用。

UML图贴上！