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

第一题

package net.mindview.innerclasses;

public class Outer {

    class Inner {

        Inner(){

            System.out.println("这是一个内部类");

        }

    }

    public Inner in(){

        return new Inner();

    }

    public static void main(String[] args) {

        Outer out = new Outer();

        Outer.Inner inner = out.in();

    }

}

第二题

package net.mindview.innerclasses;

/**

 * 选择器

 */

interface Selector3 {

    //是否结束

    boolean end();

    //当前

    Object current();

    //下一个

    void next();

}

class OtherObject3 {

    String obj;

    OtherObject3(String obj){

        this.obj = obj;

    }

    @Override

    public String toString() {

        return obj;

    }

}

/**

 * 次序

 */

public class Sequence3 {

    private Object[] items;

    private int next = ;

    //定义数组的个数

    public Sequence3(int size){

        items = new Object[size];

    }

    //添加

    public void add(Object x){

        items[next ++] = x;

    }

    //内部类--顺序选择器

    private class SequenceSelector implements Selector {

        //选择器最开始指向第一个元素

        private int i = ;

        @Override

        public boolean end() {

            return i == (items.length);

        }

        @Override

        public Object current() {

            // TODO Auto-generated method stub

            return items[i];

        }

        @Override

        public void next() {

            if(i<items.length){

                i++;

            }

        }

    }

    public Selector selector() {

        return new SequenceSelector();

    }

    public static void main(String[] args) {

        Sequence3 s = new Sequence3();

        for(int i=; i<; i++){

            s.add(new OtherObject("对象"+i));

        }

        Selector selector = s.selector();

        while(!selector.end()){

            System.out.println(selector.current());

            selector.next();

        }

    }

}

第三题

package net.mindview.innerclasses;

/**

 * 选择器

 */

interface Selector3 {

    //是否结束

    boolean end();

    //当前

    Object current();

    //下一个

    void next();

    @Override

    public String toString();

}

class OtherObject3 {

    String obj;

    OtherObject3(String obj){

        this.obj = obj;

    }

    @Override

    public String toString() {

        return obj;

    }

}

/**

 * 次序

 */

public class Sequence3 {

    private Object[] items;

    private int next = ;

    private String str;

    //定义数组的个数

    public Sequence3(int size, String str){

        items = new Object[size];

        this.str = str;

    }

    //添加

    public void add(Object x){

        items[next ++] = x;

    }

    //内部类--顺序选择器

    private class SequenceSelector implements Selector3 {

        //选择器最开始指向第一个元素

        private int i = ;

        @Override

        public boolean end() {

            return i == (items.length);

        }

        @Override

        public Object current() {

            // TODO Auto-generated method stub

            return items[i];

        }

        @Override

        public void next() {

            if(i<items.length){

                i++;

            }

        }

        public String toString() {

            return str;

        }

    }

    public Selector3 selector() {

        return new SequenceSelector();

    }

    public static void main(String[] args) {

        Sequence3 s = new Sequence3(, "三星");

        for(int i=; i<; i++){

            s.add(new OtherObject("对象"+i));

        }

        Selector3 selector = s.selector();

        while(!selector.end()){

            System.out.println(selector.current());

            selector.next();

            System.out.println(selector.toString());

        }

    }

}

第四题

package net.mindview.innerclasses;

/**

 * 选择器

 */

interface Selector {

    //是否结束

    boolean end();

    //当前

    Object current();

    //下一个

    void next();

}

class OtherObject {

    String obj;

    OtherObject(String obj){

        this.obj = obj;

    }

    @Override

    public String toString() {

        return obj;

    }

}

/**

 * 次序

 */

public class Sequence {

    private Object[] items;

    private int next = ;

    //定义数组的个数

    public Sequence(int size){

        items = new Object[size];

    }

    //添加

    public void add(Object x){

        items[next ++] = x;

    }

    //内部类--顺序选择器

    private class SequenceSelector implements Selector {

        //选择器最开始指向第一个元素

        private int i = ;

        @Override

        public boolean end() {

            return i == (items.length);

        }

        /**

         * 新增方法: 在内部类中引用外部类

         */

        public Sequence outer(){

            return Sequence.this;

        }

        @Override

