【ThinkingInJava】笔记

参考文献(References)

[1] Bruce Eckel.Java编程思想(ThinkingJava FourEdition)第四版[M].陈昊鹏,北京：机械出版社,2007.6(2014.11重印)

看完一本书很容易，但是想要把一本书实践完并精通的话，没有长时间研读是别想的。

1.1:    Unified Modelling Language统一建模语言，类名在顶部，数据成员在中间部分，方法在底部
1.2:    复用某个类，直接使用该类的一个对象
1.3:    使用现有的类合成一个新类称为组合、动态发生称为聚合
1.4:    组合→拥有  汽车◆▬引擎
1.5:    处处使用继承导致难以使用并过分复杂的设计
1.6:    建立新类时，优先考虑组合
1.7:    有了经验后能够看出必须使用继承的场合了
1.8:    创建了一个新类后，有另一个新类与之相似，此时可用继承
1.9:    基类◁▬导出类
1.10:    使用继承构建一个类型层次结构
1.11:    使基类与导出类产生差异：
1.12:    ① 直接在导出类中添加新方法
1.13:    ② 覆盖@Override使用相同的接口方法，做些不同的事情
1.14:    导出类只覆盖基本的方法叫纯粹代替，替代原则，is-a关系
1.15:    后期绑定，向对象发送信息，被调用的代码知道运行时才能确定
1.16:    编译器确保被调用方法的存在，并不知道将被执行的确切代码
1.17:    C++用Virtual实现后期绑定
1.18:    Java是默认的
1.19:    向上转型
1.20:    把导出类看成是基类
1.21:    Java中所有的类都基于一个类Object
1.22:    单根继承结构：① 共用一个接口 ② 保证所有的对象都具备某些功能
1.23:    使垃圾回收栈的实现变得容易得多
1.24:    Java中容器和集合有不同的含义
1.25:    标准模板类库(standart template library,STL)
1.26:    可视化构件库(Visual Component Library,VCL)
1.27:    List存储序列，Map关联数组
1.28:    Set(每种对象类型只持有一个)
1.29:    参数化类型——泛型
1.30:    堆的内存池中创建对象
1.31:    Java垃圾回收机制自动发现对象何时不再被使用，继而销毁它
1.32:    机器底层的知识来编写中断服务机制，主进程的挂起通过硬件中断来触发
1.33:    并发最常见的例子就是用户界面
1.34:    共享资源：某个任务锁定某项资源
1.35:    完成其任务，然后释放资源锁，使其他任务可以使用这项资源
1.36:    客户/服务器系统具有一个中央信息存储池(central repository of information)，存储某项数据(通常 in DB)
1.37:    分发给某些人员或机器集群
1.38:    客户端编程： 1. 插件plug-in  2.脚本语言Java是基于C++的
1.39:    String创建的只是引用并不是对象
1.40:    带引号的文本初始化，必须采用更通用的初始化方法 new String("asdf")
1.41:    寄存器(最快),堆栈(随机访问存储器RAW)，堆(通用的内存池，位于RAM区)，常量存储(ROM只读存储器),非RAM存储(数据完成活于程序之外),流对象和持久性对象
1.42:    流对象，字节流，发送往另一台机器
1.43:    持久化对象存放于磁盘中，把对象转化成可以存放在其他媒介上的事物
1.44:    基本类型char <-> 包装器类型character
1.45:    高精度BigInteger和BigDecimal
1.46:    每个引用自动初始化为null
1.47:    Java不允许用{}隐藏变量如:{int x;{int x;}}
1.48:    出作用域，引用s消失，指向的String对象仍占据内存
1.49:    垃圾回收器辨别不再引用的对象使其释放
1.50:    char的默认值'\u0000'(null)
1.51:    变量作为类的成员使确保给定其默认值0，不适用于局部变量，得到的是任意值，Java会Error
1.52:    Java的函数叫方法
1.53:    Java设计者希望程序使用自己的Internet域名，保证它们肯定是独一无二的
1.54:    java.lang默认导入到每一个Java文件中
1.55:    System.out(PrintStream)
1.56:    java.library.path
1.57:    @see link docRoot inheritDoc version author…… P34
1.58:    驼峰风格
1.59:    静态导入static import，import static XXX
1.60:    取右边的值(右值)复制给左边(左值)
1.61:    t1 = t2 ， 将t1绑定到t2上导致t1指向的对象丢失
1.62:    Random.nextInt()
1.63:    无符号右移位操作符>>>，无论正负在高位插0
1.64:    在C和C++中,while(x=y){}y为非零值则无限循环
1.65:    类型转换cast
1.66:    窄化转换narrowing conversion，多信息type→少信息type，需要显示转换
1.67:    扩展转换widening conversion，少信息type→多信息type
1.68:    整数溢出不会警告出错或出现异常！
1.69:    唯一用到逗号操作符的地方是for，其它时候是逗号分隔符
1.70:    foreach语法for(float x:f)
1.71:    Java无goto
1.72:    带标签outer的continue到达标签为止，break+标签跳出标签所指的循环
1.73:    Tree(int)是唯一的构造器则无其它构造方式
1.74:    参数类型顺序不同也能重载→代码难以维护
1.75:    要是在代码中出现了大量static方法，就该重新考虑自己的设计了
1.76:    finalize()对象可能不被垃圾回收，垃圾回收不等于“析构”
1.77:    垃圾回收器不能完全代替析构函数，也绝对不能直接调用finalize()
1.78:    protected void finalize(){if(boolean)Erro:checked out}被当做垃圾胡思后前将boolean置false(初始化为true)，一旦忘记，用system.gc()销毁
1.79:    super.finalize()
1.80:    垃圾回收器一面工作，一面使堆中的对象紧密排列，“堆指针”更容易移动传送带开始处
1.81:    对象←引用计数器，引用+1，出作用域或null、-1。0释放
1.82:    对象之间循环引用，该回收时引用计数不会零
1.83:    更快的模式，追溯到堆栈和静态存储区的引用，引用追踪对象→所有引用，解决交互自引用对象组的问题
1.84:    自适应，停止-复制stop-copy，将所有存活的对象从当前堆复制到另一堆，没有被复制到的全部都是垃圾，堆复制后对象一个接一个
1.85:    按需从堆中分配几块较大的内存，操作在这几块内存之间进行
1.86:    没有新垃圾——产生，换标记——清扫(mark and sweep)，产生少量垃圾时快
1.87:    即时编译器，翻译成本地机器码
1.88:    转载类→找到.class文件→该类的字节码转入内存→即时编译器、惰性评估，只在必要的时候用即时编译器
1.89:    构造器初始化：类变量i先置0再变7，变量先于方法调用初始化
1.90:    Table类名静态对象B在Table第一次创建或第一次访问静态数据时创建
1.91:    构造器实际上也有静态方法
1.92:    Integer[] a= new Integer[20]
1.93:    引用数组，没有初始化就调用会产生异常
ENDP100 20151123 星期一

