Thinking in Java 第四版完整版 第八章练习题 多态

Thinking in Java 第四版完整版 第八章练习题，记录一下(jdk1.8.0)

1.

/**
 * 练习1：创建一个Cycle类，它具有子类Unicycle、Bicycle和
 * Tricycle。演示每一个类型的示例都可以经由ride()方法向上
 * 转型为Cycle。
 * @author admin11
 * @date 2018年3月28日
 */
class Cycle {}

class Unicycle extends Cycle {}

class Bicycle extends Cycle {}

class Tricycle extends Cycle {}

public class Exercise801 {
    public static void ride(Cycle cycle) {}

    public static void main(String[] args) {
        ride(new Unicycle());
        ride(new Bicycle());
        ride(new Tricycle());
    }
}

2.

/**
 * 练习2：在几何图形的示例中添加@Override注解。
 * @author admin11
 * @date 2018年3月28日
 */
 public class Shape {
    public void draw() {}
    public void erase() {}
}

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Circle.draw()");
    }
    @Override
    public void erase() {
        System.out.println("Circle.erase()");
    }
}

public class Square extends Shape{
    @Override
    public void draw() {
        System.out.println("Square.draw()");
    }
    @Override
    public void erase() {
        System.out.println("Square.erase()");
    }
}

public class Triangle extends Shape{
    @Override
    public void draw() {
        System.out.println("Triangle.draw()");
    }
    @Override
    public void erase() {
        System.out.println("Triangle.erase()");
    }
}

import java.util.Random;

public class RandomShapeGenerator {
    private Random rand = new Random(47);
    public Shape next() {
        switch (rand.nextInt(3)) {
        default:
        case 0:
            return new Circle();
        case 1:
            return new Square();
        case 2:
            return new Triangle();
        }
    }
}

public class Shapes {
    private static RandomShapeGenerator gen = new RandomShapeGenerator();
    public static void main(String[] args) {
        Shape[] s = new Shape[9];
        for (int i = 0; i < s.length; i++) {
            s[i] = gen.next();
        }
        for (Shape shape : s) {
            shape.draw();
        }
    }
}

3.

/**
 * 练习3：在基类Shapes.java中添加一个新方法，用于打印一条消息，
 * 但导出类中不要覆盖这个方法。请解释发生了什么。现在，在其中一个导出
 * 类中覆盖该方法，而在其他的导出类中不予覆盖，观察又有什么发生。最后，
 * 在所有的导出类中覆盖这个方法。
 * @author admin11
 * @date 2018年3月28日
 */
public class Shape {
    public void draw() {}
    public void erase() {}
    public void testPrint() {
        System.out.println("shape.testPrint()");
    }
}

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Circle.draw()");
    }
    @Override
    public void erase() {
        System.out.println("Circle.erase()");
    }
    @Override
    public void testPrint() {
        System.out.println("Circle.testPrint()");
    }
}

public class Square extends Shape{
    @Override
    public void draw() {
        System.out.println("Square.draw()");
    }
    @Override
    public void erase() {
        System.out.println("Square.erase()");
    }
    @Override
    public void testPrint() {
        System.out.println("Square.testPrint()");
    }
}

public class Triangle extends Shape{
    @Override
    public void draw() {
        System.out.println("Triangle.draw()");
    }
    @Override
    public void erase() {
        System.out.println("Triangle.erase()");
    }
    @Override
    public void testPrint() {
        System.out.println("Triangle.testPrint()");
    }
}

import java.util.Random;

public class RandomShapeGenerator {
    private Random rand = new Random(47);
    public Shape next() {
        switch (rand.nextInt(3)) {
        default:
        case 0:
            return new Circle();
        case 1:
            return new Square();
        case 2:
            return new Triangle();
        }
    }
}