        public Object current() {

            // TODO Auto-generated method stub

            return items[i];

        }

        @Override

        public void next() {

            if(i<items.length){

                i++;

            }

        }

    }

    public Selector selector() {

        return new SequenceSelector();

    }

    public static void main(String[] args) {

        Sequence s = new Sequence();

        for(int i=; i<; i++){

            s.add("对象"+i);

        }

        Selector selector = s.selector();

        while(!selector.end()){

            System.out.println(selector.current());

            selector.next();

        }

    }

}

第五题

package net.mindview.innerclasses;

class Outter{

    class Inner{

    }

}

public class Test5 {

    public void getInner(){

        Outter outter = new Outter();

        Outter.Inner in = outter.new Inner();

    }

}

第六题

package net.mindview.innerclasses.test6.one;

public interface One {

    public String one();

}

package net.mindview.innerclasses.test6.two;

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

public class Two {

    protected class TwoInner implements One{

        public TwoInner() {

            System.out.println("这时two的内部类,继承自One");

        }

        @Override

        public 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;

public class Three extends Two{

    private Two two;

    public Three(Two two){

        System.out.println("这时Three类");

        this.two = two;

    }

    public One three(){

        return two.new TwoInner();

    }

    public static void main(String[] args) {

        Three three = new Three(new Two());

        One one = three.three();

        System.out.println(one.one());

    }

}

第七题

package net.mindview.innerclasses.test7;

interface Update{

    String update();

}

public class Show {

    private String str;

    private String showStr(){

        return str;

    }

    private class InnerUpdate implements Update{

        private int abc = ;

        public String update(){

            str = "内部类修改";

            System.out.println(str);

            return showStr();

        }

    }

    public void visitInner(){

        InnerUpdate update = new InnerUpdate();

        System.out.println(update.abc);

        update.update();

    }

    public static void main(String[] args) {

        Show show = new Show();

        show.visitInner();

    }

}

(略)

第九题

package net.mindview.innerclasses.test9;

interface Show{

    String show();

}

public class Test9 {

    public String update(){

        class Inner implements Show{

            @Override

            public String show() {

                return "学习";

            }

        }

        Inner inner = new Inner();

        return inner.show();

    }

    public static void main(String[] args) {

        Test9 t = new Test9();

        System.out.println(t.update());

    }

}

第十题

package net.mindview.innerclasses.test9;

interface Show{

    String show();

}

public class Test9 {

    public String update(boolean flag){

        String str=null;

        if(flag){

            class Inner implements Show{

                @Override

                public String show() {

                    return "学习";

                }

            }

            Inner inner = new Inner();

            str = inner.show();

        }

        return str;

    }

    public static void main(String[] args) {

        Test9 t = new Test9();

        System.out.println(t.update(true));

    }

}

第十一题

package net.mindview.innerclasses.test10;

interface InterfaceClass{

    void i();

}

public class Test10 {

    private class Inner implements InterfaceClass{

        @Override

        public void i() {

        }

    }

    public InterfaceClass inner(){

        return new Inner();

    }

    public static void main(String[] args) {

        Test10 test10 = new Test10();

        InterfaceClass inner = test10.inner();

        //这样不可以,所以被隐藏了

        //Inner inner = test10.inner();

    }

}

第十二题

package net.mindview.innerclasses.test12;

interface Update{

    String update();

}

public class Show {

    private String str;

    private String showStr(){

        return str;

    }

    private class InnerUpdate implements Update{

        private int abc = ;

        public String update(){

            str = "内部类修改";

            System.out.println(str);

            return showStr();

        }

    }

    public Update visitInner(){

        return new Update(){

            private int abc = ;

            @Override

            public String update() {

                str = "内部类修改";

                System.out.println(str);

                return showStr();

            }

        };

    }

    public static void main(String[] args) {

        Show show = new Show();

        show.visitInner().update();

    }

}

第十三题

package net.mindview.innerclasses.test13;

interface Show{

    String show();

}

public class Test13 {

    public String update(boolean flag){

        String str=null;

        if(flag){

            return new Show(){

                @Override

                public String show() {

                    return "学习";

                }

            }.show();

        }

        return str;

    }