2.1:    static void printArray(Object……args)
2.2:    可变参数列表枚举类型集
2.3:    public enum Spiciness{}
2.4:    事实上enum是类
2.5:    重构及重写代码
2.6:    环境变量CLASSPATH中放路径，路径中饭.class文件,Java解释器会在这里面找
2.7:    jar文件需要指明，定制工具库，包访问权限
2.8:    默认访问权限包内可见包外为private
2.9:    accessor(get),mutator(set)方法
2.10:    java文件内无public类是可能的，此时文件可随意命名
2.11:    唯一的public class是该文件的对外接口
2.12:    类不能是private也不能是protected
2.13:    定义对象的地方初始化先于构造器
2.14:    在使用这些对象之前初始化，减少额外的负担，叫惰性初始化
2.15:    代理
2.16:    @Override注解，可以防止你在不想重载时而意外地进行了重载，即你本来想重写基类的一个方法，单参数和返回值不对导致与想重写的那个方法不同，这是重载
2.17:    组合能显示地分解一个类的功能使其清晰可见，继承则是全部函数堆在一起
2.18:    将域保持为private，保留更改底层实现的权利，通过protected方法控制类的继承类访问权限
2.19:    可以在域的定义处或构造器给final初始化
2.20:    final+方法把方法锁定不让继承类覆盖
2.21:    private隐式指定final
2.22:    final+class不允许继承
2.23:    多态(动态绑定，后期绑定或运行时绑定)
2.24:    绑定，一个基类和二子类都play()，上转型基类来作参，调用play，调用哪个类的play()
2.25:    后期绑定，根据对象类型进行绑定
2.26:    子类方法采取与基类private方法不同的名字
2.27:    清理：给类创建dispose方法
2.28:    共享对象时不能简单地调用dispose()
2.29:    交给引用计数处理 P161
2.30:    纯粹继承，完全的is-a关系，导出类完全可以代替基类
2.31:    ClassCastException类转型异常，运行时类型识别RTTI
2.32:    public abstract void play(Noten)
2.33:    抽象类比较有用的重构工具
2.34:    interface接口
2.35:    接口方法必须是public
2.36:    完全解耦，策略设计模式
2.37:    根据所传递参数对象不同而具有不同行为的方法
2.38:    extends Processor和extends Filler的不同类、执行Apply,process(Processor)时，前者可以，后者不能，即便可以运行，因为Processor和Filter的成员基本一致(不同在Object和Waveform上，后者是前者子类)
2.39:    这就叫耦合，以此引出interface
2.40:    接口从具体实现中的解耦使得接口可以应用于多种不同的具体实现
2.41:    接口嵌套在类中
2.42:    内部类可以访问外部类所有元素
2.43:    dn.newInner()，创建的内部类对象，必须使用外部类对象，静态除外
2.44:    方法内定义类——局部内部类
2.45:    匿名内部类用外部定义的对象需要用final
ENDP200 20151124 Tuesday

