java核心技術卷1基礎知識整理

• 1.java概述
• 2.java程序設計
• 3.對象與類
• 4 繼承
• 5 接口、lambda 表達式與內(nèi)部類
• 6 并發(fā)

1.java概述

1.Java 剔除了 C++ 中許多很少使用、 難以理解、 易混淆的特性， 在目前看來， 這些特性帶來的麻煩遠遠多于其帶來的好處。
2.Java 有一個豐富的例程庫， 用于處理像 HTTP 和 FIT 之類的 TCP/IP 協(xié)議。Java 應用
程序能夠通過 URL 打開和訪問網(wǎng)絡上的對象， 其便捷程度就好像訪問本地文件一樣。
3.Java 和 C++ 最大的不同在于 Java 采用的指針模型可以消除重寫內(nèi)存
和損壞數(shù)據(jù)的可能性。
4.Java 編譯器能夠檢測許多在其他語言中僅在運行時才能夠檢測出來的問題。
5.Java 適用于網(wǎng)絡 / 分布式環(huán)境。 為了達到這個目標， 在安全方面投入了很大精力。 使用 Java 可以構建防病毒、 防篡改的系統(tǒng)。從一開始，Java 就設計成能夠防范各種攻擊，其中包括：運行時堆棧溢出。 如蠕蟲和病毒常用的攻擊手段。破壞自己的進程空間之外的內(nèi)存。未經(jīng)授權讀寫文件。
6.解釋虛擬機指令肯定會比全速運行機器指令慢很多。 然而， 虛擬機有一個選項，可以將執(zhí)行最頻繁的字節(jié)碼序列翻譯成機器碼，這一過程被稱為即時編譯。
7.與 C 和 C++ 不同，Java 規(guī)范中沒有“ 依賴具體實現(xiàn)” 的地方，基本教據(jù)類型的大小以及有關運算都做了明確的說明。（例如，Java 中的 int 永遠為 32 位的整數(shù)，而在 C/C++ 中， int 可能是 16 位整數(shù)、 32 位整數(shù)， 也可能是編譯器提供商指定的其他大小）。
8.Java 成功地推出后不久， 微軟就發(fā)布了一個叫做 J++ 的產(chǎn)品，它與 Java 有幾乎相同的編程語言以及虛擬機，現(xiàn)在， 微軟不再支持 J++, 取而代之的是另一種名為 C# 的語言。C# 與 Java 有很多相似之處， 然而使用的卻是完全不同的虛擬機。
9.JavaScript 和Java 幾乎沒有任何關系。

2.java程序設計

