Thinking in Java 第四版完整版 第九章练习题 接口

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

1.

package com.test.c09;
/**
 * 练习1：修改第八章练习9中的Rodent,使其成为一个抽象类。只要有可能，
 * 就将Rodent的方法声明为抽象方法。
 * @author admin11
 * @date 2018年4月1日
 */
abstract class Rodent {
    public abstract void hop();
    public abstract void scurry();
    public abstract void reproduce();
} 

class Mouse extends Rodent {
    @Override
    public void hop() {
        System.out.println("Mouse hopping");
    }
    @Override
    public void scurry() {
        System.out.println("Mouse scurrying");
    }
    @Override
    public void reproduce() {
        System.out.println("Making more Mice");
    }
    @Override
    public String toString() {
        return "Mouse";
    }
}

class Gerbil extends Rodent {
    @Override
    public void hop() {
        System.out.println("Gerbil hopping");
    }
    @Override
    public void scurry() {
        System.out.println("Gerbil scurrying");
    }
    @Override
    public void reproduce() {
        System.out.println("Making more Gerbils");
    }
    @Override
    public String toString() {
        return "Gerbil";
    }
}

class Hamster extends Rodent {
    @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 Exercise901 {
    public static void main(String[] args) {
        Rodent[] rodents = {
                new Mouse(),
                new Gerbil(),
                new Hamster()
        };
        for (Rodent rodent : rodents) {
            rodent.hop();
            rodent.scurry();
            rodent.reproduce();
            System.out.println(rodent);
        }
    }
}

2.

package com.test.c09;
/**
 * 练习2：创建一个不包含任何抽象方法的抽象类，并验证我们不能为该类
 * 创建任何实例。
 * @author admin11
 * @date 2018年4月1日
 */
abstract class NoAbstractMethods {
    void f() {
        System.out.println("f()");
    }
}

public class Exercise902 {
    public static void main(String[] args) {
        // Cannot instantiate the type NoAbstractMethods
        // new NoAbstractMethods();
    }
}

3.

package com.test.c09;
/**
 * 练习3：创建一个基类，让它包含抽象方法print()，并在导出类中覆盖
 * 该方法。覆盖后的方法版本可以打印导出类中定义的某个整型变量的值。在
 * 定义该变量之处，赋予它非零值。在基类的构造器中调用这个方法。现在，
 * 在main()方法中，创建一个导出类对象，然后调用它的print()方法。
 * 请解释发生的情形。
 * @author admin11
 * @date 2018年4月1日
 */
abstract class BaseClass {
    public BaseClass() {
        print();
    }
    public abstract void print();
}

class ImportClass extends BaseClass{
    public int count = 10;
    @Override
    public void print() {
        System.out.println("count = " + count);
    }
}

public class Exercise903 {
    public static void main(String[] args) {
        new ImportClass().print();
        // 该print()方法被调用了两次，第一次是在创建导出类时，
        // 调用了基类的构造器，基类的构造器调用了print()方法，
        // 变量count此时被赋值成0；第二次是导出类对象调用print()
        // 方法，count在导出类中被赋值了。
    }
}

4.

package com.test.c09;
/**
 * 练习4：创建一个不包含任何方法的抽象类，从它那里导出一个类，并添加一个
 * 方法。创建一个静态方法，它可以接受指向基类的引用，将其向下转型到导出类，
 * 然后再调用该静态方法。在main()中，展现它的运行情况。然后，为基类中
 * 的方法加上abstract声明，这样就不再需要进行向下转型。
 * @author admin11
 * @date 2018年4月1日
 */
abstract class NoMethods {}

class Extended1 extends NoMethods {
    public void f() {
        System.out.println("Extended1.f()");
    }
}

abstract class WithMethods {
    abstract public void f();
}

class Extended2 extends WithMethods {
    @Override
    public void f() {
        System.out.println("Extended2.f()");
    }
}

public class Exercise904 {
    public static void test1(NoMethods nm) {
        ((Extended1) nm).f();
    }
    public static void test2(WithMethods wm) {
        wm.f();
    }
    public static void main(String[] args) {
        NoMethods nm = new Extended1();
        test1(nm);
        WithMethods wm = new Extended2();
        test2(wm);
    }
}

5.

package com.test.c09.e05;

import com.test.c09.e05.inter.AnInterface;
/**
 * 练习5：在某个包内创建一个接口，内含三个方法，然后在另一个包中实现
 * 此接口。
 * @author admin11
 * @date 2018年4月1日
 */
class ImplementInterface implements AnInterface {
    @Override
    public void f() {
        System.out.println("ImplementInterface.f()");
    }
    @Override
    public void g() {
        System.out.println("ImplementInterface.g()");
    }
    @Override
    public void h() {
        System.out.println("ImplementInterface.h()");
    }
}

public class Exercise905 {
    public static void main(String[] args) {
        ImplementInterface imp = new ImplementInterface();
        imp.f();
        imp.g();
        imp.h();
    }
}

package com.test.c09.e05.inter;

public interface AnInterface {
    void f();
    void g();
    void h();
}

6.

package com.test.c09;

import com.test.c09.e05.inter.AnInterface;

/**
 * 练习6：证明接口内所有的方法都自动是public的。
 * @author admin11
 * @date 2018年4月1日
 */
public class Exercise906 implements AnInterface{
    // The type Exercise906 must implement the inherited abstract method AnInterface.f()
    @Override
    public void f() {}
    @Override
    public void g() {}
    @Override
    public void h() {}
    public static void main(String[] args) {

    }
}

7.

package com.test.c09;
/**
 * 练习7：修改第八章中的练习9，使Rodent成为一个接口。
 * @author admin11
 * @date 2018年4月1日
 */
interface Rodent2 {
    public abstract void hop();
    public abstract void scurry();
    public abstract void reproduce();
} 

class Mouse2 implements Rodent2 {
    @Override
    public void hop() {
        System.out.println("Mouse hopping");
    }
    @Override
    public void scurry() {
        System.out.println("Mouse scurrying");
    }
    @Override
    public void reproduce() {
        System.out.println("Making more Mice");
    }
    @Override
    public String toString() {
        return "Mouse";
    }
}

class Gerbil2 implements Rodent2 {
    @Override
    public void hop() {
        System.out.println("Gerbil hopping");
    }
    @Override
    public void scurry() {
        System.out.println("Gerbil scurrying");
    }
    @Override
    public void reproduce() {
        System.out.println("Making more Gerbils");
    }
    @Override
    public String toString() {
        return "Gerbil";
    }
}

class Hamster2 implements Rodent2 {
    @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 Exercise907 {
    public static void main(String[] args) {
        Rodent2[] rs = {
                new Mouse2(),
                new Gerbil2(),
                new Hamster2()
        };
        for (Rodent2 rodent2 : rs) {
            rodent2.hop();
            rodent2.scurry();
            rodent2.reproduce();
            System.out.println(rodent2);
        }
    }
}

8.

package com.test.c09;
/**
 * 练习8：在polymorphism.Sandwich.java中，创建接口FastFood
 * 并添加合适的方法，然后修改Sandwich以实现FastFood接口。
 * @author admin11
 * @date 2018年4月1日
 */
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()");
    }
}

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()");
    }
}