    public static void main(String[] args) {

        Test13 t = new Test13();

        System.out.println(t.update(true));

    }

}

(略)

第十五题

package net.mindview.innerclasses.test15;

class Person {

    private String name;

    public Person(String name){

        this.name = name;

    }

    @Override

    public String toString() {

        return name;

    }

}

public class Test15 {

    public Person method(String name){

        return new Person(name){

            @Override

            public String toString() {

                return super.toString();

            }

        };

    }

    public static void main(String[] args) {

        Test15 t = new Test15();

        System.out.println(t.method("张三").toString());

    }

}

第十六题

package net.mindview.innerclasses.test16;

interface Cycle {

    void make();

}

interface CycleFactory {

    Cycle getCycle();

}

class Unicycle implements Cycle{

    private Unicycle(){}

    @Override

    public void make() {

        System.out.println("make Unicycle");

    }

    public static CycleFactory factory = new CycleFactory(){

        @Override

        public Cycle getCycle() {

            return new Unicycle();

        }

    };

}

class Bicycle implements Cycle{

    private Bicycle(){}

    @Override

    public void make() {

        System.out.println("make Bicycle");

    }

    public static CycleFactory factory = new CycleFactory(){

        @Override

        public Cycle getCycle() {

            return new Bicycle();

        }

    };

}

class Tricycle implements Cycle{

    private Tricycle(){}

    @Override

    public void make() {

        System.out.println("make Tricycle");

    }

    public static CycleFactory factory = new CycleFactory(){

        @Override

        public Cycle getCycle() {

            return new Tricycle();

        }

    };

}

public class Cycles {

    public static void serice(CycleFactory factory){

        Cycle c = factory.getCycle();

        c.make();

    }

    public static void main(String[] args) {

        //我想要什么样的车,就找这种车的工厂去制作一辆车就可以了

        serice(Unicycle.factory);

        serice(Bicycle.factory);

        serice(Tricycle.factory);

    }

}

第十七题

package net.mindview.innerclasses.test17;

import java.util.Random;

/**

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

 */

interface ThrowProduct {}

interface ThrowFactory{

    ThrowProduct getProduct();

}

class ThrowCorn implements ThrowProduct{

    Random rand = new Random();

    private ThrowCorn(){

        if(rand.nextInt() %  ==){

            System.out.println("硬币的正面");

        }else{

            System.out.println("硬币的反面");

        }

    }

    public static ThrowFactory factory = new ThrowFactory(){

        @Override

        public ThrowProduct getProduct() {

            return new ThrowCorn();

        }

    };

}

class ThrowDice implements ThrowProduct{

    Random rand = new Random();

    private ThrowDice(){

        System.out.println("掷的骰子数是"+(rand.nextInt()+));

    }

    public static ThrowFactory factory = new ThrowFactory(){

        @Override

        public ThrowProduct getProduct() {

            return new ThrowDice();

        }

    };

}

public class ThrowFrame {

    public static void service(ThrowFactory f){

        ThrowProduct p = f.getProduct();

    }

    public static void main(String[] args) {

        service(ThrowCorn.factory);

        service(ThrowDice.factory);

    }

}

第十八题

package net.mindview.innerclasses.test18;

public class Test18 {

    public static class QianTao{

    }

    public static void main(String[] args) {

        QianTao q = new QianTao();

    }

}

第十九题

package net.mindview.innerclasses.test19;

public class Test19 {

    //这时一个嵌套类

    public static class Inner1{

        //这时定义在嵌套类中的嵌套类

        static class Inner2{

            public static int i = ;

        }

    }

    public static void main(String[] args) {

        System.out.println(Inner1.Inner2.i);

    }

}

编译后的文件结构:

第二十题

package net.mindview.innerclasses.test20;

interface InnerInInterface{

    static class Inner{

        public Inner(){

            System.out.println("嵌套类构造方法");

        }

    }

}

public class Test20 {

    public static void main(String[] args) {

        //直接使用  new 外围类.嵌套类

        InnerInInterface.Inner inner = new InnerInInterface.Inner();

    }

}

第二一题

package net.mindview.innerclasses.test21;

interface InterfaceClass {

    void f();

    void b();

    class InnerClass{

