java00_知識點整理

javaOO知識點彙總

-->OO:Object Oriented-->面向對象.

1.類,對象,包

(1)對象

對象因關注而產生,萬物皆對象.

1.結構化編程：

面向過程的結構化編程是將整個工程分佈式的按照步驟從上到下依次執行。

2.面向對象編程：

面向對象就是在模擬生活中的各類場景.
面向對象：經過對象之間的屬性和行爲的相互關聯來完成特定的功能.
創建對象模型，將問題域化爲不一樣的對象去處理.
|-->找對象 ---->建立一個類來描述對象的行爲和屬性

3.面向對象和麪向過程的區別：

面向過程是將整個業務流程分解成若干步驟,最後再按照前後順序串聯起來,程序圍繞着問題的自己
來設計; 面向對象要先明確一個對象的行爲和屬性,程序圍繞着問題域中的對象來設計.

(2)類

類是對象的抽象，對象是類的實例。

1.類的特徵:

在面向對象的編程中,類是一個獨立的程序單元,是具備相同屬性和行爲的一組對象的集合。
在程序中用類來模擬現實中的實體。 其規則有:類首字母大寫(駝峯命名法);
文件名必須和public類對應的類名保持一致;一個文件能夠定義多個類,可是隻有一個public類
類能夠看作是模板,產生的實例是對象.
方法:訪問修飾符--返回類型--方法名稱--參數列表--方法體

2.類的三要素:

1)類的標誌--類的一個有別於其餘類的必不可少的名字。
2)屬性的說明：用來描述相同對象的靜態特徵，
3)類的方法--相同對象動態的特徵(針對對象時就是行爲，針對類時就是方法)

3.實例化對象

類是抽象出來的概念,對象纔是真實存在的實體。 程序中經過類來實例化對象(new)

4.this

this表示當前類中對象的引用。
建立(new)的是哪一個對象,this就表示這個對象的引用

(3)包

對文件的分類和管理-->文件夾

提供了一個組織類的機制，能夠表示類的全路徑，
包能夠用來分辨類，包的命名方式採用公司的網址。com.xxx.包name,而且包名要小寫.
包名(com.xxx.xxx)-->位於Java文件的首行,表示當前文件在某個文件夾下

系統包:java.功能.類名--> 命名時儘可能不要使用系統使用過的名字

java.lang-基礎類/java.util-工具類/java.io-輸入輸出類
要使用其餘包下面的類，使用import來導入,或者:包名.類名(.*)
import不能導入本文件所在的類--會提示警告,默認就是導入本類

2.對象的行爲

(1)棧,隊列

棧是一端受限,一端容許操做的限線表--先進後出. 例:洗碗洗好放到籃子底下的最後才能拿出來
隊列是限定性的限線表--先進先出. 例:排隊買票,先排隊先買票,後排隊候買票。

(2)方法調用棧

定義多個方法,互相調用,先執行的方法後結束,後執行的方法先結束.
改變流程控制的方式:方法調用,選擇語句,循環語句.

(3)重載

方法名相同,參數列表不一樣

當一個類有兩個到多個同名可是有不一樣參數列表的方法時,就是方法的重載
參數列表:參數的類型,參數的個數,參數的先後位置
重載提升了方法的利用率:相同的行爲,不一樣的表現形式

public class Fuction {
    public void show() {
        System.out.println("這是無參方法");
    }   
    public void show(int id) {
        System.out.println("這是有1個int參數的方法");
    }   
    public void show(String name) {
        System.out.println("這是有1個String參數的方法");
    }   
    public void show(int id, String name) {
        System.out.println("這是有2個參數的方法");
    }
    public void show(String name, int id) {
        System.out.println("這是有2個參數的方法,與上個方法參數位置不一樣");
    }
}

(4)構造器

與類名一致而且只在實例化時被執行一次的特殊方法

構造器的目的是初始化類的實例,使其成爲一個有效的狀態. 構造器也是重載的一種表現,建立對象的時候,虛擬機會根據參數列表來決定調用哪一個構造方法.
在實例化對象時,若類中沒有無參構造,則編譯器會自動建立一個默認的無參構造;
若建立了一個有參構造那麼編譯器就不會再加上默認的無參構造.

public class Fuction {
    public Fuction() {
        System.out.println("這是無參構造");
    }   
    public Fuction(int id, String name, int age) {
        System.out.println("這是有參構造");
    }   
    public int show(int id) {
        System.out.println("這是普通方法");
        return id;
    }
}

1-構造函數的做用:

1)建立對象:建立對象的時候必需要有構造,能夠初始化一些內容，由虛擬機來調用;
2)對象的初始化:構造函數能夠對對象進行初始化,每個類必需要有構造.

2-構造器和普通方法的區別

1)格式不一樣:構造方法不存在返回值,方法名必須和類型一致;普通方法能夠有返回值,名稱能夠和類名不一樣,只要符合規範就行;
2)調用的時間不一樣:構造方法老是在類建立的時候運行;普通方法必須是對象調用時才執行;
3)執行次數不一樣:一個對象建立後構造方法只在new的時候執行一次;普通函數由對象來調用,調用一次就執行一次

3-構造方法使用的場景:

在分析具體事物的時候,發現事物一出現就具有了某些特徵,就能夠將其定義在構造中.

3.繼承

面向對象的特徵:封裝,繼承,多態,抽象.

(1)繼承的概念:

在java中繼承表示的是類與類之間的關係,是is-a的關係. 除繼承外類與類之間還有組合關係has-a. has-a是類之間相互依賴的表現;is-a是繼承中子類和父類的關係,它們均可以達到代碼的複用. 類是單繼承的,一個類只有一個父類. 經過extends關鍵字實現類的繼承.父類(基類)-->子類(派生類) 經過擴展已有的父類/基類,建立一個新的子類/衍生類/派生類. 就能夠擁有父類的全部的屬性和方法,而且子類還能夠擴展父類的屬性和方法 public class Doctor extends Peopel { //Doctor是子類,它繼承了Peopel類 }

(2)方法的重寫:

當子類繼承父類以後,當子類中的方法和父類方法的方法名同樣 參數同樣 返回類型同樣,就能夠稱爲子類重寫了父類的方法.重寫以後會優先調用子類的方法. 重寫的規則:1.子類方法必須與父類方法的返回值類型 方法名和形式參數一致;2.子類的訪問修飾符不可大於父類 3.子類不可拋出比父類更多的異常. 重寫與重載的區別:重寫是子類方法與父類方法之間關係的體現;重載是一個類當中多個方法之間參數不一樣的體現. @Override是僞代碼,表示當前方法是重寫方法:
a.能夠將@Override當作是註解; b.加強了代碼的可讀性,該標籤能夠表示它是一個重寫的方法.

public class Doctor extends Peopel {
     @Override public int attack() {
         int docAtta = super.attack(); return docAtta; 
    }

     @Override public int defense(int foeAttack) {
        int docDefen = super.defense(foeAttack); return docDefen; 
    }

    @Override public void lvUp() { 
        super.lvUp(); 
    } 
}

(3)Object類

Object類是全部類根類,一個類若是沒有顯式的繼承Object，虛擬機都會自動加上extends Object. equals()方法是Objiect類的方法，是用來判斷兩個對象的引用是否相等. 若是在子類想要判斷兩個對象的內容是否相等,就須要在子類重寫equals方法.子類調用的時候就優先調用重寫後的方法; toString: 一個字符串想要和另一個類型進行鏈接,toString方法能夠將其餘類型轉換爲字符串再進行鏈接. 若是輸入的是對象，默認調用toString並打印:內存地址+hashcode碼. 對象-->getclass():類對象;new實例化的對象:類的對象. 類的對象關注的是數據;類對象關注的是屬性.

重寫equals方法目的是判斷對象的行爲和屬性是否相同
建立子類對象首先會去調用父類的構造，而後再執行子類的構造
-->首先產生父類對象,再產生子類對象,因此子類能夠共享父類的屬性和行爲
重寫和重載:兩個方法分別在父類和子類中,而且方法名和參數列表都相同,就稱爲重寫
重載是指在同一個類中的方法,他們的方法名相同而且參數列表不一樣,體現的是相同的引用不一樣的表現形式
父類對象屬性初始化-->父類構造-->子類對象屬性初始化-->子類構造

this

子類定義了和父類相同的屬性則this.屬性指代得是子類自己的屬性,-->屬性沒有重寫,它們屬於不一樣的對象
若子類沒有改屬性則this.屬性指代的是共享自父類的屬性,

super.方法

表示調用父類的方法-->super表示指向父類對象的引用
在子類構造中能夠動態控制調用哪一個構造super()調用無參構造,傳入參數後根據參數類型肯定調用哪一個構造
父類至關於模板,子類繼承的只是模板中屬性的引用和方法,不繼承數據

final關鍵字:

final修飾類,表示當前類爲終態類(最終類),不能被繼承;final修飾方法,表示該方法不能被重寫; final修飾變量,表示該變量的值不能被修改(常量).

4.封裝

java設計理念之一:
各個模塊之間儘可能減小關聯,相互獨立。

(1)封裝的概念:

將類中的信息隱藏在類的內部,不容許外部程序直接訪問,而是經過類提供的一些方法進行訪問和操做。 字面上理解就是包裝的意思-->信息隱藏，利用抽象數據類型將數據和類操做捆綁在一塊兒,使其成爲一個不可分割的實體。 外部不須要知道對象裏面的細節,可是外部用戶能夠經過類對外暴露的接口來訪問對象 封裝的優勢：1.能夠對變量設置只讀和只寫; 2.能夠對其中的成員變量進行總體控制(控制對象的結構); 3.類的用戶不須要知道類中是如何存儲和操做數據的; 4.良好地封裝能夠減少耦合

(2)訪問修飾符:

public:公開級別的訪問,任何對象均可以訪問,沒有包的限制; protected:受保護訪問級別,同一個包中的類能夠訪問 子類能夠訪問(無論子類是否同包); 默認修飾符:默認訪問級別,同一個包中的類能夠訪問; private:私有訪問級別,權限最低的訪問級別,只有原本可操做,不對外公開。 若是父類設置的屬性和方法是private,那子類是沒法訪問和重寫的, public > protected > 默認 > private

(3)javabean:

1.概念:

bean中文釋義爲豆子,javabean是一種特殊的類,一般用來實現一些簡單的功能,很容易被重用也很容易被插入到其餘應用程序, 按照bean規則編寫的類均可以被成爲javabean。 bean的含義是能夠重複使用的java組件,組件是一個能夠進行自由內部管理的一個或幾個類所組成，外部程序無需瞭解其內部信息和運行方式, 想要使用就只能經過暴露的接口-->內部信息隱藏、進行數據傳遞.

2.javabean的規範:

全部的javabean必須放在一個包中(bean包); javabean必需要生成publicclass 類,文件的名字必須和類名一致 全部的屬性都必須進行封裝(private),不能出現public屬性 私有屬性經過get方法獲取,經過set方法進行設置 必需要有一個無參構造

3.javabean的結構:

屬性:javabean的類成員變量,描述javabean對象的狀態; 方法:構造方法,普通方法; 事件:可用來監控屬性的修改

(4)static變量:

1.static靜態的概念

在java裏面沒有全局變量的概念,可是我們能夠通過一個static關鍵字構造一個僞全局變量,static表示"全局"、"靜態"。 若是用static來修飾了某一個變量,那這個變量就屬於類變量(再也不是對象的成員變量),經過對象的引用能夠獲取static變量。 JVM在加載類的時候會把變量分紅兩種類型,一個是成員變量一個是靜態變量(全局),若是存在靜態變量則在加載類的時候就會將其保存到方法區(共享), 而成員變量就必需要在建立對象的時候纔會加載到內存。 靜態變量(類變量)在內存中一旦改變就不可恢復,類全部的實例均可以共享靜態變量,能夠經過類訪問也可經過對象的引用來訪問

2.static方法:

能夠經過static來修飾稱爲靜態方法(類方法),main方法就是典型的靜態方法, 靜態方法裏面不能直接使用成員變量,只能使用靜態變量,能夠調用其餘靜態方法但不能調用普通方法,只能經過對象調用普通方法; 而在普通方法中就便可使用靜態變量也可以使用非靜態變量,便可調用靜態方法也可調用非靜態方法.

3.靜態塊:

初始化塊--> { xxx },用來對對象的數據進行賦值,一旦發現有對象產生就會自動執行初始化塊在賦值時將 =??? 的操做放入構造. 靜態塊 --> static{ xxx },靜態塊也是用於初始化數據,但只會在第一次產生對象的時候執行一次. 靜態變量能夠加載不少數據信息,或者操做文件.下次經過成員變量就只能引用靜態變量.

5.多態和抽象:

動態多態和靜態多態,相同的行爲,不一樣的表現.

(1)多態概述:

對象的多種形態,多態在不少面嚮對象語言中都存在,生物學中的多態是指生物存在不少形態和階段,而在OOP中指的是一個對象有多種形式的能力-->相同行爲有不一樣的表現形式.
靜態多態:經過重載機制實現,在編譯時就肯定會加載那個方法;
動態多態(引用多態):經過繼承的父類引用能夠指向不一樣子類對象的特性實現,須要在程序運行時才能肯定要加載那個子類;
方法多態:父類引用指向的是哪一個實例就調用該對象的方法,若是被指向的子類沒有這個方法,就調用繼承自父類的方法。
多態的優點: 經過父類的引用能夠共享全部子類方法和屬性;
向上轉型和向下轉型: 基本數據類型的自動提高屬於向上轉型,向下轉型即便強轉爲更小的類;
父類引用指向子類對象是子類對象默認向上轉型爲父類對象的具現.
對象的向上轉型:子類能夠共享父類的屬性和方法,還能夠擴展出子類獨有的屬性和方法, 當這個子類的引用屬於父類對象時,自動發生的將子類向上提高爲父類.
向上轉型會致使子類一些屬性和行爲的丟失,由於父類引用沒法指向父類模板中不存在的子類特有擴展功能,全部沒法調用這些屬性和行爲;
向下轉型:改變引用(強轉),父類引用指向子類對象時,若還想使用子類特有的屬性就要將該引用強制轉換爲特定 的子類(強轉以後就沒有多態特徵了),強轉以後的引用仍然能夠指向原先的子類對象.
instanceof:比較先後兩個對象是否屬於同一個對象類型.
java多態可能致使引用和實際對象的類型不一致,這時可經過instanceof運算符來鑑別當前對象的類型.
instanceof雖然能夠匹配對象類型,可是不推薦使用(沒有很好的利用面向對象的多態性),能夠用重載替換 instanceof

(2)多態存在的條件:

1.必須有繼承; 2.必須有方法的重寫;3.父類的引用指向子類對象. 抽象: 若是多個對象有相同的屬性和行爲,咱們能夠提取出這些共同點讓這些對象共享. -->人類經過分析和綜合在腦海中再現對象的本質和本質方法 抽象類:用關鍵字abstract修飾的一種特殊類,用來規定其子類必須實現的某些功能(抽象方法沒有具體實現)， 有多個相同特徵的類抽象出一個抽象類,以該類爲模板來規避子類設計的隨意性. 一個類中如有抽象方法,那此類必須是抽象類,抽象類中能夠有抽象方法也可由普通方法, 抽象類不能被實例化,只能做爲其餘類的父類。

(3)接口:

1.接口的概念:

接口是抽象方法和常量值的一個集合,是一直特殊的抽象類,只能有抽象方法不可有普通方法。 接口定義了某一些類所須要遵循的規範,但它不關注裏面的數據和具體實現

2.接口的語法:

interface-->接口 class-->類 public [abstract] interface name[estends 接口1,接口2]{抽象方法, 常量 } []裏面的內容可有可無。 接口還能夠繼承其餘的接口並可實現多繼承。

3.接口內部:

在接口裏面定義的方法沒有abstract修飾，則編譯器會自動加上.由於接口裏面默認只能存在抽象方法； 在接口定義的常量會自動轉換成 public static final *** ；接口裏面只能存在公共的靜態常量。 在接口裏面的方法,若省略了訪問修飾符,則會默認成爲public。 接口的設計目的是用來被其餘類實現的，所以類的訪問權限也應該設置爲public。

4.接口能夠繼承多個其餘接口 ====>等價於一個類實現多個接口。

接口能夠彌補java類不能多繼承的缺陷，

6.異常處理

(1)異常概述:

異常是指程序在運行期間出現的錯誤.出現錯誤最重要的是查看代碼行,關注錯誤的名字. Java在出現異常時默認將該錯誤打印到控制檯.

(2)異常的分類：

Error：錯誤指的是用戶或程序員沒法控制的問題.系統內部出現的錯誤,程序設計時不須要在代碼中進行處理;
Exception:全部異常的父類,其子類異常對應各類不一樣的異常狀況,通常出現了異常都須要用戶進行捕獲處理,
檢查異常,通常檢查異常都是用戶代碼錯誤或者程序沒法預見的錯誤。例如:打開不存在的文件 運行時異常--RunTimeException:在運行的過程當中發生的,能夠被避免的程序異常,能夠忽略,提示設計人員該 段代碼須要優化。程序沒法預見的異常,如Math類除數爲0 下標越界.

(3)異常的執行流程:

1.main方法在棧的最底部,method2在最頂部,若是method2拋出了異常,就會立刻被彈出方法棧. 2.當前出現的問題會同時拋給方法調用者method1,而後在拋給main方法； 3.若main裏面也沒有處理該異常,Java虛擬機就會來處理這個異常,建立一個異常對象, 將信息經過調用tostring方法輸出到控制檯。

(4)異常的體系結構:

Throwable類是因此異常的基類;ClassNotFoundExceptiong/DataFormatException /IllegalAccessException/IOException/CloneNotSupportedException/NoSuchFielException/ 其直接子類是:Error類和Exception類
RunTimeException:ArrayStoreException/ClassCastException/ArithmeticException /NullPointerException/IllegalArgumentException Error/UnKnownError/OutOfMemoryError

(5)捕獲異常:

try{}catch{} try裏面放的是可能有異常的代碼。一旦出現異常就能夠自動進入catch塊, 在裏面打印輸出該異常.若無異常就不執行catch塊,無論catch塊是否執行,後面的程序都會正常執行. try-catch-finally 塊: finally爲異常語句提供了一個統一的出口,能夠對程序作一個統一的管理. 不管是否異常最後都要執行finally塊。 能夠經過finally塊來進行資源的清理工做,關閉鏈接/關閉文件/刪除某些臨時文件. try或者catch裏面有return語句也不影響finally模塊的執行(這三個塊是一個總體). 若是有多個catch塊就要注意,catch塊的順序必需要從小到大(子類在前父類在後),同級別的異常就無要求

(6)聲明並拋出異常:

throw:將異常進行拋出(動做);throws:聲明將要拋出何種類型的異常(聲明). 子類重寫的方法,子類拋出的異常不能大於父類的異常, 但如果子類異常小於父類時,語法無錯但沒法所有接受來自父類的異常,因此沒法調用父類方法。

(7)自定義異常:

某些異常在程序裏面沒法表達出來,就要自定義異常; 自定義規則:1.繼承java.lang.Exception，聲明本身是異常類; 2.在方法適當的位置生成自定義異常的實例,throw進行拋出; 3.用throws進行聲明。

7.經常使用類:

(1)System類: err/out/in

1)表明了Java運行的平臺(系統)，經過system類能夠進輸入輸出; 2)system類是final類,不能進行繼承.其中的屬性和方法都是靜態的 3)經常使用的操做:程序的執行時間、數組的copy、獲取一些系統信息 獲取當前毫秒數-->currentTimeMillis();獲取系統信息-->getProperties();