interface FastFood {
    void rushOrder();
    void gobble();
}

class FastSandwich extends Sandwich implements FastFood {
    @Override
    public void rushOrder() {
        System.out.println("Rushing your sandwich order");
    }
    @Override
    public void gobble() {
        System.out.println("Chomp! Snort! Gobble!");
    }
}

public class Exercise908 {
    public static void main(String[] args) {
        FastSandwich burger = new FastSandwich();
        System.out.println("Fries with that?");
        System.out.println("Super Size?");
        burger.rushOrder();
        burger.gobble();
    }
}

9.

package com.test.c09;
/**
 * 练习9：重构Music5.java将在Wind、Percussion和Stringed
 * 中的公共方法移入一个抽象类中。
 * @author admin11
 * @date 2018年4月1日
 */
enum Note {
    MIDDLE_C, C_SHARP, B_FLAT;
}

abstract class Instrument {
    public void play(Note n) {
        System.out.println(this + ".play() " + n);
    }
    public void adjust() {
        System.out.println(this + ".adjust()");
    }
    public abstract String toString();
}

class Wind extends Instrument {
    @Override
    public String toString() {
        return "Wind";
    }
}

class Percussion extends Instrument {
    @Override
    public String toString() {
        return "Percussion";
    }
}

class Stringed extends Instrument {
    @Override
    public String toString() {
        return "Stringed";
    }
}

class Brass extends Wind {
    @Override
    public String toString() {
        return "Brass";
    }
}

class Woodwind extends Wind {
    @Override
    public String toString() {
        return "Woodwind";
    }
}

