JAVA编程思想第九章练习

练习1：

package Cycle1;
abstract class Rodent1{
    public abstract void hop();
    public abstract void scurry();
    public abstract void reproduce();
        }
class Mouse1 extends Rodent1{
    @Override
    public void hop() {
        System.out.println("Mouse1");
    }

    @Override
    public void scurry() {
        System.out.println("Mouse2");
    }

    @Override
    public void reproduce() {
        System.out.println("Mouse3");
    }

    @Override
    public String toString() {
        return "Mouse";
    }
}
class Gerbil1 extends Rodent1{
    @Override
    public void hop() {
        System.out.println("Gerbil1");
    }

    @Override
    public void scurry() {
        System.out.println("Gerbil2");
    }

    @Override
    public void reproduce() {
        System.out.println("Gerbil3");
    }

    @Override
    public String toString() {
        return "Gerbil";
    }
}
class Hamster1 extends Rodent1{
    @Override
    public void hop() {
        System.out.println("Hamster1");
    }

    @Override
    public void scurry() {
        System.out.println("Hamster2");
    }

    @Override
    public void reproduce() {
        System.out.println("Hamster3");
    }

    @Override
    public String toString() {
        return "Hamster";
    }
}
public class E01 {
    public static void main(String[] args) {
        Rodent1[] rodent1s = {new Mouse1(),new Gerbil1(),new Hamster1()};
        for (Rodent1 r :
                rodent1s) {
            r.hop();
            r.reproduce();
            r.scurry();
            r.toString();
        }
    }

}

练习2：

abstract class test{
    void f(){
        System.out.println("f()");
    }
}
public class E02 extends test{
    public static void main(String[] args) {
        new test();
    }
}

练习3： 

abstract class printf{
    public abstract void print();
}
public class E03 extends printf{
    int i = 47;
    @Override
    public void print() {
        System.out.println("i = " + i);
    }

    public static void main(String[] args) {
        E03 e03 = new E03();
        e03.print();
    }
}

 

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{
    public void f(){
        System.out.println("Extended2.f");
    }
}
public class E04 {
    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);
    }
}

 

import filters.Interface1;

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

    @Override
    public void g() {
        System.out.println("g()");
    }

    @Override
    public void h() {
        System.out.println("h()");
    }

    public static void main(String[] args) {
        E05 e05 = new E05();
        e05.f();
        e05.h();
        e05.g();
    }
}

练习6： 

import filters.Interface1;

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

    @Override
    void g() {
        System.out.println("g()");
    }

    @Override
    void h() {
        System.out.println("h()");
    }

    public static void main(String[] args) {
        E05 e05 = new E05();
        e05.f();
        e05.h();
        e05.g();
    }
}

 

 练习7：

package Cycle1;
interface Rodent1{
    public void hop();
    public void scurry();
    public void reproduce();
        }
class Mouse1 implements Rodent1{
    @Override
    public void hop() {
        System.out.println("Mouse1");
    }

    @Override
    public void scurry() {
        System.out.println("Mouse2");
    }

    @Override
    public void reproduce() {
        System.out.println("Mouse3");
    }

    @Override
    public String toString() {
        return "Mouse";
    }
}
class Gerbil1 implements Rodent1{
    @Override
    public void hop() {
        System.out.println("Gerbil1");
    }

    @Override
    public void scurry() {
        System.out.println("Gerbil2");
    }

    @Override
    public void reproduce() {
        System.out.println("Gerbil3");
    }

    @Override
    public String toString() {
        return "Gerbil";
    }
}
class Hamster1 implements Rodent1{
    @Override
    public void hop() {
        System.out.println("Hamster1");
    }

    @Override
    public void scurry() {
        System.out.println("Hamster2");
    }

    @Override
    public void reproduce() {
        System.out.println("Hamster3");
    }

    @Override
    public String toString() {
        return "Hamster";
    }
}
public class E01 {
    public static void main(String[] args) {
        Rodent1[] rodent1s = {new Mouse1(),new Gerbil1(),new Hamster1()};
        for (Rodent1 r :
                rodent1s) {
            r.hop();
            r.reproduce();
            r.scurry();
            r.toString();
        }
    }

}

练习8：

练习9：

练习10： 

 

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 String process(Object input) {
        return CharacterPairSwapper.swap((String) input);
    }
}

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

    public static void main(String[] args) {
        apply(new SwapperAdapter(),"1234");
        apply(new SwapperAdapter(),"abcde");

    }
}

 

interface CanClimb{
    void climb();
}

class Hero2 extends ActionCharacter implements CanFight,CanSwim,CanFly,CanClimb{
    @Override
    public void swim() {

    }

    @Override
    public void fly() {

    }

    @Override
    public void climb() {

    }
}

public class E12 {
    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 z(CanClimb x){
        x.climb();
    }

    public static void w(ActionCharacter x) {
        x.fight();
    }

    public static void main(String[] args) {
        Hero2 h = new Hero2();
        t(h);
        u(h);
        v(h);
        z(h);
        w(h);
    }
}

interface Base{
    void f();
}
interface Min extends Base{
    @Override
    void f();
}
interface Last extends Base{
    @Override
    void f();
}
interface Combined extends Min,Last{
    @Override
    void f();
}
class CombinedImpl implements Combined{
    @Override
    public void f() {
        System.out.println("Combined.f()");
    }
}
public class E13 {
    public static void main(String[] args) {
        new CombinedImpl().f();
    }
}