(2)Runtime類:

表明的是Java運行的環境,每一個java程序都會有一個對應的Runtime對象,將程序和環境進行了一個鏈接. 程序不能本身建立Runtime對象,只能經過Runtime的靜態方法getRuntime()獲取實例. 獲取虛擬機的最大內存-->maxMemory();

(3)字符串相關類(String/StringBuffer/StringBuilder):

String是一個不可變的字符串對象,一旦一個String被建立那麼這個字符串中的內容就不可變, 直至該字符串被銷燬. String類是一個final類不能被繼承,之後咱們操做字符串則會每次返回一個新的字符 串。拼接/排序/截取 String str = "abc"; 在編譯期間就會在字符串常量池裏面分配空間產生abc，而且被str指向; String str2 = "abc";-->str2會去常量池找abc，若是存在abc就直接經過str2 引用該abc。 String str3 = new String("abc"); 在運行時纔會執行，在堆空間建立一個字符串對象,裏面內容爲abc， str3引用執行堆空間字符串,則每次都會產生一個新的對象。

(4)字符串中的方法:

獲取下標爲n的字符-->charAt(n);比較兩個字符串-->compareTo(""); 將str2拼接到str-->str.concat(str2);(複製的方式,效率比+高) CharSequece(字符序列)-->contains(); endsWith(); 獲取hash碼-->hashcode(); equels在比較兩個字符串的時候,其實是比較hashcode編碼， 若是兩個字符串同樣那麼它們hashcode必定相等，若兩個hashcode碼同樣則字符串不必定相等 忽略大小寫-->equelsIgnoreCase(); 獲取字符串的字節數據-->getBytes(); 獲取字符串長度-->length(); 拆分字符串用,分割-->split(","); 將字符串轉換成字符數組-->toCharArray(); 將值用字符串輸出-->String.valueOf(xxx); 忽略首尾的空格-->trim();

(5)StringBuffer:

String和StringBuffer都是用來表示字符串,內部實現方式有差異,致使它們使用的範圍不一樣, 對於StringBuffer,每次對字符串進行操做都是在原來的基礎上繼續增刪改,不會產生新的字符串, 所以StringBuffer處理字符串的效率比String高. 定義一個字符串,若用StringBuffer的方式,就必須經過構造的方式進行初始化, StringBuffer s = new StringBuffer("sdfsdav"); s.append("asdfg").append("12345"); 字符串拼接效率: StringBuffer > concat > String ; 只定義一個字符串常量就使用String,若要對字符串進行大量的操做就使用StringBuffer;

(6)StringBuild

也是一個可變的字符串對象,與StringBuffer相比,線程不安全,適合單線程的程序使用, 因此其效率比StringBuffer高.

區別:
              類型
String       字符常量    不可變  線程安全   產生新對象 
StringBuffer 字符常量     可變   線程安全  不會產生新對象
StringBuild  字符串常量   可變   線程不安全  不會產生新對象

(7)日期相關類:

產生一個data實例就能夠獲取到日期(默認的時間). Date和Calender 是java裏面的兩個日期處理類,Data沒法達到國際化標準,jdk1.1以後基本上用Calender來 替換,Data裏面不少方法都被廢棄了. 建立須要的日期格式,須要格式化日期,java.text.DateFormat抽象類,不能實例化,可是他提供了不少預約義 的日期格式. SimpleDateFormat:根據用戶自定義的格式來顯示日期.-->針對Date類型的轉換 除了將日期轉換爲指的格式外,還可將字符串轉換爲日期格式. Calendar不支持SimpleDateFormat,必須先將Calendar轉化爲Date才能用SimpleDateFormat設置格式.

(8)Math類:

隨機數-->random 向下取整-->floor 向上取整-->ceil 四捨五入-->round pow 平方根-->sqrt() Random: Random類中實現的類都是僞隨機.有規則的隨機,在進行隨機時,必需要提供一個種子數, 在種子數的基礎上進行了必定的變化. 相同種子數產生的隨機數是同樣的. 經過時間產生的種子每次隨機數都不同.

(9)經常使用包裝類

將基礎類型的變量裝箱成包裝類對象,將包裝類對象拆箱成基礎類型的變量
針對基本數據類型的變量
java中之前皆對象,爲基本數據的變量提供了一個包裝類,能夠將基礎類型的變量當作對象同樣進行操做。
全部的包裝類都是final類型，不能建立子類.包裝類一旦建立就不能改變裏面的數據

number:int-->Integer,byte-->Byte,short-->Short,long-->Long,float-->Float,double-->Double;             
object: boolean-->Boolean  char-->Charactor    


代碼實例:
Integer it = new Integer("365");
int res = it.intValue();  

int i = 12;
Integer it2 = new Integer(i);  

Integer it3 = Integer.parseInt("456");

裝箱和拆箱只針對包裝類和基本數據類型.

8.正則表達式

用來驗證特定格式的一個字符串模板.
使用String的matches（）方法進行比較

1.字符類:

[abc]---->匹配a/匹配b或者匹配c  
[^abc] ---->能夠匹配任何字符,除了abc  
[a-zA-Z]---->能夠匹配字母a-z,A-Z      //[A-Z][a-z] Bn  
[0-9] ---->匹配數字

2.預約義格式類:

. ---->任何字符,我就是.字符自己。    \.    
\d ----> 數字；  \D ---->非數字  
\w ----> [a-zA-Z0-9_]小寫字母 大寫字母 數字 下劃線  
\W---->非字符。  [^\w]

3邊界匹配:

^ ---->表示行的開頭  
$ ---->表示行的結尾

4.數量詞:

? 例如：[0-9]? 數字出現一次或一次也沒有，  
* 例如：[0-9]* 數字出現0次或屢次  
+ 例如: \\w+  或者 [a-z0-9]+  出現一次或屢次  
{n} 例如 [0-9]{6} 6位數字  
{n,} 例如 [0-9]{6,} 數字6位或以上  
{n,m} 例如 [0-9]{4,8} 數字至少4次,最多8次

5.運算符：

xy ---->x後面必須是y  
x|y ---->要麼是x 要麼是y  
(x) ----> 將括號裏面的內容x 單獨當作一個組

6.中文：

[\u4e00-\u9fa5] ----> 匹配中文漢字

9.集合框架

數組弊端：定長，同類型數據
集合:對象,容器,存數據。元素類型可不一樣,集合長度可變,空間不固定。存儲,檢索,傳輸對象。

(1)集合：

生活中指不少事物湊在一塊兒,數學裏指具備相同屬性事物的一個總體,
java中指用來存儲數據,一某種組織結構並一特色的方式來進行訪問,目的是提供一個能夠用來處理對象的集合和框架。(一種工具,容器,存儲任意數量的對象)

(2)集合的做用：

1.在類的內部,對數據進行組織,好比當前每一個學生均可以選擇學習科目, 2.簡單而快速的搜索內容

(3)集合的結構

collection：collection接口是最基本的集合接口,他不提供直接的實現,collection表明第一種規則。
所包含的元素都必須遵循一條或多條規則(某些實現類能夠重複數據,也有的不能重複;
按照指定順序插入或散列插入;排序或不排序),在程序中不會直接使用collection接口,都是使用它的子接口.

(4)list

list接口爲collection的直接子接口,list接口表明的是有序的集合,使用某種特定的插入順序來維護元素的數據。
對集合中每一個元素獲取到的精確位置進行訪問,也就是經過索引訪問元素,容許數據重複。
設置對象到集合裏面,默認是用object來接收.

1.ArrayList：

ArrayList是list的實現類,是一個動態數組,底層是封裝的數組,容許插入null.
建立ArrayList對象的時候,不用指定大小,虛擬機會默認設置初始容量10,該容量會隨着數據的增長而增加,
每次添加數據都會判斷容量是否足夠,若將要溢出時就進行動態擴容,容許數據重複.

2.LinkedList:

實現了list接口的類,方法和屬性和ArrayList相似,是一個雙向鏈表結構的集合(記錄了先後元素的位置),
額外提供了不少方法,如 insert。 區別: 底層方式不一樣,linkedlist不能隨機訪問,全部操做都是按照雙向鏈表的要求執行,
要在裏面獲取元素必須從第一個元素開始遍歷,可是在進行增長和刪除或修改的操做時就效率比較高.
雙向鏈表:每一個元素在內存裏面都是獨立的,每一個空間都會保存上一個和下一個元素的位置.

3.vector：

與 ArrayList很是類似,Java1.0開發出來的vector,在1.2版本後java才提出了集合框架,爲了向下兼容,就將vector加入到了集合框架,同時與現有框架保持一致(放在list接口下面).
特定:vector線程同步,線程安全x效率低；底層是數組。

(5)泛型:

對集合中的元素類型進行約束,規定數據格式.
操做list會出現不管什麼數據類型均可以加入到集合裏面,這時當須要進行對象強轉的時候就會出現異常.
若是王其中加入基本數據類型會進行自動裝箱,取出時則進行自動拆箱。
概念:容許在定義類、接口時指定形參類型,而在list裏面聲明泛型也是對集合作數據類型的規範。
要求必需要傳遞那個類型的數據,不然就報錯。
< ?>-->泛型的佔位符,在定義時不肯定數據類型,在運行產生實例時再來肯定泛型的數據類型(多態).

(6)Set集合

set繼承了collection,實現了collection的全部方法
特定:a.不能包含重複元素,當加入一個元素的時候,要判斷元素的內容是否重複,
若是要往set集合加入對象就必須重寫equals,才能判斷當前對象是否重複; b.可能有順序也可能沒有順序(無序)； c.set是無序的,因此set集合不能用索引進行訪問。

1.HashSet:

hashset是基於hash算法的set接口實現, 元素容許爲空.
hashset沒法經過索引訪問,只能經過foreach或者迭代器進行循環.
往set集合中加入對象,要判斷對象是不是同一個,須要判斷對象的全部屬性是否相等.
java中判斷兩個對象是否相等:
a.判斷hashcode碼是否相同(肯定元素的位置--桶算法);若是hashcode碼不相等那這兩個對象就不能認爲是相等; b.若是hashcode相等,接下來就比較equal方法(比較對象中的元素),若是不相等則對象不相等.

2.TreeSet

基於TreeMap實現,底層是二叉樹.生成老是一個處於排序的set集合,
它可讓set裏面的元素按照必定規則進行默認排序,也能夠自定義順序(排序:Comparator接口). 與HashSet比較:速度慢,排序。集合要排序就要將全部的元素進行兩兩比較，根據返回值進行排序.

(7)集合中兩個比較器

兩個接口comparable和comparator:
comparable能夠當作是一個內比較器,兩個對象中的元素能夠進行相互比較,依賴於comparaTo進行天然比較,比較者大於被比較者返回值爲正整數,等於則返回0小於則返回負整數;
comparator能夠當作一個外比較器,適用於兩個對象要進行相互比較但卻不進行內部特定元素的比較,使用方法compara（object1，object2）進行比較,object1大於object2返回正整數,等於則返回0小於則返回負整數.

(8)迭代器:

Itrtator接口,Iterable接口,用於遍歷集合中的數據(循環輸出集合中的數據).
Itrtator對象，經過該對象能夠操做集合中的每一個元素.

(9)Map接口

每一個條目單獨包含兩部分-->key value,鍵值key不可重複.
1.map和set、list的區別:
由鍵值對進行內容的組織,提供了key-value的印射
2.沒有基礎collection接口；
3.key-value是一一對應關係,key不可重複value可重；
4.map的實現類有: hashmap，treemap，hashtable 5.key是單獨儲存的,若是將全部key放在一塊兒就是一個set集合(無序不可重)

1.hashmap

以hash表的結構來實現,經過hash算法進行位置尋找,查詢快速,key不可重複value能夠重複,容許空鍵空值;

2.TreeMap

TreeMap是基於紅黑樹算法來的,鍵值是放在set集合中的並對其進行了天然排序。TreeMap包含了treeSet

hashtable

hashmap和hashtable都是map的子類,hashtable先出來hashmap後出來，hashmap容許null鍵null值線程不安全,hashtable不容許空值線程安全效率較高.

10.IO流

數據從外部進入內存(input)和從內存取出(output)的過程,就是數據的輸入輸出(I/O).

(1)流的概念

流相似於在文件和程序之間的一個虛擬管道,數據能夠按照特定方向流入或流出.
流就是一個管道里面有數據(二進制),這個管道鏈接了程序和文件.
java中當須要讀取數據的時候,就會開啓一個數據源設備的流(經過代碼控制),這個數據源能夠是文件、內存或網絡路徑;一樣的當寫入數據的時候,就會開啓一個通往目的地的流(用代碼建立一個虛擬管道)。
用流來抽象IO的緣由:流的兩個特徵-->1.流是流質能夠流動 2.流具備方向不能隨意更改.

(2)流的分類

java.io包裏面包含了全部流的內容,能夠當作是存放各種型流的倉庫.

1.按照方向：

1.輸入流：將數據讀取到內存,只能讀取不能寫入.InputStream,Reader;
2.輸出流:將數據從程序寫出到目的地,只能寫入不能讀取.OutputStream,Writer.

2.按照類型:

1.字節流:以byte爲最小單位進行傳輸(8位),字節流都必須繼承InputStream或OutputStream抽象類
2.字符流:以char爲最小單位進行傳輸(16位),字符流必須繼承Writer或Reader抽象類。

3.按照功能:

1.節點流:對特定數據源進行讀寫操做,能夠直接操做數據底層(如內存、硬盤、二進制)；
2.處理流:不直接鏈接設備而是鏈接在其餘流上面的特殊流,經過對數據的處理爲程序提供強大的功能(高級流).

(3)操做流的步驟:

1.創建流

根據不一樣的數據類型選擇不一樣的流(建立管道);

2.操做流

將數據讀取到內存或將內存中的數據寫入到數據源;

3.關閉流

操做結束後須要關閉輸入輸出流.

(4)File類

java.io.File類主要用來管理磁盤文件或者文件目錄的基本功能，能夠獲取到文件的信息，文件夾的一些操做。不能訪問或者操做文件的內容。