public class Shapes {
    private static RandomShapeGenerator gen = new RandomShapeGenerator();
    public static void main(String[] args) {
        Shape[] s = new Shape[9];
        for (int i = 0; i < s.length; i++) {
            s[i] = gen.next();
        }
        for (Shape shape : s) {
            shape.draw();
            shape.testPrint();
        }
    }
}

4.

/**
 * 练习4：向Shapes.java中添加一个新的Shape类型，并在main()
 * 方法中验证：多态对新类型的作用是否与在旧类型中的一样。
 * @author admin11
 * @date 2018年3月28日
 */
class Shape {
    public void draw() {}
    public void erase() {}
    public void testPrint() {
        System.out.println("shape.testPrint()");
    }
}

class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Circle.draw()");
    }
    @Override
    public void erase() {
        System.out.println("Circle.erase()");
    }
    @Override
    public void testPrint() {
        System.out.println("Circle.testPrint()");
    }
}

class Square extends Shape{
    @Override
    public void draw() {
        System.out.println("Square.draw()");
    }
    @Override
    public void erase() {
        System.out.println("Square.erase()");
    }
    @Override
    public void testPrint() {
        System.out.println("Square.testPrint()");
    }
}

class Triangle extends Shape{
    @Override
    public void draw() {
        System.out.println("Triangle.draw()");
    }
    @Override
    public void erase() {
        System.out.println("Triangle.erase()");
    }
    @Override
    public void testPrint() {
        System.out.println("Triangle.testPrint()");
    }
}

class newShape extends Shape{
    @Override
    public void draw() {
        System.out.println("newShape.draw()");
    }
    @Override
    public void erase() {
        System.out.println("newShape.erase()");
    }
    @Override
    public void testPrint() {
        System.out.println("newShape.testPrint()");
    }
}

public class Exercise804 {
    public static void main(String[] args) {
        Shape[] sp = {new Circle(), new Square(),
                new Triangle(), new newShape()};
        for (Shape shape : sp) {
            shape.draw();
            shape.erase();
            shape.testPrint();
        }
    }
}

5.

/**
 * 练习5：以练习1为基础，在Cycle中添加wheels()方法，它将返回
 * 轮子的数量。修改ride()方法，让它调用wheels()方法，并验证
 * 多态起作用了。
 * @author admin11
 * @date 2018年3月28日
 */
class Cycle {
    public String wheels() {
        return "Cycle wheels : none";
    }
}

class Unicycle extends Cycle {
    @Override
    public String wheels() {
        return "Unicycle wheels : 4";
    }
}

class Bicycle extends Cycle {
    @Override
    public String wheels() {
        return "Bicycle wheels : 2";
    }
}

class Tricycle extends Cycle {
    @Override
    public String wheels() {
        return "Tricycle wheels : 3";
    }
}

public class Exercise805 {
    public static void ride(Cycle cycle) {
        System.out.println(cycle.wheels());
    }
    public static void main(String[] args) {
        Cycle[] c = {new Unicycle(), new Bicycle(),
                new Tricycle()};
        for (Cycle cycle : c) {
            ride(cycle);
        }
    }
}

6.

/**
 * 练习6：修改Music3.java,使what()方法成为根Object的
 * toString()方法。试用System.out.println()方法打印
 * Instrument对象（不用向上转型）。
 * @author admin11
 * @date 2018年3月28日
 */
enum Note {
    MIDDLE_C, C_SHARP, B_FLAT;
}

class Instrument {
    void play(Note n) {
        System.out.println("Instrument.play() " + n);
    }
    @Override
    public String toString() {
        return "Instrument";
    }
    void adjust() {
        System.out.println("Adjusting Instrument");
    }
}

class Wind extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Wind.play() " + n);
    }
    @Override
    public String toString() {
        return "Wind";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Wind");
    }
}

class Percussion extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Percussion.play() " + n);
    }
    @Override
    public String toString() {
        return "Percussion";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Percussion");
    }
}

class Stringed extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Stringed.play() " + n);
    }
    @Override
    public String toString() {
        return "Stringed";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Stringed");
    }
}