3.1:    优先使用类而不是接口
3.2:    如果你的设计中需要某个接口，你必须了解它，否则不到迫不得已，不要将其放入你的设计中
3.3:    不需要内部类对象与起外围类对象之间有联系，那么内部类声明为static，这通称为嵌套类
3.4:    static应用于内部类时的含义
3.5:    普通的内部类隐式地保存了一个引用
3.6:    内部类是static的时候就不是这样的了
3.7:    普通的内部类不能有static数据和static字段
3.8:    C++嵌套类只不过C++不能访问私有成员，Java可以
3.9:    每个类放main()方法测试这个类，却必须带着编译过的额外代码，所以可以用嵌套类来测试代码，最后可简单地删除Tester.class
3.10:    在内部类实现外围接口
3.11:    一个内部类被嵌套多少层并不重要——透明地访问所有它所嵌入的外围类的所有成员
3.12:    内部类允许接受多个非接口类型(类或抽象类)，多重继承
3.13:    如果Sequence.java不使用内部类就必须声明"Sequence是一个Sector"，对于某个特定的Sequence只能有一个Selector
3.14:    然而使用内部类很容易就能拥有另一个方法reverseSelector()、用它来生成一个反方向遍历序列的Selector
3.15:    只有内部类才有这种灵活性
3.16:    练习22
3.17:    闭包closure
3.18:    内部类有权操作所有的成员、包括private
3.19:    记录了一些来自其作用域的信息
3.20:    回调、携带在稍后时刻调用它初始的对象的信息
3.21:    实现GUI功能时，到处都用到了回调
3.22:    extends和implements有相同名字的函数时使用内部类进行区分
3.23:    回调——别的类获取该类中内部类接口的引用，回调该类
3.24:    控制框架control framework，应用程序框架(application framework)
3.25:    运用af:继承一至多个类，覆盖某些方法，以解决特定问题
3.26:    Java Swing库使用了大量的内部类
3.27:    List<> -> add,size,foreach,remove
3.28:    继承内部类需要将外部类的引用传进来
3.29:    继承外部类要继承内部类，外/内部类都需要继承，直接定义内部类不继承是不能覆盖的
3.30:    类产生，class文件，meta-class外围类名+&+内部类名+.class
3.31:    一个程序包含固定数量且生命周期都是已知的对象
3.32:    List必须按照插入的顺序来保存元素，Set不能有重复元素..Queue排队
3.33:    Map键值对，ArrayList数字来查值
3.34:    ArrayList -> List 上转型
3.35:    Arrays.asList(1,2,3,4,5)
3.36:    Collection<Integer>.addAll(Arrays.asList(Integerp[]))
3.37:    Map.put(key,value),Map.get(key)
3.38:    HashMap,TreeMap,LinkedHashMap
3.39:    HashSet,HashMap
3.40:    contains()确定某个对象是否在列表汇总
3.41:    可以将这个对象的引用传递给remove()方法
3.42:    subList()、retainAll()、removeAll()、toArray()
3.43:    迭代器
3.44:    LinkedList可用作栈、队列或双端队列的方法
3.45:    Set不保存重复的元素
3.46:    HashSet
3.47:    TreeSet——红黑色数据结构
3.48:    Set类用了散列
3.49:    想对结果排序用TreeSet代替HashSet
3.50:    SortedSet<Integer> intset = new TreeSet<Integer>(),intset.add(...)
3.51:    new.mindview.TextFile,打开一个文件，将其读入一个Set
3.52:    Set<String> words = new TreeSet<String>(new TextFile("SetOperation.java","\\W+"));
3.53:    String.CASE_INSENTIVE_ORDER按照字母序排列
3.54:    扩展到多维Map<Person,List<Pet>>
3.55:    Queue先进先出
3.56:    LinkedList用Queue接口，可向上转型Queue
3.57:    offer()，Queue插入到队尾，或都返回false
3.58:    peek()和element()
3.59:    poll()和remove()移除返回队头，队头为空poll()返回null,remove()抛出NoSuchElementException异常
3.60:    不鼓励将queue转型会LinkedList
3.61:    PriorityQueue优先级队列
3.62:    Comparator
3.63:    Collection附属接口，表示其它若干个接口的共性而出现的接口
3.64:    java.util.Abstract，Collection提供Collection的默认实现
3.65:    实现Collection就意味着需要提供iterator()方法
3.66:    remove()方法是一个“可选操作”
3.67:    Foreach与迭代器
3.68:    由于cs是一个Collection,能够与foreach一起工作是所有Collection对象的特性
3.69:    任何实现Iterable的类可以用于foreach语句中
3.70:    implements Iterable<String>，Iterable<String> iterator()，String next(),void remove()
3.71:    Iterable Class确实可以用于foreach语句中
3.72:    System.getenv()返回一个Map,entrySet由Map.Entry构成的Set
3.73:    新程序不应该使用过时的Vector,Hashtable、Stack
3.74:    点线框表示接口,实线框表示普通的类、带有空心箭头的点线表示一个特点实现了一个接口
3.75:    异常参数
3.76:    终止模型恢复模型，不能回来继续运行，修正后继续运行一遇到错误调用修正方法或把try块放进while里，直到得到满意的结果
3.77:    创建自定义异常 extends Exception
3.78:    异常与记录日志 java.util.logging 工具将输出记录的日志中
3.79:    e.getStackTrace()
3.80:    StackTraceElement.getMethodName()
3.81:    重新抛出异常catch(){throw e;}
3.82:    异常链——捕获一个异常抛出另一个异常，保留前者信息
3.83:    Java标准异常Throwable,RuntimeException 不受检查异常，使用finally进行清理
3.84:    sw.off()方法的调用
3.85:    在try中return，finally都会执行
3.86:    异常的限制
3.87:    由于finally导致异常丢失
3.88:    构造函数阶段可能会抛出异常
3.89:    异常匹配，异常类的派生类也能捕获
3.90:    吞食异常try{}catch{}//Gulp!
3.91:    将异常抛出放函数后面交给控制台
3.92:    throw newRuntimeException(e)避免吞食异常函数传递一个对引用的拷贝
3.93:    Java不允许程序员重载任何操作符
3.94:    append多次调用产生一大堆需要垃圾回收的中间对象
3.95:    javap -c Concatenation生成JVM字节码
3.96:    String.append()编译器自动引入了java.lang.StringBuilder类,用以构造最终的String，并为每个字符串调用一次StringBuilder的append()方法。
3.97:    P284 - 286
3.98:    无意识地递归toString(){return "abc"+this+"\n";}
3.99:    如果内容没有发生改变，String的方法只是返回原对象的引用而已
3.100:    格式化输出printf,System.out.format() -> PrintStream、PrintWriter
3.101:    java.uti.Formatter类处理 -> format("%s",x)
3.102:    格式化说明符format("%-15s %5s %10s\n","Item","Oty","Price");
3.103:    String.format("(t%d,q%d)%s",tId,qId,message);
3.104:    一个十六进制转储(dump)工具P294
3.105:    正则表达式：一位数\\d,一个反斜线\\\\，换行制表符\n\t，一负号后跟一至多位数字 -?\\d+
3.106:    String.matches(regex)
3.107:    (-|\\+)?  |表示或操作
3.108:    split()依据正则表达式切开
3.109:    split()重载版本允许设定分割次数
3.110:    replceFirst和replaceAll
3.111:    ^一行起始、$一行结束
3.112:    量词、贪婪型、勉强型？、占有型+
3.113:    abc+和(abc)+
3.114:    Pattern.compile()编译你的正则表达式
3.115:    String -> Pattern -> matcher() -> Matcher对象、replaceAll()
3.116:    static Pattern/compile()、matches
3.117:    lookingAt()
3.118:    Matcher.find()
3.119:    charSequence
3.120:    replaceFirst()和replaceAll()
3.121:    reset()
3.122:    正则表达式与Java I/O
3.123:    扫描输入P309
3.124:    numArray.split();
3.125:    Scanner 大大减轻扫描输入的工作负担
3.126:    (File对象、InputStream、String、Readable[BufferedReader])->Scanner
3.127:    useDelimiter() 设置定界符，还有一个delimiter()方法返回定界符使用的Pattern对象
3.128:    scanner.next(pattern);
3.129:    StringTokenizer分割字符串
3.130:    RTTI(Run-Time Type identification)基类指针引用指向派生类
3.131:    Class.forName("ClassName")加载类常量FancyToy.class/TYPE，建议使用".class"的形式保持与普通类的一致性
3.132:    加载、链接、初始化
3.133:    Class c = ClassName.class用于获取类应用调用静态变量
3.134:    新的转型语法 cast()方法
3.135:    类型转换前先做检查if(x instanceof Dog)
3.136:    如果程序中编写了许多的instanceof表达式则设计可能存在瑕疵
3.137:    类字面常量预加载一个Map
3.138:    动态instanceof,Map.Entry.getKey().isInstance(pet)
3.139:    递归计数，计算Class<?>中各类数量，isAssignableFrom()
3.140:    注册工厂，Factory<? extends Part>
3.141:    instanceof和isInstance()生成的结果一样，会考虑继承
3.142:    getClass().equals()和==结果一样，不会考虑继承
3.143:    反射、运行时的类信息
3.144:    反射，运行时的类信息,Class+java.lang.reflect类库,Field，Method，Constructor(Member接口),invoke(),getFields(),getMethods(),getConstructors()
3.145:    Class->getMethods(),getConstructors()->Method和Constructor，解析其对象所代表的方法、获取其名字，输入参数以及返回值，动态代理，代理是基本的设计模式之一
3.146:    Class1{Class2 c2;f(){c2.doSomeThing();}}
3.147:    Proxy.newProxyInstance()创建动态代理P339
3.148:    可用interface NULL{}来代替空对象null
3.149:    模拟对象与桩
3.150:    interface关键字允许程序员隔离构件，进而降低耦合性
3.151:    通过使用RTTI，发现a是被当做B实现的
3.152:    私有内部类
3.153:    P352泛型，通常而言，我们只会使用容器来存储一个种类型的对象
3.154:    元祖tuple允许读取不允许存放
3.155:    return new TwoFuple -> FiveFuple<...>(...)
3.156:    一个堆栈类下推推栈
3.157:    net.mindview.util.Stack用一个LinkedList实现的
3.158:    RandomList.select()
3.159:    泛型接口，生成器generator，专门负责创建对象的类
3.160:    实现Generator<Coffee>接口随机生成不同类型的coffee对象
3.161:    重写Iterable的Fibonacci生成器，不过，你并不是总能拥有源代码的控制权，并且除非必须这么做否则我们也不愿重写一个类
3.162:    或者创建一个适配器adapter来实现所需的接口
3.163:    extends Fibonacci implements Iterable<Integer>
3.164:    iterator(){return new Iterator<Integer>(){}}
3.165:    应该尽量使用泛型方法
3.166:    static方法访问泛型得先成为泛型方法
3.167:    public<T> void f(T x){}
3.168:    使用了泛型的函数可以识别各种类型
3.169:    泛型使用无需知参数
3.170:    编译器会为我们找出具体的类型称为类型参数推断
3.171:    相等f()被无限次地重载过
3.172:    编号一个工具类，包含各种各样的static方法，专门用来创建各种常用的(泛型)容器对象，类型推断只对赋值有效，传参无效
3.173:    解决传参问题
3.174:    f(New<Person,List<Pet>>map())
3.175:    泛型方法和可变参数列表能够很好地共存
3.176:    public static<T> List<T> makeList(T..args){}
3.177:    Generator<T> create(Class<T> type)
3.178:    TupleTest.java
3.179:    EnumSet.range()
3.180:    Generator<Customer> generator()
3.181:    用泛型构造复杂模型
3.182:    擦除
3.183:    ArrayList.class可以
3.184:    ArrayList<Integer>.class不能声明
3.185:    ArrayList<String> == ArrayList<Integer>返回true
3.186:    然而放String或Integer所得到的行为完全不同
3.187:    泛型类中Class.getTypeParameters()输出中发现的只是用作参数占位符的标识符，因此现实是，在泛型代码内部，无法获取任何有关泛型参数类型的信息——List<Integer>事实上是相同类型
3.188:    擦除即泛型的类型无法在类中得知，但C++可以
3.189:    可以用<T extends HasF>来指定类型
3.190:    希望代码能跨多个类工作时，使用泛型才有帮助
3.191:    迁移兼容性——泛化的客户端可以用非泛化的类库来使用
3.192:    编写泛型类时需要提醒自己“不，他只是一个Object”
3.193:    泛型可以表示没有任何意义的事物,String.class -> Class<T> kind
3.194:    擦除在方法体中移除了类型信息，运行时的问题就是边界， P379-380
3.195:    new T()无法实现，需要使用工厂，使类自带newInstance()方法构造
3.196:    泛型数组Generic<Integer>[]
3.197:    边界<T extends Dimension&HasColor&Weight>
3.198:    Fruit[] fruit = new Apple[10]正确List<Fruit>flist = new ArrayList<Apple>()错误
3.199:    flist = <List<? extends Fruit>>具有任何从Fruit继承的类型的列表
3.200:    编译器有多聪明，只是传参类型为Object而已
3.201:    逆变，超类型通配符<? super MyClass>、<? super T>不能声明成<T super MyClass>
3.202:    放松了在可以向方法传递的参数上所作的限制,f(List<T>,T)不能将Apple放入List<Fruit>，(List<? super T>,T)能将Apple放入List<Fruit>
3.203:    协变，通配符P394
3.204:    无界通配符<?>泛型参数可以持有任何类型
3.205:    多个泛型类型参数的无界通配符<?,Object> <?,?> <String,?>
3.206:    List<?>表示具有某种特定类型的非原生List,只是不知道类型,List<Object>持有object类型的原生list
3.207:    List == List<Object>
3.208:    捕获转换——需要使用而不是原生类型
3.209:    <?>方法传递原生类型
3.210:    任何基本类型都不能作为类型参数
3.211:    ArrayList<Integer> 自动包装机制 int -> Integer，不能用于数组
3.212:    使用带泛型类型的转型或instanceof不会有任何效果
3.213:    转型或警告
3.214:    泛型重载无效，使用不同的方法名fl(List<V> v),f2(List<W> v)
3.215:    基类劫持了接口,Comparable<ClassName>接口 implements
3.216:    自限定类型<T extends SelfBounded<T>>
3.217:    循环泛型A<T>，B extends A<B>
3.218:    BasicHolder<Subtype> -> Subtype
3.219:    CRG本质：基类用到处类替代其参数，泛型基类是所有导出类的公共功能的模板
3.220:    自限定SelfBounded<T extends SelfBounded<T>>
3.221:    A extends SelfBounded<A>
3.222:    参数协变、方法参数类会随子类而变化,set(T arg)，set(ClassName cn)继承的问题
3.223:    动态类型安全.newArrayList<Dog>():List.add(new Cat())允许
3.224:    Collections.checkedList(new ArrayList<Dog>(),Dog.class).add(new Cat())
3.225:    异常、catch语句不能捕获泛型类型的异常，泛型类不能直接或间接继承自Throwable
3.226:    混型——混合多个类的能力,产生一个可以表示混型中的所有类型的类
3.227:    C++：template<class T> class ClassName:public T{},A<B<C>>,通过继承类模板实现混型
3.228:    Java:使用接口 D extends C implements B,C
3.229:    使用装饰器模式——满足各种可能的组合、直接子类化会产生过多的类
3.230:    Basic -> Decorator -> TimeStamped、SerialNumbered
3.231:    动态代理创建一种比装饰器更贴近混型模型的机制
3.232:    潜在类型机制
3.233:    "泛化"——无需修改就可以应用于更多情况的代码P416
3.234:    潜在类型机制一种代码组织和复用机制，Python动态，C++静态
3.235:    template<class T> void perform(T anything){anything.speak();anything.sit();}
3.236:    反射，确定形参形参Object类是否有该方法try-catch
3.237:    将一个方法应用于序列，foreach语句用反射
3.238:    无接口时依赖于定义一个Collection的子类型，调用add()
3.239:    适配器仿真潜在类型机制fill(Addable<T> addable,Class<? extends T>classToken,int size)
3.240:    将函数对象用作策略——适配器方式创建真正泛化的代码
3.241:    泛型类型机制吸引人的地方在于使用容器类
3.242:    转型——狗在猫列表
END