1.根據(jù) Java語言規(guī)范， main 方法必須聲明為 public。
2.System.out 還有一個 print 方法， 它在輸出之后不換行。 例如， System.out.print
“( Hello”）打印“ Hello” 之后不換行。
3.在 Java 中，/* / 注釋不能嵌套 ? 也就是說， 不能簡單地把代碼用 / 和 */ 括起來
作為注釋， 因為這段代碼本身可能也包含一個 */ 。
4.Java 是 -種強類型語言。這就意味著必須為每一個變量聲明一種類型: 在 Java 中，共有 8
種基本類型 , 其中有 4 種整型、2 種浮點類型、 1 種用于表示 Unicode 編碼的字符
單元的字符類型 char 和 1 種用于表示真值的 boolean 類型。
5.Java 沒有任何無符號（unsigned) 形式的 int、 long、 short 或 byte 類型。
6.可以使用十六進制表示浮點數(shù)值。例如，0.125=2^{-3} 可以表示成 0x1.0p-3。在十六
進制表示法中， 使用 p 表示指數(shù)， 而不是 e。 注意， 尾數(shù)采用十六進制， 指數(shù)采用十進
制。指數(shù)的基數(shù)是 2， 而不是 10。
7.常量 Double.POSITIVE_INFINITY、Double.NEGATIVE_INFINITY 和 Double.NaN
( 以及相應的 Float 類型的常量）分別表示這三個特殊的值(正無窮大，負無窮大，NaN， 但在實際應用中很少遇到。特別要說明的是， 不能檢測一個特定值是否等于 Double.NaN，然而， 可以使用Double.isNaN 方法。
8.char 類型的值可以表示為十六進制值，其范圍從 \u0000 到 \Uffff。
9.所有轉義序列都可以出現(xiàn)在加引號的字符字面量或字符串中。 例如，’\02122’ 或 "Hello\n”。 轉
義序列 \u還可以出現(xiàn)在加引號的字符常量或字符串之外（而其他所有轉義序列不可以）。 例
如：public static void main(String\u005B\ u005D args) 就完全符合語法規(guī)則， \u005B 和 \u005D 是 [ 和 ] 的編碼。
10.Unicode 轉義序列會在解析代碼之前得到處理。 例如，"\u0022+\u0022” 并不是一個由引號（U+0022) 包圍加號構成的字符串。 實際上， \u0022 會在解析之前轉換為 "， 所以說這是一個空串。
11.更隱秘地， 一定要當心注釋中的 \u。注釋 // \u00A0 is a newline 會產(chǎn)生一個語法錯誤， 因為讀程序時 \u00A0 會替換為一個換行符。類似地， 下面這個注釋：
// Look inside c:\users
也會產(chǎn)生一個語法錯誤， 因為 \u 后面并未跟著 4 個十六進制數(shù)。
12.在 1991 年發(fā)布了 Unicode 1.0, 當時僅占用 65 536 個代碼值中不到一半的部分。在設計 Java 時決定采用 16 位的 Unicode 字符集，這樣會比使用 8 位字符集的程序設計語言有很大的改進。十分遺憾， 經(jīng)過一段時間， 不可避免的事情發(fā)生了。Unicode 字符超過了 65 536 個，其主要原因是增加了大量的漢語、 日語和韓語中的表意文字。現(xiàn)在， 16 位的 char 類型已經(jīng)不能滿足描述所有 Unicode 字符的需要了。
13.UTF-16 編碼采用不同長度的編碼表示所有 Unicode 碼點。在基本的多語言級別中，每個字符用 16 位表示，通常被稱為代碼單元（code unit) ; 而輔助字符采用一對連續(xù)的代碼單元進行編碼。、
14.在 Java 中，char 類型描述了 UTF-16 編碼中的一個代碼單元。強烈建議不要在程序中使用 char 類型， 除非確實需要處理 UTF-16 代碼單元。最好將字符串作為抽象數(shù)據(jù)類型處理。
15.變量名必須是一個以字母開頭并由字母或數(shù)字構成的序列。需要注意，與大多數(shù)程序設計語言相比，Java 中“ 字母” 和“ 數(shù)字” 的范圍更大。字母包括 ’A’ ~ ’Z’、 ’a’~ ’z’、‘_’，‘$’或在某種語言中表示字母的任何 Unicode 字符。
16.變量名中所有的字符都是有意義的，并且大小寫敏感。變量名的長度基本上沒有限制。
17.如果想要知道哪些 Unicode 字符屬于 Java 中的“ 字母”， 可以使用 Character 類的isJavaldentifierStart 和 isJavaldentifierPart 方法來檢查。
18.盡管 $ 是一個合法的 Java 字符， 但不要在你自己的代碼中使用這個字符。 它只用
在 Java 編譯器或其他工具生成的名字中。
19. const 是 Java 保留的關鍵字， 但目前并沒有使用。 在 Java 中， 必須使用 final定義常量。
20. 需要注意， 整數(shù)被 0 除將會產(chǎn)生一個異常， 而浮點數(shù)被 0 除將會得到無窮大或 NaN 結果。
21. 操作數(shù)轉換為同一種類型，然后再進行計算。

• 如果兩個操作數(shù)中有一個是 double 類型， 另一個操作數(shù)就會轉換為 double 類型。
• 否則， 如果其中一個操作數(shù)是 float 類型， 另一個操作數(shù)將會轉換為 float 類型。
• 否則， 如果其中一個操作數(shù)是 long 類型， 另一個操作數(shù)將會轉換為 long 類型。
• 否則， 兩個操作數(shù)都將被轉換為 int 類型。
  6 個實心箭頭，表示無信息丟失的轉換； 有 3 個虛箭頭， 表示可能有精度損失的轉換。

22.如果試圖將一個數(shù)值從一種類型強制轉換為另一種類型， 而又超出了目標類型的表示范圍， 結果就會截斷成一個完全不同的值。 例如，（byte) 300 的實際值為 44。
23.如果 x 是一個 int, 則以下語句x += 3.5 是合法的，它將把 x 設置為（int)(x + 3.5)。
24.應用在布爾值上時，& 和丨運算符也會得到一個布爾值。這些運算符與 &&和| |運
算符很類似， 不過 & 和丨運算符不采用“ 短路” 方式來求值。
25.>>> 運算符會用 0 填充高位，這與>>不同，它會用符號位填充高位。不存在 <<<運算符。
26.如果虛擬機始終將相同的字符串共享， 就可以使用運算符檢測是否相等。但實際上只有字符串常量是共享的，而+ 或 substring 等操作產(chǎn)生的結果并不是共享的。因此，千萬不要使甩 運算符測試字符串的相等性， 以免在程序中出現(xiàn)糟糕的 bug。
27.java中的String類型的length()方法實際上返回的是代碼單元的數(shù)量，而不是碼點(字符)的數(shù)量。
28.在 C++ 中， 可以在嵌套的塊中重定義一個變量。在內(nèi)層定義的變量會覆蓋在外層定義的變量。這樣， 有可能會導致程序設計錯誤， 因此在 Java 中不允許這樣做。
29.對于switch語句，case 標簽可以是：

