Java学习笔记---抽象类和接口

14.2 抽象类

一个父类设计的非常抽象,以至于它都没有任何具体的实例.这样的类称为抽象类.

抽象类和常规类很像,但是不能用new操作符创建它的实例.抽象方法只有定义而没有实现.它的实现由子类提供.

一个包含抽象方法的类必须申明为抽象类,还有一点值得注意的是抽象方法必须为非静态方法

在UML图形中,抽象方法和抽象类用斜体表示

public abstract class GeometricObject { //用 abstract 修饰抽象类
    private String color = "white";
    private boolean filled; // 默认为false
    private java.util.Date dateCreated;

    protected GeometricObject() //因为为抽象类,所以将构造方法定义为私有方法,可以避免实例化
    {
        dateCreated = new java.util.Date();
    }

    protected GeometricObject(String color,boolean filled)
    {
        this.color = color;
        this.filled = filled;
    }

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

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

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

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

    public String toString()
    {
        return "created on" + this.dateCreated + "\ncolor:" + this.color + "and filled:" + this.filled;
    }
    public abstract double getArea();
    public abstract double getPerimeter();
}

虽然不能用new操作符从一个抽象类创建一个实例,但是抽象类可以作为一种数据类型.所以下面这条语句是正确的:

GeometricObject[] objects = new GeometricObject[10]; GeometricObject unit_object;

然后创建该类的非抽象子类的实例,例如:

unit_object = new Circle();
objects[0] = new Circle();

14.3 举例:日历类Calendar和公历类GregorianClalendar

import java.util.Calendar; //抽象类
import java.util.GregorianCalendar; //Galendar的子类
import java.util.Date;
public class TestCalendar {
    public static void main(String[] args)
    {
        Calendar calendar = new GregorianCalendar();
        System.out.println("现在时间是: " + new Date());
        System.out.println("年: " + calendar.get(Calendar.YEAR));
        System.out.println("月: " + calendar.get(Calendar.MONTH)); //月的参数是基于0开始的,也就是说 0 表示一月
        System.out.println("日: " + calendar.get(Calendar.DATE));
        System.out.println("时: " + calendar.get(Calendar.HOUR));
        System.out.println("分: " + calendar.get(Calendar.MINUTE));
        System.out.println("秒: " + calendar.get(Calendar.SECOND));
        System.out.println("DAY_OF_WEEK " + calendar.get(Calendar.DAY_OF_WEEK));
        System.out.println("DAY_OF_MONTH " + calendar.get(Calendar.DAY_OF_MONTH));
        System.out.println("HOUR_OF_DAY " + calendar.get(Calendar.HOUR_OF_DAY));

    }
}

14.4 接口

接口和抽象类的区别

1、 抽象层次不同。抽象类是对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。

2、 跨域不同。抽象类所跨域的是具有相似特点的类，而接口却可以跨域不同的类。我们知道抽象类是从子类中发现公共部分，然后泛化成抽象类，子类继承该父类即可，但是接口不同。实现它的子类可以不存在任何关系，共同之处。例如猫、狗可以抽象成一个动物类抽象类，具备叫的方法。鸟、飞机可以实现飞Fly接口，具备飞的行为，这里我们总不能将鸟、飞机共用一个父类吧！所以说抽象类所体现的是一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在”is-a” 关系，即父类和派生类在概念本质上应该是相同的。对于接口则不然，并不要求接口的实现者和接口定义在概念本质上是一致的， 仅仅是实现了接口定义的契约而已。

3、 设计层次不同。对于抽象类而言，它是自下而上来设计的，我们要先知道子类才能抽象出父类，而接口则不同，它根本就不需要知道子类的存在，只需要定义一个规则即可，至于什么子类、什么时候怎么实现它一概不知。比如我们只有一个猫类在这里，如果你这是就抽象成一个动物类，是不是设计有点儿过度？我们起码要有两个动物类，猫、狗在这里，我们在抽象他们的共同点形成动物抽象类吧！所以说抽象类往往都是通过重构而来的！但是接口就不同，比如说飞，我们根本就不知道会有什么东西来实现这个飞接口，怎么实现也不得而知，我们要做的就是事前定义好飞的行为接口。所以说抽象类是自底向上抽象而来的，接口是自顶向下设计出来的。

public class TestInterface {
    public static void main(String[] args)
    {
        Object[] objects = {new AngryBird(),new Car(),new Plane()};
        for(int i=0;i<objects.length;i++)
        {
            if (objects[i] instanceof Fly)
                System.out.println(((Fly)objects[i]).howToFly());
        }
    }

}

interface Fly //接口 {
    String howToFly();
    /* * 接口的方法必须是公共的抽象实例方法,所以上面的方法等于于下: * public abstract String howToFly(); * * 所有的变量必须是: public static final * 同样也可以简写成 int a = 1; */
}

abstract class Bird{ //抽象类
    abstract String getName();//抽象方法
}

class AngryBird extends Bird implements Fly {
    public String howToFly()
    {
        return "Use Flags";
    }

    String getName()
    {
        return "The bird's name is angry bird.";
    }
}

abstract class Traffic {
    abstract String getName();
}

class Car extends Traffic {
    public String getName()
    {
        return "The traffic's name is car";
    }
}

class Plane extends Traffic implements Fly {
    public String getName()
    {
        return "The traffic's name is plane";
    }

    public String howToFly()
    {
        return "Use the electric power";
    }
}

14.6 举例:ActionListener接口

import javax.swing.*;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.*;
public class HandleEvent extends JFrame{
    public HandleEvent()
    {
        JButton jbtOK = new JButton("OK");
        JButton jbtCancel = new JButton("Cancel");
        this.setLayout(new GridLayout(1,2));
        this.add(jbtOK);
        this.add(jbtCancel);
        OKListener listener1 = new OKListener();
        CancelListener listener2 = new CancelListener();
        jbtOK.addActionListener(listener1);
        jbtCancel.addActionListener(listener2);

    }

    public static void main(String[] args)
    {
        JFrame frame = new HandleEvent();
        frame.setSize(400, 200);
        frame.setTitle("HandleEvent");
        frame.setLocationRelativeTo(null);
        frame.setDefaultCloseOperation(EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

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

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