thinking in java test chapter10（1）~（21）

练习（1）：编写一个名为Outer的类，它包含一个名为Inner的类。在Outer中添加一个方法，它返回一个Inner类型的对象。在main()中，创建并初始化一个指向某个Inner对象的引用。

public class Test1 {
    class Inner{}
    public Inner getInner(){
        return new Inner();
    }
    public static void main(String[] args){
        Test1 t = new Test1();
        Inner i = t.getInner();
    }
}

练习（2）：创建一个类，它持有一个String，并且有一个显示这个String的toString()方法，将你的新类的若干个对象添加到一个Sequence对象中，然后显示它们。

public class Test2 {
    private Object[] items;
    private int next = 0;
    public Test2(int size) {
        items = new Object[size];
    }
    public void add(Object o) {
        if (next < items.length) {
            items[next++] = o;
        }
    }
    //迭代器设计模式，对外公布一个选择器，可以按照你所设计的顺序访问内部的存储的数据
    //外部使用者不需要关心该类的具体实现，体现了封装的原则
    private class SequenceSelector implements Selector {//内部类，能访问外部类的所有成员
        private int i = 0;
        @Override
        public boolean end() {
            return i == items.length;
        }
        @Override
        public Object current() {
            return items[i];
        }
        @Override
        public void next() {
            if (i < items.length) {
                i++;
            }
        }
    }
    public Selector selector() {
        return new SequenceSelector();
    }
    public static void main(String[] args){
        Test2 t = new Test2(10);
        for (int i = 0; i < 10; i++) {
            t.add(new myClass(i+""));
        }
        Selector selector = t.selector();
        while (!selector.end()){
            System.out.println(selector.current());
            selector.next();
        }
    }
}
class myClass{
    String str;
    public myClass(String s){
        str = s;
    }
    @Override
    public String toString() {
        return str + " " + str;
    }
}
interface Selector{
    boolean end();
    Object current();
    void next();
}

练习（3）：修改练习1，使得Outer类包含一个private string域（由构造器初始化），而Inner包含一个显示这个域的toString()方法。创建一个Inner类型的对象并显示它。

public class Test1 {
    private String str;
    public Test1(String s){
        str = s;
    }
    class Inner{
        @Override
        public String toString() {
            return str;
        }
    }
    public Inner getInner(){
        return new Inner();
    }
    public static void main(String[] args){
        String s = "lalalal";
        Test1 t = new Test1(s);
        Inner i = t.getInner();
        System.out.println(i.toString());
    }
}

练习（4）：在Sequence.SequenceSelector类中增加一个方法，它可以生成对外部类Sequence的引用。

 public Test2 getTest2(){//生成对外部类的引用
            return Test2.this;//不需要外部类的实例
        }

练习（5）：创建一个包含内部类的类，在另一个独立的类中，创建此内部类的实例。

public class Test5 {
    public static void main(String[] args){
        Bird bird = new Bird();
        Bird.Egg egg = bird.new Egg();//必须有外部类的实例才能创建内部类
    }
}
class Bird{
    class Egg{
        public Egg(){
            System.out.println("bird has an egg");
        }
    }
}

练习（6）：在第一个包中创建一个至少有一个方法的接口。然后在第二个包内创建一个类，在其中增加一个protected的内部类以实现那个接口。在第三个包中，继承这个类，并在一个方法中返回该protected内部类对象，在返回的时候向上转型为第一个包中的接口的类型。

public class Test6 extends anclass {
    public firstInter get(){
        return this.new innerClass();//报错
        return new innerClass();//此时编译器报错，该内部类是protected的，需要修改成Public才能用
    }
}

练习（7）：创建一个含有private域和private方法的类。创建一个内部类，它有一个方法可用来修改外部类的域，并调用外围类的方法。在外围类的另一个方法中，创建此内部类的对象，并且调用它的方法，然后说明对外围类对象的影响。

public class Test7 {
    private String name ="weiwei";
    private void sayHi(){
        System.out.println("HI");
    }
    public void test(){
        Test7Inner inner = new Test7Inner();
        inner.name();
    }
    class Test7Inner{
        public void name(){
            name = "xu" + name;
            sayHi();
        }
    }
    public static void main(String[] args){
        Test7 t = new Test7();
        t.test();
        System.out.println(t.name);
    }
}