4.1:    数组和ArrayList的相似性是有意设计的
4.2:    数组硕果仅存的优点是效率
4.3:    数组引用指向在堆中创建的一个真实对象
4.4:    Arrays.deepToString([][]...[])
4.5:    [[1,2,3],[4,5,6]]
4.6:    擦除会移除参数类型信息，而数组必须知道它们所持有的确切类型，以强制保证类型安全
4.7:    <T>T[]f(T[] arg){return arg;};
4.8:    创建测试数据 Arrays.fill([],T)
4.9:    给一个数组填充T
4.10:    选择Generator(十五章内容)创建任何类型数据
4.11:    Arrays->equals()数组相等,deepEquals()多维数组，fill()填充，sort()数组排序,binarySearch()已排序数组查找元素，toString()数组String,hashCode()数组散列码,asList()序列数组转List容器
4.12:    int[] i,j; 
4.13:    System.arrayCopy(i,0,j,0,i.length)复制数组
4.14:    浅复制——赋值对象数组
4.15:    Arrays.equals(int[],int[])比较整个数组
4.16:    A implements Comparable<A>,public int compareTo(A a){},A[] a = Generated.array(new A[12],generator())
4.17:    Arrays.sort(a)
4.18:    int location = Arrays.binaraySearch(a.r)
4.19:    保持有序新元素插入位置——插入点(返回值)-1
4.20:    重复元素无法保证
4.21:    TreeSet(保持排序顺序)、LinkedHashSet(保持插入顺序)
4.22:    P459容器简化图
4.23:    填充容器 new ArrayList<StringAddress>(Collections.nCopies(4,new StringAddress("Hello")));
4.24:    Collections.fill(list,new StringAddress("World!"));
4.25:    StringAddress{String;String toString();构造函数;}
4.26:    Map生成器,Pair<K,V>{K keys;V values;},泛型遍历方法可以减少在创建MapData类时所必须的类型检查数量
4.27:    Abstract类，设计模式——享元，在普通的解决方案需要过多的对象，或者产生普通对象态占用空间时使用享元
4.28:    Collection的功能方法P470
4.29:    可选操作
4.30:    未获支持的操作
4.31:    List->add()、get()、iterator()
4.32:    Set->HashSet()(默认，快速查找(hashCode)),TreeSet(树，Comparable接口，LinkedHashSet(HashSet的速度，内部链,hashCode)
4.33:    SortedSet保证元素处于排序状态 -> first()、last()、subSet(s,e)、headSet(len)、tailSet(len)
4.34:    队列Queue -> LinkedList 和 PriorityQueue
4.35:    Deqeue双向队列自己用LinkedList编写
4.36:    HashMap,TreeMap,LinkedHashmap,WeakHashMap,ConcurrentHashMap,IdentityHashMap
4.37:    SortedMap用TreeMap实现P486
4.38:    LinkedHashMap散列化
4.39:    散列与散列码，被用作HashMap的键
4.40:    为你的键覆盖hashCode和equals()
4.41:    使用散列的数据结构就无法正确处理你的键P490
4.42:    散列的速度使得查询得以快速进行
4.43:    散列码，一键对象，数据下标
4.44:    hashCode()散列函数
4.45:    多个String对象同样字符映射到同一块内存区域,hashCode一样
4.46:    public int hashCode(){return int;}
4.47:    int compareTo(ClassName cn){return -1/0/1;}
4.48:    HashTable,Vector,Stack过去遗留物,支持老程序，不要使用
4.49:    P505 ArrayList、LinkedList、Vector、Queue时间测试
4.50:    微基准测试，少点假设，测试窄化，仔细确保运行足够长时间产生有意义的程序
4.51:    剖析器——性能分析工具P507
4.52:    P508 TreeSet HashSet LinkedHashSet性能比较
4.53:    权衡选择
4.54:    P510 TreeMap HashMap LinkedHashMap IdentityHashMap WeakHashMap HashTable性能比较
4.55:    P512 使用方法
4.56:    Collection类内部静态方法
4.57:    ListIterator<T> it = list.listIterator(10)
4.58:    while(ti.hasNext()){it.next();it.remove();}
4.59:    Collections.sort(list,String.CASE_INSENSITIVE_ORDER)
4.60:    shuffler(list,new Random(47))
4.61:    Collection或Map的同步控制
4.62:    快速报错——Java容器防止多个进程同时修改抛出ConcurrentModificationException异常
4.63:    持有引用,java lang.ref类库 -> 垃圾回收
4.64:    Reference - SoftReference、WeakReference和PhantomReference
4.65:    System.gc()
4.66:    Stack继承于Vector，糟糕的设计，永远都不应该使用它
4.67:    栈用LinkedList或者从LinkedList类中创建的net.mindview.util.Stack
4.68:    BitSet long 64位 少于64位浪费空间 自己编写或采用数组
END

5.1:    Java I/O系统
5.2:    File类,FilePath,FilenameFilter接口
5.3:    查看目录列表——1. 调用不带参数的list()方法、2.得到所有有扩展名".java"的文件用目录过滤器
5.4:    使用java,utils,Arrays,sort()和String.CASE_INSENSITIVE.ORDER Comparator很容易对结果按字母顺序排序
5.5:    File.list(new A(regex))
5.6:    A{Pattern;构造函数(String);boolean accept(File,String name);
5.7:    匿名内部类FilenameFilter的引用
5.8:    目录使用工具：在文件集中执行操作，local方法产生由本地目录文件构成的File对象组,walk()目录树List<File>
5.9:    pformat()方法从Collection中产生格式化的String，而pprint()方法使用pformat()来执行其任务
5.10:    Directory实用工具放在了net.mindview.util包
5.11:    strategy接口内嵌在ProcessFiles中
5.12:    目录的检查与创建
5.13:    mkdirs()
5.14:    InputStream和Reader OutputStream和Writer
5.15:    很少使用单一的类来创建流对象，叠合多个对象来提供所期望的功能(装饰器设计模式)
5.16:    ByteArrayInputStream字节缓冲区,StringBufferInputStream，字符串中StringBuffer,FileInputStream文件读取,PipedInputStream多线程管道 SequenceInputStream,两个InputStream->一个InputStream,FilterInputStream抽象类
5.17:    ByteArrayinputStream、FileOutputStream、PipedOutputStream、FilterOutputStream
5.18:    DataInputStream读取不同的基本类型和String对象、BufferedInputStream防止每次读取时都得进行实际写操作、LineNumberInputStream->getLineNumber()和SetLineNumber(int)行号,PushbackInputStream能回退字符
5.19:    DataInputStream对应DataOutputStream、PrintStream可视化格式打印
5.20:    需要checkError()向行测试错误状态
5.21:    BufferedOutputStream更经常使用
5.22:    Reader和Writer支持Unicode
5.23:    java.util.zip面向字节非字符
5.24:    readLine()用BufferedReader，其它DataInputStream首选
5.25:    LineNumberInputStream已弃用
5.26:    RandomAccessFile适用于由大小已知的记录组成的文件，用seek()转移指针
5.27:    nio存储映射文件
5.28:    缓冲读入文件P540
5.29:    BufferedReader(FileReader)
5.30:    StringReader(BufferedInputStream(new FileInputStream("")))
5.31:    available()查看还有多少可供存取的字符
5.32:    BufferedReader(StringReader(BufferedInputFile.read("...java")))文本文件输出的快捷方式PrintWriter.println()　P543
5.33:    存储和恢复数据 -> 输出文件后从文件读入数据
5.34:    new DataOutputStream(new BufferedOutputStream(new DataOutputStream(new BufferedOutputStream("Data.txt"))))
5.35:    new DataInputStream(new BufferedInputStream(new FileInputStream("Data.txt")))
5.36:    Data流在有Java的两个平台上都能准确读写，用的是UTF-8编码
5.37:    new RandomAccessFile(String,"r"/"rw") -> seek(5*8)
5.38:    double是8字节长
5.39:    不支持装饰，可见内存映射文件来代替
5.40:    管道流->多线程
5.41:    TextFile类实例P546
5.42:    读取二进制文件BufferedInputStream(new FileInputStream(File))
5.43:    byte[] data = new byte[bf.available()]
5.44:    标准I/O,System.out/err:PrintStream,System.in:InputStream
5.45:    读取System.in之前对它进行包装
5.46:    回显输入每一行:BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in))
5.47:    ((s==stdin.readLine())!=null && s.length != 0)
5.48:    System.out -> PrintStream => PrintWriter(System.out,true)
5.49:    setIn(InputStream)，setOut(PrintStream)
5.50:    setErr(PrintStream)重定向
5.51:    大量输出滚动太快用重定向输出,重复测试某个特定用户的输入序列
5.52:    BufferedInputStream(FileInputStream("....java"))
5.53:    PrintStream(BufferedOutputStream(FileOutputStream("....out")))
5.54:    进程控制——在Java内部执行其他操作系统的程序、控制这些程序的输入和输出
5.55:    OSExecute.command新I/O,通道和缓冲器
5.56:    用户 <-> 缓冲器(byteArray) <-> 通道
5.57:    File流和RandomAccessFile产生FileChannel,通道产生Reader和allocate()分配ByteBuffer,allocateDirect()
5.58:    FileChannel<-FileOutputStream(String).getChannel()
5.59:    ByteBuffer.allocate(bsize)
5.60:    buff.rewind()
5.61:    buff.asCharBuffer()
5.62:    编码解码java.nio.charset.Charset基本类型值 asXXXBuffer().put(XXX)/.get(XXX),rewind()
5.63:    视图缓冲器view buffer IntBuffer操纵ByteBuffer中的int型数据
5.64:    查看底层ByteBuffer
5.65:    想把字节数组写入文件，写入FileChannel
5.66:    交换邻近字符算法P561
5.67:    内存映射文件——创建修改因太大无法放入内存的文件MappedByteBuffer = RandomAccesFile(String,"rw").getChannel().map(FileChannel.MapMode.READ_WRITE,0,length)->put、get
5.68:    runTest()模板方法
5.69:    文件加锁-FileLock = FileOutStream.getChannel().tryLock()
5.70:    fl.release()
5.71:    TimeUnit.MILLISECONDS.sleep(100)
5.72:    trylock(position,size,shared(boolean))
5.73:    isShared()独占锁还是共享锁
5.74:    对映射文件部分加锁LockAndModify()
5.75:    压缩：Checked流、DeflaterOutputStream、Zip流、GZip流
5.76:    BufferedOutputStream(GZIPOutputStream(FileOutputStream(String)))
5.77:    BufferedReader(FileReader(String))
5.78:    BufferedReader(InputStreamReader(GZIPInputStream(FileInputStream(String))))
5.79:    用zip进行多文件保存
5.80:    jar[options]destination[manifest]inputfiles(s)
5.81:    对象序列化-保存类变量的信息
5.82:    对象序列化实现了Serializable接口的对象转换成一个字节序列
5.83:    轻量级持久性
5.84:    class Data implements Serializable{}
5.85:    ObjectOutputStream(FileOutputStream(String))->writeObject
5.86:    ObjectInputStream(FileInputStream(String))->readObject;
5.87:    ObjectOutputStream(ByteArrayOutputStream())
5.88:    ObjectInputStream(ByteArrayInputStream(bout.toByteArray()))
5.89:    寻找类ObjectOutputStream(FileOutputStream(String))
5.90:    序列化控制Blip1 implements Externalizable
5.91:    transient(瞬时)关键字
5.92:    defaultWriteObject()
5.93:    版本控制
5.94:    存储程序状态,随后很容易将程序恢复
5.95:    P583 计算机辅助设计(CAD)系统
5.96:    Shape类实现了Serializable，继承自Shape类的自动是Serializable
5.97:    Java产生和修改 XML的方式
5.98:    Person对象序列化到XML，Person有getXML(),nu.xom,Element
5.99:    Preferences自动存储和读取小的，受限的数据集合
END

