抽象类和接口

一、抽象类

抽象类（abstract class）：不能实例化的类，使用关键字abstract修饰，含有抽象方法（abstract method）。

抽象方法（abstract method）：在方法头中使用关键字abstract修饰，只有函数的声明定义，没有函数体的方法。

　　　　 包含抽象方法的类必须是抽象类，抽象类可以不包含抽象方法。

之前有写过一个几何、圆、矩形的类，现在改写几何类为抽象类，包括求面积、求周长这两个抽象方法：

package demo;

import java.util.Date;

/**
 * 定义一个几何抽象类
 * Created by luts on 2015/11/29.
 */
public abstract class GeometricObject {
    private String name = null; //几何形状名字
    private String color = "white";
    private boolean filled = false;
    private java.util.Date dateCreated;

    //无参构造器
    protected GeometricObject(){
        dateCreated = new java.util.Date();
    }

    //含参构造器
    protected GeometricObject(String name, String color, boolean filled){
        this.name = name;
        this.color = color;
        this.filled = filled;
        dateCreated = new java.util.Date();
    }


    public String getName() {
        return name;
    }

    public void setName(String name){
        this.name = name;
    }

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

    public boolean isFilled() {
        return filled;
    }

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

    public Date getDateCreated() {
        return dateCreated;
    }

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

    public abstract double getArea();  //求面积的抽象函数，在子类中实现

    public abstract double getPerimeter(); //求周长的抽象函数，在子类中实现
}

package demo;

/**
 * 圆类，继承于几何类
 * Created by luts on 2015/11/29.
 */

public class Circle extends GeometricObject {
    private double radius;

    public Circle(){

    }

    public Circle(String name, double newRadius){
        this.setName(name);
        this.radius = newRadius;
    }

    public Circle(double newRadius, String newColor, boolean newFilled){
        this.radius = newRadius;
        setColor(newColor);
        setFilled(newFilled);
    }

    public double getRadius(){
        return radius;
    }

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

    public double getDiameter(){
        return 2 * radius;
    }

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

    public void printCircle(){
        System.out.println("The circle is creadted " + getDateCreated() + " and the raius is " + radius);
    }
}

package demo;

/**
 * 矩形类，继承于几何类
 * Created by luts on 2015/11/29.
 */

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

    public Rectangle(){

    }

    public Rectangle(String name, double newWidth, double newHeight){
        this.setName(name);
        this.width = newWidth;
        this.height = newHeight;
    }

    public  Rectangle(double newWidth, double newHeight, String newColor, boolean newFilled){
        this.width = newWidth;
        this.height = newHeight;
        setColor(newColor);
        setFilled(newFilled);
    }

    public double getWidth(){
        return width;
    }

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

    public double getHeight(){
        return height;
    }

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

    public double getArea(){
        return width * height;
    }

    public double getPerimeter(){
        return 2 * (width + height);
    }
}

package demo;

/**
 * Created by luts on 2015/11/29.
 */

public class TestGeometericObject {
    public static void main(String[] args){
        GeometricObject geoObject1 = new Circle("Circle",5); //多态 父类类型指向子类实例的引用
        GeometricObject geoObject2 = new Rectangle("Rectangle", 5, 3);

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

        displayGeometricObject(geoObject1);

        displayGeometricObject(geoObject2);
    }


    public static boolean equalsArea(GeometricObject obj1, GeometricObject obj2){
        return obj1.getArea() == obj2.getArea();
    }

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

输出：

The two objects have the same area ?false

The new Circle's area is: 78.53981633974483
The new Circle'perimeter is: 31.41592653589793

The new Rectangle's area is: 15.0
The new Rectangle'perimeter is: 16.0

　　  上述例子中，如果GeometricObject 类中没有定义getArea()方法，就不能在程序中定义equalsArea方法来计算这两个几何对象的面积是否相等。JVM根据运行时的实际对象动态地调用getArea方法（多态）。

　　  · 抽象类与常规类很相似，但是不能使用new操作符创建其实例对象，可以声明引用变量。

　　· 抽象方法只有定义没有实现，子类提供具体的实现方式。一个包含抽象方法的类必须声明为抽象类。

　　· 抽象类的构造方法定义为protected，因为只能被子类使用。创建一个具体的子类的时候，其父类的构造方法被调用，以初始化父类中定义的数据域。

一些值得注意的：

　　· 抽象方法不能包含在非抽象类中。如果抽象父类的子类不能实现所以的抽象方法，那么子类也应该声明为抽象类。也就是说在抽象类扩展的子类中，必须实现所有的抽象方法。抽象方法是非静态的。

　　· 抽象类不能使用new操作符来初始化。但是仍然可以定义其构造方法，这个构造方法在子类中被调用。

　　· 即使父类是具体的，这个子类也可以是抽象。例如Object是具体的，但是它的子类如上例中的GeometricObject可以是抽象的。

　　· 子类可以覆盖父类的方法并将其定义为abstract。也就是当父类的方法在子类的方法实现是没有意义的时候，可以将其覆盖声明为抽象方法，这时子类必须定义为abstract。

　　· 不能使用new操作符从一个抽象类创建一个实例，但是抽象类可以作为一种数据类型。

二、接口（interface）

　　接口（interface）是一种与类相似的结构，只包含常量和抽象方法，目的是指明多个对象的共同行为。（比如，通过使用正确的接口，可以指明这些对象是可比较的，可食用的或可克隆的）。

　　

　　接口的语法结构：

修饰符  interface 接口名{
        //常量名
        //方法签名
    }
    
 
   