(5)輸入輸出流

1.緩衝流：

BufferedInputStream，BufferedOutputStream

在操做磁盤數據的時候，不用一直去訪問磁盤，先將數據放在緩衝區，當數據讀取完以後再一次性將數據寫到硬盤，一次性讀取到內存。

2.數據輸出流，數據輸入流：

DateInputStream，DateOutputStream

輸出內容的時候，無論哪一種數據類型均可以直接調用輸出方法進行輸出，底層就是封裝了getbytes（）。

3.字符輸入流

reader、writer抽象類
以字符爲單位進行數據傳輸,全部在傳輸的過程能夠一次獲取一箇中文
inputstreamreader將字節流轉換爲字符流 outputstreamwriter將字節流轉換成字符進行輸出

4.字符流和字節流的選擇:

在操做內容上,字節流擅長於處理二進制文件或者大型文件;
字符流擅長於處理文本文件(普通文檔,中文),字節流操做中文後可能就沒法讀取到完整的中文.

(6)對象流

對象的序列化和反序列化.
序列化:將對象轉化爲byte序列進行傳輸,

public static void objChange(Student s){
    String objPath = "obj\\student.dat";        
    OutputStream out = null;
    ObjectOutputStream objout = null;
    try {
        out = new FileOutputStream(objPath);
        objout = new ObjectOutputStream(out);   
        //writeObject將對象進行序列化的方法
        objout.writeObject(s);
    }    
    。。。。。。。。。。。。 
}

反序列化:將byte序列轉化爲對象以獲取裏面的內容.

public static void getObj(File f) throws Exception{
    //建立一個讀取流和一個對象讀取流
    FileInputStream in = new FileInputStream(f);
    ObjectInputStream objin = new ObjectInputStream(in);  
    //readObject將文件進行反序列化的方法,獲取到存入其中的對象 
    Object obj = objin.readObject();
    Student stu = (Student)obj; 
    。。。。。。。。。。。。。       
}

序列化流:ObjectOutputStream、ObjectInputStream、
-->writeObject(obj)方法可將傳入的對象轉化成二進制流()，對象必須實現Serializable接口，transient修飾符能夠保護可序列化類中的屬性不被序列化;
-->writeObject(obj)方法能夠讀取文件中的數據,獲取到被序列化後的對象.

11.java圖形界面

(1)awt和swing-->抽象類

在Java中提供了兩套組件用於編寫用戶界面,-->AWT SWING
awt jdk提供的抽象窗口包,用於編寫用戶界面,採用的方法是在某平臺基於底層的一個實現,嚴重依賴於操做系統,運行的外觀取決於操做系統.重量級框架
Swing在awt基礎上開發的新GUI輕量級組件,有純java編寫,不依賴於底層的操做系統,具備很高的可移植性.

JFrame類

容器和組件 用戶界面必須有重量級的容器,swing的輕量級是指容器中的組件 lang.Object -->awt.Component -->awt.Container -->awt.Window -->awt.Frame -->swing.JFrame

(2)awt和swing的架構

Component:屬於容器,全部能夠顯示出來的可見元素均可以稱爲Component
Container:歸屬於Component的一種特殊圖形,但Container自己也是一個容器,能夠容納其餘元素.
Container下面的子類 -->window --pannel
window是能夠獨立顯示出來的,包含各類各樣窗口的,一個獨立的窗口.
Frame:就是咱們平時看到的窗口
JFrame: 屬於swing包的輕量級,其餘的和Frame基本一致
Dialog:彈框,頁面上的提示框、輸入框、確認框等. pannel一個比較小的容器,能夠容納其餘的佈局元素,不能獨立顯示出來,必需要依賴於window.多用於小程序 -->Applet面板,用於分隔容器的空間,以更好的定位.
Jcomponet:Component的子類,屬於swing包.裏面裝的是swing的容器和組件.

(3)容器和組件

容器和組件是組成GUI界面可見或不可見的內容,全部的容器也都是一種組件,兩者的區別在於他們的用途.組件指能夠獨立的可視化控件--按鈕、文本框、密碼框;容器是被設計出來容納其餘容器或組件的模塊.組件要顯示出來就必需要放在容器中.

(4)佈局管理

1.空佈局(絕對佈局):元素的位置能夠更改,默認在左上角,setbounds設置座標和大小;
2.流式佈局:FlowLayout，元素從左到右一行滿了就換一行;
3.BorderLayout邊框佈局,東南西北中五塊;
4.GridLayout:表格佈局,將空間劃分爲規則的矩形網絡,每一個區域的大小都相等;
5.CardLayout:卡片佈局讓幾個組件共享一個顯示空間,這些組件是堆疊起來的,經過卡片提供的一些操做能夠動態切換組件;
6.GridBagLayout:網格佈局

(5)內部類

1.什麼是內部類:

定義在一個類的內部這樣的類叫內部類,包含內部類的類叫外部類.

2.爲何要定義內部類

內部類能夠把內部信息更好的封裝到類的內部,內部類不容許同包中的其餘類訪問;
內部類能夠訪問它所在外部類的全部屬性和方法(包括私有);
內部類實現的功能,外部類也能實現,可是內部類更方便;

3.內部類的分類:

--成員內部類、靜態內部類、方法內部類、匿名內部類.

4.成員內部類

最多見的普通內部類,針對外部類的特殊補充.

public class InnerClass {
    private int num = 10;       
    public class inner{
        public int sum =100;
        public void show(){
            System.out.println(num);
            System.out.println(sum);
        }
    }       
    public static void main(String[] args) {
        InnerClass in = new InnerClass();
        System.out.println(in.num); //能夠訪問   

        //不能夠直接訪問內部類的屬性
        //System.out.println(in.sum);

        //建立內部類實例要經過外部類
        inner in2 = in.new inner();
        in2.show();
    }
}

特色:內部類能夠直接訪問外部類的屬性和方法,外部類不能訪問內部類的數據;
建立內部類對象必須經過 外部類引用.new 內部類
內部類和外部類是連個class文件,若內部類有與外部類相同的方法或屬性,要訪問外部類就必須經過 外部類.this.屬性 (在內部類之中).

5.匿名內部類:

匿名內部類是指沒有名字的內部類,它只能使用一次,一般用來簡化代碼;
使用匿名內部類就必須繼承一個父類或者實現一個接口.

public abstract class InnerClass2 {
    public abstract void play();

    public static void main(String[] args) {
        InnerClass2 in = new InnerClass2(){
            @Override
            public void play() {
                System.out.println("這是匿名內部類");          
            }           
        };
        in.play();
    }
}

(6)事件:

事件源對象 ----> 監聽器對象
在事件源上註冊監聽器,--當某事件發生的時候(event-->封裝了事件的信息,如鼠標座標、事件類型等),該event對象就以參數的形式傳入到監聽器;
事件源:可以建立一個事件並觸發該事件的組件,便是指可以操做的元素(事件類的根類:utile.EvevtObject).
監聽器:可以處理事件源觸發的某事件的對象就是監聽器(用來監控某種行爲的發生並執行相應的代碼). 採用匿名內部類建立監聽器表示當前按鈕擁有的惟一監聽器

12.java數據庫--JDBC

Java DataBase Connectivity

(1)JDBC:

是Java提供的一套操做數據庫的api，定義了一套用來訪問數據庫的標準類庫.
位於java.sql/javax.sql,能夠經過jdbc和各類數據庫創建鏈接.

(2)原理:

1.java api 定義了一系列的規格,提供的是各類接口,須要數據庫廠商來實現;
2.數據庫廠商將實現接口的方法封裝成了jar包,程序若須要訪問相應的數據庫,就必須下載對應的驅動;
3.jdbc也提供了一個驅動管理器,是一個實現類用於加載jdbc驅動的各個類,生成數據庫鏈接,訪問各個數據庫都要用到驅動管理器.

(3)工做原理

應用程序-->Java Api -->驅動管理器-->JDBC驅動-->網絡協議API-->數據庫

(4)JDBC的驅動分類

1.JDBC-ODBC Bridge:移植性差,效率低
2.Native-API partly-Java driver:本地庫Java驅動程序,維護較難
3.是的發送到
4.說得對發 在程序設計中如何選中驅動包:
若程序只會訪問一個數據庫就用第四種,若須要訪問多個數據庫就用第三種,若第四和第三種都不適合就用第二種,第一種基本上不會考慮,由於嚴重依賴於底層Windows系統移植性差效率低.

(5)JDBC--API