• 類型為 char、byte、 short 或 int 的常量表達式
• 枚舉常量
• 從 Java SE 7 開始， case 標簽還可以是字符串字面量

30.當在 switch 語句中使用枚舉常量時，不必在每個標簽中指明枚舉名，可以由 switch 的表
達式值確定。例如：

31. 與C++ 不同， Java 沒有提供運算符重載功能。 程序員無法重定義 + 和 * 運算符， 使其應用于 BigInteger類的 add 和 multiply 運算。 Java 語言的設計者確實為字符串的連接重載了 + 運算符，但沒有重載其他的運算符，也沒有給 Java 程序員在自己的類中重載運算符的機會。
32. 使用靜態(tài)的 valueOf 方法可以將普通的數(shù)值轉換為大數(shù)值。遺憾的是，不能使用人們熟悉的算術運算符（如：+ 和 *) 處理大數(shù)值。 而需要使用大數(shù)值類中的 add 和 multiply 方法。
33. for each 循環(huán)語句不能自動處理二維數(shù)組的每一個元素。它是按照行， 也就是一維數(shù)組處理的。要想訪問二維教組 a 的所有元素， 需要使用兩個嵌套的循環(huán)。
34. 要想快速地打印一個二維數(shù)組的數(shù)據(jù)元素列表， 可以調用：
System.out.println(Arrays.deepToString(a)) ;
35.Java 實際上沒有多維數(shù)組， 只有一維數(shù)組。 多維數(shù)組被解釋為“數(shù)組的數(shù)組”。

3.對象與類