class Brass extends Wind {
    @Override
    void play(Note n) {
        System.out.println("Brass.play() " + n);
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Brass");
    }
}

class Woodwind extends Wind {
    @Override
    void play(Note n) {
        System.out.println("Woodwind.play() " + n);
    }
    @Override
    public String toString() {
        return "Woodwind";
    }
}

public class Exercise806 {
    static Instrument[] orchestra = {
            new Wind(),
            new Percussion(),
            new Stringed(),
            new Brass(),
            new Woodwind()
    };

    public static void printAll(Instrument[] e) {
        for (Instrument instrument : e) {
            System.out.println(instrument);
        }
    }

    public static void main(String[] args) {
        printAll(orchestra);
    }
}

7.

/**
 * 练习7：向Music3.java添加一个新的类型Instrument,
 * 并验证多态性是否作用于所添加的新类型。
 * @author admin11
 * @date 2018年3月28日
 */
enum Note {
    MIDDLE_C, C_SHARP, B_FLAT;
}

class Instrument {
    void play(Note n) {
        System.out.println("Instrument.play() " + n);
    }
    @Override
    public String toString() {
        return "Instrument";
    }
    void adjust() {
        System.out.println("Adjusting Instrument");
    }
}

class Wind extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Wind.play() " + n);
    }
    @Override
    public String toString() {
        return "Wind";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Wind");
    }
}

class Percussion extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Percussion.play() " + n);
    }
    @Override
    public String toString() {
        return "Percussion";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Percussion");
    }
}

class Stringed extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Stringed.play() " + n);
    }
    @Override
    public String toString() {
        return "Stringed";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Stringed");
    }
}

class Brass extends Wind {
    @Override
    void play(Note n) {
        System.out.println("Brass.play() " + n);
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Brass");
    }
}

class Woodwind extends Wind {
    @Override
    void play(Note n) {
        System.out.println("Woodwind.play() " + n);
    }
    @Override
    public String toString() {
        return "Woodwind";
    }
}

class Electronic extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Electronic.play() " + n);
    }
    @Override
    public String toString() {
        return "Electronic";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Electronic");
    }
}

public class Exercise807 {

    public static void main(String[] args) {
        Instrument[] orchestra = {
                new Wind(),
                new Percussion(),
                new Stringed(),
                new Brass(),
                new Woodwind(),
                new Electronic()
        };

        for (Instrument instrument : orchestra) {
            instrument.play(Note.MIDDLE_C);
            instrument.adjust();
            System.out.println(instrument);
        }
    }
}

8.

import java.util.Random;
/**
 * 练习8：修改Music3.java,使其可以像Shapes.java中的方式
 * 那样随机创建Instrument对象。
 * @author admin11
 * @date 2018年3月28日
 */
enum Note {
    MIDDLE_C, C_SHARP, B_FLAT;
}

class Instrument {
    void play(Note n) {
        System.out.println("Instrument.play() " + n);
    }
    @Override
    public String toString() {
        return "Instrument";
    }
    void adjust() {
        System.out.println("Adjusting Instrument");
    }
}

class Wind extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Wind.play() " + n);
    }
    @Override
    public String toString() {
        return "Wind";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Wind");
    }
}

class Percussion extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Percussion.play() " + n);
    }
    @Override
    public String toString() {
        return "Percussion";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Percussion");
    }
}

class Stringed extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Stringed.play() " + n);
    }
    @Override
    public String toString() {
        return "Stringed";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Stringed");
    }
}

class Brass extends Wind {
    @Override
    void play(Note n) {
        System.out.println("Brass.play() " + n);
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Brass");
    }
}

class Woodwind extends Wind {
    @Override
    void play(Note n) {
        System.out.println("Woodwind.play() " + n);
    }
    @Override
    public String toString() {
        return "Woodwind";
    }
}