Driver接口:是全部jdbc驅動都要實現的一個接口,讓數據庫去實現,在程序中不會直接調用Driver而是要經過DriverManager調用實現; 驅動管理器:DriverManager,用於管理驅動; Connection:用於與特定數據庫創建鏈接; Statement:用於執行靜態的sql語句,經過調用connection提供的方法createStatement()建立該對象;
preparedStatement:預編譯sql語句,也是經過connection對象來建立;
CallableStatement:用於執行數據庫裏面的存儲過程; Resultset:用於接收sql查詢的返回值,並處理返回值;

(6)jdbc鏈接數據庫的步驟:

1.根據訪問的數據庫,加載不一樣的驅動類型;
2.鏈接到數據庫,獲得connection對象;
3.經過connection對象產生Statement(或preparedStatement),執行sql語句;
4.返回結果集,Resultset;
5.灰色資源,關閉鏈接.

(7)Statemen和PreparedStatement

Statement執行的是靜態的sql,每次執行都要編譯一次,可能發生sql注入;
PreparedStatement動態的sql,只編譯一次之後就直接直接調用,不會再編譯,能夠防止sql注入.

(8)架構模式

1.MVC

屬於一種架構理念,在大多數程序語言都有這個模式,並非java特有的.
m(model):模型,用於封裝數據傳遞數據,業務邏輯處理(文件操做);-->javabean
v(view)視圖: 用於數據的顯示和獲取,用戶可見的頁面;-->JFrame/HTML
c(controller)控制器:用於獲取數據併發送給視圖,調用業務方法,可是它不處理業務.-->監聽器

2.三層架構:

什麼是三層架構,爲何要使用三層架構,區分三層架構和兩層架構
什麼是三層架構？ 對系統進行架構的規範,將系統分爲三部分,是設計模式的一種.
在程序中：-->表示層,顯示數據接收數據; -->業務層,用於處理業務邏輯,完成某些既定功能;-->持久層,負責對數據進行一個持久化保存或者從中獲取所需數據.
三層架構就是爲了讓系統分工明確,各司其職,來源於生活.

3.在Java中

表示層(UI層):用於接收和顯示數據(交互界面);
業務層(service):鏈接表示層和持久層,處理業務邏輯(驗證、算法、規則);
數據持久層(數據訪問層):與數據庫或文件交互,實現數據的增刪改查,將數據庫的數據提取出來傳遞給業務層或將業務層數據保存到數據庫.
實體層(域模型層):串聯三層作一個數據的傳遞,是單獨的概念不屬於任何一層(Entity).
1.實現了面向對象的封裝思想;2.貫穿於三層在其中傳遞數據；3.對於初學者,數據庫裏面的一張表中的一行就對應一個實體,在程序中用實體來進行封裝;4.簡化了傳遞數據的方式(如果傳遞的變量太多就能夠封裝成實體bean).

4.開閉原則

開閉原則是面向對象複用設計的模塊,指在程序設計中要對修改進行關閉,對擴展功能進行關閉,擴展功能的前提是不改變原來已有的代碼。-->抽象化設計(抽象層接口)

5.依賴倒轉原則

抽象不該該依賴於細節,便是有個面向接口進行編程而不是實現類.
抽象不該該依賴於細節(子類/實現類);3.細節應該依賴於抽象(父類/接口).
模塊間的依賴是經過抽象發生的,-->接口的引用指向實現類(多態的應用),面向接口編程.
優勢:採用依賴倒轉能夠減小類之間的耦合性(類之間的依賴關係),提升系統的可維護性,減小並行開發的風險.

6.三層架構的優缺點

1.結構清晰,耦合度低了;2.可維護性增長,可擴展性增長;
3.利於開發任務同步進行,適應需求變化;

缺點:下降了系統的性能,分層越多效率越低;增長了代碼量和工做量.

13.多線程編程

(1)進程:

運行程序時首先會將代碼放在方法區,但卻並無立刻執行,但這個時候已經有一個進程在準備了,進程產生後代碼仍是沒有運行,這就是一個進程.
進程是一個靜態的概念,運行中的程序都是一個進程,擁有內存和cpu資源.
咱們常說的進程開始運行,其實是進程裏面的主線程在開始運行了,系統調用main方法，就產生一個主線程,在計算機上運行的其實是線程.

(2)線程

線程實際上就是進程裏面的一段程序,一個進程能夠有多段程序.
線程自己是不佔任何資源的(共享進程的資源).
線程就至關於一個程序裏面不一樣的執行路徑.

(3)線程和進程的區別

每一個進程都有本身獨立的代碼和進程空間,進程間進行切換時,內存開銷比較大;
線程能夠當作是輕量級的進程,同一類線程共享代碼和數據空間,每一個線程有獨立的線程棧和計數器.線程間的切換內存消耗小.
多進程:在操做系統中運行多個任務; 多線程:在同一個應用程序中有多個流程同時執行.

(4)處理器對線程任務的分配:

cpu運行的速度很是快,一秒鐘能夠執行幾億次.CPU將本身的時間分紅了不少小的時間片斷,某一個時間片在執行某線程,下一個時間片又在執行另外一個線程,雖然系統要執行幾十個線程,可是因爲速度很快,感受上就是同時在運行.
什麼纔是真正的多線程:計算機有多個CPU-->雙核/四核.

(5)線程的建立

java.lang.Thread類,用來表示一個線程,建立也是用Thread來進行.
建立線程的兩種方案: 1.寫一個類繼承Thread類,重寫run方法;

class Thread1 extends Thread {
    @Override
    public void run() {  
        //重寫run方法
    }
}

2.寫一個類實現Runnable接口,實現run方法.

public class RunTest {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Thread2(),"1號");
        Thread t2 = new Thread(new Thread2(),"2號");
        Thread t3 = new Thread(new Thread2(),"3號");         
        t1.start();
        t2.start();
        t3.start();
        System.out.println("main執行");
    }
}
class Thread2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"執行:"+i);
        }           
    }
}

一旦執行程序,虛擬機會自動建立一個主線程(main),建立線程的實例就會產生一個線程,當前線程處於就緒狀態,
在運行時處理器經過調用start方法使兩個線程一塊兒運行,由虛擬機經過CPU和線程的優先級等因素,來決定先執行哪一個線程.
Thread類提供了一個靜態方法currentThread().getName(),能夠獲取到當前運行線程的名字.

(6)線程優先級的概念

程序運行的順序並非按照建立線程的順序來執行,而是經過優先級來控制的.
java線程的優先級:java提供了一個線程調度器來監控線程的運行,監控處於就緒狀態的線程.
線程調度器會按照線程的優先級來決定調度哪個線程來執行.
線程優先級是用數字來表示的（1-10）,建立的線程缺省值默認就是5.
優先級的值越大表示優先級越高,main方法的優先級默認也是5.線程運行的順序是有虛擬機來控制的,線程的優先級是相對的.
理論上優先級高的會首先佔據運行的權利,可是實際上獲得的結果並非優先級高就徹底佔據執行的權利,線程運行的順序和環境也是息息相關的.
具備高優先權的線程會分配更多的運行資源.

Thread3 t = new Thread3();
Thread4 t2 = new Thread4();
Thread5 t3 = new Thread5();     
t.start();
t.setPriority(t.MAX_PRIORITY);//設置優先級爲最大值       
t2.start();
t2.setPriority(t2.MIN_PRIORITY);//設置優先級爲最小值 
t3.start();
t3.setPriority(6);//設置優先級爲6

(7)線程的狀態

1.新建狀態:

當線程對象建立後就處於新建狀態-->Thread t = new Thread();

2.就緒狀態-Runnable:

當程序調用start方法,當前線程就處於就緒狀態,可是尚未被執行

3.運行狀態(Running):

當調度器到調用當前線程的時候,線程就進入運行狀態,此時線程才處於運行,就緒狀態是進入運行狀態的惟一途徑;

4.阻塞狀態(Blocked):

處於運行中線程,可能會由於某些因素放棄對CPU的使用,中止運行,這個時候線程就處於阻塞狀態,要回到就緒狀態才能繼續運行;

5.死亡狀態(Dead):

線程執行完畢或者由於某些因素異常退出了,該線程就結束了生命週期,等待被回收.
sleep()讓運行的線程處於阻塞狀態,yield()暫停當前正在執行的線程對象，並執行其餘線程(讓運行的線程回到就緒狀態).
join()讓其餘線程中止運行,等待該線程執行完畢,再運行其餘線程.

(8)多線程的關係圖

1.鎖機制:

