java编程思想第四版第十章习题

package net.mindview.innerclasses;

public class Outer {
     Inner {
        Inner(){
            System.out.println("这是一个内部类");
        }
    }

    public Inner in(){
        return new Inner();
    }
    
    static void main(String[] args) {
        Outer out =  Outer();
        Outer.Inner inner = out.();
    }
}

package net.mindview.innerclasses;
/**
 * 选择器
 */
interface Selector3 {
    //是否结束
    boolean end();
    当前
    Object current();
    下一个
     next();
}

 OtherObject3 {
    String obj;
    OtherObject3(String obj){
        this.obj = obj;
    }
    
    @Override
    public String toString() {
        return obj;
    }
}

*
 * 次序
  Sequence3 {
    private Object[] items;
    private int next = 0;
    定义数组的个数
    public Sequence3(int size){
        items =  Object[size];
    }
    添加
     add(Object x){
        items[next ++] = x;
    }
    
    内部类--顺序选择器
     SequenceSelector implements Selector {
        选择器最开始指向第一个元素
        int i = ;
        @Override
         boolean end() {
            return i == (items.length);
        }

        @Override
         Object current() {
             TODO Auto-generated method stub
             items[i];
        }

        @Override 
         next() {
            if(i<items.length){
                i++;
            }
        }
    }
    
     Selector selector() {
         SequenceSelector();
    }
    
     main(String[] args) {
        Sequence3 s = new Sequence3(10);
        for(int i=0; i<10; i++){
            s.add(new OtherObject(对象"+i));
        }
        Selector selector = s.selector();
        while(!selector.end()){
            System.out.println(selector.current());
            selector.next();
        }
    }

}

 next();
    @Override
     String toString();
}

 String str;
     size,String str){
        items =  Object[size];
        this.str = str;
    }
     SequenceSelector implements Selector3 {
        ;
            }
        }
        
         String toString() {
             str;
        }
    }
    
     Selector3 selector() {
        10,三星i));
        }
        Selector3 selector =.println(selector.current());
            selector.next();
            System..println(selector.toString());
        }
    }

}

 Selector {
     OtherObject {
    String obj;
    OtherObject(String obj){
         Sequence {
    public Sequence( (items.length);
        }
        *
         * 新增方法: 在内部类中引用外部类
         */
         Sequence outer(){
            return Sequence.this;
        }

        @Override
         main(String[] args) {
        Sequence s = new Sequence(){
            s.add(i);
        }
        Selector selector =.println(selector.current());
            selector.next();
        }
    }

}

 Outter{
     Inner{
        
    }
}

 Test5 {
     getInner(){
        Outter outter =  Outter();
        Outter.Inner in = outter. Inner();
    }
}

package net.mindview.innerclasses.test6.one;

 One {
     String one();
}

package net.mindview.innerclasses.test6.two;

import net.mindview.innerclasses.test6.one.One;

 Two {
    protected  TwoInner implements One{
         TwoInner() {
            System.这时two的内部类,继承自One);
        }

        @Override
         String one() {
            return Two->one();
        }
        
    }
}

package net.mindview.innerclasses.test6.three;

import net.mindview.innerclasses.test6.one.One;
import net.mindview.innerclasses.test6.two.Two;

 Three extends Two{
     Two two;
     Three(Two two){
        System.这时Three类this.two = two;
    }
     One three(){
        
        return two. TwoInner();
    }
     main(String[] args) {
        Three three = new Three( Two());
        One one = three.three();
        System..println(one.one());
    }

}

package net.mindview.innerclasses.test7;
 Update{
    String update();
}
 Show {
     String str;
    
     String showStr(){
         str;
    }
    
     InnerUpdate implements Update{
        int abc = 123;
         String update(){
            str = 内部类修改;
            System..println(str);
             showStr();
        }
    }
    
     visitInner(){
        InnerUpdate update =  InnerUpdate();
        System..println(update.abc);
        update.update();
    }
    
     main(String[] args) {
        Show show =  Show();
        show.visitInner();
    }
}

package net.mindview.innerclasses.test9;

 Show{
    String show();
}

 Test9 {
     String update(){
         Inner implements Show{
            @Override
             String show() {
                学习;
            }
        }
        
        Inner inner =  Inner();
         inner.show();
    }
     main(String[] args) {
        Test9 t =  Test9();
        System..println(t.update());
    }
}

 String update(boolean flag){
        String str=nullif(flag){
             Inner implements Show{
                @Override
                 String show() {
                    ;
                }
            }
            Inner inner =  Inner();
            str = inner.show();
        }
        out.println(t.update(true));
    }
}

package net.mindview.innerclasses.test10;

 InterfaceClass{
     i();
}

 Test10 {
     Inner implements InterfaceClass{
        @Override
         i() {
        }
    }
    
     InterfaceClass inner(){
         main(String[] args) {
        Test10 test10 =  Test10();
        InterfaceClass inner = test10.inner();
        这样不可以,所以被隐藏了
        Inner inner = test10.inner();
    }

}

package net.mindview.innerclasses.test12;
 Update visitInner(){
         Update(){
            ;
            @Override
             String update() {
                str = ;
                System..println(str);
                 showStr();
            }
        };
    }
    
     Show();
        show.visitInner().update();
    }
}

package net.mindview.innerclasses.test13;

 Test13 {
     Show(){
                @Override
                ;
                }
                
            }.show();
        }
         main(String[] args) {
        Test13 t =  Test13();
        System.));
    }
}

package net.mindview.innerclasses.test15;

 Person {
     String name;
     Person(String name){
        this.name = name;
    }
    @Override
     name;
    }
}
 Test15 {
     Person method(String name){
         Person(name){
            @Override
             String toString() {
                 super.toString();
            }
        };
    }
     main(String[] args) {
        Test15 t =  Test15();
        System.out.println(t.method(张三).toString());
    }

}

