JAVA知識筆記

阿新 • • 發佈：2021-07-17

JAVA知識筆記

基本介紹

特性與優勢

面向物件
可移植性
高效能（即使編譯）
分散式
動態性（反射機制）
多執行緒（多個任務同時執行）
安全性
健壯性
簡單性

JAVA三大版本

javaSE：標準版本（桌面程式，控制檯開發）
javaME：嵌入式開發（手機，小家電）
javaEE：E企業級開發（web端，伺服器端）

JDK,JRE,JDK

jre是java基本的一個執行環境，jdk包含有jre的執行環境的同時還有一些開發工具。是開發工具包

java程式執行機制

編譯型 -將程式語言編譯成機器可執行的語言
解釋型 -走一步解釋一步，執行一段編譯一段

java先將javac進行編譯形成一個.class檔案，再對class檔案進行解釋給作業系統平臺

語法基礎

註釋

單行註釋 (//)
多行註釋 (/* xxxxx */)
文件註釋 (/** *xx *xx */)

javaDoc

生成說明文件

@author
@Version
@Since
@param
@return
@throws

#生成程式幫助文件
javadoc -enconding UTF-8 charset UTF-8 檔名

識別符號

識別符號應該以字母(a-z)，美元符號($)，或者下劃線(_)開始
字母大小寫敏感
不可使用關鍵字來命名

資料型別

強型別語言

變數的使用要嚴格符合規定（符合資料型別定義），所有變數必須先定義後使用

安全性提高
執行速度下降

java資料型別分為兩類

基本資料型別（8個）

數值型別

整數型別

byte 1個位元組 -128-127

short 2個位元組 -32768-32767

int 4個位元組 -2147483648-2147483647

long 8個位元組 -9223372036854775808-9223372036854775807 （數字後加L表示，50L）

浮點型別

float 4個位元組（數字加F表示，50.1F）

double 8個位元組

字串型別

char 2個位元組

boolean布林型別：1個位元組，只有true與false

引用型別

類

介面

陣列

型別轉換

低到高轉換順序

byte,short,char-->int-->long->float-->double

注意

布林值不能轉換
不想同的資料型別不能轉換
高精度轉低精度時，需要強制轉換
轉換可能會出現精度丟失或記憶體溢位等問題
低轉高自動轉換

什麼是位元組

位（bit）：是計算機 內部儲存 的最小單位，11001100是一個八位二進位制數字
位元組（byte）：是計算機中 資料處理 的基本單位，習慣用大寫B來表示。
1B （byte，位元組）=8bit位
字元；是指計算機中使用的字母、數字、字和符號

java進位制數表示

二進位制 0b
十進位制
八進位制 0 (int i2=010 (8))
十六進位制 0x （int i3=0x10 (16) )

資料型別拓展

浮點數不可以用於比較

浮點數是有限的數值，比較的結果離散的，會進行舍入操作，有舍入誤差，數值接近但不等於

比較浮點數可以使用 BigDecimal

所有的字元本質還是數字

可以對字元 char型別進行int的強制轉換，轉換得出的結果對應Unicode編碼中的編碼

變數

定義

可以變化的量
java是一種強型別語言，每個變數都必須宣告其型別
java變數是程式中最基本的儲存單元，其要素包括變數名，變數型別和作用域

注意事項

每個變數都有型別，可為基本型別或應用型別
變數名為合法標誌符
宣告是一個完整的語句，以分號 ; 結束

常量

使用 final 來定義
初始化後值不能改變，值不會變動

變數名命名規則

變數，方法，類名：見名知意
類成員變數：首字母小寫和駝峰原則：lastName
區域性變數名：首字母小寫和駝峰原則
常量：大寫字母和下劃線：MAX_VALUE
類名：首 字母大寫 和駝峰
方法名：首字母小寫和駝峰

變數作用域

類變數（static（靜態）修飾）
例項變數（在類下，從屬於物件）
區域性變數（在方法內，在方法裡有效，必須宣告和初始化值）

變數預設值

基本資料型別預設值為0 或0.0
布林值的預設值為false
除了基本資料型別，其餘都是null