1.封裝 （ encapsulation , 有時稱為數(shù)據(jù)隱藏）是與對象有關的一個重要概念。 從形式上看，封裝不過是將數(shù)據(jù)和行為組合在一個包中， 并對對象的使用者隱藏了數(shù)據(jù)的實現(xiàn)方式。
2.實現(xiàn)封裝的關鍵在于絕對不能讓類中的方法直接地訪問其他類的實例域。 程序僅通過對象的方法與對象數(shù)據(jù)進行交互。封裝給對象賦予了“ 黑盒” 特征， 這是提高重用性和可靠性的關鍵。這意味著一個類可以全面地改變存儲數(shù)據(jù)的方式，只要仍舊使用同樣的方法操作數(shù)據(jù)， 其他對象就不會知道或介意所發(fā)生的變化。
3.在類之間，最常用的關系有依賴關系，聚合關系和繼承關系。如果一個類的方法操縱另一個類的對象，我們就說一個類依賴于另一個類，應該盡可能地將相互依賴的類減至最少， 如果類 A 不知道 B 的存在， 它就不會關心 B的任何改變（這意味著 B 的改變不會導致 A 產(chǎn)生任何 bug )，用軟件工程的術語來說， 就是讓類之間的耦合度最小；聚合關系意味著類 A 的對象包含類 B 的對象；繼承就比較熟悉了。
4.并不是所有的類都具有面向對象特征。 例如，Math 類。在程序中，可以使用 Math 類的方法， 如 Math.random, 并只需要知道方法名和參數(shù) （如果有的話，) 而不必了解它的具體實現(xiàn)過程。這正是
封裝的關鍵所在，當然所有類都是這樣。但遺憾的是， Math 類只封裝了功能，它不需要也不必隱藏數(shù)據(jù)。 由于沒有數(shù)據(jù)，因此也不必擔心生成對象以及初始化實例域。
5.一個對象變量并沒有實際包含一個對象，而僅僅引用一個對象。
6.文件名必須與 public 類的名字相匹配。在一個源文件中， 只能有一個公有類，但可以有任意數(shù)目的非公有類。
7.構造器總是伴隨著 new 操作符的執(zhí)行被調用，而不能對一個已經(jīng)存在的對象調用構造器來達到重新設置實例域的目的。
8.在 Java 中， 所有的方法都必須在類的內(nèi)部定義， 但并不表示它們是內(nèi)聯(lián)方法。 是否將某個方法設置為內(nèi)聯(lián)方法是 Java 虛擬機的任務。 即時編譯器會監(jiān)視調用那些簡潔、 經(jīng)常被調用、 沒有被重載以及可優(yōu)化的方法。
9.一個方法可以訪問所屬類的所有對象的私有數(shù)據(jù)。

public class Person implements Cloneable {private String name;public Person(String name) {this.name = name;}public void method(Person p) {p.name = "haha";}public String getName() {return name;} } public class Test {public static void main(String[] args) throws CloneNotSupportedException {Person p = new Person("a");Person pp = new Person("b");p.method(pp); // 調用p對象的method方法。可以訪問pp對象的私有變量。System.out.println(pp.getName()); // haha} }

10.有時，可能希望將一個計算代碼劃分成若干個獨立的輔助方法。通常， 這些輔助方法不應該成為公有接口的一部分，這是由于它們往往與當前的實現(xiàn)機制非常緊密， 或者需要一個特別的協(xié)議以及一個特別的調用次序。最好將這樣的方法設計為 private 的。對于私有方法， 如果改用其他方法實現(xiàn)相應的操作， 則不必保留原有的方法。如果數(shù)據(jù)的表達方式發(fā)生了變化，這個方法可能會變得難以實現(xiàn)， 或者不再需要。然而， 只要方法是私有的，類的設計者就可以確信：它不會被外部的其他類操作調用，可以將其刪去。如果方法是公有的， 就不能將其刪去， 因為其他的代碼很可能依賴它。
11.可以將實例域定義為 final。 構建對象時必須初始化這樣的域。也就是說， 必須確保在每一個構造器執(zhí)行之后， 這個域的值被設置， 并且在后面的操作中， 不能夠再對它進行修改。
12.System.out是一個經(jīng)常使用的靜態(tài)常量。
13.如果查看一下 System 類， 就會發(fā)現(xiàn)有一個 setOut 方法， 它可以將 System.out 設置為不同的流。 那么為什么這個方法可以修改 final 變量的值呢？ 原因在于， setOut 方法是一個本地方法， 并不是用 Java 語言實現(xiàn)的。 本地方法可以繞過 Java 語言的存取控制機制。 這是一種特殊的方法， 在自己編寫程序時， 不應該這樣處理。
14.兩種使用靜態(tài)方法的情況：1.方法不需要訪問對象狀態(tài)，其所需參數(shù)都是通過顯式參數(shù)提供（例如： Math.pow ) 2.一個方法只需要訪問類的靜態(tài)域。
15.main 方法不對任何對象進行操作。事實上，在啟動程序時還沒有任何一個對象。靜態(tài)的main 方法將執(zhí)行并創(chuàng)建程序所需要的對象。
16.Java 程序設計語言總是采用按值調用。也就是說， 方法得到的是所有參數(shù)值的一個拷貝，特別是，方法不能修改傳遞給它的任何參數(shù)變量的內(nèi)容。
17.在 Java 中， this 引用等價于 C++ 的 this 指針。 但是， 在 C++ 中， 一個構造器不能調用另一個構造器 ,， 在 C++ 中， 必須將抽取出的公共初始化代碼編寫成一個獨立的方法。
18.Java 還有第三種初始化機制， 稱為初始化塊（initializationblock)。在一個類的聲明中，可以包含多個代碼塊。只要構造類的對象，這些塊就會被執(zhí)行。
19.由于初始化數(shù)據(jù)域有多種途徑，所以列出構造過程的所有路徑可能相當混亂。下面是調用構造器的具體處理步驟：