interface I1{
    void q();
    void w();
}
interface I2{
    void e();
    void r();
}
interface I3{
    void t();
    void y();
}
interface Extended extends I1,I2,I3{
    void u();
} 

class Concrete{
    String s;

    public Concrete(String s) {
        this.s = s;
    }
}
class All extends Concrete implements Extended{
    public All(String s) {
        super(s);
    }

    @Override
    public void q() {
        System.out.println("q");
    }

    @Override
    public void w() {
        System.out.println("w");
    }

    @Override
    public void e() {
        System.out.println("e");
    }

    @Override
    public void r() {
        System.out.println("r");
    }

    @Override
    public void t() {
        System.out.println("t");
    }

    @Override
    public void y() {
        System.out.println("y");
    }

    @Override
    public void u() {
        System.out.println("u");
    }
}
public class E14 {
    static void takes1(I1 i){
        i.q();
        i.w();
    }
   static void takes2(I2 i){
        i.e();
        i.r();
    }
   static void takes3(I3 i){
        i.t();
        i.y();
    }
   static void takesAll(All a){
        a.q();
        a.w();
        a.e();
        a.r();
        a.t();
        a.y();
        a.u();
    }

    public static void main(String[] args) {
        All a = new All("s");
        takes1(a);
        takes2(a);
        takes3(a);
        takesAll(a);
        
    }
}

 

 

interface I1{
    void q();
    void w();
}
interface I2{
    void e();
    void r();
}
interface I3{
    void t();
    void y();
}
interface Extended extends I1,I2,I3{
    void u();
}
abstract class Abstract{
    String s;

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

    public Concrete(String s) {
        this.s = s;
    }
}
class All extends Abstract implements Extended{
    public All(String s) {
        super(s);
    }
    void af(){
        System.out.println("af");
    }

    @Override
    public void q() {
        System.out.println("q");
    }

    @Override
    public void w() {
        System.out.println("w");
    }

    @Override
    public void e() {
        System.out.println("e");
    }

    @Override
    public void r() {
        System.out.println("r");
    }

    @Override
    public void t() {
        System.out.println("t");
    }

    @Override
    public void y() {
        System.out.println("y");
    }

    @Override
    public void u() {
        System.out.println("u");
    }
}
public class E14 {
    static void takes1(I1 i){
        i.q();
        i.w();
    }
   static void takes2(I2 i){
        i.e();
        i.r();
    }
   static void takes3(I3 i){
        i.t();
        i.y();
    }
   static void takesAll(All a){
        a.q();
        a.w();
        a.e();
        a.r();
        a.t();
        a.y();
        a.u();
    }
    static void takesAbstract(Abstract a){
        a.af();
    }

    public static void main(String[] args) {
        All a = new All("s");
        takes1(a);
        takes2(a);
        takes3(a);
        takesAll(a);
        takesAbstract(a);
    }
}

 

import java.nio.CharBuffer;
import java.util.Random;
import java.util.Scanner;

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(vowels.length)];

        }
        buffer[idx] = ' ';
        return  buffer;
    }
}
public class E16 extends CharSequence implements Readable{
    private int count;
    public E16(int count){
        this.count = count;
    }
    public int read(CharBuffer cb){
        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 E16(10));
        while (s.hasNext())
            System.out.println(s.next());
    }
}

 

interface StaticFinalTest{
    String RED = "Red";
}
class Test implements StaticFinalTest{
    public Test(){}
}
public class E17 {
    public static void main(String[] args) {
        System.out.println("staticfinaltest.red = " + StaticFinalTest.RED);
    }



}

interface Cycle{
    int wheels();
}
interface CycleFactory{
    Cycle getCycle();
}
class Unicycle implements Cycle{
    public int wheels(){return 1;}
}
class UnicycleFactory implements CycleFactory{
    public Unicycle getCycle(){return new Unicycle();}
}
class Bicycle implements Cycle{
    @Override
    public int wheels() {
        return 2;
    }
}
class BicycleFactory implements CycleFactory{
    public Bicycle getCycle() {return new Bicycle();}
}
class Tricycle implements Cycle{
    public int wheels(){return 3;}
}
class TricycleFactory implements CycleFactory{
    public Tricycle getCycle(){return new Tricycle();}
}
public class E18 {
    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：

interface Tossing{boolean event();}
interface TossingFactory {Tossing getTossing();}
class CoinTossing implements Tossing{
    private int events;
    private static final int EVENTS = 2;
    public boolean event(){
        System.out.println("Coin tossing event " + events);
        return ++events != EVENTS;
    }
}
class CoinTossingFactory implements TossingFactory{
    @Override
    public Tossing getTossing() {
        return new CoinTossing();
    }
}
class DiceTossing implements Tossing{
    private int events;
    private static final int EVENTS = 6;
    public boolean event(){
        System.out.println("events = " + events);
        return ++events != EVENTS;
    }
}
class DiceTossingFactory implements TossingFactory{
    @Override
    public Tossing getTossing() {
        return new DiceTossing();
    }
}
public class E19 {
    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());
    }
}