運算子

算術運算子
賦值運算子
關係運算符
邏輯運算子
位運算子
條件運算子
擴充套件運算子

自增符

i++:執行程式碼後，先賦值，後自增
++i:執行程式碼前，先自增，後賦值

冪運算

使用java工具 Math.pow(3,2) 3的2次方

邏輯運算&和&&區別

&邏輯運算，兩個都為真才為真，&兩邊都會執行
&&短路運算，兩個都為真才為真，前端為false，後端不執行

位運算

用二進位制運算，效率高，常用於演算法之中

System.out.print(2<<3);
//結果位8
/*
<< *2
>> /2

0000 0000 0
0000 0001 1
0000 0010 2
0000 0100 4
0000 1000 8
0001 0000 16
*/

String + 號拼接問題

int a=10;
int b=20;
System.out.println(""+a+b);
//結果位1020，""先將a和b轉換位字串，再拼接
System.out.println(a+b+"");
//結果為30，先將a+b運算，再轉換為字串拼接

三元運算子號

/*
x ? y : z
如果x為真，結果為y,否則為z
*/

流程結構

順序結構

java基本的結構就是順序結構，按照順序一句一句執行
從上到下順序進行，任何一個演算法都離不開的基本結構

選擇結構

if選擇

if單選結構
if雙選結構
if多選結構
巢狀的if結構
switch多選擇結構

switch選擇

jdk支援了Stirng型別
缺少break，出現case穿透現象
default

迴圈結構

while
do....while
for

for迴圈

for迴圈語句是支援迭代的一種通用結構，是最有效，最靈活的迴圈結構
for迴圈執行的次數在執行前就確定的。

//for迴圈多個引數定義
for(int i=0;j=array.length-1,i<array.length;i++,j--){
    //迴圈體
}

九九乘法表

for(int j=1;j<=9;j++){
    for(int i=1;i<=j;i++){
        //"\t"table空格
        System.out.print(j+"*"+i+"="+(j*i)+"\t");
    }
    System.out.println();
}

break和continue

break在任何迴圈語句的主體部分，均可用break控制迴圈的流程
break用於強制退出迴圈，不執行迴圈中剩餘的語句
continue語句用在迴圈語句體中，用於終止某次迴圈過程，接著進行下次迴圈的判定
continue通過 outer標籤 跳轉到外層指定層級的迴圈
~~goto~~關鍵字是java的一個保留字，但並未在語言中正式使用，但能使用break和continue看到相應的影子

方法

定義

java方法是語句的集合，用特定的程式碼片段完成特定功能。

方法是解決一類問題的步驟的有序組合
方法包含於類或物件中
方法在程式中被建立，在其他地方被引用

設計原則

方法本意是功能塊，是實現某個功能的語句塊和集合，設計時最好保持方法的原子性，就是一個方法只完成一個功能 ,利於後期擴充套件。

方法組成

方法包含一個方法頭和一個方法體

修飾符：可選，告訴編譯器如何呼叫該方法，定義該方法的訪問型別
返回值型別：放回值的型別，沒有放回值則用void
方法名：方法的實際名字，方法名和引數表共同構成方法簽名
引數型別：可選，引數是一個佔位符號，當方法被呼叫時，傳遞值給引數。可分為 形式引數 :在方法被呼叫時用於接收外界輸入資料。實參: 呼叫方法時實際傳給方法的資料
方法體：方法體包含具體的語句，定義該方法的功能。