package net.mindview.innerclasses.test16;
 Cycle {
     make();
}

 CycleFactory {
    Cycle getCycle();
}

 Unicycle implements Cycle{
     Unicycle(){}

    @Override
     make() {
        System.make Unicycle);
    }
    
    static CycleFactory factory =  CycleFactory(){
        @Override
         Cycle getCycle() {
             Unicycle();
        }
    };
}

 Bicycle implements Cycle{
     Bicycle(){}

    @Override
    make Bicycle Bicycle();
        }
    };
}

 Tricycle implements Cycle{
     Tricycle(){}

    @Override
    make Tricycle Tricycle();
        }
    };
}

 Cycles {
     serice(CycleFactory factory){
        Cycle c = factory.getCycle();
        c.make();
    }
     main(String[] args) {
        我想要什么样的车,就找这种车的工厂去制作一辆车就可以了
        serice(Unicycle.factory);
        serice(Bicycle.factory);
        serice(Tricycle.factory);
    }

}

package net.mindview.innerclasses.test17;

import java.util.Random;

*
 * 这时一个抛硬币和掷骰子等类型的框架
 */

 ThrowProduct {}
 ThrowFactory{
    ThrowProduct getProduct();
}
 ThrowCorn implements ThrowProduct{
    Random rand =  Random();
     ThrowCorn(){
        if(rand.nextInt(100) % 2 ==){
            System.硬币的正面);
        }else{
            System.硬币的反面);
        }
    }
    
    static ThrowFactory factory =  ThrowFactory(){
        @Override
         ThrowProduct getProduct() {
             ThrowCorn();
        }
    };
}

 ThrowDice implements ThrowProduct{
    Random rand =  ThrowDice(){
        System.掷的骰子数是"+(rand.nextInt(6)+1));
    }
    
     ThrowDice();
        }
    };
}

 ThrowFrame {
     service(ThrowFactory f){
        ThrowProduct p = f.getProduct();
    }
     main(String[] args) {
        service(ThrowCorn.factory);
        service(ThrowDice.factory);

    }

}

package net.mindview.innerclasses.test18;

 Test18 {
     QianTao{
        
    }
     main(String[] args) {
        QianTao q =  QianTao();
    }
}

package net.mindview.innerclasses.test19;

 Test19 {
    这时一个嵌套类
     Inner1{
        
        这时定义在嵌套类中的嵌套类
         Inner2{
            100; 
        }
    }
     main(String[] args) {
        System..println(Inner1.Inner2.i);
    }
}

编译后的文件结构:

?

package net.mindview.innerclasses.test20;
 InnerInInterface{
     Inner{
         Inner(){
            System.嵌套类构造方法);
        }
    }
}

 Test20 {
    直接使用  new 外围类.嵌套类
        InnerInInterface.Inner inner =  InnerInInterface.Inner();
    }
}

?

package net.mindview.innerclasses.test21;
 InterfaceClass {
     f();
     b();
     InnerClass{
        void get(InterfaceClass impl){
            impl.f();
        }
    }
}
 Test21 implements InterfaceClass{
     Test21(){
        System.这是Test21构造函数的方法);
    }
     main(String[] args) {
        
        Test21 t =  Test21();
        new InterfaceClass.InnerClass().(t);;
        
    }

    @Override
     f() {
        System.实现类   f());
    }

    @Override
     b() {
        System.实现类   b());    
    }

}

?

package net.mindview.innerclasses.test22;

选择器
 Selecotr {
    选择器是否到达尾部
下一个元素编号
     next();
    当前元素
    Object current();
    
}

 Object[] items ;
    int counter = 0; i<size; i++){
            add(i);
        }
    }
    
     add(Object o){
        items[counter++] = o;
    }
    
    public  Selecotr sequenceSelector =  Selecotr(){
         items.length;
        }
        @Override
        items.length)
                i++;
        }
        @Override
        items.length){
                 items[i];
            }
            ;
        }
    };
    反序
    public Selecotr reverseSelector = 9;
        
        @Override
        return i< next() {
            i--if(i>=){
                ;
        }
        
    };
    
    );
        
        正序
        Selecotr se = s.sequenceSelector;
        se.end()){
            System..println(se.current());
            se.next();
        }
        System.-----------反序
        Selecotr re = s.reverseSelector;
        re.end()){
            System..println(re.current());
            re.next();
        }
        
        
    }

}

?

package net.mindview.innerclasses.test23;

 U {
     method1();
     method2();
     method3();
}

 A {
    U methodA1(){
         U(){
            @Override
             method1() {
                System.A methodA1 method1());
            }

            @Override
             method2() {
                System.A methodA1 method2() method3() {
                System.A methodA1 method3());
            }
        };
    }
}

 B {
    U[] us ;
    ; 
    public B( size){
        us =  U[size];
    }
     methodB1(U u){
        us[counter++] = u;
    }
    void methodB2( i){
        us[i] = ;
    }
     methodB3(){
        0; i<us.length; i++){
            U u = us[i];
            u.method1();
            u.method2();
            u.method3();
        }
    }
    
     main(String[] args) {
        A a1 =  A();
        A a2 =  A();
        A a3 =  A();
        A a4 =  A();
        A a5 =  A();
        B b1 = new B(5);
        b1.methodB1(a1.methodA1());
        b1.methodB1(a2.methodA1());
        b1.methodB1(a3.methodA1());
        b1.methodB1(a4.methodA1());
        b1.methodB1(a5.methodA1());
        
        b1.methodB3();
        System.----------------);
        b1.methodB2(2);
        b1.methodB3();
    }
}

?