练习（8）：确定外部类是否可以访问其内部类的private元素。

public class Test8 {
    class T8inner {
        private int count;
    }
    void add(){
        T8inner inner = new T8inner();
        inner.count++;
        System.out.println(inner.count);//最后输出1，可见是可以操作的
    }
    public static void main(String[] args){
        Test8 t = new Test8();
        t.add();
    }
}

练习（9）：创建一个至少有一个方法的接口。在某个方法内定义一个内部类以实现此接口，该方法返回对此接口的引用。
练习（10）：重复前一个练习，但将内部类定义在某个方法的一个作用域内。

public class Test9 {
    private int count;

    listner onClick() {
        if (count > 5) {//在方法的某个作用域内
            class clickListner implements listner {
                @Override
                public void doclick() {
                    System.out.println("doclick");
                }
            }
            clickListner c = new clickListner();
            return c;
        }
        return null;
    }
    public void add() {
        count++;
    }
}

练习（11）：创建一个private内部类，让它实现一个public接口。写一个方法，它返回一个指向此private内部类的实例的引用，并将此引用向上转型为该接口类型。通过尝试向下转型，说明此内部类被完全隐藏了。

public class Test9 {
    private class onClickListner implements listner{
        @Override
        public void doclick() {
            System.out.println("click");
        }
        public void doOther(){
            System.out.println("other");
        }
    }
    public listner setOnClickListner(){
        listner l = new onClickListner();
        return l;
    }
    public static void main(String[] args){
        Test9 t = new Test9();
        listner l = t.setOnClickListner();
//        l.doOther();//编译器报错，cannot resolve method。
    }
}

练习（12）：重复练习7，这次使用匿名内部类。

public class Test12 {
    private int num = 3;
    private void add(){
        num++;
    }
    public anJiekou jiekou(){
        return new anJiekou() {
            @Override
            public void change() {
                num++;
                add();
            }
        };
    }
    public void anotherM(){
        anJiekou a = jiekou();
        a.change();
    }
    public static void main(String[] args){
        Test12 t = new Test12();
        t.anotherM();
        System.out.println("num" + t.num);
    }
}
interface anJiekou{
    void change();
}

练习（13）：重复练习9，这次使用匿名内部类。

public class Test13 {
    public Test13Jiekou setJiekou(){
        return new Test13Jiekou() {
            @Override
            public void method() {
                System.out.println("success");
            }
        };
    }
    public static void main(String[] args){
        Test13 t = new Test13();
        t.setJiekou().method();
    }
}
interface Test13Jiekou{
    void method();
}

练习（14）：修改interface/HorrorShow.java,用匿名类实现DangerousMonster和Vampire。
interface/HorrorShow.java在P180

public class Test14 {
    public Monster getDangerousMonster(){
        return new Monster() {
            @Override
            public void menace() {
                System.out.println("menace");
            }
            public void destroy(){//扩展的方法
                System.out.println("destroy");
            }
        };
    }
    public Lethal getVampire(){
        return new Lethal() {
            @Override
            public void kill() {
                System.out.println("kill");
            }
            public void drinkBlood(){
                System.out.println("dringkBlood");
            }
        };
    }
}
interface Monster{
    void menace();
}
interface Lethal{
    void kill();
}

练习（15）：创建一个类，它有非默认的构造器（既需要参数的构造器），并且没有默认构造器（没有无参数的构造器）。创建第二个类，它包含一个方法，能够返回对第一个类的对象的引用。通过写一个继承自第一个类的匿名内部类，来创建一个返回对象。

public class Test15 {
    public Test15class gett15(String name){
        return new Test15class(name){//继承自Test15class
          void f(){
              System.out.println("extends");
          }  
        };
    }
}
class Test15class{
    private String name;
    public Test15class(String  str){
        name = str;
    }
}

练习（16）：修改第九章中练习18的解决方案，让它使用匿名内部类。