public class Exercise909 {
    static void tune(Instrument i) {
        i.adjust();
        i.play(Note.MIDDLE_C);
    }
    static void tuneAll(Instrument[] e) {
        for (Instrument instrument : e) {
            tune(instrument);
        }
    }
    public static void main(String[] args) {
        Instrument[] ins = {
                new Wind(),
                new Percussion(),
                new Stringed(),
                new Brass(),
                new Woodwind()
        };
        tuneAll(ins);
    }
}

10.

package com.test.c09.e10;
/**
 * 练习10：修改Music5.java,添加Playable接口。将play()的声明
 * 从Instrument中移到Playable中。通过将Playable包括在
 * implements列表中，把Playable添加到导出类中。修改tune(),
 * 使它接受Playable而不是Instrument作为参数。
 * @author admin11
 * @date 2018年4月2日
 */
enum Note {
    MIDDLE_C, C_SHARP, B_FLAT;
}

interface Instrument {
    void adjust();
}

interface Playable {
    void play(Note n);
}

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

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

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

class Brass extends Wind {
    @Override
    public String toString() {
        return "Brass";
    }
}

class Woodwind extends Wind {
    @Override
    public String toString() {
        return "Woodwind";
    }
}

public class Exercise910 {
    static void tune(Playable p) {
        p.play(Note.MIDDLE_C);
    }
    static void tuneAll(Playable[] e) {
        for (Playable playable : e) {
            tune(playable);
        }
    }
    public static void main(String[] args) {
        Playable[] ps = {
                new Wind(),
                new Percussion(),
                new Stringed(),
                new Brass(),
                new Woodwind()
        };
        tuneAll(ps);
    }
}

11.

package com.test.c09;
/**
 * 练习11：创建一个类，它有一个方法用于接受一个String类型的参数，
 * 生成的结果是将该参数中的每一对字符进行互换。对该类进行适配，使得
 * 它可以用于interfaceprocessor.Apply.process()。
 * @author admin11
 * @date 2018年4月2日
 */
interface Processor {
    String name();
    Object process(Object input);
}

class Apply {
    public static void process(Processor p, Object s) {
        System.out.println("Using Processor " + p.name());
        System.out.println(p.process(s));
    }
}

class CharacterPairSwapper {
    static String swap(String s) {
        StringBuilder sb = new StringBuilder(s);
        for (int i = 0; i < sb.length() - 1; i += 2) {
            char c1 = sb.charAt(i);
            char c2 = sb.charAt(i + 1);
            sb.setCharAt(i, c2);
            sb.setCharAt(i + 1, c1);
        }
        return sb.toString();
    }
}

class SwapperAdapter implements Processor {
    @Override
    public String name() {
        return CharacterPairSwapper.class.getSimpleName();
    }
    @Override
    public Object process(Object input) {
        return CharacterPairSwapper.swap((String)input);
    }
}

public class Exercise911 {
    public static void main(String[] args) {
        Apply.process(new SwapperAdapter(), "1234");
        Apply.process(new SwapperAdapter(), "abcde");
    }
}

12.

package com.test.c09;
/**
 * 练习12：在Adventure.java中，按照其他接口的样式，增加一个
 * CanClimb接口。
 * @author admin11
 * @date 2018年4月3日
 */
interface CanFight {
    void fight();
}

interface CanSwim {
    void swim();
}

interface CanFly {
    void fly();
}

interface CanClimb {
    void climb();
}

class ActionCharacter {
    public void fight() {}
}

class Hero extends ActionCharacter 
    implements CanFight, CanSwim, CanFly, CanClimb {
    @Override
    public void fly() {}
    @Override
    public void swim() {}
    @Override
    public void climb() {}
}

public class Exercise912 {
    public static void t(CanFight x) {
        x.fight();
    }
    public static void u(CanSwim x) {
        x.swim();
    }
    public static void v(CanFly x) {
        x.fly();
    }
    public static void w(ActionCharacter x) {
        x.fight();
    }
    public static void x(CanClimb c) {
        c.climb();
    }
    public static void main(String[] args) {
        Hero h = new Hero();
        t(h);
        u(h);
        v(h);
        w(h);
        x(h);
    }
}

13.

package com.test.c09;
/**
 * 练习13：创建一个接口，并从该接口继承两个接口，然后从后面两个接口
 * 多重继承第三个接口。
 * @author admin11
 * @date 2018年4月3日
 */
interface BaseInterface {
    void f();
}

interface IntermediateInterface1 extends BaseInterface {
    void f();
}

interface IntermediateInterface2 extends BaseInterface {
    void f();
}