• 所有數(shù)據(jù)域被初始化為默認值（0、false 或 null。)
• 按照在類聲明中出現(xiàn)的次序， 依次執(zhí)行所有域初始化語句和初始化塊。
• 如果構造器第一行調用了第二個構造器， 則執(zhí)行第二個構造器主體。
• 執(zhí)行這個構造器的主體。
  20.在 JDK 6 之前， 都可以用 Java 編寫一個沒有 main 方法的“ Hello,World” 程序 ：

public class Hello { static { System.out.println("Hel1o, World"); } }

當用 java Hello 調用這個類時， 就會加栽這個類， 靜態(tài)初始化塊將會打印“ Hello,World" ，在此之后， 會顯示一個消息指出 main 未定義。 從 Java SE 7 以后，java 程序首先會檢查是否有一個 main 方法。
21.有些面向對象的程序設計語言，特別是 C++, 有顯式的析構器方法， 其中放置一些當對象不再使用時需要執(zhí)行的清理代碼。在析構器中， 最常見的操作是回收分配給對象的存儲空間。由于 Java 有自動的垃圾回收器，不需要人工回收內(nèi)存， 所以 Java 不支持析構器。
22.需要注意的是， 只能使用星號（*) 導入一個包， 而不能使用 import java.* 或import java.*.* 導入以 java 為前綴的所有包。
23.import 語句不僅可以導人類，還增加了導人靜態(tài)方法和靜態(tài)域的功能。例如，如果在源文件的頂部， 添加一條指令：import static java.lang.System.*;就可以使用 System 類的靜態(tài)方法和靜態(tài)域，而不必加類名前綴
24.如果沒有在源文件中放置 package 語句， 這個源文件中的類就被放置在一個默認包( defaulf package ) 中。默認包是一個沒有名字的包。
25.編譯器在編譯源文件的時候不檢查目錄結構。例如， 假定有一個源文件開頭有下列語句：package com.myconpany;即使這個源文件沒有在子目錄 com/mycompany 下， 也可以進行編譯。 如果它不依賴
于其他包， 就不會出現(xiàn)編譯錯誤。 但是， 最終的程序將無法運行， 除非先將所有類文件移到正確的位置上。 如果包與目錄不匹配， 虛擬機就找不到類。
26.JAR 文件使用 ZIP 格式組織文件和子目錄。可以使用所有 ZIP 實用程序查看內(nèi)部的 rt.jar 以及其他的 JAR 文件。
27.java虛擬機和編譯器定位文件的方式不一樣，編譯器更加復雜一些，這個以后再說吧，看得云里霧里的。
28.對于文檔注釋，類注釋必須放在 import 語句之后，類定義之前。