class Electronic extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Electronic.play() " + n);
    }
    @Override
    public String toString() {
        return "Electronic";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Electronic");
    }
}

class InstrumentGenerator {
    public Instrument next() {
        switch (new Random().nextInt(6)) {
        default:
        case 0:
            return new Wind();
        case 1:
            return new Percussion();
        case 2:
            return new Stringed();
        case 3:
            return new Brass();
        case 4:
            return new Woodwind();
        case 5:
            return new Electronic();
        }
    }
}

public class Exercise808 {
    public static void main(String[] args) {
        InstrumentGenerator gen = new InstrumentGenerator();
        for (int i = 0; i < 10; i++) {
            System.out.println(gen.next());
        }
    }
}

9.

/**
 * 练习9：创建Rodent（啮齿动物）:Mouse(老鼠),Gerbil(鼹鼠),
 * Hamster(大颊鼠),等等这样一个的继承层次结构。在基类中，提供对所
 * 有的Rodent都通用的方法，在导出类中，根据特定的Rodent类型覆盖
 * 这些方法，以便它们执行不同的行为。创建一个Rodent数组，填充不同
 * 的Rodent类型，然后调用基类方法，观察发生什么情况。
 * @author admin11
 * @date 2018年3月28日
 */
class Rodent {
    public void eat() {
        System.out.println("eat...");
    }
    public void sleep() {
        System.out.println("sleep...");
    }
}

class Mouse extends Rodent{
    @Override
    public void eat() {
        System.out.println("Mouse eat...");
    }
    @Override
    public void sleep() {
        System.out.println("Mouse sleep...");
    }
}

class Gerbil extends Rodent {
    @Override
    public void eat() {
        System.out.println("Gerbil eat...");
    }
    @Override
    public void sleep() {
        System.out.println("Gerbil sleep...");
    }
}

class Hamster extends Rodent {
    @Override
    public void eat() {
        System.out.println("Hamster eat...");
    }
    @Override
    public void sleep() {
        System.out.println("Hamster sleep...");
    }
}

public class Exercise809 {
    public static void main(String[] args) {
        Rodent[] rd = {
                new Mouse(),
                new Gerbil(),
                new Hamster()
        };
        for (Rodent rodent : rd) {
            rodent.eat();
            rodent.sleep();
        }
    }
}

10.

/**
 * 练习10：创建一个包含两个方法的基类。在第一个方法中可以调用第二个
 * 方法。然后产生一个继承自该基类的导出类，且覆盖基类中的第二个方法。
 * 为该导出类创建一个对象，将它向上转型到基类型并调用第一个方法，解
 * 释发生的情况。
 * @author admin11
 * @date 2018年3月28日
 */
class TwoMethods {
    public void m1() {
        System.out.println("Inside m1, calling m2");
        m2();
    }
    public void m2() {
        System.out.println("Inside m2");
    }
}

public class Exercise810 extends TwoMethods{
    public void m2() {
        System.out.println("Inside Exercise810.m2");
    }
    public static void main(String[] args) {
        TwoMethods t = new Exercise810();
        t.m1();
        // 调用导出类的m1()方法，m1()方法调用了m2,
        // m2在导出类被重写了
    }
}

11.

/**
 * 练习11：向Sandwich.java中添加Pickle类。
 * @author admin11
 * @date 2018年3月30日
 */
class Meal {
    Meal() {
        System.out.println("Meal()");
    }
}

class Bread {
    Bread() {
        System.out.println("Bread()");
    }
}

class Cheese {
    Cheese() {
        System.out.println("Cheese()");
    }
}

class Lettuce {
    Lettuce() {
        System.out.println("Lettuce");
    }
}

class Lunch extends Meal {
    Lunch() {
        System.out.println("Lunch()");
    }
}

class PortableLunch extends Lunch {
    PortableLunch() {
        System.out.println("PortableLunch()");
    }
}

class Pickle {
    Pickle() {
        System.out.println("Pickle()");
    }
}