6.1:    枚举类型enum , java.lang.Enum
6.2:    enumName.values()返回数组
6.3:    Enum类Comparable接口(CompareTo方法),Serializable接口
6.4:    getDeclaringClass()
6.5:    用import static 导入enum类
6.6:    enum添加方法,enum.values()[].getDescription()
6.7:    覆盖enum的方法
6.8:    switch与enum
6.9:    反射机制得到values()是由编译器添加进的static方法
6.10:    enum继承自java.lang.Enum,Java不支持多重继承，enum不能再继承其它类
6.11:    随机选取CartoonCharacter.next()
6.12:    使用接口组织枚举interface Food{enum A implements Food{} x n 个}
6.13:    EnumSet替代传统的基于int的位标志
6.14:    EnumMap数组实现
6.15:    enum存储函数P603
6.16:    使用enum的职责链设计模式，以多种不同方式来解决一个问题，将它们链接在一起，当一个请求到来时，遍历这个链，知道链中某个解决方案能处理该要求
6.17:    enum创建状态机，从一个状态到下一个状态
6.18:    多路分发，处理多种交互类型时程序变得杂乱
6.19:    Java只支持单路分发
6.20:    Number.plus(Number),a.plus(b),谁知道a/b是不是Number类型
6.21:    石头剪刀布游戏P613
6.22:    使用enum分发
6.23:    使用常量相关的方法
6.24:    EnumMap分发
END