當兩個或者兩個以上的線程要同時訪問共享數據的時候,必須確保某一個時間點只能有一個線程進行訪問,這個過程就是同步-->鎖機制.

3.同步塊、同步方法:-->synchronized

處於同步方法或同步塊裏的程序,要進行等待,我就調用wait(),可讓線程處於等待狀態,處於等待的線程讓出CPU的執行權利, 若是沒有設置等待時間,那就只能用notify()或notifyAll進行喚醒(喚醒後進入鎖定狀態).

(9)sleep和wait的區別:

sleep方法來自於Thread類,wait方法來自於object;
調用sleep方法在線程中均可以用,wait就必須在同步方法或同步快中;
sleep不會釋放對象鎖,wait能夠進行解鎖,線程會釋放執行的權利.

14.計算機網絡編程

(1)計算機網絡:

1.網絡的概念

把不一樣地域不一樣計算機與專門的外部設置,用通訊線路進行鏈接,造成一個規模大、功能強大的網絡系統.可讓計算機很是方便的傳遞信息.

2.網絡的主要功能：

資源共享-->
信息的傳遞和處理-->
綜合信息服務-->

(2)網絡通訊協議

1.網絡通訊協議的定義

計算機網絡要實現通訊功能就必需要遵循必定的協議和規範,對傳輸的速率、內容等進行標準的定製.

2.網絡通訊的接口

爲了使兩個節點能進行對話,就必須在它們之間創建一個通訊渠道(接口-->軟件).
接口的目的就是用於數據的交換.
知足兩個條件: 硬件裝置-->實現兩個節點之間的鏈接;
軟件裝置-->按照必定約束條件(通訊協議)進行對話.

3.通訊協議的分層思想:

兩個設備要進行信息傳遞,底層是有不少的協議和規範,須要對這些內容進行分層處理 爲何要分層:
兩個節點之間的聯繫很是複雜,在指定協議的時候,將整個流程分解爲多個步驟,再將各個步驟結合起來.最經常使用的就是分層的思想.
在通訊的過程當中,上一層會調用下一層,每一層都在處理簡單的業務,利於進行維護.

(3)OSI參考模型:

應用層--表示層--會話層--傳輸層--網絡層--數據鏈路層--物理層
每一層都在處理本身的業務
TCP/IP模型:
應用層--應用程序
傳輸層--網絡協議 TCP/UDP
網絡層--IP地址/端口
物理鏈路層--物理介質 網線/光纖/路由器
IP:提供了惟一的IP地址,可以區分每一臺主機.IP協議就位於網絡層,
IP地址一共分爲4段,每一段都是一個字節,每一個網段最大的數字不能超過255.

(4)TCP和UDP

TCP：專門設計用來在因特網上提供可靠的鏈接協議,端到端的字節流通訊協議, 是一種面向鏈接點的協議.
UDP:在發送數據的時候,不須要創建鏈接,封裝了原始IP數據段的方法,不會去管接收方有沒有接收到數據.-- 發送電報。是一種不可靠的協議
區別:TCP提供了三次握手的機會,要發送以前先和對象創建鏈接.
TCP相似於打電話,首先須要撥通對方的電話,等待對方的迴應,繼續發送信息.
是一個安全可靠的協議,可是效率就比較低.
DDP:不可靠的協議,只管發送內容不會創建鏈接,發送的數據就無論後面的內容,可是效率高傳輸速度快.

(5)端口

端口是用來區分一臺計算機上的不一樣應用程序,在計算機內部佔兩個字節,一臺計算機最多有65536個端口.
一個程序能夠佔用多個端口.一旦某個端口被佔用了,另外的程序就不能再使用這個端口.
咱們編寫程序用到的端口必須是1024以上的端口號,1024如下的端口號系統常常調用.

(6)socket編程

通常意義上的網絡編程都是指socket編程(cocket中文釋義爲插座).
若是兩個程序要進行通訊,能夠經過一個雙向鏈路進行鏈接實現數據的交換.雙向鏈路的一端就稱爲socket.
socket是用來實現 clinet(客戶端)------server(服務器) 鏈接.
java.net 裏面提供了兩個類,socket serversocket.用來實現鏈接.
經過socket創建鏈接,必需要指定IP和端口.

1.serversocket服務器端

1.建立一個serversocket對象,綁定監聽端口;
2.用accept方法監聽客戶端的請求;
3.創建鏈接後,經過輸入流讀取到客戶端的信息;
4.經過輸出流往客戶端發送內容;
5.關閉資源。

public static void main(String[] args) {
    ServerSocket ss = null;
    Socket s = null;
    InputStream in = null;
    InputStreamReader re = null;
    BufferedReader buff = null;
    OutputStream out = null;
    PrintWriter pw = null;
    try {
        ss = new ServerSocket(9000);
        while (true) {
            s = ss.accept();

            //接收來自客戶端的信息
            in = s.getInputStream();
            re = new InputStreamReader(in);
            buff = new BufferedReader(re);
            String mesg = null;
            while ((mesg = buff.readLine()) != null) {
                System.out.println("客戶端的消息:" + mesg);
            }
            s.shutdownInput();

            //向客戶端發送消息
            out = s.getOutputStream();
            pw = new PrintWriter(out);
            pw.write("歡迎訪問***服務器");
            pw.flush();
            s.shutdownOutput();
        }

    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (out != null) {
                out.close();
            }
            if (pw != null) {
                pw.close();
            }
            if (in != null) {
                in.close();
            }
            if (re != null) {
                re.close();
            }
            if (buff != null) {
                buff.close();
            }
            if (s != null) {
                s.close();
            }
            if (ss != null) {
                ss.close();
            }
        } catch (Exception e2) {
            e2.printStackTrace();
        }
    }
}

2.客戶端:

1.建立socket,指定服務器的IP和端口;
2.鏈接成功後經過輸出流往服務器傳遞數據;
3.經過輸出流獲取到服務器的信息;
4.關閉相應鏈接。

