Java 抽象类与接口

 抽象类（abstract 类）

1. 非抽象类不能包含抽象方法，包含抽象方法的类必须是抽象的

2. 在一个抽象类扩展出来的非抽象类中，所有的抽象方法必须实现

3. 允许声明没有抽象方法的抽象类

public class InstrumentTest {
    public static void main(String[] args){
        Instrument[] orchestra ={
                new Wind(),
                new Percussion(),
                new Stringed(),
                new Brass(),
                new WoodWind()
        };
        tuneAll(orchestra);
    }

    public static void tune(Instrument i) {
        i.play("Savage gradon");
    }

    public static void tuneAll(Instrument[] e) {
        for(Instrument i: e) {
            tune(i);
        }
    }
}

abstract class Instrument{
    abstract void play(String s);
    abstract void adjust();
    abstract String what();
}

class Wind extends Instrument{
    public void play(String x){
        System.out.println("WindSavage gradon");
    }
    public void adjust(){}
    public String what(){
       return null;
    }
}

class Percussion extends Instrument{
    public void play(String x){
        System.out.println("PercussionSavage gradon");
    }
    public void adjust(){}
    public String what(){
        return null;
    }
}

class Stringed extends Instrument{
    public void play(String x){
        System.out.println("StringledSavage gradon");
    }
    public void adjust(){}
    public String what(){
        return null;
    }
}

class WoodWind extends Wind{
    public void play(String x){
        System.out.println("WoodWindSavage gradon");
    }
}

class Brass extends Wind{
    public void play(String x){
        System.out.println("BrassSavage gradon");
    }
}

// 运行结果
/*
WindSavage gradon
PercussionSavage gradon
StringledSavage gradon
BrassSavage gradon
WoodWindSavage gradon
 */

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

        System.out.println("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 perimeter is " + object.getPerimeter());
        System.out.println("The area is " + object.getArea());
    }
}

abstract class GeometricObject{

    private String color = "white";
    private boolean filled;
    private java.util.Date dataCreated;

    protected GeometricObject(){
        dataCreated = new java.util.Date();
    }

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

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

    public String getColor() {
        return color;
    }

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

    public boolean isFilled() {
        return filled;
    }

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

    public abstract double getPerimeter();

    public abstract double getArea();

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

class Circle extends GeometricObject{

    public double radius;

    public Circle(){
        this(1.0);
    }

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

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

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

    public double getRadius(){
        return radius;
    }

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

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

    public String toString(){
        return ("[Circle] radius = " + radius);
    }
}

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 void setWidth(double width) {
        this.width = width;
    }

    public double getWidth() {
        return width;
    }

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

    public double getHeight() {
        return height;
    }

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

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

// 运行结果
/*
Same area? false

The perimeter is 31.41592653589793
The area is 78.53981633974483

The perimeter is 30.0
The area is 15.0
 */

接口（interface）

public class MatchTest {
    public static void main(String[] args) {

        FootballExtends ft = new FootballExtends();
        HockeyExtends he = new HockeyExtends();

        Sports s = ft;
        s.setHomeTeam("a");
        s.setVisitingTeam("b");

        Football f = ft;
        f.homeTeamScored(3);

        s = he;
        s.setHomeTeam("a");
        s.setVisitingTeam("b");

        Hockey h = he;
        h.endOfPeriod(3);

    }
}

interface Sports{
    abstract void setHomeTeam(String x);
    abstract void setVisitingTeam(String y);
}

interface Football extends Sports{
    abstract void setHomeTeam(String x);
    abstract void setVisitingTeam(String y);
    abstract void homeTeamScored(int a);
}

interface Hockey extends Sports{
    abstract void setHomeTeam(String x);
    abstract void setVisitingTeam(String y);
    abstract void endOfPeriod(int b);
}

class FootballExtends implements Football{
    public void setHomeTeam(String x){
        System.out.println("Football homeTeam is " + x);
    };
    public void setVisitingTeam(String y){
        System.out.println("Football visitingTeam is " + y);
    }
    public void homeTeamScored(int a){
        System.out.println("Football homeTeam scored " + a);
    }
}

class HockeyExtends implements Hockey{
    public void setHomeTeam(String x){
        System.out.println("Football homeTeam is " + x);
    };
    public void setVisitingTeam(String y){
        System.out.println("Football visitingTeam is " + y);
    }
    public void endOfPeriod(int b){
        System.out.println("Football homeTeam scored " + b);
    }
}

// 运行结果
/*
Football homeTeam is a
Football visitingTeam is b
Football homeTeam scored 3
Football homeTeam is a
Football visitingTeam is b
Football homeTeam scored 3
 */

public class MyInterfaceTest {
    public static void main(String[] args){
        MyInterfaceUse m = new MyInterfaceUse("类A: ");
        m.show();
    }
}

interface MyInterface{
    public static double G = 88;
    public abstract void show();
}

class MyInterfaceUse implements MyInterface{
    String s;
    public MyInterfaceUse(String s){
        this.s = s;
    }
    public void show(){
        System.out.println(s + "G = " + G);
    }
}

// 运行结果
/*
类A: G = 88.0
 */

接口和抽象类

1. 在接口中，数据必须是常量；而抽象类可以有非常量的数据域。

2. Java对类的扩展只允许单重继承；但对接口允许多重继承。