        static void get(InterfaceClass impl){

            impl.f();

        }

    }

}

public class Test21 implements InterfaceClass{

    public Test21(){

        System.out.println("这是Test21构造函数的方法");

    }

    public static void main(String[] args) {

        Test21 t = new Test21();

        new InterfaceClass.InnerClass().get(t);;

    }

    @Override

    public void f() {

        System.out.println("实现类   f()");

    }

    @Override

    public void b() {

        System.out.println("实现类   b()");

    }

}

第二十二题

package net.mindview.innerclasses.test22;

//选择器

interface Selecotr {

    //选择器是否到达尾部

    boolean end();

    //下一个元素编号

    void next();

    //当前元素

    Object current();

}

public class Sequence {

    private Object[] items ;

    static int counter = ;

    public Sequence(int size){

        items = new Object[size];

        for(int i=; i<size; i++){

            add("对象"+i);

        }

    }

    public void add(Object o){

        items[counter++] = o;

    }

    public  Selecotr sequenceSelector = new Selecotr(){

        int i = ;

        @Override

        public boolean end() {

            // TODO Auto-generated method stub

            return i == items.length;

        }

        @Override

        public void next() {

            if(i<items.length)

                i++;

        }

        @Override

        public Object current() {

            if(i<items.length){

                return items[i];

            }

            return null;

        }

    };

    //反序

    public Selecotr reverseSelector = new Selecotr(){

        int i = ;

        @Override

        public boolean end() {

            return i<;

        }

        @Override

        public void next() {

            i--;

        }

        @Override

        public Object current() {

            if(i>=){

                return items[i];

            }

            return null;

        }

    };

    public static void main(String[] args) {

        Sequence s = new Sequence();

        //正序

        Selecotr se = s.sequenceSelector;

        while(!se.end()){

            System.out.println(se.current());

            se.next();

        }

        System.out.println("-----------");

        //反序

        Selecotr re = s.reverseSelector;

        while(!re.end()){

            System.out.println(re.current());

            re.next();

        }

    }

}

第二十三题

package net.mindview.innerclasses.test23;

public interface U {

    void method1();

    void method2();

    void method3();

}

package net.mindview.innerclasses.test23;

public class A {

    U methodA1(){

        return new U(){

            @Override

            public void method1() {

                System.out.println("A methodA1 method1()");

            }

            @Override

            public void method2() {

                System.out.println("A methodA1 method2()");

            }

            @Override

            public void method3() {

                System.out.println("A methodA1 method3()");

            }

        };

    }

}

package net.mindview.innerclasses.test23;

public class B {

    U[] us ;

    private static int counter = ;

    public B(int size){

        us = new U[size];

    }

    void methodB1(U u){

        us[counter++] = u;

    }

    void methodB2(int i){

        us[i] = null;

    }

    void methodB3(){

        for(int i=; i<us.length; i++){

            U u = us[i];

            u.method1();

            u.method2();

            u.method3();

        }

    }

