public class Test {
    public static void main(String[] args) {
//        Parcel1.test();
//        Parcel2.test();
//        Sequence.test();
        DotThis.test();
    }
}

class Parcel1 {

    class Contents {
        private int i = 11;

        public int value() {
            return i;
        }
    }

    class Destination {
        private String label;

        Destination(String whereTo) {
            label = whereTo;
        }

        String readLabel() {
            return label;
        }
    }

    public void ship(String dest) {
        Contents c = new Contents();
        Destination d = new Destination(dest);

        System.out.println(d.readLabel());
    }

    public static void test() {
        Parcel1 p = new Parcel1();
        p.ship("A");
    }

}

/*
    更典型的情况是:外部类将有一个方法,该方法返回一个指向内部类的引用。

    截止到目前,内部类都是有方案被更换的
 */
class Parcel2 {
    class Contents {
        private int i = 11;

        public int value() {
            return i;
        }
    }

    class Destination {
        private String label;

        Destination(String whereTo) {
            label = whereTo;
        }

        String readLabel() {
            return label;
        }
    }

    public Destination to(String s) {
        return new Destination(s);
    }

    public Contents contents() {
        return new Contents();
    }

    public void ship(String dest) {
        //上一个实验中,这儿是手动new出来的
        Contents c = contents();
        Destination d = to(dest);
        System.out.println(d.readLabel());
    }

    public static void test() {
        Parcel2 p = new Parcel2();
        p.ship("B");

        Parcel2 p2 = new Parcel2();
        Parcel2.Destination d = p2.to("C");
        Parcel2.Contents c = p2.contents();
    }

}

/*
    当生成一个内部类的对象时,此对象与制造它的外围对象之间就有了一种联系,所以它能访问
    其他外围对象的所有成员,而不需要任何特殊条件。此外,内部类还拥有其外部类的所有元素
    的访问权。

    我突然想到了一件事,实现Iterable接口的iterator()方法时,我们就返回的是一个内部
    类。一直不理解这个内部类设计的好处,现在发现自己一直在用它。
 */

/*
    当某个外部类的对象创建了一个内部类对象时,此内部类对象必定会秘密的捕获一个指向那个
    外部类的引用。内部类对象只能在与其外围类的对象相关联的情况下才能被创建(在内部类是
    非static类时)。
 */

interface Selector {
    boolean end();

    Object current();

    void next();
}

class Sequence {
    private Object[] items;
    private int next = 0;

    public Sequence(int size) {
        items = new Object[size];
    }

    public void add(Object x) {
        if (next < items.length) {
            items[next]=x;
            next++;
        }
    }

    private class SequenceSelector implements Selector {
        private int i = 0;
        @Override
        public boolean end() {
            /*
                书中的逻辑:return i == items.length;
                我觉得不太严谨,又没有说,一定要把items装满,除非你想取到空元素
                我的逻辑:
                    return i >= next;

             */
            return i >= next;
        }

        @Override
        public Object current() {
            if (i < next) {
                return items[i];
            }
            return null;
        }

        @Override
        public void next() {
            i++;
        }
    }

    private Selector selector() {
        return new SequenceSelector();
    }

    public static void test() {
        Sequence sequence = new Sequence(100);
        for (int i = 0; i < 10; i++) {
            sequence.add(Integer.toString(i));
        }

        Selector selector = sequence.selector();
        while (!selector.end()) {
            System.out.println(selector.current()+" ");
            selector.next();
        }
    }

}

/*
    需求:
        如果你在内部类中需要生成对外部类的对象的引用,可以使用外部类的名字后面紧跟圆点和
        this。
 */
class DotThis {
    void f() {
        System.out.println("DotThis.f()");
    }

    public class Inner {
        public DotThis outer() {
            return DotThis.this;
        }
    }

    public Inner inner() {
        return new Inner();
    }

    public static void test() {
        DotThis outter = new DotThis();
        DotThis.Inner inner = outter.inner();

        inner.outer().f();
    }

}

/*
    需求:
        有时,你可能想要告知某些其他对象,去创建某个内部类的对象。要实现这个目的,你必须
        在new表达式中提供对其他外部类对象的引用,这就需要.new语法。

            ——怎么告知?

        我感觉这就是一个,创建内部类对象的语法

        想要直接创建内部类的对象,不能去引用外部内的名字,而必须使用外部类的对象来创建该
        内部类的对象,就像在上面的程序中所看到的那样。
 */

class DotNew {
    public class Inner {

    }

    public static void test() {
        DotNew dn = new DotNew();
        /*
            这种编码果然创建不了内部类的对象,编译器报错说:DotNew.this cannot 关联到
            一个静态的上下文。联系上文说的,创建一个内部类时是需要捕捉一个外围内的引用的
            这种方式得不到外围类的引用, 所以无法完成创建。

            DotNew.Inner di = new DotNew.Inner();
         */
        DotNew.Inner di = dn.new Inner();
    }
}

class Parcel3 {
    class Contents {
        private int i = 11;

        public int value() {
            return i;
        }
    }

    class Destination {
        private String label;

        Destination(String whereTo) {
            label = whereTo;
        }

        String readLabel() {
            return label;
        }
    }

    public static void test() {
        Parcel3 p = new Parcel3();

        Parcel3.Contents c = p.new Contents();
        Parcel3.Destination d = p.new Destination("D");
    }

}

