版權聲明：本文為CSDN博主「iswitched」的原創文章，遵循 CC 4.0 BY-SA 版權協議，轉載請附上原文出處鏈接及本聲明。
原文鏈接：https://blog.csdn.net/weixin_44873106/article/details/89787021
1 環境變量配置
JAVA_HOME:jdk路徑
Path：要把jdk的bin目錄路徑，添加到path變量
2.八種數據基本類型
比較簡單此處不單獨羅列
引用數據類型：數組，類，接口
2.1 char :Unicode編碼的字符，或字符的整數編碼,必須用單引號
float默認值是0.0f；
double默認值是0.0d；
2.2基本類型字面值規則
1.整數字面值是int類型，如果右側賦值超出int范圍，需要做轉型處理
2.byte，short，char 三種比int小的整數，在自身范圍內可以直接賦值。 byte d=1+3 正確，1+3編譯器會自動轉成4
3.浮點數字面值是double；浮點數轉成整數會直接舍棄小數點后位數。
4.字面值后綴，L D F
5.字面值前綴，0b 二進制；0x 16進制；0 8進制； \u char 類型16進制
2.3基本類型的運算規則
1.計算結果的數據類型與運算中的最大類型一致。
2.byte，short，char三種比int小的整數，計算時會自動轉成int 做加法運算時，數據類型會自動轉成int，除了自增加自減不進行轉化外，其它情況都是無long型時，所有非int類型轉成int類型；有long類型時，都轉成long類型。 char類型相加，提升為int類型。
3.整數運算溢出。Integer.MAX_VALUE+1 得負數最小值
4.浮點數運算不精確
5.浮點數特殊值 infinity 整數除0 ；Nan 負數開方
2.4 基本類型的類型轉換
數字類型之間可以互相轉換，從小到大自動轉換，從大到小需要強制轉型。
double d = 245; float d=100；自動轉型
2.5運算符
&& ：邏輯與(短路與)，兩邊同為真結果才為真,短路與：左邊是假，右邊忽略不執行
& ：不管左邊結果是什么都要執行右邊（&的左右兩邊都要參與運算）
|| ：邏輯或(短路或)，兩邊只要有一個真結果就是真，短路或：左邊是真，右邊忽略不執行
3.流程控制
3.1 switch：只能判斷byte short char int enum jdk1.7之后的string。
從成立的case 無條件穿透所有的case包括default直到結束或者遇到break中斷跳出循環；
如果所有條件都不成立，則執行default
3.2 for循環
3.3 break 和 continue
Break 中斷、跳出循環和switch
Continue 跳過后面的代碼 繼續進入循環的下一輪執行
3.4 for-each循環
數組遍歷、集合迭代遍歷的語法簡化
4.面向對象 —— 封裝、繼承、多態 ★ ★ ★ ★ ★
封裝
1 類：模板、圖紙 。類中定義對象的屬性數據（成員變量），方法（成員方法）類第一次使用時會加載到方法區
2 對象：從模板中創建的具體實例，實例是數據的打包
新建實例時，在堆內存中新分配內存空間給這個實例
3引用變量：理解成“遙控器”，保存一個實例的內存地址（引用變量保存在棧），引用變量的特殊值：null 不保存任何實例的內存地址
4構造方法：新建實例對象時，立即執行的一個特殊方法；構造方法必須和類同名，並且沒有返回值類型。
一個類中必須有構造方法，自己沒定義，系統會添加默認構造方法，構造方法一般用來給屬性賦值
5 構造方法重載
一個類中可以定義多個不同參數的構造方法，是方法重載的一種體現
6 方法重載Overload：
同名不同參,與返回值類型無關，所有方法都可以重載7 this關鍵字：this.xxx 特殊引用，引用當前對象的地址
this（…）：構造方法之間的調用，必須是首行代碼，如果有多個構造方法，會通過this（…）調取下面的所有構造方法，完成賦值。
注意this不能在靜態方法中使用
繼承
Java的繼承是單繼承多實現，只能繼承一個父類（如果不繼承其他類，默認繼承object類），但可以實現多個接口
1.不能繼承的有：構造方法，私有成員
過程：先新建父類對象，再新建子類對象，兩者作為一個整體對象，調用成員時，先找子類，再找父類
2.方法重寫：override
繼承的方法，在子類中重新定義父類中的方法（只能在子類重寫），方法名相同，參數的個數和類型也必須相同，返回值類型也必須相同。
方法重寫返回值類型如果是基本類型應與父類的一致；重寫要求方法名完全相同，返回值類型如果是基本類型或無返回值時必須一致。
3.父類的構造方法
新建子類對象時會先新建父類對象，也會先執行父類的構造方法
默認執行父類的無參構造，默認隱含調用super（）；
new Student（） 默認執行父類無參構造
new Student（……）默認執行父類無參構造
手動調用父類的有參構造，super（參數）：父類沒有無參構造時必須手動調用
4.super
Super.xxxx（） 方法重寫時，調用父類中同一個方法的代碼
Super（參數） 調用父類的構造方法，默認調用父類無參構造super（），手動調用有參構造super（），必須是首行代碼
注意super不能在靜態方法中使用
多態
一個對象具有多種形態的表現，多態的前提是必須有繼承。
void f(父類型 o1) { }
把一個子類型的實例當做父類型來處理，所有的子類型都可以傳遞到該方法，被當做父類型處理；作用：一致的類型
1. 類型的轉換
A． 向上轉型
子類的實例轉成父類型，用父類型的引用變量，來引用子類實例，向上轉型后，只能調用父類定義的通用成員，子類特有成員被隱藏
B． 向下轉型
已經轉成父類型的子類實例，轉回子類型為了對子類型進行特殊處理
2. Instanceof 運行期類型識別
當多種子類型都被當做父類型來處理，要對某種子類型進行特殊處理，可以先判斷其真實類型再向下轉型——對真實類型，及其父類型判斷，都返回true。格式：
s instanceof Line
5.數組
屬於object類，用來存放一組數據的數據結構，數組是最基本的一種數據結構但不是基本數據類型，數組是相同數據類型組成的集合，數組中的元素按線性順序排序
1 數組的創建
數組創建后若未指定初始值，則會依據數組類型的不同來設置默認值
int[] a = new int[6]; // 新建int[]數組，長度6，默認值都是0，數組的起始地址值保存在變量a。 int[] a = {6,2,6,8}; Int[] a= new int[]{1,2,3,4,5}; a = new int[]{7,3,8,1,7,9,3,1}； // 為存在的數組變量賦值直接初始化數據，要添加數據類型
2 數組的長度屬性 a.length
數組一旦創立，長度不可變
最大下標 a.length-1
允許0長度的數組
3 二維數組
存放數組的數組
int[][] a = new int[3][2];
外圍長度為3，內部3個數組長度為2，一共有4個數組，內部數組默認值0，外圍數組保存的是內部數組的地址。
int[][] a = new int[3][];
只建一個外圍數組長度3，3個位置都是null，之后可以建新數組放入內部。
4 Arrays 數組工具類
Arrays.toString //（數組） 把數組數據連接成字符串。 Arrays.sort //（數組） 數組排序 基本類型：優化的快速排序；引用類型：優化的合並排序。 Arrays.binarySearch //（數組，目標值） 二分法查找，在有序數組中查找目標值下標，找不到返回 -（插入點+1）。 Arrays.copyof // (數組，長度) 復制數組成一個指定長度的新數組。
5 數組 復制
Arrays.copyof // (數組，長度) 復制數組成一個指定長度的新數組 System.arraycopy // (原數組，原數組起始位置，目標數組，目標數組起始位置，復制的數量) ——不會創建新的數組，目標數組要事先存在。
6. 變量
// 1 局部變量：定義在方法中或局部代碼塊中，必須初始化（第一次賦值時分配內存空間） // 局部變量的作用域在定義它的大括號內有效，在作用范圍內不能重復定義。 // 2 成員變量：定義在類中，自動初始化默認值，訪問受訪問控制符限制；局部變量可以和成員變量同名。
7.Object類
如果一個類不繼承其他類，則默認繼承Object類
1.方法
toString（） // 獲得一個對象的字符串表示。 // Object中的默認實現是：“類名@地址”可在子類中重寫toString方法。 equals() // 當前對象與參與對象比較是否相等。 a.equals(b) // Object中的默認實現是比較內存地址。 // this == obj：== // Object中比較內存地址，基本類型默認比較內容值。
8.String 類
String是封裝char[] 數組的對象
S =”abcd”
S={-value:[‘a’,’b’,’d’,’g’]}
1.字符串創建
Char[] a ={‘a’,’b’,’c’}; String s = new String(a); >>>簡易語法>>> String s = “abcd”
2.字符串的常量池
String s1 = “abcd” // 字符串的字面值寫法。第一次使用一個字符串字面值時，會在字符串常量池中新分配內存，再次使用相同字面值時，直接訪問常量池中存在的對象，而不會重復創建
3.字符串 中的Equals 和 “==”
// “==”比較內存地址 // Equals 看父類中的方法，object中的默認方法是比較內存地址，String類中重寫了父類方法比較的是字符內容。如下說明： char[] a = {'a','b','c','d'}; String s1 = new String(a);//堆中新分配內存 String s2 = "abcd"; //在常量池新分配內存 String s3 = "abcd"; //訪問常量池中存在的對象 System.out.println(s1==s2); //false 比較內存地址 System.out.println(s2==s3); //true 比較內存地址 String類中重寫了equals方法，方法中比較的是字符內容 System.out.println(s1.equals(s2));//true 比較字符串內容 System.out.println(s2.equals(s3));//true 比較字符串內容
4.字符串不可變且字符串連接效率低，每次連接都會新建字符串對象
5.字符串的常用方法
charAt(i) // 獲取指定位置的字符 length() // 字符串長度，字符的數量 indexof（） // 找第一個子串出現的初始位置，找不到返回-1 indexof // （子串，start）從執行位置向后找 lastIndexof(子串) // 從后向前找 subString（start） // 截取start到末尾 subString（start,end ） // 截取（start,end ）范圍 trim（） // 去除兩端的空白字符 matches（） // 用來判斷是否匹配正則表達式
6.StringBuilder: 可變的字符序列，封裝char[]數組，提供了一組方法，可以對內部封裝的字符進行修改，常用來代替字符串做高效的字符串連接
append（）// 追加字符內容，內部數組默認初始容量16，放滿后翻倍+2； delete(start,end) // 刪除區間(start,end)； deleteCharAt（i）// 刪除指定位置 i； insert（i，內容） // 在指定位置插入內容； insertCharAt（i，字符）// 在指定位置插入單個字符； replace（start，end，內容）// 替換指定范圍的內容； // StringBuilder和StringBuffer // StringBuilder:線程不安全，效率高；JDK1.5版本后的新類。 // StringBuffer:線程安全，舊版本的類。
9.正則表達式
一般用來判斷用戶的輸入內容是否符合格式要求
matches（）// 字符串的方法，用來判斷是否匹配 if(s.matches(regex)) {} split（正則）：// 用匹配的子串來拆分字符串 String s = "aaa,bbb,ccc"; String[] a = s.split(",");
replace（正則，子串）替換所有匹配的子串
10.基本類型的包裝類
// 把基本類型當做對象來使用 byte – Byte short – Short int – Integer long – Long float – Float double – Double char – Character boolean – Boolean
1. 數字父類Number
// 子類：Byte，Short，Integer，Long，Float，Double，BigDecimal，BigInteger // 取出基本類型值的方法 byteValue（），shortValue（）,intValue（）,longValue（）,floatValue（）,doubleValu()
2. Intger類
// 創建Integer對象： a= { value：6} Integer a = new Integer(6); Integer a = Integer.valueOf(6); // Integer 類中存在256個Integer緩存對象，封裝-127到128；如果訪問指定范圍內的值，會訪問緩存對象，如果超出范圍，會新建對象。
3. Integer類的方法
// 字符串解析成int Integer.parseInt（）； Byte.parseByte()； Integer.toBinaryString() // 轉成二進制字符串 Integer.toOctalString() // 轉成八進制字符串 Integer.toHexString(255) // 轉成十六進制字符串
4. BigDcimal和BigInteger 類
BigDcimal精確的浮點數運算
BigInteger 超大的整數運算
創建對象：
BigDecimal bd = BigDecimal.valueOf(2); // 方法： add(BigDecimal bd) subtract(BigDecimal bd) multiply(BigDecimal bd) divide(BigDecimal bd) divide(BigDecimal bd,保留位數,舍入方式) setScale(保留位數,舍入方式)
5. 自動裝箱，自動拆箱
// 基本類型值，自動裝箱成包裝對象 // Integer a = 6; 編譯器編譯成： Integer a = Integer.valueOf(6); // 自動拆箱（自動拆箱要注意null值） // int i = a; 編譯器編譯成： int i = a.intValue();
11.抽象類
半成品類，沒有完成的類；抽象方法：沒有代碼，只有方法的定義，抽象類不能創建實例，主要用來被繼承。
public abstract void f(); //包含抽象方法的類一定是抽象類 public abstract class A { }；
抽象方法的作用：
作為通用方法，在父類中定義；要求子類，必須實現這個方法。
1）抽象類可以有自己的構造方法
2）抽象類可以有具體的方法
3）包含抽象方法的類一定是抽象類，必須使用abstract關鍵字修飾，這個方法必須由子類來實現。
4）抽象類不能使用new關鍵字來創建實例
5）當一個類中只要有一個抽象方法，這個類就必須是抽象類
6）抽象類可以定義實例變量和靜態變量以及常量
7）抽象類可以再繼承抽象類，也可以繼承普通的類
12.關鍵字 final
內存地址不可變，可以修飾常量、類、方法
1. final 常量：值不可變，但引用類型因為保存的是地址，所以內容可以變。
final Point a = new Point(3,4); a.x = 30;//對 a.y = 40;//對
2. final 方法不能在子類重寫，但可以被繼承。；final不能用於修飾構造方法，父類的private成員方法是不能被子類方法覆蓋的，因此private類型的方法默認是final類型的。
3. final 類 不能被繼承，沒有子類
Static — 靜態 共享的數據
靜態成員屬於類，而不屬於實例
靜態成員
用類來調用靜態成員 Soldier.count
實例成員
用實例來調用實例成員 s1.id
工具方法
Math.Random() Arrays.toString() String.valueOf()
靜態方法中不能直接調用實例的成員（非靜態），只能用實例調用
class A { public static void main(String[] args) { f();//靜態調靜態 } static void f() { g();//錯，靜態不能直接調用非靜態 A a = new A(); a.g();//只能用實例調用 } void g(){ } }
靜態初始化塊
class A { static { // 靜態初始化塊 // 類被加載時，只執行一次 } }
靜態變量保存在方法區類的空間中，只保存一份可以在所有實例中共享的數據
對象的加載過程
加載類
- 1.加載父類，為父類靜態變量分配內存 – 后台執行不可見
- 2. 加載子類，為子類靜態變量分配內存
- 3. 執行父類靜態變量的賦值運算，和靜態初始化塊
- 4. 執行子類靜態變量的賦值運算，和靜態初始化塊
新建實例
- 5. 新建父類實例，為父類實例變量分配內存
- 6. 新建子類實例，為子類實例變量分配內存
- 7. 執行父類的實例變量賦值運算
- 8. 執行父類的構造方法
- 9. 執行子類的實例變量賦值運算
- 10. 執行子類的構造方法
13.集合
用來存放一組數據的數據結構
數組的缺點： 長度固定 ; 訪問方式單一只能下標訪問; 前面增刪數據操作繁瑣
集合的繼承結構:
- Collection 是對象集合， Collection 有兩個子接口 List 和 Set,
- List 可以通過下標 (1,2…) 來取得值，值可以重復,而 Set 只能通過游標來取值，並且值是不能重復的
- ArrayList ， Vector ， LinkedList 是 List 的實現類
- ArrayList 是線程不安全的， Vector 是線程安全的，這兩個類底層都是由數組實現的
- LinkedList 是線程不安全的，底層是由鏈表實現的
- Map 是鍵值對集合
- HashTable 和 HashMap 是 Map 的實現類
- HashTable 是線程安全的，不能存儲 null 值
- HashMap 不是線程安全的，可以存儲 null 值
ArrayList
數組列表，封裝了一個數組，及其操作代碼和更便捷的方法，內部數組默認初始容量10 放滿后，1.5倍增長
方法
add（數據）— 添加數據；get（int i）—訪問指定下標數據； remove（int i）移除指定位置數據，返回被移除的數據； remove（數據）— 找到第一個相等的數據，找到移除並返回true，找不到返回false； size（） 元素的數量；iterator（） 輔助新建迭代器
效率
訪問任意位置效率高，增刪數據效率可能降低
LinkedList — 雙向鏈表
方法
和ArrayList有相同的方法
- LinkedList 兩端數據操作方法
- addFirst（數據）；addLast（數據）；getFirst（）；getLast（）；removeFisrt（）
- removeLast（）
- 效率
兩端效率高
HashMap — 哈希表、散列表 （面試必問） ★ ★ ★ ★ ★
存放鍵值對數據，用鍵來快速定位數據，來提取鍵對應的值
鍵：不重復，無序
- Hashmap中的key-value都是儲存中entry數組中的
- Hashmap的實現不是同步的，意味着它不是線程安全的
- Hashmap的實例有兩個參數影響其性能：初始容量，和加載因子
- 方法
- put（key,value）放入鍵值對數據，重復的鍵會覆蓋舊值
- get（key）獲得鍵對應的值，鍵不存在，得到null
- remove（key）移除鍵值對數據，返回被移除的值
- size（）鍵值對的數量
哈希運算過程
HashMap內部，使用entry[]數組存放數據
- 數組默認初始容量16
- 放滿后容量翻倍+2
- key.hashCode()獲得鍵的哈希值
- 用哈希值和數組長度，運算產生下標值 i
- 新建entry對象來封裝鍵值對數據
- Entry對象，放入i 位置
- 如果是空位置，直接放入
- 如果有數據，一次equals（）比較是否相等
- 找到相等的，覆蓋舊值
- 沒有相等的，鏈表連接在一起
- 負載率、加載因子超過0.75
- 新建翻倍容量的新數組
- 所有數據，重新執行哈希值，存入新數組
- Jdk 1.8
- 鏈表長度到8，轉成紅黑樹
- 樹上的數據減少到6，轉回成鏈表
hashCode（）
hashCode（）是object的方法，默認實現是用內存地址作為哈希值
可以重寫方法來獲得相同的哈希值
哈希運算中要有相同的哈希值，才能保證計算出相同下標值，並且要equals（）也要相等（equals方法也要重寫），才可以覆蓋舊值，否則會鏈表連接。
重寫hashCode的慣用算法：（x.y是變量的值）
14.異常
封裝錯誤信息的對象
錯誤信息：類型、提示消息、行號
異常的繼承結構
捕獲異常
try { } catch(AException e) { } catch(BException e) { } catch(父類型Exception e) { } finally { // 不管出不出錯，都會執行 }
如果拋出異常，並且中catch中有return語句，這個return語句會先執行，執行之后將結果保
存在緩存中，再去查看是否有finally，如果有finally就先執行finally語句，之后再返回緩存中
return的值，如果finally中也有return，那么finally中的return會覆蓋掉之前緩存中的return，
即最終會返回finally中的return值
throw 手動拋出異常，執行異常的拋出動作 類似 return；當程序出現邏輯錯誤，不自動創建並拋出異常，可以手動判斷邏輯錯誤，手動創建異常對象並拋出。
底層的異常往上層拋，在上層處理
if(...) { AException e = new AException(); throw e; }
異常包裝
- 捕獲的異常對象，包裝成其他類型再做拋出，多種類型簡化成一種類型，不能拋出的異常包裝成能拋出的異常再拋。
- RuntimeException 和 其他Exception
- RuntimeException— 非檢查異常，編譯器不檢查是否有異常處理代碼，存在默認的拋出管道
- 其他異常 — 編譯器檢查是否有處理代碼，不處理，不能編譯。
15.接口
極端的抽象類，結構設計工具，用來解耦合，隔離現實
Implements代替extends
Interface 代替class
接口的定義：
公開的抽象方法 公開的常量 公開的內部類、內部接口
- 1）接口只能定義常量
- 2）接口只能定義抽象方法
- 3）接口只能繼承接口，不能繼承普通的類和抽象類
- 4）接口是沒有構造方法
注意：
- 1）在接口中定義常量時，可以不用final static修飾，因為編譯器在編譯時會自動加上。
- 2）在接口中定義抽象方法時可以省略abstract關鍵字，編譯器在編譯時同樣會加上。
類可以同時繼承多個接口
class A implements X,Y,Z {} class A extends B implements X,Y,Z {}
接口和接口的繼承
interface A extends X,Y,Z {}
16.文件、字符操作流
File
封裝一個磁盤路徑字符串，提供了一組對文件、文件夾的操作方法，可以封裝文件夾路徑、文件路徑、不存在的路徑。 {path=“d:/abc”}
方法
- getName（） 獲取文件名
- getPatrent（） 獲取父目錄
- getAbsolutePath（）完整路徑
- length（） 文件字節量，對文件夾無效，會返回假數據
- isFile（） 判斷是否是文件
- isDirectory（）是否是文件夾
創建、刪除
- createNewFile（）新建文件，文件已存在不會新建，返回false;文件夾不存在會出現異常
- mkdirs（）逐層創建多層文件夾
- delete（）刪除文件、空目錄
目錄列表
- list（）得到String[] 包含所有文件名 [“a.txt”, “b.mp3”, “c.jpg”]
- listFiles() 得到 File[]，包含所有文件的封裝的File對象 [{…}, {…}, {…}]
流 Stream
數據的讀寫操作（io操作），抽象成數據在管道中流動
單方向流動
- 輸入流，只能用來讀取數據（讀入內存）
- 輸出流，只能用來輸出數據（內存數據向外輸出）
只能從頭到尾，順序流動一次，不能反復流動，如果要重復流動，可以重新創建新的流
InputStream,OutputStream
字節流的抽象父類
方法：
- write(int b) 只輸出int四個字節中，末尾的一個字節值 [1][2][3][4] —> [4]
- write(byte[], start, length) 輸出byte[] 數組中，從start開始的length個字節值
- read() 讀取一個字節值，補三個0字節，變成int [4] —> [1][2][3][4]，讀取結束后，再讀取會返回 -1。
- read(byte[] buff) 按數組的長度，讀取一批字節值，存放到指定的數組中，並返回這一批的字節數量，讀取結束后，再讀取會返回 -1。
- FileInputStream,FileOutputStream — 文件流
- ObjectInputStream，ObjectOutputStream —對象序列化、反序列化
序列化 把一個對象的信息，按固定的字節格式，變成一串字節序列輸出
方法：
- writeObject(Object obj) 把對象變成一串字節序列輸出
- readObject() 讀取序列化數據，反序列化恢復對象
- Serializable 接口——被序列化的對象，必須實現 Serializable 接口
不序列化的變量
Static — 屬於類，不隨對象被序列化輸出
Transient —臨時，只在程序運行期間，在內存中存在，不會被序列化持久保存
字符編碼
- ASC-II 0到 127，英文、指令字符
- iso-8859-1 Latin-1 西歐編碼 ，把ASC-II擴展到255
- CJK 編碼 亞洲編碼，中日韓
- GBK 國標碼 英文單字節，中文雙字節
- Unicode 萬國碼 常用表，雙字節 生僻字 三字節或四字節
- UTF-8 Unicode 的傳輸格式 Unicode Transformation format英文，單字節某些字符，雙字節；中文，三字節；特殊符號，四字節
Java的char類型是 Unicode
Java的轉碼運算
InputStreamReader,OutputStreamWriter
字符編碼轉換流 OutputStreamWriter — 把Java的Unicode編碼字符，轉成其他編碼輸出
InputStreamReader —讀取其他編碼字符，轉成Unicode字符
17.內部類
- 定義在類內部、方法內部或局部代碼塊內部的類，用來輔助外部實例運算，封裝局部數據，或局部的運算邏輯。
- 非靜態內部類、屬於實例的內部類 非靜態內部類實例，必須依賴於一個外部類的實例才能存在。
- 靜態內部類 靜態內部類，與普通的類沒有區別。
- 局部內部類
- 局部定義的類型，類似於局部變量，有作用范圍，只能在局部代碼塊內使用這種類型
局部內部類中，使用外面的局部變量，必須加 final，jdk1.8，缺省。
匿名內部類
Weapon w = new Weapon() {...}; //{} - 匿名類 //new - 新建匿名類的實例 // Weapon - 父類型 // () - super()，可傳參數super(1,2,3)
18.Java內存管理
堆內存 用來存放由new創建的對象實例和數組。Java堆是所有線程共享的一塊內存區域，在虛擬機啟動時創建，此內存區域的唯一目的就是存放對象實例。注意創建出來的對象只包含屬於各自的成員變量，並不包括成員方法。
棧內存 保存的是堆內存空間的訪問地址，或者說棧中的變量指向堆內存中的變量（Java中的指針）
l 棧：保存局部變量的值，包括：1.用來保存基本數據類型的值；2.保存類的實例，即堆區對象的引用(指針)。也可以用來保存加載方法時的幀。常量池存在於堆中（1.7b后的新版本）。
普通類型的變量在棧中直接保存它所對應的值，而引用類型的變量保存的是一個指向堆區的指針，通過這個指針，就可以找到這個實例在堆區對應的對象。因此，普通類型變量只在棧區占用一塊內存，而引用類型變量要在棧區和堆區各占一塊內存。
方法區是各個線程共享的內存區域，它用於存儲已被虛擬機加載的類信息、常量、靜態變量、即時編譯器編譯后的代碼等數據。
19.線程
在進程內部，並行執行的任務
創建線程（兩種方式）
- 繼承 Thread
- 實現 Runnable
繼承 Thread
編寫 Thread 的子類，並重寫 run() 方法。啟動之后，自動運行 run() 方法中的代碼
實現 Runnable
實現 Runnable 接口，實現它的 run() 方法，Runnable 封裝在線程中執行的代碼，新建線程對象時，把Runnable對象放在線程內，啟動
線程的狀態
線程的方法
- Thread.currentThread() 獲得正在執行的線程實例
- Thread.sleep(毫秒值) 讓正在執行的線程，暫停指定的毫秒值時長
- getName()，setName() 線程名
- start() 啟動線程 interrupt() 打斷線程的暫停狀態
- join() 當前線程暫停，等待被調用的線程結束
- setDaemon(true) 后台線程、守護線程
JVM虛擬機退出條件，是所有前台線程結束，當所有前台線程結束，虛擬機會自動退出
不會等待后台線程結束 例如：垃圾回收器是一個后台線程。
線程同步 synchronized
讓多個線程共享訪問數據時，步調一致的執行。一個線程修改時，其他線程等待修改完成后才能執行；一個線程訪問時，其他線程等待訪問結束
任何實例，都有一個“同步鎖”，synchronized 關鍵字，要求一個線程必須搶到同步鎖才能執行
synchronized(對象) { // 共享的數據訪問代碼 } // --搶對象的鎖 synchronized void f() { } // -- 搶當前實例的鎖 static synchronized void f() { }// --搶類的鎖
生產者、消費者模型
線程之間傳遞數據
等待和通知方法必須在synchronized 代碼內調用， 等待和通知的對象，必須是加鎖的對象。