7.1:    注解
7.2:    @Override覆盖，不小心拼写错误编译器会出现错误提示
7.3:    @Deprecated使用了注解为它的元素会警告
7.4:    @SuppressWarning JavaSE5后关闭不当的编译器警告信息
7.5:    @Test对test.Excute()方法进行注解
7.6:    无注解@Target @Retention @Documented @Inherited 用于何地、什么级别保存、包含在JavaDoc中，继承父类注解
7.7:    注解处理器，元素
7.8:    默认值限制，继承父类注解
7.9:    @TableColumn嵌套@SQLType、@SQLInteger、@SQLString
7.10:    注解处理工具apt处理注解
7.11:    @TestProper用于测试的方法
7.12:    @Unit用于泛型
7.13:    移除测试代码Javaassist工具类库
7.14:    -r标志删除所有@Test注解，没有-r则打印之
ENDP649 201601182021 星期一

8.1:    并发
8.2:    顺序编程，一时刻只执行一个步骤
8.3:    Java基本的Web库类
8.4:    Servlet具有天生的多线程性
8.5:    Web服务器经常包含多个处理器
8.6:    并发缺陷——时不时地神秘崩溃，可能是温和的、重要数据丢失、不好调试
8.7:    并发提高“速度”和“设计可管理性”两种
8.8:    并发提高运行在单处理器上的程序的性能
8.9:    单处理器上运行的并发程序开销比顺序执行大，增加上下文切换的代价
8.10:    因为程序控制范围之外的某些条件(通常是I/O)而导致不能继续执行、任务或线程阻塞
8.11:    单处理器性能提高——事件驱动编程
8.12:    并发最直接方式——操作系统级别使用进程
8.13:    进程是运行在它自己的地址空间内的自包容程序
8.14:    编写多线程程序最基本的困难在于协调不同线程驱动的任务之间，对这些资源的使用，以使得这些资源不会同时被多个任务访问
8.15:    将并发任务彼此的使用，以使得这些资源不会同时被多个任务访问
8.16:    将并发任务彼此隔离——函数型语言Erlang专门的并发语言
8.17:    线程机制——操作系统的透明性
8.18:    P652 Macintosh操作系统不支持多任务，因此除非在Java中添加多线程机制,否则任何并发的Java程序都无法移植到Macintosh和类似的平台上，打破"编写一次，到处运行"的要求
8.19:    仿真，没有并发的支持很难解决
8.20:    仿真，例如游戏或电影中计算机生成的动画，涉及许多交互式元素，每一个都有“其自己的想法”
8.21:    完整的仿真可能涉及非常大量的任务、协作多线程
8.22:    Java线程机制都是抢占式的，为每个线程提供时间片
8.23:    多线程机制——这些独立任务中的每一个都将由执行线程来驱动
8.24:    线程驱动任务Runnable->run()
8.25:    Thread.yield()声明“我已经执行完生命周期中最重要的部分了，此刻正是切换给其他任务执行一段时间的大好时机”->有趣的输出、换进换出的证据
8.26:    将Runnable对象提交给一个Thread构造器Thread(Runnable())
8.27:    这种交换是由线程调度器自动控制的，给多个处理器之间默默地分发线程
8.28:    java.util.concurrent.Executor管理Thread对象，简化并发编程
8.29:    Executors.newCachedThreadPool()
8.30:    ExecutorService.execute(Runnable()).shutdow()->防止新任务被提交给这个Executor，所有任务完成之后会尽快退出P656
8.31:    Executors.newFiexedThreadPool(5)->限制线程数量
8.32:    任何线程池在线程可能情况下都会自动复用
8.33:    CachedThreadPool在程序执行过程中通常会创建与所需数量相同的线程然后在回收旧线程时停止创建新进程，有问题才切换到FixedThreadPool
8.34:    SingleThreadExecutor提交多个任务，任务排列，使用相同线程，序列化任务，维护(隐藏)悬挂任务队列
8.35:    SingleThreadExecutor可以让你省去只是为了维持某些事物的原型而进行的各种协调努力
8.36:    Runnbale不返回值、Callable可以返回一个值，一个具有类型参数的泛型，类型参数表示的是从方法Call()(而不是run())中返回的值，必须用ExecutorService.submit()方法调用它
8.37:    ArrayList<Future<String>>.add(ExecutorService.submit(Callable<Stirng>))
8.38:    Future<String>.get()->获取返回值、isDone()查看任务是否完成
8.39:    休眠sleep()可能抛出Interrupted Exception异常，在run()中被捕捉、不能传回main()，所以必须在本地处理所有在任务内部产生的异常
8.40:    控制任务执行的顺序->同步控制
8.41:    某些情况下压根不使用线程编写自己的协作例程、会按照指定的顺序在互相之间传递控制权
8.42:    线程的优先级将该线程的重要性传递给调度器，优先级低的执行频率较低，优先权不会导致死锁
8.43:    Thread.currentThread().setPriority(priority)/getPriority()/toString()
8.44:    优先级兼容多平台用MAX_PRIORITY、NORM_PRIORITY、MIN_PRIORITY
8.45:    Thread.yield()暗示线程让步，不保证会采纳
8.46:    是在建议具有相同优先级的其它线程可以运行，不能依赖于yield()
8.47:    后台进程，main()是非后台程序，setDaemon()设置为后台进程，一旦所有非后台进程结束，后台进程会被杀死
8.48:    Executors.newCachedThreadPool(new DaemonThreadFactory()):ExecutorService.execute(new DaemonFromFactory())implements Runnable
8.49:    isDaemon()确定线程是否为后台线程
8.50:    后台线程创建的线程也是后台线程
8.51:    编码的变体——从Runnable到直接继承Thread
8.52:    构造器中启动线程会出现问题，优选Executor而非显式创建Thread对象
8.53:    使用内部类隐藏线程代码会很有用
8.54:    Task的名字比Runnable好
8.55:    Java线程机制基于来自C的低级的p线程方式
8.56:    Thread.join()等待一段时间直到第二个线程结束才执行，也可带超时参数,interrupt()方法 -> 对join()调用中断
8.57:    需try-catch
8.58:    创建有响应的用户界面ResponsiveUI()P671
8.59:    把计算程序放在run()中
8.60:    线程组——线程集合，一次不成功的尝试(为何?)
8.61:    Thread.UncaughtExceptionHandler，给Thread对象附着一个异常处理器
8.62:    共享受限资源，不正确地访问资源——一个任务产生偶数，其他任务消费这些偶数、其他任务消费这些偶数
8.63:    解决共享资源竞争——叉盘中的最后一块食物，食物消失，你的线程被挂起，另一餐者进入吃掉了它
8.64:    使用时上锁
8.65:    汽车前排座位是受限资源，大喊“冲啊”的孩子就会获得其上的锁
8.66:    synchronized void f(){private var;}，上锁对象需要private，所有对象都自动含有单一的锁
8.67:    class{synchronized f1(){f2();}} f2(){f3();} f3(){}}对象锁计数递增，递减至0时推给别的任务
8.68:    synchronized static
8.69:    写一个可能被——线程读取的变量，读取一个已被写过的变量，必须用同步
8.70:    访问临界共享资源的方法都必须同步
8.71:    EvenGenerator同步控制，加入synchronized防止不希望的线程访问
8.72:    使用显示的Lock对象java.util.concurrent.locks显式交互机制Lock.lock()/unlock()
8.73:    这样可以用try-catch维护正确性
8.74:    Lock.tryLock(2,TimeUnit.SECONDS)
8.75:    用于遍历链接列表中的结点的节节传递的加锁机制(锁耦合)，必须在释放当前节点的锁之前获取下一节点的锁
8.76:    原子性和易变性，并发专家才应该使用原子性来代替同步——编写用于现代微处理器的高性能JVM
8.77:    如果某人表示线程机制很容易并且很简单，那么请确保这个人没有对你的项目作出重要决策。如果这个人已经在这么做了，那么你就陷入到麻烦之中了
8.78:    域声明为volatile
8.79:    除synchronized的其它方法都有风险
8.80:    synchronized{i++;i++;}最终结果为奇数
8.81:    只有并发专家课优化，你还是应该使用Brain的同步规则
8.82:    原子类AtomicInteger/Long/Reference->compareAndSet(expectedValue,undateValue)
8.83:    AtomInteger(0).get()/.addAndGet(2)
8.84:    防止多个线程访问方法内部的部分代码、非整——临界区
8.85:    synchronized(syncObject){}同步控制块，进入前必须得到syncObject对象的锁
8.86:    Lock.lock()
8.87:    try-finally{Lock.lock();}
8.88:    在其他对象上同步
8.89:    使用其方法正被调用的当前对象
8.90:    线程本地存储，根除对变量共享，5线程都用变量x，生成5个用于x不同的存储块
8.91:    java.lang.Thread静态或存储、get()/set()/increment()
8.92:    终结任务Local
8.93:    终结任务cancel(),isCanceled()
8.94:    阻塞时终结：线程状态，新建(new)->就绪(Runnable)->阻塞(Blocked)->死亡(Dead)，进入阻塞：sleep(int),voait()就绪,notify(),notifyAll(),signal(),signalAll(),I/O，锁
8.95:    suspend，resume(),stop()弃用
8.96:    中断Thread.interrupt()
8.97:    Executor.submit()
8.98:    SleepBlock可中断的阻塞、IOBlocked和SynchronizedBlocked不可中断阻塞
8.99:    被互斥所阻塞
8.100:    检查中断interrupted()
8.101:    线程之间的协作、非彼此之间的干涉
8.102:    wait和notifyAll()
8.103:    ①多个任务出于相同原因等待一把锁，第一个任务会改变这种状况，重新挂起任务直到变化。
8.104:    ②其他任务改变使这个任务无法运行，再次wait
8.105:    ③多任务不同原因等待锁notifyAll()，检查对应任务，未到条件wait()
8.106:    错失的信号notify() wait()时错过信号
8.107:    生产者与消费者P709
8.108:    显式的Lock和Condition对象java.util.concurrent，互斥并允许任务挂起Condition->await()挂起任务->signal()唤醒
8.109:    生产者-消费者队列
8.110:    java.uti.concurrent.BlockingQueue同步队列
8.111:    LinkedBlockingQueue/ArrayBlockingQueue
8.112:    吐司制作程序BlockingQueue P715
8.113:    任务间使用管道进行输入/出PipedWriter和PipedReader类
8.114:    死锁-哲学家就餐P719
8.115:    新类库中的构件、CountDownLatch
8.116:    类库的线程安全、CyclicBarrier,DelayQueue无界BlockingQueue、PriorityBlockingQueue优先级队列
8.117:    ScheduledExecutor温室控制器P730
8.118:    Semaphore计数信号量、Semaphore(size,true)->acquie()、release()
8.119:    Exchanger两个任务之间交换对象的栅栏->一个任务生产代价昂贵的对象，另一任务消耗这些对象P735生产者消费者
8.120:    并发仿真->银行出纳员仿真——对象随机出现，要求由数量有限的服务器提供随机数量的服务时间，通过构建仿真确定理想的服务器数量P737
8.121:    饭店仿真P741
8.122:    分发工作——用于汽车的机器人组装线P744
8.123:    性能调优 —— 比较各类互斥技术synchronized快于ReentrantLock P752
8.124:    模板方法设计模式，共用的代码放基类，不同的代码隔离在到处类的accumulate()和read()实现
8.125:    Vector和Hashtable具有许多的synchronized方法，开销大
8.126:    免锁容器改与读可同时访问、读可看到改后结果
8.127:    乐观锁 P755
8.128:    1. synchronizedHashMap、2.ConcurrentHashMap、3. CopyOnWriteArrayList 3 写入影响强于2. P759
8.129:    乐观加锁、执行某项计算时实际上没有使用互斥
8.130:    ReadWriteLock对向数据结构相对不频繁地写入、但是有多个任务要经常读取这个数据结构的这类情况进行优化
8.131:    活动对象——每个对象都维护着它自己的工作器线程和消息队列、并且所有对这种对象的请求都进入队列排队，任何时刻都只能运行其中的一个
8.132:    可以串行化消息而不是方法，意味着不再需要防备一个任务在其循环的中间被中断这种问题了
8.133:    1. 每个对象拥有自己的工作期线程。2. 维护对自己的域的全部控制权 3. 活动对象之间的通信以消息形式发生 4.消息要排队
8.134:    病态行为，饿死，竞争，死锁，活塞(多个运行各自任务的线程整体无法完成)
END