4 繼承

1.在 Java 中， 所有的繼承都是公有繼承，而沒有 C++ 中的私有繼承和保護繼承 .
2.有些人認為 super 與 this 引用是類似的概念， 實際上，這樣比較并不太恰當。這是因為 super 不是一個對象的引用， 不能將 super 賦給另一個對象變量， 它只是一個指示編譯器調用超類方法的特殊關鍵字。
3.使用super 調用構造器的語句必須是子類構造器的第一條語句。如果子類的構造器沒有顯式地調用超類的構造器， 則將自動地調用超類默認（沒有參數(shù) )的構造器。 如果超類沒有不帶參數(shù)的構造器， 并且在子類的構造器中又沒有顯式地調用超類的其他構造器，則 Java 編譯器將報告錯誤。
4.一個對象變量（例如， 變量 e ) 可以指示多種實際類型的現(xiàn)象被稱為多態(tài)（polymorphism)。在運行時能夠自動地選擇調用哪個方法的現(xiàn)象稱為動態(tài)綁定（ dynamic binding。)
5.在 Java 中， 不需要將方法聲明為虛擬方法。動態(tài)綁定是默認的處理方式。如果不希望讓一個方法具有虛擬特征， 可以將它標記為 final。
6.Java 不支持多繼承。
7.在 Java 中， 子類數(shù)組的引用可以轉換成超類數(shù)組的引用， 而不需要采用強制類型轉換。然而這樣有可能會發(fā)生錯誤，為了確保不發(fā)生錯誤，所有數(shù)組都要牢記創(chuàng)建它們的元素類型， 并負責監(jiān)督僅將類型兼容的引用存儲到數(shù)組中。
8.在覆蓋一個方法的時候，子類方法不能低于超類方法的可見性。
9.如果將一個類聲明為 final， 只有其中的方法自動地成為 final,而不包括域。
10.String 類也是 final 類，這意味著不允許任何人定義 String 的子類。
11.在 Java 中， 只有基本類型 （ primitive types) 不是對象， 例如，數(shù)值、 字符和布爾類型的值都不是對象。所有的數(shù)組類型，不管是對象數(shù)組還是基本類型的數(shù)組都擴展了 Object 類。
12.由于 hashCode 方法定義在 Object 類中， 因此每個對象都有一個默認的散列碼，其值為對象的存儲地址。
13.Equals 與 hashCode 的定義必須一致：如果 x.equals(y) 返回 true, 那么 x.hashCode( ) 就必須與 y.hashCode( ) 具有相同的值。
14.只要對象與一個字符串通過操作符“ +” 連接起來，Java 編譯就會自動地調用 toString方法，以便獲得這個對象的字符串描述。
15.在 Java 中允許在運行時確定數(shù)組的大小。
16.數(shù)組列表的容量與數(shù)組的大小有一個非常重要的區(qū)別。 如果為數(shù)組分配 100 個元素的存儲空間，數(shù)組就有 100 個空位置可以使用。 而容量為 100 個元素的數(shù)組列表只是擁有保存 100 個元素的潛力 （實際上， 重新分配空間的話， 將會超過100 ), 但是在最初，甚至完成初始化構造之后，數(shù)組列表根本就不含有任何元素。
17.一旦能夠確認數(shù)組列表的大小不再發(fā)生變化， 就可以調用 trimToSize 方法。這個方法將存儲區(qū)域的大小調整為當前元素數(shù)量所需要的存儲空間數(shù)目。垃圾回收器將回收多余的存儲空間。一旦整理了數(shù)組列表的大小，添加新元素就需要花時間再次移動存儲塊，所以應該在確認不會添加任何元素時， 再調用 trimToSize。
18.對象包裝器類用 final修飾 , 因此不能定義它們的子類。
19.自動裝箱規(guī)范要求 boolean、byte、char 127，介于-128 ~ 127之間的 short 和int 被包裝到固定的對象中。
20.裝箱和拆箱是編譯器認可的， 而不是虛擬機。編譯器在生成類的字節(jié)碼時， 插人必要的方法調用。虛擬機只是執(zhí)行這些字節(jié)碼。
21.包裝器類不可以用來實現(xiàn)修改數(shù)值參數(shù)的方法。
22.能夠分析類能力的程序稱為反射（reflective )。反射是一種功能強大且復雜的機制。 使用它的主要人員是工具構造者， 而不是應用程序員。
23.在程序運行期間，Java 運行時系統(tǒng)始終為所有的對象維護一個被稱為運行時的類型標識。這個信息跟蹤著每個對象所屬的類。 虛擬機利用運行時類型信息選擇相應的方法執(zhí)行。然而， 可以通過專門的 Java 類訪問這些信息。保存這些信息的類被稱為 Class。
24.一個 Class 對象實際上表示的是一個類型， 而這個類型未必一定是一種類。 例如，int 不是類， 但 int.class 是一個 Class 類型的對象。
25.Class 類實際上是一個泛型類。例如， Employee.class 的類型是 Class<Employee>。沒有說明這個問題的原因是： 它將已經(jīng)抽象的概念更加復雜化了。 在大多數(shù)實際問題中， 可以忽略類型參數(shù)， 而使用原始的 Class 類。
26.虛擬機為每個類型管理一個 Class 對象。 因此， 可以利用==運算符實現(xiàn)兩個類對象比較的操作。
27.還有一個很有用的方法 newlnstance( )， 可以用來動態(tài)地創(chuàng)建一個類的實例例如e.getClass().newlnstance();創(chuàng)建了一個與 e 具有相同類類型的實例。 newlnstance 方法調用默認的構造器 （沒有參數(shù)的構造器）初始化新創(chuàng)建的對象。 如果這個類沒有默認的構造器， 就會拋出一個異常。
28.Class類中的 getFields、 getMethods 和 getConstructors 方 法 將 分 別 返 回 類 提 供 的public 域、 方法和構造器數(shù)組， 其中包括超類的公有成員。Class 類的 getDeclareFields、getDeclareMethods 和 getDeclaredConstructors 方法將分別返回類中聲明的全部域、 方法和構造器， 其中包括私有和受保護成員，但不包括超類的成員。
29.反射機制的默認行為受限于 Java 的訪問控制。然而， 如果一個 Java 程序沒有受到安全管理器的控制， 就可以覆蓋訪問控制。 為了達到這個目的， 需要調用 Field、 Method 或Constructor 對象的 setAccessible 方法。
30.setAccessible 方法是 AccessibleObject 類中的一個方法， 它是 Field、 Method 和 Constructor類的公共超類。這個特性是為調試、 持久存儲和相似機制提供的。
31.將一個 Employee[ ]臨時地轉換成 Object[ ] 數(shù)組， 然后再把它轉換回來是可以的，但從一開始就是 Object[]的數(shù)組卻永遠不能轉換成 Employee[]數(shù)組。
32.invoke 的參數(shù)和返回值必須是 Object 類型的。這就意味著必須進行多次的類型轉換。

5 接口、lambda 表達式與內(nèi)部類

1.接口中的所有方法自動地屬于 public。 因此， 在接口中聲明方法時， 不必提供關鍵字public。

6 并發(fā)

1.當線程的 run 方法執(zhí)行方法體中最后一條語句后， 并經(jīng)由執(zhí)行 return 語句返冋時， 或者出現(xiàn)了在方法中沒有捕獲的異常時，線程將終止。
2.沒有可以強制線程終止的方法。然而， interrupt 方法可以用來請求終止線程。
3.

總結

以上是生活随笔為你收集整理的java核心技术卷1基础知识整理的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。