Java编程思想:内部类基础部分的更多相关文章

  1. Java编程思想学习(八) 内部类

    可以将一个类的定义放在另一个类的定义内部,这就是内部类. 内部类的定义是简单的,但是它的语法确实很是复杂,让人不是很好理解.下面就内部类做一个小结. 一.内部类的分类 总的来讲内部类分为普通内部类,匿 ...

  2. java编程思想-基础

    interface: 方法默认为public:成员变量默认 static and final 对象数组的定义:理解? 多接口继承:可以多个接口,但只有一个具体类,具体类在前面 自:多接口继承时,来自不 ...

  3. 《java编程思想》--多线程基础--Runnable

    一.简单说下Runnable是什么 1.它是一个接口 2.只提供了run方法 3.这个接口提供了一个协议:实现这个接口的类是active的(不必成为Thread的子类) 4.run方法没有返回值 /* ...

  4. Java编程思想 (1~10)

    [注:此博客旨在从<Java编程思想>这本书的目录结构上来检验自己的Java基础知识,只为笔记之用] 第一章 对象导论 1.万物皆对象2.程序就是对象的集合3.每个对象都是由其它对象所构成 ...

  5. Java编程思想(前十章)

    Java编程思想 有C++编程基础的条件下, 前10章可以快速过一下,都是基本语法,不需要花太多时间. 着重中后段的一些章节,类型信息.泛型.容器.IO.并发等. 中文翻译版 阅读地址 对于一个架构师 ...

  6. 《Java编程思想第四版完整中文高清版.pdf》-笔记

    D.2.1 安插自己的测试代码 插入下述“显式”计时代码,对程序进行评测: long start = System.currentTimeMillis(); // 要计时的运算代码放在这儿 long ...

  7. 《Java编程思想第四版》附录 B 对比 C++和 Java

    <Java编程思想第四版完整中文高清版.pdf>-笔记 附录 B 对比 C++和 Java “作为一名 C++程序员,我们早已掌握了面向对象程序设计的基本概念,而且 Java 的语法无疑是 ...

  8. Java编程思想第四版勘误

    坊间传说这本书翻译得很烂,我倒觉得还好.虽然看原文更准确,但是如果在具备一定编程思维和基础.能够看出来疑问的情况下,还是看中文更快一些,而且这本书本身也不适合初学者看.当然,错误和不通顺还是有的,而且 ...

  9. 《Java编程思想》阅读笔记二

    Java编程思想 这是一个通过对<Java编程思想>(Think in java)进行阅读同时对java内容查漏补缺的系列.一些基础的知识不会被罗列出来,这里只会列出一些程序员经常会忽略或 ...

  10. Java编程思想(第4版) 中文清晰PDF完整版

    Java编程思想(第4版) 中文清晰PDF完整版 [日期:2014-08-11] 来源:Linux社区  作者:Linux [字体:大 中 小]     <Java编程思想>这本书赢得了全 ...

随机推荐

  1. Win10《芒果TV - Preview》更新v3.1.31.0,全新播放页蜕变,预加载提速技术

    Win10<芒果TV - Preview>(商店内测版) v3.1.31.0 于2016年11月21日星期一晚上九点半登陆商店 主要是全面升级改造桌面播放页,新增观看互动评论.猜你喜欢功能 ...

  2. Have You Tried Delphi on Amazon Linux? (就是AWS用的Linux)

    The new Delphi Linux compiler enables customers to take new or existing Windows server applications ...

  3. android adb socket 通信

    今天遇到一个问题:pc客户端和android的App通信,心跳通道(心跳包27个字节,是一个业务空包)在部分pc上总是会超时(5秒超时),nagle算法也给禁用了,pc端时按按量发送心跳的,怀疑来怀疑 ...

  4. 微信小程序把玩(三十五)Video API

    原文:微信小程序把玩(三十五)Video API 电脑端不能测试拍摄功能只能测试选择视频功能,好像只支持mp4格式,值得注意的是成功之后返回的临时文件路径是个列表tempFilePaths而不是tem ...

  5. .net EF Join 关联表分页查询

    Join中第二个参数和第三个参数即为两张表关联对应的字段 第四个参数new 后面如果不写Model名,系统会自动生成带字段的list类型 IQueryable<Operator> oper ...

  6. tftp的安装及配置

    1.安装tftp服务客户端sudo apt-get install tftp 2.安装tftp服务器端sudo apt-get install tftpd 3.安装xinetd注意同类似的还有open ...

  7. QObject提供了QMetaObject元类信息(相当于RTTI和反射),信号与连接,父子关系,调试信息,属性,事件,继承关系,窗口类型,线程属性,时间器,对象名称,国际化

    元类信息(相当于RTTI和反射),信号与连接,父子关系,调试信息,属性,事件,继承关系,窗口类型,线程属性,时间器,对象名称,国际化其中元类又提供了:classInfo,className,构造函数, ...

  8. spring通过注解方式依赖注入原理 (私有成员属性如何注入)

    一.spring如何创建依赖的对象 用过spring的都知道我们在dao.service层加上@repository.@Service就能将这两个对象交给spring管理,在下次使用的时候使用@res ...

  9. 分享Nginx在Windows下的管理命令(bat文件)

    话不多说,复制下面的内容,存成bat文件,放到nginx目录下. ====================================================@echo offrem 当前 ...

  10. 电商、P2P等大型互联网系统包含哪些业务模块?

    01 前言 在互联网飞速发展的时代,各大互联网公司正在进行激烈的竞争,业务模式也在不断的扩张,这种现状使得目前各大公司的架构系统面临着极大的挑战,而对于我们普通的软件开发者而言,如果你仅仅了解过一些关 ...