thinking in java test chapter9接口（11）~（19）适配器模式,工厂模式

练习（11）：创建一个类，它有一个方法用于接受一个String类型的参数，生成的结果是将该参数中每一个字符进行互换。对该类进行适配，使得它可以用于interfaceprocessor.Apply.process()。
适配器设计模式，就是接受你所拥有的接口，并产生你所需要的接口。
这里我们可以写一个adapter类，它继承了interfaceprocessor里的processor接口，并且有一个你所编写的类成员对象，在他的process方法里，调用了你所编写的类的转换方法。

public class StringChange {
    public String name(){
        return getClass().getSimpleName();
    }
    public String change(String str){
        char[] chars = str.toCharArray();

        int length = chars.length - 1;
        for (int i = 0; i < length/2; i++) {
            char a = chars[i];
            chars[i] = chars[length -i];
            chars[length - i] = a;
        }
        StringBuilder builder = new StringBuilder();
        for (char a :
                chars) {
            builder.append(a);
        }
        return builder.toString();
    }
    public static void main(String[] args){
        String str = "abcdefg";
        Apply.process(new StringAdapter(new StringChange()),str);
    }
}
class StringAdapter implements Processor{
    StringChange sc;
    public StringAdapter(StringChange stringChange){
        sc = stringChange;
    }
    @Override
    public String name() {
        return sc.name();
    }
    @Override
    public Object process(Object input) {//关键部分，连接你的接口与提供的接口
        return sc.change((String) input);
    }
}

练习（12）：在Adventure.java中，按照其他接口的样式，增加一个CanClimb接口。
练习（13）：创建一个接口，并从该接口继承两个接口，然后从后面两个接口多重继承第三个接口。

public class Adventure {
}
interface CanDo{//1，创建一个接口
    void dodo();
}
interface CanFight extends CanDo,CanFly{//2，继承，多重继承第三个接口
    void fight();
}
interface CanSwim extends CanDo,CanFly{//接口是可以多重继承的,因为接口是完全抽象的，没有任何具体实现
    void swim();
}
interface CanFly{
    void fly();
}
interface CanCimb{//创建一个新接口
    void climb();
}
class ActionCharacter{
    public void fight(){}//该方法与接口CanFight中的方法同名，所以Hero类继承该类与CanFight接口但不需要显示的写fight方法
}
class Hero extends ActionCharacter implements CanFight,CanFly,CanSwim,CanCimb{
    @Override
    public void swim() {}
    @Override
    public void fly() {}
    @Override
    public void climb() {}
    @Override
    public void dodo() {}
}

练习（14）：创建三个接口，每个接口都包含两个方法。继承出一个接口，它组合了这三个接口并添加了一个新方法。创建一个实现了该新接口并且继承了某个具体类的类。现在编写四个方法，并且每一个都接受这四个接口之一作为参数。在main()方法中，创建这个类的对象，并将其传递给这四个方法。

public class Test14 {
    public static void main(String[] args){
        CanDoAll cda = new CanDoAll();
        cda.doFirst(cda);
        cda.doSecond(cda);
        cda.doThird(cda);
        cda.doAll(cda);
    }
}
interface First{
    void doF();
    void drawF();
}
interface Second{
    void doS();
    void drawS();
}
interface Third{
    void doT();
    void drawT();
}
interface All extends First,Second,Third{
    void doAll();
}
class CanDoAll extends Test1 implements All{
    public void doFirst(First f){
        System.out.println("doFirst");
    }
    public void doSecond(Second s){
        System.out.println("doSecond");
    }
    public void doThird(Third t){
        System.out.println("doThird");
    }
    public void doAll(All a){
        System.out.println("doAll");
    }
    @Override
    public void doF() {}
    @Override
    public void drawF() {}
    @Override
    public void doS() {}
    @Override
    public void drawS() {}
    @Override
    public void doT() {}
    @Override
    public void drawT() {}
    @Override
    public void doAll() {
    }
}

可以看到，虽然java中没有类似c++继承多个类，接口使我们可以将一个类向上转型为多种类型，也可认为是多重继承。

练习（15）：将前一个练习修改为:创建一个抽象类，并将其继承到一个导出类中。

public class Test14 {
    public static void main(String[] args){
        CanDoAll cda = new CanDoAll();
       cda.doFirst(cda);
    }
}
abstract class First{
    void doF(){};
    void drawF(){};
}
class CanDoAll extends First{
    public void doFirst(First f){
        System.out.println("doFirst");
    }
}

练习（16）：创建一个类，它将生成一个char序列，适配这个类，使其可以成为Scanner对象的一种输入.

public class Test16 {
    public static void main(String[] args){
        Scanner s = new Scanner(new CharAdapter(10));
        while (s.hasNext()){
            System.out.println(s.next());
        }
    }
}
class MyChar {
    private static Random rand = new Random(1000);
    public char next(){
        return (char) rand.nextInt(50);
    }
}
class CharAdapter extends MyChar implements Readable{
    private int count ;
    public CharAdapter(int i){
        count = i;
    }
    @Override
    public int read(CharBuffer cb) throws IOException {
        if (count -- == 0){
            return -1;
        }
        cb.append(next());
        return cb.length();
    }
}

练习（17）：证明在接口中的域隐式的是static和final的。
在Java SE5之前，没有enum，所以那时候都是用接口来实现类似enum的功能。

public class Test17 {
    public static void main(String[] args){
        ceshi c = new ceshi();
        System.out.println(c.j);
        ceshi c1 = new ceshi();
        System.out.println(c1.j);
        //两个输出一样，证明是static的
    }
}
interface yu{
    int i = 10;
    int j = 20;
}
class ceshi implements yu{
    void add(){
//        i++;//编译器报错，can not assign a value to final variable
    }
}

练习（18）：创建一个Cycle接口及其Unicycle,Bicycle和Tricycle实现。对每种类型的Cycle都创建相应的工厂，然后编写代码使用这些工厂。

public class Test18 {
    public static void main(String[] args){
        new UniFactory().getUnicycle();
        new BiFactory().getBicy();
        new TriFactory().getTri();
    }
}
interface Cycle{
    void ride();
}
class Unicycle implements Cycle{
    @Override
    public void ride() {
        System.out.println("Unicycle");
    }
}
class UniFactory {
    public Unicycle getUnicycle(){
        return new Unicycle();
    }
}
class Bicycle implements Cycle{
    @Override
    public void ride() {
        System.out.println("Bicycle");
    }
}
class BiFactory {
    public Bicycle getBicy(){
        return new Bicycle();
    }
}
class Tricycle implements Cycle{
    @Override
    public void ride() {
        System.out.println("Tricycle");
    }
}
class TriFactory {
    public Tricycle getTri(){
        return new Tricycle();
    }
}

练习（19）：使用工厂方法来创建一个框架，它可以执行抛硬币和掷骰子功能。

public class PlayGame {
    public static void main(String[] args){
        PlayYingBi yingBi = new PlayYingBi();
        PlayShaiZi shaiZi = new PlayShaiZi();
        gameFactory factory = new gameFactory();
        factory.play(yingBi);
        factory.play(shaiZi);
    }
}
interface Play{
    void game();
}
interface PlayFactory{
    void play(Play play);
}
class PlayYingBi implements Play {
    @Override
    public void game() {
        System.out.println("抛硬币");
    }
}
class PlayShaiZi implements Play{
    @Override
    public void game() {
        System.out.println("掷骰子");
    }
}
class gameFactory implements PlayFactory{
    @Override
    public void play(Play p) {
        p.game();
    }
}