public static void main(String[] args) {
    try {
        //鏈接到服務器
        Socket s = new Socket("127.0.0.1", 9000);

        //接收來自客戶端的信息
        OutputStream out = s.getOutputStream();
        PrintWriter pw = new PrintWriter(out);
        pw.write("XXX訪問服務器");
        pw.flush();         
        s.shutdownOutput();

        //向客戶端發送消息
        InputStream in = s.getInputStream();
        InputStreamReader re = new InputStreamReader(in);
        BufferedReader buff = new BufferedReader(re);
        String mesg = null;
        while((mesg = buff.readLine()) != null){
            System.out.println("服務器提示:"+mesg);
        }
        s.shutdownInput(); //關閉輸入流

        //關閉相應的鏈接
        in.close();
        re.close();
        buff.close();
        out.close();
        pw.close();
        s.close();

    } catch (UnknownHostException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

15.反射

(1)類和對象的關係

類是對象的抽象,對象是類的實例具現.類體現了面向對象的抽象特徵.
在java在中,靜態變量和變量-->對象. 也提供了包裝類來將基本數據類型轉換成對象.
類產生的實例稱爲對象,可是類它自己也是一個對象. -->public class dog(){ } 是java.lang.class類的實例對象.
getName()-->以 String 的形式返回此 Class 對象所表示的實體（類、接口、數組類、基本類型或 void）名稱.
class類對象只有java虛擬機可以產生,不能直接實例化class.-->類類型(class type),數據類型就是class.
經過類類型產生類的實例:
第一步:Class s1 = Student.class; /Class s2 = s.getClass(); /Class s3 = Class.forNanme("全路徑").
第二步:Student stu = (Student) s1.newInstance();

(2)靜態加載類

編譯時就對當前這個類裏面全部對象進行加載,加載的對象必須存在,而且沒有錯誤.
缺陷:要對整個系統都進行判斷,只要存在 new 關鍵字,都必須建立實例,不能靈活的操做.編譯的效率較低.

(2)動態加載類

編譯時不會加載類,運行時再裝載.
優勢:編譯時不會花不少時間去建立對象,也不會由於對象錯誤而加載失敗,利於程序的擴展,更方便於後期的維護;
缺點:效率較低,每次都要經過路徑去加載類的實例.
類的反射-->動態加載類。

(3)經過類類型獲取到方法和變量的信息

1.獲取到方法信息

public static void getFunMesg(Object o){
    Class c = o.getClass();
    c.getName();
    c.getSimpleName();
    Method [] m = c.getMethods(); //獲取類中的全部public方法
    m = c.getDeclaredMethods();//獲取到該類本身聲明的方法
    for (Method method : m) {
        System.out.print(method.getName());

        //獲取到方法的參數類型
        Class[] para = method.getParameterTypes();
        for (Class class1 : para) {
            System.out.print(class1.getName()+" ");
        }           
        method.getReturnType(); //獲取方法的返回類型
    }
}

2.獲取到變量的信息

public static void getMesg(Object o){
    Class c = o.getClass();     
    Field [] fs = c.getDeclaredFields();
    for (Field f : fs) {
        f.getType(); //獲取變量的類型
        f.getName(); //獲取變量的名字          
        try {
            f.get(o); //獲取到非私有的變量值  

            //設置String類型變量的值
            if (f.getType().toString().contains("String")) {
                f.set(o, "設置變量的值");
            }               
        } catch (Exception e) {
            e.printStackTrace();
        }
    }       
}

16.面向對象的設計原則和模式

(1)理解設計原則

面向對象的設計原則OOPS(面向對象程序設計系統)編程的核心:繼承、封裝、多態、抽象。
設計原則就是追求高類聚、低耦合:
程序設計的時候追求模塊的獨立性,也就是每一個模塊只完成特定的功能,而且與其餘模塊的聯繫最少。若是有接口那也要接口儘可能簡單。

1.耦合性

1.耦合性也稱爲塊間的聯繫,指的是軟件系統中,各模塊之間的聯繫緊密度。模塊間聯繫越多耦合性越強,聯繫越少耦合性越弱。模塊的耦合性多少取決於接口的複雜程度,調用方法、傳遞參數的多少。

2.類聚度:

類聚度又稱爲塊內的聯繫,是模塊功能強度的一個度量。即一個模塊內部內部各個元素之間彼此結合的緊密度。
一個模塊內各個元素包含語句、方法變量,其聯繫越緊密則它的類聚度就越高。

(2)常見的設計原則:

單一原則、里氏替換原則、開閉原則、依賴倒轉、迪米特法則、合成/複用原則、接口隔離原則。代碼複用

1.單一原則:

就一個類而言,應該僅有一個引發它變化的緣由。一個類要單純,只完成本身特定的功能。
例如:Student類中的T一、T2兩個模塊,若修改了T1就會影響到T2，可能會讓本來正常運行的功能發生錯誤。
解決方案:遵循單一原則,分別創建兩個類各自完成T1和T2的功能,這樣的話當擴展T1模塊時就不會影響T2模塊。
若一個類的功能太多了,可能致使影響到其餘功能。

2.里氏替換原則:

子類必須可以替代它的父類,也能夠說子類能夠擴展父類沒有的功能,但卻不能改變父類的功能。
這個原則是開閉原則的基礎,有了此原則才能存在繼承的設計理念,從而實現功能的擴展。

3.開閉原則:

軟件實體(類、方法、函數)應該能夠擴展,可是不能修改。
來源:在軟件的發展週期中,由於功能變化或升級會致使業務愈來愈多、愈來愈複雜,在維護程序的時候,
可能改變原來的舊代碼,可能使得須要對整個程序的架構進行重構,重構以後還需再次測試。
解決方法:當軟件須要改變的時候,咱們只是對程序進行擴展,而不該該對已經存在的代碼進行修改。

4.依賴倒轉原則:

1.高層模塊不該該依賴於低層模塊,都應該依賴於抽象;
2.抽象不該該依賴於細節,細節應該依賴於抽象。
高層模塊實際上就是調用端,低層模塊指的是具體的操做類。
抽象指的是抽象類或接口,都不能直接被實例化;細節指的是具體的實現類,能夠直接被實例化。
依賴倒轉的核心就是進行面向 接口/抽象類編程。

public interface IVideo {
    public void run();
}   
public class VideoPlayer {  
    //視頻播放器程序
    public void play(IVideo v){
        v.run();
    }
}
 public class VideoAVI implements IVideo{
    @Override
    public void run(){
        System.out.println("播放avi視頻");
    }
}  
public class VideoMP4 implements IVideo{
    @Override
    public void run(){
        System.out.println("播放MP4視頻");
    }
}
public class VideoWMV implements IVideo{
    @Override
    public void run() {
        System.out.println("播放WMV視屏");      
    }
}
//程序執行入口
public static void main(String[] args) {
    VideoPlayer p = new VideoPlayer();
    VideoMP4 mp = new VideoMP4(); //接口的引用指向實現類的實例
    p.play(mp);     
    IVideo vi = new VideoAVI(); //接口的引用指向實現類的實例
    p.play(vi);     
    IVideo wmv = new VideoWMV(); //接口的引用指向實現類的實例
    p.play(wmv);        
}

5.合成/聚合複用的原則:

儘可能使用合成、組合,避免使用繼承。
由來:類和類之間的關係越緊密,耦合度越高,當其中一個發生變化,會影響到另外一個。
用到了繼承以後,兩個類之間的耦合度就很高。
在設計dao層的時候,工具包儘可能選擇用靜態方法和靜態屬性,避免用繼承的方式去實現功能。

6.接口隔離原則:

接口隔離指的是,若一個類不須要接口就儘可能不去實現接口。
接口的功能一個單一,不該該太複雜。
緣由:一個接口包含多個功能,而實現類只須要其中的某一個功能。
接口必定要設計好,由於如果某個類實現了接口,那就必須實現裏面的全部方法。

7.迪米特法則:

若兩個類彼此之間不直接通訊,則這兩個類就不該該發生直接關係。若是類須要和另外一個類創建關係,應該經過第三方紐帶來聯繫。
不要和陌生程序發生聯繫。

public class subComp {
    public List<SubEmp> getAllEmp(){
        List<SubEmp> subEmpList = new ArrayList<SubEmp>();      
        for (int i = 0; i < 10; i++) {
            subEmpList.add(new subEmp("子公司員工"+(i+1)));
        }           
        return subEmpList;
    }       
    public void printEmp(){
        List<SubEmp> subList = getAllEmp();
        for (SubEmp subemp : subList) {
            System.out.println(subemp.getId());
        }
    }
}  
public class headComp {
    public List<Emp> getAllEmp(){
        List<Emp> empList = new ArrayList<Emp>();           
        for (int i = 0; i < 10; i++) {
            empList.add(new Emp("總公司員工"+(i+1)));
        }   
        return empList;
    }               
    public void printEmp(subComp sub){
        //獲得子公司的員工數據,是經過子公司獲取,而不是在總公司中直接獲取
        sub.printEmp();
        //總公司的員工數據,在本類中直接獲取
        List<Emp> empList = getAllEmp();
        for (Emp emp : empList) {
            System.out.println(emp.getId());
        }
    }
}

(3)設計模式 -->代碼結構

設計模式就是一套被反覆使用的,被不少人所知道的,多代碼進行分類,對架構進行總結的一些經驗總結。
爲何使用? -->使用設計模式能夠重用代碼,讓代碼更利於被人理解,保證了程序的可靠性。
工廠模式、單例模式、代理模式、裝飾器模式、適配器模式、觀察者模式。

1.單例模式:

什麼是單例模式? -->某個類只有一個實例,只產生一個對象;這些類能夠本身實例化;這個了對整個系統來講是可見的。
怎麼實現單例模式? 餓漢式/懶漢式
1.設置構造器爲私有的(private);
2.產生一個實例對象,並設置其屬性爲靜態;
3.建立一個公共的靜態方法。

a.餓漢模式:

優勢:寫起來簡單,不存在多線程同步的問題,線程安全,效率比較低。
缺點在於:當類被加載時就初始化靜態變量,建立並在內存中分配空間,在該類被卸載前都會一直消耗這塊內存,不利於系統優化。

public class Singletion {       
    private Singletion(){           
    }       
    private static final Singletion s = new Singletion;

    public static Singletion getSingletion(){
        return s;
    }
}

b.懶漢模式

優勢:寫起來簡單,加載類的時候不會建立實例,也就不會佔用內存的靜態空間,在調用的時候才建立並分配內存;
缺點:併發環境下(多線程),可能會產生多個實例,線程不安全,效率較高。
若要保證線程安全能夠給方法加同步鎖。

public class Singletion {       
    private Singletion(){           
    }       
    private static Singletion s;        

    public static Singletion getSingletion(){
        if (s == null) {
            //使用同步塊,在建立對象的時候,只有一個線程可以操做
            synchronized (Singletion.class) {
                s = new Singletion();
            }
        }
        return s;
    }
}

2.工廠模式

工廠模式就是將大量的有共同接口的類進行實例化的一種設計模式。 生成大量有共同接口的對象,要產生對象的時候,只須要下達命令,不須要知道工廠是如何建立的類。