public class Test16 {
    public static void getAnCycle(CycleFactory factory){
        Cycle c = factory.getCycle();
        c.ride();
    }
    public static void main(String[] args){
        getAnCycle(Unicycle.factory);
        getAnCycle(Bicycle.factory);
        getAnCycle(Tricycle.factory);
    }
}
interface Cycle{
    void ride();
}
interface CycleFactory{
    Cycle getCycle();
}
class Unicycle implements Cycle{
    private Unicycle(){}
    @Override
    public void ride() {
        System.out.println("Unicycle ride");
    }
    public static CycleFactory factory = new CycleFactory() {
        @Override
        public Unicycle getCycle() {
            return new Unicycle();
        }
    };
}
class Bicycle implements Cycle{
    private Bicycle(){}
    @Override
    public void ride() {
        System.out.println("Bicycle ride");
    }
    public static CycleFactory factory = new CycleFactory() {
        @Override
        public Cycle getCycle() {
            return new Bicycle();
        }
    };
}
class Tricycle implements Cycle{
    private Tricycle(){}
    @Override
    public void ride() {
        System.out.println("Tricycle");
    }
    public static CycleFactory factory = new CycleFactory() {
        @Override
        public Cycle getCycle() {
            return new Tricycle();
        }
    };
}

练习（17）：修改第9章练习19的解决方案，让它使用匿名内部类。

public class Test19 {
    public static void playGame(PlayGame p){
        Game game = p.getGame();
        game.play();
    }
    public static void main(String[] args){
        playGame(PaoYingBi.playGame);
        playGame(ZhiShaiZi.playGame);
    }
}
interface Game{
    void play();
}
interface PlayGame{
    Game getGame();
}
class PaoYingBi implements Game{
    private PaoYingBi(){}
    @Override
    public void play() {
        System.out.println("抛硬币");
    }
    public static PlayGame playGame = new PlayGame() {
        @Override
        public Game getGame() {
            return new PaoYingBi();
        }
    };
}
class ZhiShaiZi implements Game{
    private ZhiShaiZi(){}
    @Override
    public void play() {
        System.out.println("掷硬币");
    }
    public static PlayGame playGame = new PlayGame() {
        @Override
        public Game getGame() {
            return new ZhiShaiZi();
        }
    };
}

练习（18）：创建一个包含嵌套类的类。在main()中创建起内部类的实例。

public class Test18 {
    static class Innerstatic{//静态内部类又称为嵌套类
        private void f(){
            System.out.println("innerstatic created");
        }
        private int anInt = 10;
    }
    public static void main(String[] args){
        Innerstatic innerstatic = new Innerstatic();
        //嵌套类不需要外部类的引用即可创建
    }
}

练习（19）：创建一个包含内部类的类，而此内部类又包含有内部类。使用嵌套类重复这回过程。注意编译器生成的.class文件的名字。

public class Test19real {
    static class Birdd{
        private String name;
        public Birdd(String str){
            name = str;
        }
        static class Chicken{
            void eat(){
                System.out.println("吃小米");
            }
        }
    }
    public static void main(String[] args){
        Birdd.Chicken c = new Birdd.Chicken();
        c.eat();
    }
}

练习（20）：创建一个包含嵌套类的接口，实现此接口并创建嵌套类的实例。

public class Test20 implements includeInner{
    public static void main(String[] args){
        inside i = new inside();
        i.f();
    }
}
interface includeInner{
    class inside{
        static void f(){
            System.out.println("接口嵌套类内部静态方法");
        }
    }
}

练习（21）：创建一个包含嵌套类的接口，该嵌套类中有一个static方法，它将调用接口中的方法并显示结果。实现这个接口，并将这个实现的一个实例传递给这个方法。

public class Test21 implements Dog{
    @Override
    public void bite() {
        System.out.println("Test21");
    }
    public static void main(String[] args){
        WangWang w = new WangWang();
        w.f();
    }
}
interface Dog{
    void bite();
    class WangWang implements Dog{
        static void f(){
            new WangWang().bite();
        }
        @Override
        public void bite() {
            System.out.println("bite");
        }
    }
}