think in java 的目錄(轉)

think in java 的目錄(轉)

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.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 intset = new TreeSet(),intset.add(…)

3.51: new.mindview.TextFile,打開一個檔案，将其讀入一個Set

3.52: Set words = new TreeSet(new TextFile(“SetOperation.java”,"\W+"));

3.53: String.CASE_INSENTIVE_ORDER按照字母序排列

3.54: 擴充到多元Map<Person,List>

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，Iterable 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對象

3.161: 重寫Iterable的Fibonacci生成器，不過，你并不是總能擁有源代碼的控制權，并且除非必須這麼做否則我們也不願重寫一個類

3.162: 或者建立一個擴充卡adapter來實作所需的接口

3.163: extends Fibonacci implements Iterable

3.164: iterator(){return new Iterator(){}}

3.165: 應該盡量使用泛型方法

3.166: static方法通路泛型得先成為泛型方法

3.167: public void f(T x){}

3.168: 使用了泛型的函數可以識别各種類型

3.169: 泛型使用無需知參數

3.170: 編譯器會為我們找出具體的類型稱為類型參數推斷

3.171: 相等f()被無限次地重載過

3.172: 編号一個工具類，包含各種各樣的static方法，專門用來建立各種常用的(泛型)容器對象，類型推斷隻對指派有效，傳參無效

3.173: 解決傳參問題

3.174: f(New<Person,List>map())

3.175: 泛型方法和可變參數清單能夠很好地共存

3.176: public static List makeList(T…args){}

3.177: Generator create(Class type)

3.178: TupleTest.java

3.179: EnumSet.range()

3.180: Generator generator()

3.181: 用泛型構造複雜模型

3.182: 擦除

3.183: ArrayList.class可以

3.184: ArrayList.class不能聲明

3.185: ArrayList == ArrayList傳回true

3.186: 然而放String或Integer所得到的行為完全不同

3.187: 泛型類中Class.getTypeParameters()輸出中發現的隻是用作參數占位符的辨別符，是以現實是，在泛型代碼内部，無法擷取任何有關泛型參數類型的資訊——List事實上是相同類型

3.188: 擦除即泛型的類型無法在類中得知，但C++可以

3.189: 可以用來指定類型

3.190: 希望代碼能跨多個類工作時，使用泛型才有幫助

3.191: 遷移相容性——泛化的用戶端可以用非泛化的類庫來使用

3.192: 編寫泛型類時需要提醒自己“不，他隻是一個Object”

3.193: 泛型可以表示沒有任何意義的事物,String.class -> Class kind

3.194: 擦除在方法體中移除了類型資訊，運作時的問題就是邊界， P379-380

3.195: new T()無法實作，需要使用工廠，使類自帶newInstance()方法構造

3.196: 泛型數組Generic[]

3.197: 邊界<T extends Dimension&HasColor&Weight>

3.198: Fruit[] fruit = new Apple[10]正确Listflist = new ArrayList()錯誤

3.199: flist = <List<? extends Fruit>>具有任何從Fruit繼承的類型的清單

3.200: 編譯器有多聰明，隻是傳參類型為Object而已

3.201: 逆變，超類型通配符<? super MyClass>、<? super T>不能聲明成

3.202: 放松了在可以向方法傳遞的參數上所作的限制,f(List,T)不能将Apple放入List，(List<? super T>,T)能将Apple放入List

3.203: 協變，通配符P394

3.204: 無界通配符<?>泛型參數可以持有任何類型

3.205: 多個泛型類型參數的無界通配符<?,Object> <?,?> <String,?>

3.206: List<?>表示具有某種特定類型的非原生List,隻是不知道類型,List持有object類型的原生list

3.207: List == List

3.208: 捕獲轉換——需要使用而不是原生類型

3.209: <?>方法傳遞原生類型

3.210: 任何基本類型都不能作為類型參數

3.211: ArrayList 自動包裝機制 int -> Integer，不能用于數組

3.212: 使用帶泛型類型的轉型或instanceof不會有任何效果

3.213: 轉型或警告

3.214: 泛型重載無效，使用不同的方法名fl(List v),f2(List v)

3.215: 基類劫持了接口,Comparable接口 implements

3.216: 自限定類型<T extends SelfBounded>

3.217: 循環泛型A，B extends A

3.218: BasicHolder -> Subtype

3.219: CRG本質：基類用到處類替代其參數，泛型基類是所有導出類的公共功能的模闆

3.220: 自限定SelfBounded<T extends SelfBounded>

3.221: A extends SelfBounded

3.222: 參數協變、方法參數類會随子類而變化,set(T arg)，set(ClassName cn)繼承的問題

3.223: 動态類型安全.newArrayList():List.add(new Cat())允許

3.224: Collections.checkedList(new ArrayList(),Dog.class).add(new Cat())

3.225: 異常、catch語句不能捕獲泛型類型的異常，泛型類不能直接或間接繼承自Throwable

3.226: 混型——混合多個類的能力,産生一個可以表示混型中的所有類型的類

3.227: C++：template class ClassName:public T{},A<B>,通過繼承類模闆實作混型

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 void perform(T anything){anything.speak();anything.sit();}

3.236: 反射，确定形參形參Object類是否有該方法try-catch

3.237: 将一個方法應用于序列，foreach語句用反射

3.238: 無接口時依賴于定義一個Collection的子類型，調用add()

3.239: 擴充卡仿真潛在類型機制fill(Addable 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[]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,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(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 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

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>.add(ExecutorService.submit(Callable))

8.38: Future.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 星期二