    public static void main(String[] args) {

        A a1 = new A();

        A a2 = new A();

        A a3 = new A();

        A a4 = new A();

        A a5 = new A();

        B b1 = new B();

        b1.methodB1(a1.methodA1());

        b1.methodB1(a2.methodA1());

        b1.methodB1(a3.methodA1());

        b1.methodB1(a4.methodA1());

        b1.methodB1(a5.methodA1());

        b1.methodB3();

        System.out.println("----------------");

        b1.methodB2();

        b1.methodB3();

    }

}

java编程思想第四版第十章习题的更多相关文章

java编程思想第四版第十章总结
1. 内部类的特性他允许你把一些逻辑相关的类组织在一起. 2. 使用.this 如果你需要在内部类中堆外部类进行应用,可以使用外部类的名字后面加.this.下面展示了如何使用 .this packa ...
java编程思想第四版第九章习题
第三题 package net.mindview.interfaces; abstract class Base{ public Base(){ print(); } abstract void pr ...
java编程思想第四版第八章习题
第一题 package net.mindview.polymorphism; //基类-自行车 class Cycle{ } //子类-单轮车 class Unicycle extends Cycle ...
java编程思想第四版中net.mindview.util包下载，及源码简单导入使用
在java编程思想第四版中需要使用net.mindview.util包,大家可以直接到http://www.mindviewinc.com/TIJ4/CodeInstructions.html 去下载 ...
《Java编程思想第四版》附录 B 对比 C++和 Java
<Java编程思想第四版完整中文高清版.pdf>-笔记附录 B 对比 C++和 Java “作为一名 C++程序员,我们早已掌握了面向对象程序设计的基本概念,而且 Java 的语法无疑是 ...
Java编程思想第四版勘误
坊间传说这本书翻译得很烂,我倒觉得还好.虽然看原文更准确,但是如果在具备一定编程思维和基础.能够看出来疑问的情况下,还是看中文更快一些,而且这本书本身也不适合初学者看.当然,错误和不通顺还是有的,而且 ...
Java编程思想第四版完整中文高清版.pdf
Java编程思想第四版完整中文高清版.pdf 链接: https://pan.baidu.com/s/1vV5BHF3L-bnaG6WGurdJ_A 提取码: vigy 复制这段内容后打开百度网盘手机 ...
《Java编程思想第四版完整中文高清版.pdf》-笔记
D.2.1 安插自己的测试代码插入下述“显式”计时代码,对程序进行评测: long start = System.currentTimeMillis(); // 要计时的运算代码放在这儿 long ...
《Java编程思想第四版》附录 C Java 编程规则
附录 C Java 编程规则本附录包含了大量有用的建议,帮助大家进行低级程序设计,并提供了代码编写的一般性指导: (1) 类名首字母应该大写.字段.方法以及对象(句柄)的首字母应小写.对于所有标识符 ...

随机推荐

毕业设计过程中的一些学习Android网站
安卓巴士:http://www.apkbus.com/CSDN:(下载资源)http://www.csdn.net/?ref=toolbar博客园:http://www.cnblogs.com/极客学 ...
linux-pclint代码检测
win10.ubuntu16.04, vs2017. 1.安装pc-lint到C盘. 2.将linux下的usr整个目录打包拷贝到win10某盘下. 3.获取lint检测linux c++ 代码的宏参 ...
tkinter基础-标签、按钮
本节内容: 明白标签.按钮的使用实现简单的点击界面 Tkinter 简称tk,在python中属于内置模块,不需要进行安装,可直接引用,import tkinter 一. 首先我们做一个如图所示的图 ...
LeetCode刷题总结-递归篇
递归是算法学习中很基本也很常用的一种方法,但是对于初学者来说比较难以理解(PS:难点在于不断调用自身,产生多个返回值,理不清其返回值的具体顺序,以及最终的返回值到底是哪一个?).因此,本文将选择Lee ...
mysql字段按逗号，拆分并按条件查找
mysql字段按逗号,拆分并按条件查找 mysql 表结构 CREATE TABLE `subid` ( `id1` varchar(255) DEFAULT NULL, `id2` varchar( ...
CSS 阴影动画优化技巧一则
本技巧来自这篇文章 -- How to animate box-shadow with silky smooth performance 本文不是直译,因为觉得这个技巧很有意思很有用,遂起一文. bo ...
Spring Cloud Alibaba（三）Sentinel之熔断降级
本项目演示如何使用 Sentinel 完成 Spring Cloud 应用的熔断降级调用. Sentinel 是阿里巴巴开源的分布式系统的流量防卫组件,Sentinel 把流量作为切入点,从流量控制, ...
Centos7 安装需要的软件环境
Mysql 安装下载安装下载并安装MySQL官方的 Yum Repository wget -i -c http://dev.mysql.com/get/mysql57-community-rel ...
设计模式（十七）Observer模式
在Observer模式中,当观察对象的状态发生变化时,会通知给观察者.Observer模式适用于根据对象状态进行相应处理的场景. 首先看一下示例程序的视图. 然后用实际代码来理解这种设计模式. pac ...
Pandas | 17 缺失数据处理
数据丢失(缺失)在现实生活中总是一个问题. 机器学习和数据挖掘等领域由于数据缺失导致的数据质量差,在模型预测的准确性上面临着严重的问题. 在这些领域,缺失值处理是使模型更加准确和有效的重点. 使用重构 ...

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

java编程思想第四版第十章习题的更多相关文章

随机推荐

热门专题