/* 修飾符 返回值型別 方法名(引數型別，引數名){
	方法體
	return 返回值;
}

方法的呼叫

靜態方法：static修飾的方法，可直接通過類名來呼叫
非靜態方法：需要實列化（new）類來呼叫方法
形參和實參：形參引數的名，實參傳遞的資料，兩者型別需要相同
值傳遞和應用傳遞
this關鍵字

方法的過載

過載：在一個類中，相同的函式名，但形參不同的函式

過載的規則

方法名稱必須相同
引數列表必須不同（個數，型別，引數排列順序等）
方法的返回型別可以相同也可以不相同
僅僅返回型別不同，不可以過載方法

可變引數

JDK 1.5開始，java支援傳遞同類型的可變引數給一個方法
在方法宣告中，在指定引數型別後加一個省略號(...)
一個方法只可以有一個可變引數，必須在方法的最後一個引數。

public void test1(int...a){
  }

命令列傳引數

通過命令列給main方法傳遞引數

public static void main(String [] args){    for(int i=0;i<args.length;i++){        System.out.println(args[i])    }}

命令列傳參

#先編譯#javac 檔名javac hello.java#java 檔案 引數java hello hello1 world

遞迴

定義

方法自身呼叫自己
遞迴的能力在於在有限的語句來定義物件的無限集合。

遞迴結構

遞迴頭：什麼時候不呼叫自身方法，若沒有將會死迴圈
遞迴體：什麼時候需要呼叫自身方法

陣列

定義

陣列是相同型別資料的有序集合
按照一定先後次序排列組合而成
每一個數組稱作一個數組元素，每個陣列元素可以通過小標來訪問它們
通過索引進行訪問，即下標一般從“0”開始

java簡單記憶體分析

java記憶體

堆

存放new物件和陣列

可以被所有的執行緒共享，不會存放別的物件引用

棧

存放基本變數型別（會包含這個基本型別的具體數值）

引用物件的變數（會存放這個引用在堆裡面的具體地址）

方法區

可以被所有的執行緒共享

包含所有的class和static變數

陣列的特徵

陣列長度是確定的，一旦被建立，大小不可以改變。
其元素的資料型別必須相同，不允許有混合型別
陣列元素可以是任何資料型別，包括基本資料型別和引用資料型別
陣列變數屬於引用型別，陣列也可以看成是物件，陣列中的元素相當於其中的成員變數
陣列本身就是物件，java中物件是在堆中，因此陣列本身是在堆中

多維陣列

多維陣列就是陣列的元素中還是陣列。

//二維陣列int[][] arr = new int[11][11];int [][] array={{2,3},{4,5}};

Arrays類

陣列的工具類，java.util.Arrays
Arrays類中的方法都是static修飾的靜態方法，使用是可以直接使用類名呼叫

具有以下功能

給陣列賦值:通過fill方法
對陣列排序:通過sort方法，升序
比較陣列:通過equals方法比較陣列中的元素是否相等
查詢陣列元素:通過binarySearch方法能對排序好的陣列進行二分查詢法的操作

排序方法

八大排序方法

內部排序

插入排序

直接插入排序

希爾排序

選擇排序

簡單選擇排序

堆排序

交換排序

氣泡排序

快速排序

歸併排序

基數排序

外部排序

氣泡排序

比較陣列中兩個相鄰元素的大小，如果第一個元素比，第二個元素大，則交換他們的位置
每一次比較，都會產生出一個最大，或者最小的數字
下一輪可以減少一次排序
依次迴圈比較
巢狀迴圈，時間複雜度為O(n^2)

//臨時變數int temp=0//外層迴圈，判斷需要迴圈多少次for(int i=0;i<array.length-1;i++){    //標誌位    boolean flag=false;    //內層比較大小,比較完的可以不用再進行比較    for(int j=0;j<array.length-1-i;j++){        if(array[j]>array[j+1]){            temp=array[j];            array[j]=array[j+1];            array[j+1]=temp;            flag=true;        }      }    if(flag==false){        break;    }}return array;

稀疏陣列

當一個數組中大部份元素的值相時，可以使用稀疏陣列儲存，節省空間
記錄陣列一共有幾行幾列，有多少個不同的值
把具有不同值的元素和行列及值記錄在一個小規模的陣列中，從而縮小程式的規模

//建立一個二維陣列 11*11 記錄棋盤棋子資訊 0:沒有棋子 1：黑棋 2:白棋        int [][] array1=new int[11][11];        array1[1][2]=1;        array1[2][3]=2;        //輸出原始陣列        System.out.println("原始陣列");        for (int[] ints:array1){            for (int anInt:ints){                System.out.print(anInt+"\t");            }            System.out.println();        }        System.out.println("=========");        //轉換位稀疏陣列儲存        //獲取有效值的個數        int sum=0;        for (int i=0;i<11;i++){            for (int j=0;j<11;j++){                if (array1[i][j]!=0){                    sum++;                }            }        }        System.out.println("稀疏陣列");        System.out.println("有效值的個數"+sum);        //建立一個稀疏陣列        int[][] array2=new int[sum+1][3];        array2[0][0]=11;        array2[0][1]=11;        array2[0][2]=sum;        //遍歷二維陣列，將非零的值，存放稀疏陣列中        int count=0;        for (int i = 0; i < array1.length; i++) {            for (int j=0;j<array1[i].length;j++){                if (array1[i][j]!=0){                    count++;                    array2[count][0]=i;                    array2[count][1]=j;                    array2[count][2]=array1[i][j];                }            }        }        //輸出        for (int i = 0; i < array2.length; i++) {            System.out.println(array2[i][0]+"\t"                    +array2[i][1]+"\t"                    +array2[i][2]+"\t");        }        //還原稀疏        //讀取稀疏陣列        int[][] array3=new int[array2[0][0]][array2[0][1]];        //給其中的元素還原它的值        for (int i = 1; i < array2.length; i++) {            array3[array2[i][0]][array2[i][1]]=array2[i][2];        }        System.out.println("=========");        //列印        System.out.println("輸出還原陣列");        for (int[] ints:array3){            for (int anInt:ints){                System.out.print(anInt+"\t");            }            System.out.println();        }    }

面向物件程式設計

面向過程思想

步驟清晰，
面對過程適合處理一些簡單問題

面向物件思想

物以類聚，分類的思維模式，思考問題首先需要那些分類，然後對這些分類進行單獨思考，最後，對某個分類下的細節進行面向過程的思考。
適合處理複雜問題，需要多人協作處理問題

對於複雜的事物，從巨集觀上把握、合理分析，需要使用面向物件的思路分析整個系統。但是具體到微觀操作，仍然需要面向過程的思路去處理。

什麼是面向物件

面向物件程式設計（Object-Oriented Programming，oop）
面向物件的本質是：以類的方式組織程式碼，以物件的方式組織（封裝）資料
抽象：把物件中所共有的東西抽取出來，形成大家所共有的東西
從認識的角度考慮是，先有物件後有類。物件，是具體的事物。類，是抽象的，是對物件的抽象
從程式碼執行考慮是現有類後有物件。類是物件的模板

三大特性

封裝：把資料包裝起來，定義私有屬性，通過set，get暴露出來給方法呼叫
繼承：子類繼承父類所有的屬性
多型：同一個事物，會有多種形態，同一個物件有不同的表現形式

類與物件的關係

類是一種抽象的資料型別，它是對某一事物整體描述/定義，但是不能代表某一個具體的事物。
類是抽象的，只有在例項化（new）的時候，才成為物件
類例項化後，返回一個自己的物件
student物件就是一個student類的具體例項

建立與例項化物件

使用new關鍵字建立的時候，除了分配記憶體空間外，還會給建立好的物件進行預設的初始化，以及對類的構造器的呼叫

構造器

類中的構造器也稱為構造方法，是進行建立物件的時候必須呼叫的。有以下特點

必須和類的名字相同
必須沒有返回型別，也不能寫void
定義有參構造器時，需要顯示定義無參構造器

封裝

程式設計追求”高內聚，低耦合“。高內聚就是類的內部資料操作細節自己完成，不允許外部干涉；低耦合：僅暴露少量的方法給外部使用。

封裝（資料的隱藏）

通常，應禁止直接訪問一個物件中資料的實際表示，而應通過操作介面來訪問。
屬性私有化，get/set表示

繼承

繼承的本質是對某一批類的抽象
extends的意思是 ”擴充套件“ 的意思，子類是父類的擴充套件
JAVA中只有單繼承，沒有多繼承
繼承是類和類之間的一種關係。除此外類和類之間還有依賴關係、組合、聚合。
子類和父類之間，應該是”is a“關係

instanceof

判斷是否為繼承關係，返回true和false

super與this關鍵字

super關鍵字的作用是呼叫父類中的構造器，且在程式碼的首行
this關鍵字是呼叫類自身的構造器，且在程式碼的首行
super和this不能同時呼叫構造方法

方法的重寫

重寫是方法的重寫，和屬性無關
靜態方法不能被重寫
重寫發生在繼承當中，子類重寫父類中的方法
方法名相同，引數列表相同
修飾符範圍可以擴大，但不能縮小：Public>Protected>Default>Private
丟擲的異常：範圍可以縮小，但不能擴大；ClassNotFoundEXception -->Exception(大)

多型

同一方法可以根據傳送物件的不同而採用多種不同的行為方式。

一個物件的實際型別是確定的，但可以指向物件的引用的型別有很多

多型的存在條件

有繼承關係
子類重寫父類的方法
父類引用指向子類的物件

多型注意事項

多型是方法的多型，屬性沒有多型
父類和子類，繼承關係，方法需要重寫
父類引用指向子類 Father f1=new Son();

理解

多型是同一個行為具有多個不同表現形式或形態的能力。

多型性是物件多種表現形式的體現。

現實中，比如我們按下 F1 鍵這個動作：

如果當前在 Flash 介面下彈出的就是 AS 3 的幫助文件；

如果當前在 Word 下彈出的就是 Word 幫助；

在 Windows 下彈出的就是 Windows 幫助和支援。

同一個事件發生在不同的物件上會產生不同的結果。

多型的優點

消除型別之間的耦合關係
可替換性
可擴充性
介面性
靈活性
簡化性

多型存在的三個必要條件

繼承
重寫
父類引用指向子類物件：Parent p = new Child();

型別轉換

父類需要呼叫子類的方法需要進行強制型別轉換

由父類轉換成子類，由高轉低，需要強制型別轉換

由子類轉成父類，由低轉高，不需要強型別轉換，會丟失精度，失去子類的方法

抽象類

abstract修飾符可以用來修飾類或者修飾方法，如果方法即為抽象方法，修飾類，即為抽象類
抽象類中可以沒有抽象方法，但是有抽象方法的類必須為抽象類
抽象類，不能例項化（new）來建立，它是通過子類來繼承的
抽象方法，只有方法的宣告，沒有方法的實現，它是用來讓子類實現的。
子類繼承抽象類，那麼就必須要實現抽象類沒有實現的抽象方法，否則該子類也要宣告為抽象類。

特點

不能例項化（new）抽象類，只能繼承，靠子類去實現它：約束
抽象類中可以寫普通方法
抽象方法必須在抽象類中

介面

介面就是規範，定義的是一組規則，體現了現實世界中，“如果你是...則必須能...”的思想，如果你是汽車，則必須能跑，如果你是好人，必須做好事等。
介面的本質是契約，就像法律一樣，我們必須遵守
OOP的精髓，是對物件的抽象，能體現這一點的就是介面。
介面的關鍵字是interface

作用

約束
定義一些方法，讓不同的人實現
可以實現多個，必須重寫介面中的方法

內部類

內部類就是在一個類中定義一個類，比如在A類中定義了一個B類，那麼B類相對A類來說就是內部類，反之為外部類。

可獲取外部內中的私有屬性和私有方法

可以分為：

成員內部類
靜態內部類
區域性內部類：方法裡定義類
匿名內部類

異常

定義

異常指，程式執行中出現不期而至的各種狀況，如找不到檔案、網路連線失敗、非法引數等
異常發生在程式執行期間，它影響正常的程式執行流程

異常體系

java把異常當作物件來處理，並定義一個基類java.lang.Throwable作為異常的超類
在javaAPI中定義了許多異常類，主要分為 錯誤ERROR和 異常Exception

ERROR

Error類物件由java虛擬機器生成並丟擲，大多數錯誤與程式碼編寫者所執行的操作無關。
java虛擬機器執行錯誤，當JVM不再有繼續執行操作所需的記憶體資源時，將出現 OutOfMemoryError 。這些異常發生時，java虛擬機器，一般會選擇線終止
虛擬機器試圖執行應用時，如類定義錯誤、連結錯誤。這些錯誤是不可查的，因為它們在應用程式控制和處理能力之外，而且絕大多數是程式執行時不允許出現的狀況。
StackOverFlow ：棧溢位
OutOfMemory：記憶體溢位

Exception

在Exception分支中有一個重要子類，RuntimeException（執行時異常）

執行時異常

一般是指我們開發中，編譯執行程式後，遇到在控制檯所發生的異常，一般有：

ArrayIndexOutOfBoundsException（陣列下標越界）
NullPointerException（空指標異常）
ArithmeticException （算術異常）
MissingResourceException （丟失資源）
ClassNotFoundException （找不到類）

這些異常一般是由程式邏輯錯誤引起的，程式應該從邏輯角度避免這類異常

非執行時異常（一般異常）

checked exceptions，非執行時異常（編譯異常）：是RuntimeException以外的異常，型別上都屬於Exception類及其子類。從程式語法角度講是必須進行處理的異常，如果不處理，程式就不能編譯通過。如IOException、SQLException等以及使用者自定義的Exception異常，一般情況下不自定義檢查異常。通俗的話說就是在寫程式碼時出現紅線，需要try catch或者throws時出現的異常。

執行和非執行的區別

異常表示程式執行過程中可能出現的非正常狀態，執行時異常表示虛擬機器的通常操作中可能遇到的異常，是一種常見執行錯誤。java編譯器要求方法必須宣告丟擲可能發生的非執行時異常，但是並不要求必須宣告丟擲未被捕獲的執行時異常。

Error和Exception區別

Error通常是災難性的致命的錯誤，是程式無法控制和處理的，當出現這些異常時，java虛擬機器（JVM）一般會選擇終止執行緒；Exception通常情況下是可以被程式處理的，並且在程式中應儘可能的去處理這些異常。

處理機制

丟擲異常：throw、throws
捕獲異常：try、catch、finally
常用關鍵字：try、catch、finally、finally、throw、throws

自定義異常

步驟

建立自定義異常類，繼承Exception類
在方法中通過throw關鍵字丟擲異常物件
如果在當前丟擲異常的方法中處理異常，可以使用trycatch語句捕獲並處理；否則在方法宣告處通過throws指明丟擲給方法呼叫者的異常，繼續執行下一步
在出現異常方法的呼叫者中捕獲並處理異常

常用類

Object類

hashcode（）
toString（）
clone（）
getClass（）
notify（）
wait（）
equals（）

Math類

常見數學運算

Random類

生成隨機數

File類

建立檔案
檢視檔案
修改檔案
刪除檔案

包裝類

自動裝箱和拆箱

Date類

Date
SimpleDateFormat（yyy-MM-dd:HH:mm:ss）

String

字串內容不可以改變 final，操作量少

StringBuffer

字元長內容可以改變 append（）
多執行緒，資料量較大時,效率低，安全

StringBuilder

字串內容可以改變
單執行緒，資料量較大，效率高，不安全

集合框架

Collection

List（有序可重複）

ArrayList（陣列）

add（）

remove（）

contains（）

size（）

LinkedList （連結串列）

getFirst（）

getLast（）

removeFirst（）

addFirst（）

Vector（迭代器）

Stack（棧）

Set（無序不可重複）

HashSet

TreeSet

Map

HashMap

TreeMap

IO流

位元組流

輸出：OutputStream
輸入：InputStream

字元流

Reader
Wirter

節點流

CharArrayReader，Writer，inputStream，outputStream
StringReader，Writer
pipe（管道流）PipedOutputStream

處理流

buffer

bufferInputStream

bufferOutputStream

bufferReader

bufferwirter

data

DataInputStream

DataOutPUtStream

轉換流

InputstreamReader

OutputStreamWriter

filter （四個）

object (四個)

print

PrintWirter

printStream

序列化反序列化 Serializable transient（透明）

多執行緒

程序和執行緒
run（），start（）

執行緒建立的方式

Thread start0，本地方法，java無權呼叫，交給底層的C處理 private native void start0（）；
Runnable 函式式介面 lambda
Callable 可以有返回值

靜態代理

new Thread（Runnable）.start（）

Lambda表示式

函數語言程式設計
避免內部類定義過多

執行緒狀態

新建狀態：生成執行緒物件，並沒有呼叫start（）方法
就緒狀態：執行緒呼叫start（）方法後，進入就緒狀態，執行緒位於可執行執行緒池中，等待被排程
執行狀態：執行緒獲得cpu使用權，執行程式碼塊
阻塞：因某種原因放棄了cpu的使用權，讓出了cpu，暫時停止執行。直到執行緒進入到就緒狀態，後被排程再次執行
- 等待阻塞：執行(running)的執行緒執行o.wait()方法，JVM會把該執行緒放入等待佇列(waitting queue)中。
- 同步阻塞：執行(running)的執行緒在獲取物件的同步鎖時，若該同步鎖被別的執行緒佔用，則JVM會把該執行緒放入鎖池(lock pool)中。
- 其他阻塞：執行(running)的執行緒執行Thread.sleep(long ms)或t.join()方法，或者發出了I/O請求時，JVM會把該執行緒置為阻塞狀態。當sleep()狀態超時、join()等待執行緒終止或者超時、或者I/O處理完畢時，執行緒重新轉入可執行(runnable)狀態。
死亡：執行緒執行run（）方法結束，或因異常退出run（）方法，執行緒執行狀體結束。

執行緒常用方法

sleep
join
yield
isLive
start
setPriority
interrupt

執行緒同步

多個物件操作同一個資源，併發
佇列+鎖

Synchronized

同步方法弊端：鎖太多
同步程式碼塊（常用）
第一個執行緒進來拿到鎖，後面就要排隊，直到這個人釋放鎖，後面拿到鎖才能進去
死鎖互斥，請求保持，不剝奪條件，迴圈等待條件

Lock（優先順序高）

ReentrantLock lock，trylock，unlock

執行緒通訊

緩衝區：訊息佇列
標誌位：紅綠燈
wait（）
notifyAll（）喚醒

執行緒池

池化技術
池的大小
最大連線數目
保持時間

網路程式設計

ip
埠
Socket程式設計
TCP 三次握手，四次揮手，面想連線
UDP 無連線，Packet
URL
Tomcat
聊天通訊
檔案上傳

註解和放射

註解

元註解
內建註解
自定義註解
放射註解

反射

Class newInstance（）
類載入機制
Method invoke，存在過載，也需要寫引數的型別
Field set
Construct
破壞私有關鍵字
效能分析
放射獲得註釋，泛型

JAVA知識筆記

JAVA知識筆記

基本介紹

特性與優勢

JAVA三大版本

JDK,JRE,JDK

java程式執行機制

語法基礎

註釋

識別符號

資料型別

型別轉換

什麼是位元組

java進位制數表示

資料型別拓展

變數

變數作用域

變數預設值

運算子

自增符

冪運算

邏輯運算&和&&區別

位運算

String + 號拼接問題

三元運算子號

流程結構

順序結構

選擇結構

迴圈結構

方法

方法的呼叫

方法的過載

可變引數

命令列傳引數

遞迴

陣列

java簡單記憶體分析

陣列的特徵

多維陣列

Arrays類

排序方法

稀疏陣列

面向物件程式設計

什麼是面向物件

類與物件的關係

構造器

封裝

繼承

super與this關鍵字

方法的重寫

多型

多型的優點

多型存在的三個必要條件

型別轉換

抽象類

介面

內部類

異常

分類

異常體系

ERROR

Exception

執行時異常

非執行時異常（一般異常）

執行和非執行的區別

Error和Exception區別

處理機制

自定義異常

常用類

集合框架

IO流

多執行緒

執行緒建立的方式

執行緒狀態

執行緒常用方法

執行緒同步

執行緒通訊

執行緒池

網路程式設計

註解和放射