public class Sandwich extends PortableLunch {
    private Bread b = new Bread();
    private Cheese c = new Cheese();
    private Lettuce l = new Lettuce();
    private Pickle p = new Pickle();
    public Sandwich() {
        System.out.println("Sandwich()");
    }
    public static void main(String[] args) {
        new Sandwich();
    }
}

12.

/**
 * 练习12：修改练习9，使其能够演示基类和导出类的初始化顺序。然后
 * 向基类和导出类中添加成员对象，并说明构建期间初始化发生的顺序。
 * @author admin11
 * @date 2018年3月30日
 */
class Member {
    public Member(String id) {
        System.out.println("Member constructor " + id);
    }
}

class Rodent2 {
    Member m1 = new Member("r1"),
            m2 = new Member("r2");
    public Rodent2() {
        System.out.println("Rodent constructor");
    }
    public void hop() {
        System.out.println("Rodent hopping");
    }
    public void scurry() {
        System.out.println("Rodent scurrying");
    }
    public void reproduce() {
        System.out.println("Making more Rodents");
    }
    public String toString() {
        return "Rodent";
    }
}

class Mouse2 extends Rodent2 {
    Member m1 = new Member("m1"),
            m2 = new Member("m2");
    public Mouse2() {
        System.out.println("Mouse2 constructor");
    }
    public void hop() {
        System.out.println("Mouse2 hopping");
    }
    public void scurry() {
        System.out.println("Mouse2 scurrying");
    }
    @Override
    public void reproduce() {
        System.out.println("Making more Mice");
    }
    @Override
    public String toString() {
        return "Mouse";
    }
}

class Gerbil2 extends Rodent2 {
    Member m1 = new Member("g1"),
            m2 = new Member("g2");
    public Gerbil2() {
        System.out.println("Gerbil2 constructor");
    }
    @Override
    public void hop() {
        System.out.println("Gerbil2 hopping");
    }
    @Override
    public void scurry() {
        System.out.println("Gerbil2 scurrying");
    }
    @Override
    public void reproduce() {
        System.out.println("Making more Gerbils");
    }
    @Override
    public String toString() {
        return "Gerbil";
    }
}

class Hamster2 extends Rodent2 {
    Member m1 = new Member("h1"),
            m2 = new Member("h2");
    public Hamster2() {
        System.out.println("Hamster constructor");
    }
    @Override
    public void hop() {
        System.out.println("Hamster hopping");
    }
    @Override
    public void scurry() {
        System.out.println("Hamster scurrying");
    }
    @Override
    public void reproduce() {
        System.out.println("Making more Hamsters");
    }
    @Override
    public String toString() {
        return "Hamster";
    }
}

public class Exercise812 {
    // 先初始化基类的成员变量，调用基类的构造方法；
    // 然后初始化导出类的成员变量，调用导出类的构造方法。
    public static void main(String[] args) {
        new Hamster2();
    }
}

13.

/**
 * 练习13：在ReferenceCounting.java中添加一个finalize()
 * 方法，用来校验终止条件。
 * @author admin11
 * @date 2018年3月30日
 */
class Shared {
    private int refcount = 0;
    private static int counter = 0;
    private int id = counter++;
    public Shared() {
        System.out.println("Creating " + this);
    }
    public void addRef() {
        refcount++;
    }
    protected void dispose() {
        if(--refcount == 0) {
            System.out.println("Disposing " + this);
        }
    }
    protected void finalize() {
        if(refcount != 0) {
            System.out.println("Error: object is not properly cleaned-up!");
        }
    }
    @Override
    public String toString() {
        return "Shared" + id;
    }
}

class Composing {
    private Shared shared;
    private static int counter = 0;
    private int id = counter++;
    public Composing(Shared shared) {
        System.out.println("Creating " + this);
        this.shared = shared;
        this.shared.addRef();
    }
    protected void dispose() {
        System.out.println("disposing" + this);
        shared.dispose();
    }
    @Override
    public String toString() {
        return "Composing " + id;
    }
}