 public interfaceEdibleInterface{ 
　　public abstract String howToEat();
}

　　· 接口被看成是一种特殊的类，与抽象类类似，不能使用new操作符创建接口实例，可以使用接口作为变量的数据类型或类型转换的结果等。

 例子：使用接口EdibleInterface来明确一个对象是否可食用。需要使用implements关键字让对象的类实现这个接口。类和接口之间的关系成为接口继承（interface inheritance）。

package demo;

/**
 * Created by luts on 2015/11/30.
 */
public abstract interface EdibleInterface {
    //Describe hoe to eat
    public abstract String howToEat();
}

package demo;

import java.util.Objects;

/**
 * Created by luts on 2015/11/30.
 */
public class TestEdible {
    public static void main(String[] args){
        Object[] objects = {new Tiger(), new Chicken(), new Apple()};
        for (int i = 0; i < objects.length; i++){
            if (objects[i] instanceof EdibleInterface)
                System.out.println(((EdibleInterface) objects[i]).howToEat());
        }
    }
}

class Animal{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class Chicken extends Animal implements EdibleInterface{
    public String howToEat(){
        return "Chiken: Fry it";
    }
}

class Tiger extends Animal {

}

abstract class Firut implements EdibleInterface{

}

class Apple extends Firut{
    @Override
    public String howToEat() {
        return "Apple: Make apple cider";
    }
}

　 　· 当一个类实现接口的时候，该类实现了定义在接口中的所有带确切签名和返回值类型的方法。如果继承接口的类不实现抽象方法，那么必须声明为抽象类，如abstract Fruit类。

　　· 接口中所有的数据域都是public final static。所有的方法都是public abstract，java允许忽略这些修饰符。

　　· 接口内定义的常量可以使用语法“接口名.常量名”来访问。

ActionListener接口例子：

package demo;

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

/**
 * Created by luts on 2015/11/30.
 */
public class HandleEvent extends JFrame{
    public HandleEvent(){
        //创建两个按钮
        JButton jbtOK = new JButton("OK");
        JButton jbtCancel = new JButton("Cancel");

        JPanel panel = new JPanel();
        panel.add(jbtOK);
        panel.add(jbtCancel);

        add(panel);

        OKListenerClass listener1 = new OKListenerClass();
        CancelListenrClass listener2 = new CancelListenrClass();
        jbtOK.addActionListener(listener1);
        jbtCancel.addActionListener(listener2);

    }

    public static void main(String [] args){
        JFrame frame = new HandleEvent();
        frame.setTitle("Handle Event");
        frame.setSize(200, 150);
        frame.setLocation(200, 100);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

class OKListenerClass implements ActionListener{
    public void actionPerformed(ActionEvent e){
        System.out.println("OK button clicked");
    }
}

class CancelListenrClass implements ActionListener{
    public void actionPerformed(ActionEvent e){
        System.out.println("Cancel button clicked");
    }
}

输出：

Cancel button clicked
Cancel button clicked
OK button clicked
Cancel button clicked
OK button clicked
OK button clicked

三、接口和抽象类

	变量	构造方法	方法
抽象类	无限制	子类通过构造方法链调用构造方法，抽象类不能使用new操作符实例化	无限制（可为抽象方法或非抽象方法），一般都含有抽象方法
接口	所有变量必须是 public static final	没有构造方法，接口不能用new操作符实例化	所有方法必须是公共的抽象实例方法

　　　· java只允许为类的扩展做单一的继承，但是允许使用接口做多重扩展。

public class NewClass extends BaseClass implements Interface1, ..., InterfaceN{
   ....
}

　　· 利用关键字extends，接口可以继承其他接口。这样的接口称为子接口（subinterface）。

public interface NewInterface extends Interface1, ..., InterfaceN{
  .....
}

　　一个类实现上述的NewInterface必须实现Interface1, ..., InterfaceN中定义的所有抽象方法。接口可以扩展其他接口，但不能扩展类，一个类可以扩展它的父类同时实现多个接口。

　　· 所有类共享同一个根类Object，但是接口没有共同的根。

　　· 与类类似，接口也可以定义一种类型。一个接口类型的变量可以引用任何实现该接口的类的实例。也就是，一个类如果实现了一个接口，那么这个接口就类似于该类的一个父类。

接口和抽象类都是用来确定多个对象的共同特征的。那么什么时候使用接口，什么时候使用抽象类呢？

　　一般来说，详细描述父子关系的强是关系（strong is-a relationship）应该用类建模。弱是关系（weak is-a relationship）也称为类属关系（is-kind-relationship），它表明对象拥有某种属性。弱是关系可以用接口来建模。