interface CombinedInterface extends 
    IntermediateInterface1, IntermediateInterface2 {
    void f();
}

class CombinedImpl implements CombinedInterface {
    @Override
    public void f() {
        System.out.println("CombinedImpl.f()");
    }
}

public class Exercise913 {
    public static void main(String[] args) {
        new CombinedImpl().f();
    }
}

14.

package com.test.c09;
/**
 * 练习14：创建三个接口，每个接口都包含两个方法。继承出一个接口，它组合
 * 了这三个接口并添加了一个新方法。创建一个实现了该新接口并继承了某个具体
 * 类的类。现在编写四个方法，每一个都接受这四个接口之一作为参数。在main
 * ()方法中，创建这个类的对象，并将其传递给这四个方法。
 * @author admin11
 * @date 2018年4月3日
 */
interface Interface1 {
    void f1();
    void g1();
}

interface Interface2 {
    void f2();
    void g2();
}

interface Interface3 {
    void f3();
    void g3();
}

interface Multiple 
    extends Interface1, Interface2, Interface3 {
    void h();
} 

class Concrete {
    String s;
    public Concrete(String s) {
        this.s = s;
    }
}

class All extends Concrete implements Multiple {
    public All() {
        super("All");
    }
    @Override
    public void f1() {
        System.out.println("All.f1()");
    }
    @Override
    public void g1() {
        System.out.println("All.g1()");
    }
    @Override
    public void f2() {
        System.out.println("All.f2()");
    }
    @Override
    public void g2() {
        System.out.println("All.g2()");
    }
    @Override
    public void f3() {
        System.out.println("All.f3()");
    }
    @Override
    public void g3() {
        System.out.println("All.g3()");
    }
    @Override
    public void h() {
        System.out.println("All.h()");
    }
}

public class Exercise914 {
    static void takes1(Interface1 i) {
        i.f1();
        i.g1();
    }
    static void takes2(Interface2 i) {
        i.f2();
        i.g2();
    }
    static void takes3(Interface3 i) {
        i.f3();
        i.g3();
    }
    static void takesAll(All a) {
        a.f1();
        a.g1();
        a.f2();
        a.g2();
        a.f3();
        a.g3();
        a.h();
    }
    public static void main(String[] args) {
        All a = new All();
        takes1(a);
        takes2(a);
        takes3(a);
        takesAll(a);
    }
}

15.

package com.test.c09.e15;
/**
 * 练习15：将前一个练习修改为：创建一个抽象类，并将其继承到一个
 * 导出类中。
 * @author admin11
 * @date 2018年4月3日
 */
interface Interface1 {
    void f1();
    void g1();
}

interface Interface2 {
    void f2();
    void g2();
}

interface Interface3 {
    void f3();
    void g3();
}

interface Multiple 
    extends Interface1, Interface2, Interface3 {
    void h();
} 

abstract class Concrete {
    String s;
    public Concrete(String s) {
        this.s = s;
    }
}

class All extends Concrete implements Multiple {
    public All() {
        super("All");
    }
    @Override
    public void f1() {
        System.out.println("All.f1()");
    }
    @Override
    public void g1() {
        System.out.println("All.g1()");
    }
    @Override
    public void f2() {
        System.out.println("All.f2()");
    }
    @Override
    public void g2() {
        System.out.println("All.g2()");
    }
    @Override
    public void f3() {
        System.out.println("All.f3()");
    }
    @Override
    public void g3() {
        System.out.println("All.g3()");
    }
    @Override
    public void h() {
        System.out.println("All.h()");
    }
}

public class Exercise915 {
    static void takes1(Interface1 i) {
        i.f1();
        i.g1();
    }
    static void takes2(Interface2 i) {
        i.f2();
        i.g2();
    }
    static void takes3(Interface3 i) {
        i.f3();
        i.g3();
    }
    static void takesAll(All a) {
        a.f1();
        a.g1();
        a.f2();
        a.g2();
        a.f3();
        a.g3();
        a.h();
    }
    public static void main(String[] args) {
        All a = new All();
        takes1(a);
        takes2(a);
        takes3(a);
        takesAll(a);
    }
}

16.

package com.test.c09;

import java.io.IOException;
import java.nio.CharBuffer;
import java.util.Random;
import java.util.Scanner;
/**
 * 练习16：创建一个类，它将生成一个char序列，适配这个类，使其可以成为
 * Scanner对象的一种输入。
 * @author admin11
 * @date 2018年4月9日
 */