public class Exercise813 {
    public static void main(String[] args) {
        Shared shared = new Shared();
        Composing[] composing = { new Composing(shared),
            new Composing(shared),  new Composing(shared),
            new Composing(shared), new Composing(shared)
        };
        for (Composing c : composing) {
            c.dispose();
        }
        System.gc();
        new Composing(new Shared());
        System.gc();
    }
}

14.

/**
 * 练习14：修改练习12，使得其某个成员对象变为具有引用计数的共享对象，
 * 并证明它可以正确运行。
 * @author admin11
 * @date 2018年3月30日
 */
class NonSharedMember {
    public NonSharedMember(String id) {
        System.out.println("Non shared member constructor " + id);
    }
}

class SharedMember {
    private int refcount;
    public void addRef() {
        System.out.println("Number of references " + ++refcount);
    }
    protected void dispose() {
        if(--refcount == 0) {
            System.out.println("Disposing " + this);
        }
    }
    public SharedMember() {
        System.out.println("Shared member constructor");
    }
    @Override
    public String toString() {
        return "Shared member";
    }
}

class Rodent3 {
    private SharedMember m;
    NonSharedMember m1 = new NonSharedMember("r1"),
            m2 = new NonSharedMember("r2");
    public Rodent3(SharedMember sm) {
        System.out.println("Rodent constructor");
        m = sm;
        m.addRef();
    }
    public void hop() {
        System.out.println("Rodent hopping");
    }
    public void scurry() {
        System.out.println("Rodent scurrying");
    }
    public void reproduce() {
        System.out.println("Making more Rodents");
    }
    public void dispose() {
        System.out.println("Disposing " + this);
        m.dispose();
    }
    @Override
    public String toString() {
        return "Rodent";
    }
}

class Mouse3 extends Rodent3 {
    NonSharedMember m1 = new NonSharedMember("m1"),
            m2 = new NonSharedMember("m2");
    public Mouse3(SharedMember sm) {
        super(sm);
        System.out.println("Mouse constructor");
    }
    @Override
    public void hop() {
        System.out.println("Mouse hopping");
    }
    @Override
    public void scurry() {
        System.out.println("Mouse scurring");
    }
    @Override
    public void reproduce() {
        System.out.println("Making more Mice");
    }
    @Override
    public String toString() {
        return "Mouse";
    }
}

class Gerbil3 extends Rodent3 {
    private SharedMember m;
    NonSharedMember m1 = new NonSharedMember("g1"),
            m2 = new NonSharedMember("g2");
    public Gerbil3(SharedMember sm) {
        super(sm);
        System.out.println("Gerbil constructor");
    }
    @Override
    public void hop() {
        System.out.println("Gerbil hopping");
    }
    @Override
    public void scurry() {
        System.out.println("Gerbil scurring");
    }
    @Override
    public void reproduce() {
        System.out.println("Making more Gerbils");
    }
    @Override
    public String toString() {
        return "Gerbil";
    }
}

class Hamster3 extends Rodent3 {
    private SharedMember m;
    NonSharedMember m1 = new NonSharedMember("h1"),
            m2 = new NonSharedMember("h2");
    public Hamster3(SharedMember sm) {
        super(sm);
        System.out.println("Hamster constructor");
    }
    @Override
    public void hop() {
        System.out.println("Hamster hopping");
    }
    @Override
    public void scurry() {
        System.out.println("Hamster scurring");
    }
    @Override
    public void reproduce() {
        System.out.println("Making more Hamsters");
    }
    @Override
    public String toString() {
        return "Hamster";
    }
}

public class Exercise814 {
    public static void main(String[] args) {
        SharedMember sm = new SharedMember();
        Rodent3[] rodents = {
                new Hamster3(sm),
                new Gerbil3(sm),
                new Mouse3(sm)
        };
        for (Rodent3 rodent3 : rodents) {
            rodent3.dispose();
        }
    }
}