9.1:    JFrame->setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)、setSize(300,100),setVisible(true)
9.2:    SwingUtilties.invokeLater()放置到待执行事件队列中
9.3:    FlowLayout从左到右，从上到下连续均匀分布
9.4:    addActionListener(ActoinListen(actionPerformed(){}))
9.5:    JTextFiled
9.6:    JTextArea包装进JScrollPane
9.7:    BorderLayout上下左右中GrideLayout行列表格组件
9.8:    GridBayLayout精确判断视窗区域布局，视窗大小变化如何安置组件
9.9:    TableLayout在java.sun.com下载
9.10:    绝对定位，setBounds()或reShapre()，非最佳方式
9.11:    BoxLayout水平垂直控制组件，支架和浇水(strust and glue)
9.12:    add/removeXXXListener() P779，P782
9.13:    按钮P785
9.14:    Icon(ImageIcon(getClass().getResource("XXX.gif")))
9.15:    jb.setIcon(Icon)
9.16:    setToolTipText(String)工具提示
9.17:    setBorder(Border)P790
9.18:    JTextPane控件
9.19:    页签面板JTabbedPane P796
9.20:    消息框
9.21:    菜单
9.22:    弹出式菜单JPopupMenu P802
9.23:    绘图 P803
9.24:    三值翻转 P806
9.25:    文件对话框 P808
9.26:    组件中的HTML文本
9.27:    滑块与进度条 P810
9.28:    JNLP和JavaWebStart网络发布协议
9.29:    Swing与并发P816
9.30:    可视化线程机制，可视化编程与JavaBean
9.31:    鼠标绘制圆圈、按下鼠标Bang P829
9.32:    SWT应用P844,P855
END 201601191434 星期二