class CharSequence {
    private static Random rand = new Random(47);
    private static final char[] capitals = 
            "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
    private static final char[] lowers = 
            "abcdefghijklmnopqrstuvwxyz".toCharArray();
    private static final char[] vowels = 
            "aeiou".toCharArray();
    char[] generate() {
        char[] buffer = new char[10];
        int idx = 0;
        buffer[idx++] = capitals[rand.nextInt(capitals.length)];
        for(int i = 0; i < 4; i++) {
            buffer[idx++] = vowels[rand.nextInt(vowels.length)];
            buffer[idx++] = lowers[rand.nextInt(lowers.length)];
        }
        buffer[idx] = ' ';
        return buffer;
    }
}

public class Exercise916 extends CharSequence 
    implements Readable {
    private int count;

    public Exercise916(int count) {
        this.count = count;
    }

    @Override
    public int read(CharBuffer cb) throws IOException {
        if(count-- == 0) {
            return -1;
        }
        char[] buffer = generate();
        cb.put(buffer);
        return buffer.length;
    } 
    public static void main(String[] args) {
        Scanner s = new Scanner(new Exercise916(10));
        while(s.hasNext()) {
            System.out.println(s.next());
        }
    }
}

17.

package com.test.c09;
/**
 * 练习17:证明在接口中的域隐式地是static和final的。
 * @author admin11
 * @date 2018年4月9日
 */

interface StaticFinalTest {
    String RED = "Red";
}

class Test implements StaticFinalTest {
    public Test() {
        // The final field StaticFinalTest.RED cannot be assigned
        // RED = "blue";
    }
}

public class Exercise917 {
    public static void main(String[] args) {
        System.out.println("StaticFinalTest.RED = " + StaticFinalTest.RED);
    }
}

18.

package com.test.c09;
/**
 * 练习18：创建一个Cycle接口及其Unicycle、Bicycle和Tricycle
 * 实现。对每种类型的Cycle都创建相应的工厂，然后编写代码使用这些工厂。
 * @author admin11
 * @date 2018年4月10日
 */
interface Cycle {
    int wheels();
}

interface CycleFactory {
    Cycle getCycle();
}

class Unicycle implements Cycle {
    @Override
    public int wheels() {
        return 1;
    }
}

class UnicycleFactory implements CycleFactory {
    @Override
    public Unicycle getCycle() {
        return new Unicycle();
    }
}

class Bicycle implements Cycle {
    @Override
    public int wheels() {
        return 2;
    }
}

class BicycleFactory implements CycleFactory {
    @Override
    public Bicycle getCycle() {
        return new Bicycle();
    }
}

class Tricycle implements Cycle {
    @Override
    public int wheels() {
        return 3;
    }
}

class TricycleFactory implements CycleFactory {
    @Override
    public Tricycle getCycle() {
        return new Tricycle();
    }
}

public class Exercise918 {
    public static void ride(CycleFactory fact) {
        Cycle c = fact.getCycle();
        System.out.println("Num of wheels: " + c.wheels());
    }
    public static void main(String[] args) {
        ride(new UnicycleFactory());
        ride(new BicycleFactory());
        ride(new TricycleFactory());
    }
}

19.

package com.test.c09;
/**
 * 练习19：使用工厂方法来创建一个框架，它可以执行抛硬币和掷骰子功能。
 * @author admin11
 * @date 2018年4月10日
 */
interface Tossing {
    boolean event();
}

interface TossingFactory {
    Tossing getTossing();
}

class CoinTossing implements Tossing {
    private int events;
    private static final int EVENTS = 2;
    @Override
    public boolean event() {
        System.out.println("Coin tossing event " + events);
        return ++events != EVENTS;
    }
}

class CoinTossingFactory implements TossingFactory {
    @Override
    public CoinTossing getTossing() {
        return new CoinTossing();
    }
}

class DiceTossing implements Tossing {
    private int events;
    private static final int EVENTS = 6;
    @Override
    public boolean event() {
        System.out.println("Dice tossing event " + events);
        return ++events != EVENTS;
    }
}

class DiceTossingFactory implements TossingFactory {
    @Override
    public DiceTossing getTossing() {
        return new DiceTossing();
    }
}

public class Exercise919 {
    public static void simulate(TossingFactory fact) {
        Tossing t = fact.getTossing();
        while(t.event()) 
            ;
    }
    public static void main(String[] args) {
        simulate(new CoinTossingFactory());
        simulate(new DiceTossingFactory());
    }
}