15.

/**
 * 练习15：在PolyConstructors.java中添加一个RectangularGlyph，
 * 并证明会出现本节所描述的问题。
 * @author admin11
 * @date 2018年3月30日
 */
class Glyph {
    void draw() {
        System.out.println("Glyph.draw()");
    }
    Glyph() {
        System.out.println("Glyph() before draw()");
        draw();
        System.out.println("Glyph() after draw()");
    }
}

class RoundGlyph extends Glyph {
    private int radius = 1;
    RoundGlyph(int r) {
        radius = r;
        System.out.println("RoundGlyph.RoundGlyph(), radius = " + radius);
    }
    @Override
    void draw() {
        System.out.println("RoundGlyph.draw(), radius = " + radius);
    }
}

class RectangularGlyph extends Glyph {
    private int width;
    private int height;
    RectangularGlyph(int width, int height) {
        this.width = width;
        this.height = height;
        System.out.println("RectangularGlyph.RectangularGlyph(), width = " + width + ", height = " + height);
    }
    @Override
    void draw() {
        System.out.println("RectangularGlyph.draw(), area = " + width * height);
    }
}

public class Exercise815 {
    public static void main(String[] args) {
        new RoundGlyph(5);
        new RectangularGlyph(2, 2);
    }
}

16.

/**
 * 练习16：遵循Transmogrify.java这个例子，创建一个Starship
 * 类，包含一个AlertStatus引用，此引用可以指示三种不同的状态。纳入
 * 一些可以改变这些状态的方法。
 * @author admin11
 * @date 2018年3月30日
 */
class AlertStatus {
    public String getStatus() {
        return "None";
    }
}

class RedAlertStatus extends AlertStatus {
    @Override
    public String getStatus() {
        return "Red";
    }
}

class YellowAlertStatus extends AlertStatus {
    @Override
    public String getStatus() {
        return "Yellow";
    }
}

class GreenAlertStatus extends AlertStatus {
    @Override
    public String getStatus() {
        return "Green";
    }
}

class Starship {
    private AlertStatus status = new GreenAlertStatus();
    public void setStatus(AlertStatus istatus) {
        status = istatus;
    }
    @Override
    public String toString() {
        return status.getStatus();
    }
}

public class Exercise816 {
    public static void main(String[] args) {
        Starship eprise = new Starship();
        System.out.println(eprise);
        eprise.setStatus(new YellowAlertStatus());
        System.out.println(eprise);
        eprise.setStatus(new RedAlertStatus());
        System.out.println(eprise);
    }
}

17.

/**
 * 练习17：使用练习1中的Cycle的层次结构，在Unicycle和Bicycle
 * 中添加balance()方法，而Tricycle中不添加。创建所有这三种类型
 * 的实例，并将它们向上转型为Cycle数组。在该数组的每一个元素上都尝试
 * 调用balance()，并观察结果。然后将它们向下转型，再次调用
 * balance()，并观察将所产生什么。
 * @author admin11
 * @date 2018年3月31日
 */
class Cycle {}

class Unicycle extends Cycle {
    public void balance() {
        System.out.println("Unicycle.balance()");
    }
}

class Bicycle extends Cycle {
    public void balance() {
        System.out.println("Bicycle.balance()");
    }
}

class Tricycle extends Cycle {}

public class Exercise817 {
    public static void main(String[] args) {
        Cycle[] cs = {
                new Unicycle(),
                new Bicycle(),
                new Tricycle()
        };

        for (Cycle cycle : cs) {
            // cycle.balance();
            // The method balance() is undefined for the type Cycle
        }

        ((Unicycle) cs[0]).balance();
        ((Bicycle) cs[1]).balance();
        // The method balance() is undefined for the type Tricycle
        // ((Tricycle) cs[2]).balance();
    }
}