JavaSe基礎回顧（一）

JavaSe基礎知識點總結

1、變量

變量是內存中用來存放特定數據類型數據的一塊內存空間,它的值是能夠改變的。Java中的變量有四個基本屬性：變量名，數據類型，存儲單元和變量值
變量名：合法的標識符

變量的數據類型：能夠是基本類型和引用類型（必須包含類型）

存儲單元：存儲單元大小是由數據類型決定的，如：int 爲4個字節32位
變量值：在存儲單元中存放的值
變量的聲明格式：
類型 變量名；

2、運算符

運算符種類                       符號

賦值運算符                       =、 +=、 -=、 *=、 /=、 %=

算術運算符                       ++、--、+、-、*、/、%

                                                ++自增 --自減 注意前置和後置

關係(比較)運算符           > 、 < 、 >= 、 <=、 ==、 !=  

邏輯運算符                       &&（且）有短路功能、||（或）有短路功能、！（非）、&（且）                                                   沒有短路功能、|（或）

真 && 真 && 假  假

假 && 真 && 真  假

test（）& my（）

    三目運算符                       a?b:c

                                                         條件判斷 ？語句1：語句2

                                                         若是條件爲真返回1，條件爲假返回2

3、數據類型

Java 總共有兩種數據類型， 主要有基本類型和引用類型， 基本類型有 8 種， 引用數據類型有3 種
<1> 基本數據類型（系統預先定義好的，拿來就用）
數值類型
整數型(byte,short,int,long)
浮點型(float,double)
字符類型(char)
布爾類型(boolean,只能取值 true 和 false)
<2> 引用數據類型（須要咱們本身去定義的）
數組、類、接口

4、java中的方法

語句的集合就是方法

方法定義包括方法頭和方法體。

方法頭：

修飾符 返回值類型 方法名稱（參數）

方法體：{ }之中的內容

5、遞歸調用

遞歸就是方法本身調用本身

遞歸也是一種重複運算

能夠遞歸的問題判斷：能夠劃分爲一個或多個子問題，而處理子問題的規則與處理原問題的規則是同樣的。

遞歸須要知足兩個條件纔會使用

1-       有反覆執行的過程（調用自身）

2-       有跳出反覆執行的條件（遞歸出口）

遞歸算法設計時，須要首先考慮如下兩個問題：

1-       肯定遞歸公式。把規模大的、較難解決的問題變成規模較小、易解決的具備重複性同一問題，這是遞歸問題的難點。

2-       肯定邊界（終了）條件。在什麼狀況下須要中止遞歸？就是問題的邊界條件及邊界值的肯定。

         遞歸的效率要低於普通循環，因此設計程序的時候優先考慮使用循環結構，實在沒有更好的辦法時再使用遞歸

6、Scanner類的用法

從鍵盤輸入信息並保存須要以下幾步：

第一步： 在程序開頭輸入

「import java.util.Scanner;」

表示導入鍵盤輸入功能，系統已經寫好了，只須要拿到程序中使用就能夠了；

第二步： 在程序執行體中輸入：

「Scanner input =new Scanner(System.in);」；

第三步：

表示輸入功能初始化，

若是要接受一個整型的數據就要定義一個整型的變量來接收，

如：

「int num1=input.nextInt();」，

若是是其餘類型的變量， 則「=input.next***();」中的***也要改爲相應的類型， 如

七、    import java.util.Scanner;

八、   

九、    import javax.print.DocFlavor.INPUT_STREAM;

十、    public class JieChen {

十一、        static Scanner input =new Scanner(System.in);   

十二、        public static void main(String[] args) {

1三、            // TODO Auto-generated method stub

1四、            int num1=input.nextInt();

1五、            System.out.println(num1);

1六、        }

1七、        public static int jieChen(int x) {

1八、            int sum;

1九、            if (0==x) {

20、                return 1;

2一、            }

2二、            sum = x*jieChen(x-1);       

2三、            return sum;

2四、        }

2五、          }

7、Java的變量類型（定義變量的位置）

類變量：獨立於方法以外的變量，用 static 修飾。做用範圍是整個類

實例變量：獨立於方法以外的變量，不過沒有 static 修飾。做用範圍是實例化後的對象

局部變量：類的方法中的變量。使用前必須初始化  做用範圍是方法內

8、Java修飾符

1-    訪問控制修飾符

public （公有的）對全部的類均可見，使用位置：變量 方法 類 接口

protected（受保護的）對同一包內的類和全部子類可見 使用位置：變量 方法 內部類

default（默認的）在同一包內可見，不用寫修飾符，使用位置：變量 方法 類 接口

private（私有的）只在同一類可見，使用位置：變量 方法 內部類

 

修飾符	當前類	同包內	子孫類	其餘包
public	是	是	是	是
protected	是	是	是	否
default	是	是	否	否
private	是	否	否	否

 

2-    非訪問控制修飾符

static 靜態的 使用位置：變量 方法

聲明靜態變量 靜態變量也叫類變量 局部變量不能聲明爲static變量

類中全部的對象均可以使用，而且只有一份

靜態方法 靜態方法不能使用非靜態變量

final  常態的

final變量 也就是常量 只能初始化一次，以後值不能被改變

final常和static搭配來聲明類的常量

final方法 主要目的是防止方法的內容被修改（子類繼承）

final類 不能被繼承的類

abstract 抽象的

9、基本數據類型間的轉換

Boolean型不能和其餘的基本類型相互轉換

 

byte  char  short  int  long  float  double

 1     2     2    4    8     4     8

10、面向對象三大特性（若是非要說四大特性，就加上抽象）

1-    封裝

表現： 函數就是一個最基本的封裝體， 類也是一個封裝體。
特色： 隱藏屬性， 提供對外訪問的方法
好處：

一、 提升了代碼的複用性；
二、 隱藏了實現細節， 但能夠對外提供可訪問的方法；
三、 提升了安全性.

2-    繼承

定義： 繼承表示存在於面向對象程序中的兩個類之間的一種關係.當一個類自動擁有另外一個類的全部屬性（ 域和方法） 時， 就稱這兩個類之間具備繼承關係。 被繼承的類稱爲父類（ 或超類） ， 繼承了父類的類被稱爲子類。
父類與子類之間的關係：
  1.共享性 即子類能夠共享父類的域和方法。
  2.差別性 即子類和父類必定存在某些差別。
  3.層次性 即由java規定的單繼承性，每一個類都處於繼承關係中的某一個層面
繼承的主要優勢：
  1.程序結構清晰
  2.編程量少
  3.易於修改和維護

3-    多態

概念： 對象的多種形態
1.引用多態
父類的引用能夠指向本類對象
父類的引用能夠指向子類的對象
2.方法多態
建立本類對象時， 調用的方法爲本類方法
建立子類對象時， 調用的方法爲子類重寫或繼承的方法

 

11、類和對象

類是對具備共性事物的抽象描述，是在概念上的一個描述.

對象就是用來描述客觀事物的一個實體，有一組屬性和方法構成。

Object-orientated

1.  1.    對象

客觀世界中任何一個具體事物均可以當作一個對象，對象可大可小，能夠是一個天然物體，也能夠是一種邏輯結構  有針對性

舉例：如今講課的這張桌子，房子、門外停的那輛車、票子

  1- 屬性：對象的靜態特徵  成員變量

  2- 行爲：對象的動態特徵  方法

1.  2.    封裝和信息隱蔽

封裝是將有關代碼封裝在一個對象中，造成一個基本單位，使各個對象之間相對獨立，互不干擾

對象中的某些部分對外隱蔽，留下少許接口，與外界聯繫，這樣有利於數據安全

1.  3.    抽象

抽象的過程，是將有關事物的共性概括、集中的過程

抽象的做用就是來表示同一類事物的本質

1.  4.    繼承與重用

已經創建了一個A類，又想創建一個B類，B類基本上與A相同，只是在A的基礎上加了一些屬性和行爲，咱們就沒有必要從新創建一個B類，使之繼承A類便可

  若是B繼承於A  A叫作B的超類（父類） B叫作A的子類（派生類）

12、class和public class

在一個*.java的文件中，只能有一個public class的聲明，可是容許有多個class的聲明

被public修飾的類，類名必須和文件名相同

13、package和import

在類中定義包名的語法以下：

package 包名；用來講明當前的文件在哪一個包中  

import關鍵字導入包的語法以下：

import com.xxx.*;

在使用import關鍵字時，能夠指定類的完整描述，若是爲了使用包中更多的類，能夠在使用import關鍵字指定時在包指定後加上*,這表示能夠在程序中使用包中的全部類（不包括子目錄中的類）。

14、繼承和構造方法

每一個類都有構造方法，在沒有顯示定義構造方法時，java編譯器會有一個默認的構造方法，這個構造方法什麼也不作

建立對象時，至少會調用一個構造方法

構造方法的名稱和類同名，而且沒有返回值（這裏是真正的沒有返回值，並非void）

一個類能夠有多個構造方法，根據使用參數不一樣，選擇性調用

15、方法的重載（overload）

方法有相同的名稱，可是參數列表不相同的情形，重載出如今同一個類中

返回值能夠不一樣，可是不能做爲重載的判斷

咱們在使用方法的時候，必定要注意參數的數量及類型順序

方法重載是讓類以統一的方式處理不一樣類型數據的一種手段。Java構造方法的重載就是在類中能夠建立多個構造方法，但具備不一樣的參數列表(這一點和普通方法的重載是同樣的)。調用時經過傳遞參數的不一樣來決定具體使用哪一個構造方法

16、方法的重寫（override）

子類對父類的方法做必定的修改，這就須要採用方法的重寫。方法重寫又稱方法覆蓋。

若是在子類有和父類相同（這裏指方法名和參數以及返回值都相同）的方法，子類的這個方法叫方法重寫

注意：

1-    若是要構成方法的重寫,返回值、方法名、參數列表要相同

2-    修飾符的訪問範圍不能小於父類

3-    子類的方法不能拋出比父類更多(或更高)的異常

4-    靜態的方法不存在重寫,可是能夠繼承。

 

     1、方法重寫(0veriding)

在Java程序中，類的繼承關係能夠產生一個子類，子類繼承父類，它具有了父類全部的特徵，繼承了父類全部的方法和變量。

子類能夠定義新的特徵，當子類須要修改父類的一些方法進行擴展，增大功能，程序設計者經常把這樣的一種操做方法稱爲重寫，也叫稱爲覆寫或覆蓋。

重寫體現了Java優越性，重寫是創建在繼承關係上，它使語言結構更加豐富。在Java中的繼承中，子類既能夠隱藏和訪問父類的方法，也能夠覆蓋繼承父類的方法。

在Java中覆蓋繼承父類的方法就是經過方法的重寫來實現的。所謂方法的重寫是指子類中的方法與父類中繼承的方法有徹底相同的返回值類型、方法名、參數個數以及參數類型。

這樣，就能夠實現對父類方法的覆蓋。若是子類將父類中的方法重寫了，調用的時候確定是調用被重寫過的方法，那麼若是如今必定要調用父類中的方法該怎麼辦呢?

此時，經過使用super關鍵就能夠實現這個功能，super關鍵字能夠從子類訪問父類中的內容，若是要訪問被重寫過的方法，使用「super.方法名(參數列表)」的形式調用。

若是要使用super關鍵字不必定非要在方法重寫以後使用，也能夠明確地表示某個方法是從父類中繼承而來的。使用super只是更加明確的說，要從父類中查找，就不在子類查找了。

 

2、重寫規則
在重寫方法時，須要遵循如下的規則： 
(一) 父類方法的參數列表必須徹底與被子類重寫的方法的參數列表相同，不然不能稱其爲重寫而是重載。
(二) 父類的返回類型必須與被子類重寫的方法返回類型相同，不然不能稱其爲重寫而是重載。.. 
(三) Java中規定，被子類重寫的方法不能擁有比父類方法更加嚴格的訪問權限。編寫過Java程序的人就知道，

父類中的方法並非在任何狀況下均可以重寫的，當父類中方法的訪問權限修飾符爲private時，該方法只能被本身的類訪問，

不能被外部的類訪問，在子類是不能被重寫的。若是定義父類的方法爲public，在子類定義爲private，程序運行時就會報錯。

(四) 因爲父類的訪問權限修飾符的限制必定要大於被子類重寫方法的訪問權限修飾符，而private權限最小。

因此若是某一個方法在父類中的訪問權限是private，那麼就不能在子類中對其進行重寫。若是從新定義，也只是定義了一個新的方法，不會達到重寫的效果。
(五) 在繼承過程當中若是父類當中的方法拋出異常，那麼在子類中重寫父類的該方法時，也要拋出異常，

並且拋出的異常不能多於父類中拋出的異常(能夠等於父類中拋出的異常)。換句話說，重寫方法必定不能拋出新的檢查異常，

或者比被重寫方法聲明更加寬泛的檢查型異常。例如，父類的一個方法申明瞭一個檢查異常IOException，在重寫這個方法時就不能拋出Exception，

只能拋出IOException的子類異常，能夠拋出非檢查異常。一樣的道理，若是子類中建立了一個成員變量，

而該變量和父類中的一個變量名稱相同，稱做變量重寫或屬性覆蓋。可是此概念通常不多有人去研究它，由於意義不大。

 

3、方法重載(Overloading)

方法重載是讓類以統一的方式處理不一樣類型數據的一種手段。調用方法時經過傳遞給它們的不一樣個數和類型的參數來決定具體使用哪一個方法，這就是多態性。
所謂方法重載是指在一個類中，多個方法的方法名相同，可是參數列表不一樣。參數列表不一樣指的是參數個數、參數類型或者參數的順序不一樣。

方法的重載在實際應用中也會常常用到。不只是通常的方法，構造方法也能夠重載。

在方法重載時，方法之間須要存在必定的聯繫，由於這樣能夠提升程序的可讀性，通常只重載功能類似的方法。

重載是指咱們能夠定義一些名稱相同的方法，經過定義不一樣的參數來區分這些方法，而後再調用時，Java虛擬機就會根據不一樣的參數列表來選擇合適的方法執行

。也就是說，當一個重載方法被調用時，Java用參數的類型或個數來決定實際調用的重載方法。所以，每一個重載方法的參數的類型或個數必須是不一樣。

雖然每一個重載方法能夠有不一樣的返回類型，但返回類型並不足以區分所使用的是哪一個方法。

當Java調用一個重載方法是，參數與調用參數匹配的方法被執行。在使用重載要注意如下的幾點:
1.在使用重載時只能經過不一樣的參數列表，必須具備不一樣的參數列表。

2.不能經過訪問權限、返回類型、拋出的異常進行重載。
3.方法的異常類型和數目不會對重載形成影響。
4.能夠有不一樣的返回類型，只要參數列表不一樣就能夠了。
5.能夠有不一樣的訪問修飾符。

6.能夠拋出不一樣的異常。

 

4、方法重寫與方法重載的區別

 

17、this關鍵字

this關鍵字的使用：this表明當前類的對象。哪一個對象調用了this所屬的方法，這個this就表明哪一個對象。

經過this顯式的去使用當前對象的成員(屬性、方法)若是須要在一個構造方法中調用另一個構造方法來初始化信息可使用this

this平時是隱式調用，也能夠顯式的調用

this能用在哪些地方？

1-this能夠用在成員方法中（訪問當前對象的屬性， 調用當前對象的方法）

2-this能夠用在構造方法中，語法：

this（實參） ；

目的： 代碼重用

注意:經過this去調用構造方法時必須是在第一行

構造方法不能夠主動調用

 

18、super關鍵字

在對象的內部能夠表明父類對象

1.能夠用super調用父類方法

super.方法名（ ） ;

2.能夠用super調用父類屬性

super.屬性;

 

子類的構造方法中必定會去調用其父類的構造方法

若是未顯式調用，則默認調用父類無參構造

若是顯式調用，則super（）必須位於第一行

若是未顯示而父類沒有無參構造則程序報錯

19、static關鍵字

概念： static是一個修飾符,用來修飾類的成員(包括了屬性、 方法)

static關鍵字的使用:

特色： 在類加載時就加載(運行、 初始化)靜態初始化優於對象的

靜態的成員(屬性和方法)能夠經過 類名.操做符直接訪問

注意：

只有在全部對象都是同一個屬性值的時候咱們才建議到屬性上用static修飾

在static的方法或者語句塊中不能使用this、 super關鍵字

在static的方法或者語句塊中不能使用非static的成員(屬性、 方法)

在非static的方法或者語句塊中可使用static的成員(屬性和方法)也可使用非static的成員

 

代碼塊的區別

1-    普通代碼塊  方法或語句中出現的{ }

2-    構造代碼塊  類中出現且沒有static修飾的{ }

3-    靜態代碼塊  類中出現被static修飾的{ }

靜態代碼塊只執行一次

執行順序：

靜態→main方法→構造代碼塊→構造方法

20、final關鍵字

使用final關鍵字作標識有「最終」的含義

final能夠修飾類，方法和變量：

1.final修飾類，則該類不容許被繼承

2.final修飾方法，則該方法不容許被重寫

    3.final修飾變量，則該變量的值只能賦一次，即變爲常量

遇到不想被改變的時候就加final

21、Object類，toString，equals方法的重寫

Object類的介紹：Object在Java中被定義爲一個頂級父類，它是任何類的父類，咱們能夠顯式的繼承也能夠隱式繼承。

Object類經常使用方法的使用：

        1-toString方法：toString 方法會返回一個「以文本方式表示」此對象的字符串。結果應是一個簡明易於讀懂的信息表達式。建議全部子類都重寫此方法。

2-equals方法： Object類的equals方法默認比較的是對象的引用是否指向同一個內存地址，若是須要判斷自定義類型對象內容是否相等，則須要重寫equals方法(字符串重寫了equals方法)

重寫equals方法必須保證以下特性：

1. 自反性：若是傳入一個非空的引用a  a. equals（a）返回true
2. 對稱性：若是傳入兩個非空引用a，b  a. equals（b）返回true當且僅當b. equals（a）返回true
3. 傳遞性：a. equals（b）返回true，b. equals（c）返回true，那麼就有a. equals（c）也返回true
4. 一致性：不論調用多少次，結果要保持一致   屢次比較中間咱們沒有修改過兩個引用的信息

3-==： 比較的是值是否相同若是相同返回true,不然返回false若是是引用數據類型變量比較的是地址值(地址值相等返回true， 不然返回false)

22、抽象類

在瞭解抽象類以前，先來了解一下抽象方法。抽象方法是一種特殊的方法：它只有聲明，而沒有具體的實現。抽象方法的聲明格式爲：

abstract void methodName();

抽象方法必須用abstract關鍵字進行修飾。若是一個類含有抽象方法，則稱這個類爲抽象類，抽象類必須在類前用abstract關鍵字修飾。不能用抽象類建立對象。緣由？：抽象類不象具體類那樣描述一類具體事物，它是提取多種具備類似性的具體事物的共同特徵而產生的，好比，helicoptor, jet, fighter父類plane，有start(),takeOff(),speedUp(),changeDirection()等方法，這是共性，但現實中有一個具體的plane嗎？沒有，它是抽象出來的，根本不存在。因此實例化一個plane是沒有意義的，所以面向對象程序設計機制禁止對象實例化，抽象類能夠聲明對象，可是不能使用自身的構造方法建立對象，可是可使用子類的構造方法進行建立。
public abstract class A{ }
public class B extends A{ }
A a = new B();

 

定義：包含抽象方法的類稱爲抽象類。抽象類是專門用來繼承的

抽象類和普通類的主要有三點區別：

1） 抽象方法必須爲public或者protected（ 由於若是爲private， 則不能被子類繼承， 子類便沒法實現該方法），缺省狀況下默認爲public。

2） 抽象類不能用來建立對象；====》禁止對象實例化

3） 若是一個類繼承於一個抽象類，則子類必須實現父類的抽象方法。若是子類沒有實現父類的抽象方法，則必須將子類也定義爲abstract類。

在其餘方面，抽象類和普通的類並無區別

23、接口interface

       抽象類型，是抽象方法的集合，接口一般以interface來聲明。一個類經過繼承接口的方式，從而來繼承接口的抽象方法。類繼承接口的時候咱們叫作實現 一個類實現了某個接口

接口並非類，編寫接口的方式和類很類似，可是它們屬於不一樣的概念。類描述對象的屬性和方法。接口則包含類要實現的方法。

1-    接口與類類似點：

1. 一個接口能夠有多個方法
2. 接口文件也是寫在.java文件中，文件名和接口名統一
3. 編譯後的接口也是.class文件
4. 接口的目錄結構與類相同

2-    接口與類的區別：

1-    接口不能實例化對象

2-    接口沒有構造方法

3-    接口裏的方法都是抽象方法

4-    接口不能包含除static和final的成員變量

5-    接口不能被類繼承，是被類實現的

6-    類只能單繼承，接口支持多繼承

3-    接口特性

接口中的方法都會隱式指定爲public abstract

接口中的變量都會隱式指定爲public static final

接口中的方法不能在接口中實現 就是說不能有定義（方法體）

4-    抽象類和接口的區別

1-    抽象類的方法能夠有方法體，但接口不能

2-    抽象類中的成員能夠是各類類型的，接口只能是public static final

3-    接口中不能含有靜態代碼塊以及靜態方法 抽象類能夠有

4-    一個類只能繼承一個抽象類，但能夠實現多個接口

      

 

24、多態

多態存在的必要條件：

1-     繼承

2-    重寫

3-    父類引用指向子類對象 

25、內部類

class 類名{

    class 成員內部類名稱 {

    }

    static class 靜態內部類名稱 {

    }

 

    public static void main(String[] args) {

           class 局部內部類 {

           }

           new 類名稱() {

           匿名內部類 ...

           }

    }

}

1-    概念

將一個類定義在另外一個類裏面，對裏面那個類就稱爲內部類（內置類，嵌套類）

訪問特色：

內部類能夠直接訪問外部類中的成員，包括私有成員。

而外部類要訪問內部類中的成員必需要創建內部類的對象。

內部類做用：

1） 內部類提供了更好的封裝，能夠把內部類隱藏在外部類以內，不容許同一個包中的其餘類訪問該類

2） 內部類成員能夠直接訪問外部類的私有數據，由於內部類被當成其外部類成員，同一個類的成員之間能夠互相訪問。但外部類不能訪問內部類的實現細節。

3） 匿名內部類適用於建立那些僅須要一次使用的類。

4） 內部類比外部類能夠多使用三個修飾符：private、protected、static——外部類不可使用這三個修飾符。

5） 非靜態內部類不能擁有靜態成員。

2-    成員內部類

位置：成員內部類沒有用static修飾且定義在在外部類類體中

1-    成員內部類中的方法能夠直接使用外部類的實例變量和實例方法

2-    在成員內部類中能夠直接用內部類建立對象

內部類擁有和外部類相同的成員或方法的時候，默認狀況下會訪問內部類的成員，若是要在內部類中訪問外部類的同名成員，須要下面這種形式：

外部類.this.成員變量

外部類.this.成員方法

外部類若是要訪問內部類的成員，必須先實例化一個內部類的對象

 

3-    局部內部類

位置：在方法體或語句塊（包括方法、構造方法、局部塊或靜態初始化塊）內部定義的類稱爲局部內部類。

局部內部類不能加任何訪問修飾符，由於它只對局部塊有效。

1） 局部內部類只在方法體中有效，就像定義的局部變量同樣，在定義的方法體外不能建立局部內部類的對象

2） 在方法內部定義類時，應注意如下問題：

1.方法定義局部內部類同方法定義局部變量同樣，不能使用private、protected、public等訪問修飾說明符修飾，也不能使用static修飾，但可使用final和abstract修飾

2.方法中的內部類能夠訪問外部類成員。對於方法的參數和局部變量，必須有final修飾才能夠訪問。

3.static方法中定義的內部類能夠訪問外部類定義的static成員

4-    匿名內部類

內部類的一種簡化寫法，能夠調用其中的方法等等，可是沒法有實例化對象。而且匿名內部類必須是繼承或者實現一個外部類或者接口。

因爲匿名內部類沒有名稱，因此類體中不能定義構造方法，因爲不知道類名也不能使用關鍵字來建立該類的實例

5-    靜態內部類

與類的其餘成員類似，能夠用static修飾內部類，這樣的類稱爲靜態內部類。靜態內部類與靜態內部方法類似，只能訪問外部類的static成員，不能直接訪問外部類的實例變量，與實例方法，     只有經過對象引用才能訪問。

26、數組

1-    一維數組

聲明數組：

數據類型[ ] 數組名；

數據類型 數組名[]; //和上面效果同樣，可是不推薦，這是保留C/C++的寫法，目的                               是爲了讓C/C++程序員快速理解JAVA語言

 

2-    二維數組（多維數組）

3-    數組的處理

最經常使用的處理方式就是利用循環

foreach

數組的使用

1-    數組做爲函數的參數  直接傳入同類型的數組名

2-    數組做爲函數返回值  須要返回的是數組的地址或者引用

4-    Arrays類

 

 

 

數組

1-    數組排序

正序和倒序

冒泡排序  選擇排序

2-    數組搜索

二分查找（折半查找）

3-    Arrays工具類

對數組直接操做

Arrys.相關方法名稱（參數）；

binarySearch  二分查找

equals            判斷值是否相等

fill                   範圍填充

sort                升序排列

 

 

 

 

 

 

 

 

 

27、經常使用工具類String

1-    String類

2-    String類（字符串類）並非基本數據類型（自定義數據類型）

ps：打上刪除線的方法是新版本不推薦的方法

String類的構造方法有11種

 

 

StringBuffer和StringBuilder

當對字符串進行修改的時候，須要使用StringBuffer和StringBuilder類。和String類不一樣的是，StringBuffer和StringBuilder類的對象可以被屢次的修改，而且不產生新的未使用對象。

StringBuilder類在Java 5中被提出，它和StringBuffer之間的最大不一樣在於StringBuilder的方法不是線程安全的（不能同步訪問）。

因爲StringBuilder相較於StringBuffer有速度優點，因此多數狀況下建議使用StringBuilder類。然而在應用程序要求線程安全的狀況下，則必須使用StringBuffer類。

StringBuffer的主要方法：

 

 

3-    基本類型對應包裝類

 

包裝類主要提供了兩大類方法：

1. 將本類型和其餘基本類型進行轉換的方法

2. 將字符串和本類型及包裝類互相轉換的方法

基本類型轉換爲字符串有三種方法：

1. 使用包裝類的 toString() 方法

2. 使用String類的 valueOf() 方法

3. 用一個空字符串加上基本類型， 獲得的就是基本類型數據對應的字符串

4-    日期類

date類

在程序開發中，常常須要處理日期和時間的相關數據，此時咱們可使用java.util包中的Date類。這個類最主要的做用就是獲取當前時間，咱們來看下Date類的使用：

Calendar類

Calendar類是一個抽象類，在實際使用時實現特定的子類的對象。因爲Calendar類是抽象類，且Calendar類的構造方法是protected的，因此沒法使用Calendar類的構造方法來建立對象，API中提供了getInstance方法用來建立對象。

a、 建立一個表明系統當前日期的Calendar對象

Calendar c = Calendar.getInstance();//默認是當前日期

b、 建立一個指定日期的Calendar對象

使用Calendar類表明特定的時間，須要首先建立一個Calendar的對象，而後再設定該對象中的年月日參數來完成。

//建立一個表明2013年5月5日的Calendar對象

Calendar c1 = Calendar.getInstance();

c1.set(2013, 5, 5);

simpleDateFormat類

SimpleDateFormat 是一個以與語言環境相關的方式來格式化和分析日期的具體類。 它容許進行格式化（日期->文本）、分析（文本->日期）和規範化。

因此本類能夠實現： String 到 Date Date到String的互轉

5-    Math類

Java 的 Math 包含了用於執行基本數學運算的屬性和方法，如初等指數、對數、平方根和三角函數。

Math 的方法都被定義爲 static 形式，經過 Math 類能夠在主函數中直接調用。

loge

SimpleDateFormat格式字符串規定

 

28、異常

1-    什麼是異常

是程序中的一些錯誤

異常  錯誤（error）和異常（exception）兩類

按定義分：

系統定義的異常

用戶自定義異常

按處理方式劃分：

運行時異常

非運行時異常（編譯時異常）

2-    java中異常的層次結構

 

3-    異常中使用的關鍵字

try（檢查）   catch（捕捉）   finally（最終）   throw（拋出）  throws

 

異常的語句結構

try{

…………//被檢查的代碼

}catch（異常類型）{

…………//處理異常的代碼

}

 

try{

…………//被檢查的代碼

}finally{

…………//最終都要執行的部分

}

 

try{

…………//被檢查的代碼

}catch（異常類型）{

…………//處理異常的代碼

}finally{

…………//最終都要執行的部分

}

 

4-    finally關鍵字

finally須要建立try代碼塊後面

若是有catch，寫在最後一個catch代碼塊後面

不管是否發生異常，finally塊必定會執行

finally用來作清理和藹後的工做

權限要高於return

5-    throw/throws

throw 是拋出一個異常，不管它是咱們本身實例化的仍是剛捕獲到的

位置是在方法體內

throws 聲明當前方法可能發生的異常類型

位置是在方法名後方法體前   ）throws 異常類型 {

6-    Throwable類的主要方法

getMessage() 獲取異常的詳細信息

getCause()  返回的對象表明異常緣由

toString()   返回一個類的串名稱

printStackTrace()  打印tostring（）結果和棧信息，也就是定位到代碼哪一行報異常

29、枚舉enum

enumeration  JDK1.5引入的新特性

1-    1.5以前的作法

使用接口定義常量來實現相似枚舉的做用

 

2-    枚舉的定義方式

 

用枚舉類型建立的對象（變量），值只能是枚舉類型建立時所列舉出的，不能夠有其餘值

 

3-    枚舉的經常使用操做

遍歷  switch

4-    enum對象的經常使用方法

int  compareTo(E o)                   比較當前的枚舉類型和指定對象的順序

Class<E>  getDeclaringClass()           返回和當前枚舉常量的枚舉類型對應的class對象

String  name()                                  返回枚舉常量的名稱

int  ordinal()                              返回枚舉常量的序號

String  toString()                        返回枚舉常量的名稱

static  <T extends Enum<T>> T                    valueOf(Class<T>  enumType , String name)

靜態的 返回帶着指定名稱的指定枚舉類型的枚舉常量   指定枚舉類型  指定名稱

30、形參和實參

 

形參，方法頭括號裏的參數，也就是方法體中使用的部分

實參，給方法傳入的參數

傳值調用 ，基本數據類型做爲參數，會產生值的副本，形參操做不影響實參

傳引用調用 ，引用類型做爲參數 類類型 接口 數組 傳引用類型的地址，形參操做會對實參形成影響

 

實參給形參傳遞的都是值  傳值的過程都是複製的過程

基本數據類型是將值直接複製  引用類型是將地址進行了賦值

 

String 和Integer Double等包裝類，定義爲不可改值的類型immutable，這時會進行特殊處理，要理解爲值傳遞，形參操做不影響實參

緣由是以上這些類中，並無改變對象自身值的操做

 

String若是要使用引用類型，能夠選擇使用stringbuffer和stringbuilder

 

 

 

31、Java泛型

1-    概念

泛型的本質是參數化類型

泛型只對編譯時有效

2-    爲何要用泛型

至關於類型的通配符（通用匹配），就像是一個虛擬的類型

3-    泛型的使用

1-    泛型類

class FX<T>

2-    泛型方法

public static <E> void showArrayAll(E[] a)

3-    集合中的類型（在集合中講）

4-    泛型的通配符

？爲了讓父類子類等都經過泛型的使用

5-    泛型的上下邊界

上邊界

<? extends Number> 往上只能繼承到Number 也就是說只能用Number以及子類做爲泛型的具體類型使用

 

下邊界

<? super Number> 往下只能用到當前類，當前類以及它的父類能夠做爲泛型的具體類型

 

6-    泛型使用的好處

1） 類型安全

經過泛型的定義，咱們能夠界定變量的類型限制，提升Java程序的類型安全

2） 消除類型強制轉換

防止類型之間的強制轉換，

3） 提升性能

由於消除了強制轉換，強制轉換的代碼不會被編譯器插入到字節碼中，減小執行部分，從而提升性能

.java  →  .class 

7-    泛型使用的注意事項

1） 泛型的類型參數只能是類類型，不能是基本類型

2） 泛型的類型參數能夠有多個

3） 不能對確切泛型類型是instanceof操做

泛型的對象 instanceof  FX<Number>  //非法操做

4） 不能建立一個確切的泛型類型的數組

32、集合框架（一）（重點）

1-    集合的意義

集合是爲了連續的存儲數據搭建的框架

數組：能夠存儲基本數據類型和引用類型，數組的長度是固定的，當元素數量未知的狀況下不適合使用

集合：只能存儲對象，集合的長度可變，多數狀況下使用集合

2-    集合框架的層次結構

 

collection接口是集合類接口的根接口，這個接口沒有實現類，List和Set接口是繼承它而來的

Map接口也是集合類接口的一部分，它和collection獨立，Map以鍵值對的形式存儲數據

（迭代器）Iterator接口，全部的集合類中，都實現了Iterator接口，用於遍歷集合中元素的接口，三個重要的方法：

hasNext（） 是否有下一個元素

next（）    返回下一個元素

remove（）  刪除元素

 

3-    List、Set和Map

List（列表）：list中的對象是有序的而且元素能夠重複的，list是自帶索引的，因此查詢速度快

Set（集）：set裏存放的對象是無序的而且不能夠重複，set中的對象並不排序，只是簡單的加入集合

Map（映射）：map中存的是鍵值對，鍵不能重複，值能夠重複，根據鍵能夠獲得值

		是否有序	元素是否能夠重複
collection
List		是	是
set	HashSet	否	否
	TreeSet	是（二叉排序樹）	否
Map	HashMap	否	key值惟一，value能夠重複
	TreeMap	是（二叉排序樹）

 

4-    List的使用

ArrayList 和 LinkedList這兩個類都實現了List接口

這兩個在用法上沒有區別，LinkedList用在增刪操做較多，查詢操做較少的狀況，ArrayList是在查詢多，增刪少的操做中。

33、集合框架（二）（重點）

1-    Set（集）

Set和List的區別 Set中的元素不重複且無序，List中的元素是可重複且有序

Set有着collection徹底同樣的接口，因此不像list同樣有額外的功能

存入Set中的元素必須都是惟一的

HashSet：爲了快速查找設計的Set，以hash算法對元素進行標記

TreeSet：保存次序的Set，基本結構是樹結構，提供有序的序列

LinkedHashSet：以鏈表的形式存儲的HashSet

2-    Map（映射）

Map接口並不繼承collection 但它也是集合的一部分

Map使用鍵值對存儲數據  每一個值都有一個和他相關聯的鍵，咱們經過鍵就能夠訪問到對應的值

HashMap：Map基於散列的形式

TreeMap：Map基於紅黑樹的形式

LinkedHashMap：鏈表形式的HashMap

WeakHashMap：一種特殊形式，具備弱鍵的Map，對象容許釋放

3-    Iterator（迭代器）

集合全都實現了的接口，用途是遍歷集合

4-    集合的遍歷

list和set遍歷的方式通用 for  foreach  Iterator

map須要轉換成set才能進行遍歷

 

集合的嵌套

34、集合框架（三）（重點）

集合之間的嵌套

list和set結構基本相同，不作介紹

1-    list中套list 

針對將全部數據都顯示時方便

2-    list中套map

對顯示每條規律的數據的其中一條比較方便

3-    map中套map

針對數據的查詢很方便

4-    map中套list

查詢表頭方便

 

無論多複雜的程序，永遠脫離不了基礎語法

 

 

 

 

 

 

35、文件和流（一）（重點）

1-    java.io包介紹

i : input   o : output

IO表示程序中將數據輸出到程序之外或在程序之外將數據輸入到程序內。

也就是程序與外界的數據交流。能夠輸出到控制檯，文件，或網絡上的其餘計算機上

java.io包也是Java內置的包，其中包含一系列對文件和目錄的屬性進行操做，對文件進行讀寫操做的類；

程序中若是要使用到該包中的類，對文件或流進行操做，則必須顯式地聲明以下語句：

import  java.io.*;

 

2-    File類

File類的對象不但能夠表示文件，還能夠表示目錄，在程序中一個File類對象能夠表明一個文件或目錄；

當建立一個文件對象後， 就能夠利用它來對文件或目錄的屬性進行操做， 如： 文件名、 最後修改日期、文件大小等等；

須要注意的是， File對象並不能直接對文件進行讀/寫操做， 只能查看文件的屬性；

File構造方法：

File(String pathname)

指定文件（ 或目錄） 名和路徑建立文件對象

File類中的經常使用方法

方 法 原 型 說 明

boolean exists()            判斷文件是否存在，存在返回true，不然返回false

boolean isFile()             判斷是否爲文件，是文件返回true，不然返回false

boolean isDirectory()    判斷是否爲目錄，是目錄返回true，不然返回false

String getName()          得到文件的名稱

String getAbsolutePath() 得到文件的絕對路徑

long length()                得到文件的長度（字節數）

boolean createNewFile() throws IOException

建立新文件，建立成功返回true，不然返回false，有可能拋出IOException異常，必須捕捉

boolean delete()           刪除文件，刪除成功返回true，不然返回false（刪除失敗：1.文件不存在2.文件被佔用3.權限不足）

    File[] listFiles()               返回文件夾內的子文件與子文件夾的數組

3-    IO繼承結構

IO流的兩個頂級接口 Closeable  Flushable

IO流的四個頂級類 InputStream  OutputStream  Reader  Writer

字節流

 

 

字符流

 

 

4-    流的分類

按照數據流向分：

1. 從程序向外的叫作輸出流
2. 從外部向程序的叫輸入流

按照流的最小傳輸單位分：

1. 字符流 Unicode（萬國碼） 一個字符（char）=兩個字節（2byte）=16位（16bit）
2. 字節流 1字節（1byte）=8位（8bit）

       字符流只用來讀寫文本格式 字符須要編解碼

       字節流能夠讀寫全部格式 字節流不會對文件進行編解碼

按照功能分：

1. 節點流
2. 處理流

 

5-    FileInputStream和FileOutputStream

FileInputStream類稱爲文件輸入流， 繼承於InputStream類， 是進行文件讀操做的最基本類；

它的做用是將文件中的數據輸入到內存（指程序運行的內存部分）中，咱們能夠利用它來讀文件；

因爲它屬於字節流，所以在讀取Unicode字符（如中文）的文件時可能會出現問題。因此字節流盡可能不要讀取字符類的文本文件，字節流經常使用來讀取圖片，音頻，視頻等多媒體文件

FileOutputStream類稱爲文件輸出流， 繼承於OutputStream類，是進行文件寫操做的最基本類；

它的做用是將內存中的數據輸出到文件中，咱們能夠利用它來寫文件。

 

6-    FileReader、 FileWriter

FileReader類稱爲文件讀取流， 容許以字符流的形式對文件進行讀操做。

FileWriter類 稱爲文件寫入流， 以字符流的形式對文件進行寫操做與FileReader類類似， FileReader和FileWriter類須要使用緩衝流進行包裝，經過包裝來提升效率。

 

7-    BufferedReader、 BufferedWriter

BufferedReader類主要爲字符流提供緩衝，以提升效率

BufferedReader類的構造方法：

BufferedReader(Reader in)

將字符讀取流對象包裝成緩衝讀取流對象。

BufferedWriter類 能夠爲FileWriter類提供緩衝

BufferedWriter的構造方法：

BufferedWriter(Writer out)

將字符寫入流對象包裝成緩衝寫入流對象。

 

8-    BufferInputStream、 BufferOutputStream

BufferInputStream:表示帶緩衝的字節輸入流；

BufferOutStream:表示帶緩衝的字節輸出流；

 

9-    DataInputStream、 DataOutputStream

DataInputStream類是數據字節流： 將數據類型帶着寫進去

要使用DataOutputStream讀取數據必須提早知道該文件中數據的存儲格式和順序。讀取順序和寫入的順序要相同。

 

10- ObjectOutputStream、 ObjectInputStream

ObjectOutputStream: 把對象轉換爲字節序列的過程稱爲對象的序列化。

ObjectInputStream:把字節序列恢復爲對象的過程稱爲對象的反序列化。

主要有兩種用途：

把對象的字節序列永久地保存到硬盤上，一般存放在一個文件中；

在網絡上傳送對象的字節序列。

 

11- InputStreamReader、 OutputStreamWriter

InputStreamReader 是字節流通向字符流的橋樑： 它使用指定的 charset 讀取字節並將其解碼爲字符。

每次調用 InputStreamReader 中的一個 read() 方法都會致使從底層輸入流讀取一個或多個字節。 要啓用從字節到字符的有效轉換， 能夠提早從底層流讀取更多的字節， 使其超過知足當前讀取操做所需的字節。 爲了達到最高效率， 可要考慮在 BufferedReader 內包裝 InputStreamReader；

BufferedReader in= new BufferedReader(new InputStreamReader(System.in));

OutputStreamWriter 是字符流通向字節流的橋樑

每次調用write()方法都會致使在給定字符（或字符集）上調用編碼轉換器。在寫入底層輸出流以前，獲得的這些字節將在緩衝區中累積。 能夠指定此緩衝區的大小， 不過， 默認的緩衝區對多數用途來講已足夠大。 注意， 傳遞給 write() 方法的字符沒有緩衝。 爲了得到最高效率，可考慮將OutputStreamWriter包裝到BufferedWriter中，以免頻繁調用轉換器。

BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));

 

12- PrintWriter、 PrintStream

PrintStream在OutputStream基礎之上提供了加強的功能， 便可以方便地輸出各類類型的數據（ 而不只限於byte型）的格式化表示形式。 PrintStream的方法從不拋出IOEceptin

PrintWriter提供了PrintStream的全部打印方法， 其方法也從不拋出IOException。

與PrintStream的區別： 做爲處理流使用時， PrintStream只能封裝OutputStream類型的字節流， 而PrintWriter既能夠封裝OutputStream類型的字節流， 還可以封裝Writer類型的字符輸出流並加強其功能

36、進程與線程

1.進程和線程的區別：

進程：每一個進程都有獨立的代碼和數據空間（進程上下文），進程間的切換會有較大的開銷，一個進程至少包含1個線程（1至n個）。進行中的程序

每個打開的應用程序就是一個進程.

線程：同一類線程共享代碼和數據空間，每一個線程有獨立的運行棧和程序計數器(PC)，線程切換開銷小。線程必須依附在進程上

線程和進程同樣都分爲五個階段：建立、就緒、運行、阻塞、終止。

多進程是指操做系統能同時運行多個任務（程序）。

多線程是指在同一程序中有多個順序流在執行。

多線程能夠達到高效並充分利用cpu的程序

 

2.線程的使用方法

java中實現多線程有三種方式：

1-    繼承Thread類

2-    實現Runable接口

3-    經過實現callable接口和future對象

 

繼承Java.lang.Thread類，並覆蓋run()方法

class MyThread extends Thread {

public void run( ) {

/* 覆蓋該方法*/

}

}

 

實現Java.lang.Runnable接口，並實現run()方法

class MyThread implements Runnable{

public void run( ) {

/* 實現該方法*/

}

}

 

實現callable接口

class MyThread implements callable<?>{

public <?> call(){

/*實現方法*/

}

}

總結：

實現Runnable接口和Callable接口比繼承Thread類所具備的優點：

1）適合多個相同的程序代碼的線程去處理同一個資源

2）能夠避免java中的單繼承的限制

3）增長程序的健壯性，代碼能夠被多個線程共享，代碼和數據獨立

 

提醒一下你們：main方法其實也是一個線程。在java中全部的線程都是同時啓動的，至於何時執行，哪一個先執行，徹底看誰先獲得CPU的資源。

在java中，每次程序運行至少啓動2個線程。一個是main線程，一個是垃圾收集線程。由於每當使用java命令執行一個類的時候，實際上都會啓動一個ＪＶＭ，每個ｊＶＭ就是在操做系統中啓動了一個進程。

 

3.線程的生命週期

       1-新建狀態:

       使用 new 關鍵字和 Thread 類或其子類創建一個線程對象後，該線程對象就處於新建 狀態。它保持這個狀態直到程序 start() 這個線程。

       2-就緒狀態:

       當線程對象調用了start()方法以後，該線程就進入就緒狀態。就緒狀態的線程處於就緒 隊列中，要等待JVM裏線程調度器的調度。

       3-運行狀態:

       若是就緒狀態的線程獲取 CPU 資源，就能夠執行 run()，此時線程便處於運行狀態。處      於運行狀態的線程最爲複雜，它能夠變爲阻塞狀態、就緒狀態和死亡狀態。

       4-阻塞狀態:

       若是一個線程執行了sleep（睡眠）、suspend（掛起）等方法，失去所佔用資源以後，該     線程就從運行狀態進入阻塞狀態。在睡眠時間已到或得到設備資源後能夠從新進入就緒       狀態。能夠分爲三種：

              等待阻塞：運行狀態中的線程執行 wait() 方法，使線程進入到等待阻塞狀態。

              同步阻塞：線程在獲取 synchronized 同步鎖失敗(由於同步鎖被其餘線程佔用)。

              其餘阻塞：經過調用線程的 sleep() 或 join() 發出了 I/O 請求時，線程就會進入到                           阻塞狀態。當sleep() 狀態超時，join() 等待線程終止或超時，或者 I/O 處                          理完畢，線程從新轉入就緒狀態。

       5-死亡狀態:

       一個運行狀態的線程完成任務或者其餘終止條件發生時，該線程就切換到終止狀態。死亡狀態的線程不能夠再執行

      

 

 

37、多線程操做

1. 線程調度

線程優先級：java中的線程是具備優先級的，優先級高的線程會得到更多的運行機會。

Java中線程的優先級是用整數來表示的，取值範圍是1-10

Thread類中有三個靜態常量：

static int MAX_PRIORITY

線程能夠具備的最高優先級，取值爲10。

static int MIN_PRIORITY

線程能夠具備的最低優先級，取值爲1。

static int NORM_PRIORITY

       分配給線程的默認優先級，取值爲5。

能夠用Thread類的setPriority和getPriority方法分別來設置和獲取線程的優先級

可是線程優先級不能保證線程執行的順序，只能說明優先級高的線程更加劇要

 

1. 線程經常使用方法

sleep():                         強迫一個線程睡眠Ｎ毫秒。

join():                           等待線程終止。

currentThread():           獲得當前線程（拿到當前方法所在的線程對象）。

isDaemon():                 一個線程是否爲守護線程。

setDaemon():               設置一個線程爲守護線程。(用戶線程和守護線程的區                                      別在於，是否等待主線程依賴於主線程結束而結束)

setName():                   爲線程設置一個名稱。

wait():                          強迫一個線程等待。

notify():                        通知一個線程繼續運行。

       setPriority():                 設置一個線程的優先級。

 

1. 多線程使用的時機

多線程的目的是讓程序併發執行，改變原有的串行執行方式，來提升效率，當程序中有兩個子系統須要併發執行的時候，就須要使用多線程。

多線程是能夠編寫出高效率的程序，可是必定要注意，太多的線程卻會讓程序的執行效率實際上下降，由於線程間的切換也是對CPU資源有開銷的，過多的線程會使CPU在上下文（線程之間）切換的時間大於程序執行的時間。

 

1. 線程安全

當多個線程訪問某個類時，無論運行環境如何調度，這些線程如何交替運行，咱們也不須要在主調試代碼中加入額外的同步或者協調，這個類都能作出正確的行爲，得出正確的結果，咱們稱這個類是線程安全的。

37、線程間通訊(線程同步)

線程之間的通訊方式

 

線程的同步並非說線程並行執行，而是指協同工做，將好像兩個工人加工同一個零件

 

1-    同步（synchronized/ volatile）

爲了保證同一對象的結果一致有效

使用synchronized同步

1） 得到同步鎖

2） 清空工做內存

3） 從主內存拷貝對象副本到工做內存

4） 執行代碼

5） 刷新主內存

6） 釋放同步鎖

 

volatile是使變量對線程有可見性，volatile 不能和final同時修飾一個字段

 

總結：開始學習時儘可能使用synchronized同步線程，當理解深刻後自行決定該使用那一種

2-    while輪詢（循環詢問的意思）

很是浪費CPU系統資源的，比方說一部電話沒有鈴聲，沒有震動，咱們得一直盯着看來沒來電話

還存在內存可見性的問題

3-    wait/notify機制

避免了像輪詢同樣過多的CPU資源佔用，就是說CPU的利用率提升了

缺點：若是通知提早發送，而等待後執行，那麼等待的線程就可能永遠不被喚醒，打亂程序的執行邏輯

 

守護線程和非守護線程

守護線程是一種提供後臺通用服務的線程，好比內存回收線程就是守護線程。

守護線程並非程序不可或缺的一部分。

守護線程和非守護線程沒有本質區別，可是當非守護線程所有執行完成時，守護線程也就沒有做用了，隨之會中止。

將線程轉換爲守護線程能夠經過調用Thread對象的setDaemon(true)方法來實現。在使用守護線程時須要注意一下幾點：

 

(1)   thread.setDaemon(true)必須在thread.start()以前設置，不然會拋出一個IllegalThread StateException異常。不能把正在運行的常規線程設置爲守護線程。

(2) 在Daemon線程中產生的新線程也是Daemon的。

(3) 守護線程應該永遠不去訪問固有資源，如文件、數據庫，由於它會在任什麼時候候甚至在一個操做的中間發生中斷。

38、線程死鎖+守護線程

線程死鎖

1-    死鎖的概念

多個線程同時被阻塞，這些線程中的一個或者所有都在等待某個資源被釋放，因爲線程無限期的阻塞，程序不可能正常終止的狀況

2-    死鎖產生的四個必要條件

1） 互斥使用，當一個資源被一個線程佔用時，其它線程不能使用

2） 不可搶佔，資源不能被資源請求者從資源佔有者那裏搶奪，只能由佔有者主動釋放

3） 請求和保持，請求者在請求其餘資源的時候還對原有的資源保持佔有

4） 循環等待，線程1佔有線程2的資源，線程2佔有線程3的資源，線程3佔有線程1的資源，這樣就是一個等待環路。

       當以上四個條件都成立的時候，就會造成死鎖。若是有一個被打破，死鎖就解除了。

       死鎖是咱們不但願出現的狀況，咱們要千方百計的解決它

3-    生產者消費者問題

生產者和消費者同時使用一個存儲空間

 

 

守護線程

守護線程和非守護線程（用戶線程）

守護線程是一種提供後臺通用服務的線程，好比內存回收線程就是守護線程。

守護線程並非程序不可或缺的一部分。

守護線程和非守護線程沒有本質區別，可是當非守護線程所有執行完成時，守護線程也就沒有做用了，隨之會中止。

將線程轉換爲守護線程能夠經過調用Thread對象的setDaemon(true)方法來實現。在使用守護線程時須要注意一下幾點：

 

(1)   thread.setDaemon(true)必須在thread.start()以前設置，不然會拋出一個IllegalThread StateException異常。不能把正在運行的常規線程設置爲守護線程。

(2) 在Daemon線程中產生的新線程也是Daemon的。

(3) 守護線程應該永遠不去訪問固有資源，如文件、數據庫，由於它會在任什麼時候候甚至在一個操做的中間發生中斷。

39、反射機制

1-    反射的概念

JAVA反射機制是指在運行狀態中，對於任意一個類，都可以知道這個類的全部屬性和方法；對於任意一個對象，都可以調用它的任意一個方法和屬性；這種動態獲取信息以及動態調用對象的方法的功能稱爲JAVA語言的反射機制。

 

2-    Class類（區別於class關鍵字）

Class 類的實例表示正在運行的 Java 應用程序中的類和接口。也就是jvm中有N多的實例每一個類都有該Class對象。（包括基本數據類型）

 

Class 沒有公共構造方法。Class 對象是在加載類時由 Java 虛擬機以及經過調用類加載器中的defineClass 方法自動構造的。也就是這不須要咱們本身去處理建立，JVM已經幫咱們建立好了。

 

3-    反射的使用

獲取Class對象的三種方式：

1. Object ——> getClass();
2. 任何數據類型（包括基本數據類型）都有一個「靜態」的class屬性
3. 經過Class類的靜態方法：forName（String  className）

 

4-    經過反射獲取構造方法

 

5-    經過反射獲取成員變量

 

6-    經過反射獲取成員方法

 

7-    經過反射獲取main方法

 

8-    可變長參數

1. 可變長參數的定義方法
2. 可變長參數方法的調用
3. 可變長參數的使用規則

一、 在調用方法的時候，若是可以和固定參數的方法匹配，也可以與可變長參數的方法匹配，則選擇固定參數的方法。

二、 若是要調用的方法能夠和兩個可變參數匹配，則出現錯誤

三、 一個方法只能有一個可變長參數，而且這個可變長參數必須是該方法的最後一個參數

1. 可變長參數使用注意事項

一、 避免帶有可變長參數方法的重載

二、 null值有可能引發變長參數方法的二義性

三、 重寫變長參數方法同樣要遵照方法重寫規則（子類重寫父類方法）

40、8.0新特性

1-    Base64

Base64是一種加密方式

Java 8 內置了 Base64 編碼的編碼器和解碼器。

Base64工具類提供了一套靜態方法獲取下面三種BASE64編解碼器：

基本：輸出被映射到一組字符A-Za-z0-9+/，編碼不添加任何行標，輸出的解碼僅支持A-Za-z0-9+/。

URL：輸出映射到一組字符A-Za-z0-9+_，輸出是URL和文件。

MIME：輸出隱射到MIME友好格式。輸出每行不超過76字符，而且使用'\r'並跟隨'\n'做爲分割。編碼輸出最後沒有行分割。

 

2-    新的日期時間API

在舊版的 Java 中，日期時間 API 存在諸多問題，其中有：

非線程安全 − java.util.Date 是非線程安全的，全部的日期類都是可變的，這是Java日期類最大的問題之一。

設計不好 − Java的日期/時間類的定義並不一致，在java.util和java.sql的包中都有日期類，此外用於格式化和解析的類在java.text包中定義。java.util.Date同時包含日期和時間，而java.sql.Date僅包含日期，將其歸入java.sql包並不合理。另外這兩個類都有相同的名字，這自己就是一個很是糟糕的設計。

時區處理麻煩 − 日期類並不提供國際化，沒有時區支持，所以Java引入了java.util.Calendar和java.util.TimeZone類，但他們一樣存在上述全部的問題。

Java 8 在 java.time 包下提供了不少新的 API。如下爲兩個比較重要的 API：

Local(本地) − 簡化了日期時間的處理，沒有時區的問題。

Zoned(時區) − 經過制定的時區處理日期時間。

新的java.time包涵蓋了全部處理日期，時間，日期/時間，時區，時刻（instants），過程（during）與時鐘（clock）的操做。

軟通動力

 

3-    Nashorn JavaScript引擎

Nashorn取代Rhino(JDK 1.6, JDK1.7)成爲Java的嵌入式JavaScript引擎。Nashorn徹底支持ECMAScript 5.1規範以及一些擴展。它使用基於JSR 292的新語言特性，其中包含在JDK 7中引入的 invokedynamic，將JavaScript編譯成Java字節碼。

與先前的Rhino實現相比，這帶來了2到10倍的性能提高。

 

4-    Optional 類

Optional 類是一個能夠爲null的容器對象。若是值存在則isPresent()方法會返回true，調用get()方法會返回該對象。

Optional 是個容器：它能夠保存類型T的值，或者僅僅保存null。Optional提供不少有用的方法，這樣咱們就不用顯式進行空值檢測。

Optional 類的引入很好的解決空指針異常。

 

5-    Stream

Java 8 API添加了一個新的抽象稱爲流Stream，可讓你以一種聲明的方式處理數據。Stream 使用一種相似用 SQL 語句從數據庫查詢數據的直觀方式來提供一種對 Java 集合運算和表達的高階抽象。

Stream API能夠極大提升Java程序員的生產力，讓程序員寫出高效率、乾淨、簡潔的代碼。

這種風格將要處理的元素集合看做一種流， 流在管道中傳輸， 而且能夠在管道的節點上進行處理， 好比篩選， 排序，聚合等。

元素流在管道中通過中間操做（intermediate operation）的處理，最後由最終操做(terminal operation)獲得前面處理的結果。

stream是將數據，像輸入輸出流的形式同樣來處理

 

6-    默認方法

Java 8 新增了接口的默認方法。

簡單說，默認方法就是接口能夠有實現方法，並且不須要實現類去實現其方法。

咱們只需在方法名前面加個default關鍵字便可實現默認方法。

爲何要有這個特性？

首先，以前的接口是個雙刃劍，好處是面向抽象而不是面向具體編程，缺陷是，當須要修改接口時候，須要修改所有實現該接口的類，目前的java 8以前的集合框架沒有foreach方法，一般能想到的解決辦法是在JDK裏給相關的接口添加新的方法及實現。然而，對於已經發布的版本程序，是無法在給接口添加新方法的同時不影響已有的實現。因此引進的默認方法。他們的目的是爲了解決接口的修改與現有的實現不兼容的問題。

 

7-    函數式接口

函數式接口(Functional Interface)就是一個只具備一個方法的普通接口。

函數式接口能夠被隱式轉換爲lambda表達式。

函數式接口能夠對現有的函數友好地支持 lambda。

 

JDK 1.8以前已有的函數式接口:

java.lang.Runnable

java.util.concurrent.Callable

java.security.PrivilegedAction

java.util.Comparator

java.io.FileFilter

java.nio.file.PathMatcher

java.lang.reflect.InvocationHandler

java.beans.PropertyChangeListener

java.awt.event.ActionListener

javax.swing.event.ChangeListener

 

JDK 1.8 新增長的函數接口：

java.util.function

 

8-    方法引用

方法引用經過方法的名字來指向一個方法。

方法引用可使語言的構造更緊湊簡潔，減小冗餘代碼。

方法引用使用一對冒號 :: 。

 

9-    Lambda 表達式

Lambda 表達式，也可稱爲閉包，它是推進 Java 8 發佈的最重要新特性。

Lambda 容許把函數做爲一個方法的參數（函數做爲參數傳遞進方法中）。

使用 Lambda 表達式可使代碼變的更加簡潔緊湊。

 

lambda表達式的重要特徵:

可選類型聲明：不須要聲明參數類型，編譯器能夠統一識別參數值。

可選的參數圓括號：只有一個參數無需定義圓括號，但多個參數須要定義圓括號。

可選的大括號：若是主體只包含了一個語句，就不須要使用大括號。

可選的返回關鍵字：若是主體只有一個表達式返回值則編譯器會自動返回值，大括號須要指定明表達式返回了一個數值。

 

lambda表達式形式

（參數列表）-> 返回值或表達式或者方法語句

 

（）-> 返回

41、正則表達式

一、 概念和用途

正則表達式定義了字符串的模式。

正則表達式能夠用來搜索、編輯或處理文本。

正則表達式並不只限於某一種語言，可是在每種語言中有細微的差異。

二、 Java中的使用類

java.util.regex 包主要包括如下三個類：

1-    Pattern 類：

pattern 對象是一個正則表達式的編譯表示。Pattern 類沒有公共構造方法。要建立一個 Pattern 對象，你必須首先調用其公共靜態編譯方法，它返回一個 Pattern 對象。該方法接受一個正則表達式做爲它的第一個參數。

2-    Matcher 類：

Matcher 對象是對輸入字符串進行解釋和匹配操做的引擎。與Pattern 類同樣，Matcher 也沒有公共構造方法。你須要調用 Pattern 對象的 matcher 方法來得到一個 Matcher 對象。

3-    PatternSyntaxException：

PatternSyntaxException 是一個非強制異常類，它表示一個正則表達式模式中的語法錯誤。

^  輸入法爲半角而且是英文的狀態  shift+6   

三、 正則表達式語法

字符	說明
\	將下一字符標記爲特殊字符、文本、反向引用或八進制轉義符。例如，"n"匹配字符"n"。"\n"匹配換行符。序列"\\\\"匹配"\\"，"\\("匹配"("。
^	匹配輸入字符串開始的位置。若是設置了 RegExp 對象的 Multiline 屬性，^ 還會與"\n"或"\r"以後的位置匹配。
$	匹配輸入字符串結尾的位置。若是設置了 RegExp 對象的 Multiline 屬性，$ 還會與"\n"或"\r"以前的位置匹配。
*	零次或屢次匹配前面的字符或子表達式。例如，zo* 匹配"z"和"zoo"。* 等效於 {0,}。
+	一次或屢次匹配前面的字符或子表達式。例如，"zo+"與"zo"和"zoo"匹配，但與"z"不匹配。+ 等效於 {1,}。
?	零次或一次匹配前面的字符或子表達式。例如，"do(es)?"匹配"do"或"does"中的"do"。? 等效於 {0,1}。
{n}	n 是非負整數。正好匹配 n 次。例如，"o{2}"與"Bob"中的"o"不匹配，但與"food"中的兩個"o"匹配。
{n,}	n 是非負整數。至少匹配 n 次。例如，"o{2,}"不匹配"Bob"中的"o"，而匹配"foooood"中的全部 o。"o{1,}"等效於"o+"。"o{0,}"等效於"o*"。
{n,m}	M 和 n 是非負整數，其中 n <= m。匹配至少 n 次，至多 m 次。例如，"o{1,3}"匹配"fooooood"中的頭三個 o。'o{0,1}' 等效於 'o?'。注意：您不能將空格插入逗號和數字之間。
?	當此字符緊隨任何其餘限定符（*、+、?、{n}、{n,}、{n,m}）以後時，匹配模式是"非貪心的"。"非貪心的"模式匹配搜索到的、儘量短的字符串，而默認的"貪心的"模式匹配搜索到的、儘量長的字符串。例如，在字符串"oooo"中，"o+?"只匹配單個"o"，而"o+"匹配全部"o"。
.	匹配除"\r\n"以外的任何單個字符。若要匹配包括"\r\n"在內的任意字符，請使用諸如"[\s\S]"之類的模式。
(pattern)	匹配 pattern 並捕獲該匹配的子表達式。可使用 $0…$9 屬性從結果"匹配"集合中檢索捕獲的匹配。若要匹配括號字符 ( )，請使用"\("或者"\)"。
(?:pattern)	匹配 pattern 但不捕獲該匹配的子表達式，即它是一個非捕獲匹配，不存儲供之後使用的匹配。這對於用"or"字符 (|) 組合模式部件的狀況頗有用。例如，'industr(?:y|ies) 是比 'industry|industries' 更經濟的表達式。
(?=pattern)	執行正向預測先行搜索的子表達式，該表達式匹配處於匹配 pattern 的字符串的起始點的字符串。它是一個非捕獲匹配，即不能捕獲供之後使用的匹配。例如，'Windows (?=95|98|NT|2000)' 匹配"Windows 2000"中的"Windows"，但不匹配"Windows 3.1"中的"Windows"。預測先行不佔用字符，即發生匹配後，下一匹配的搜索緊隨上一匹配以後，而不是在組成預測先行的字符後。
(?!pattern)	執行反向預測先行搜索的子表達式，該表達式匹配不處於匹配 pattern 的字符串的起始點的搜索字符串。它是一個非捕獲匹配，即不能捕獲供之後使用的匹配。例如，'Windows (?!95|98|NT|2000)' 匹配"Windows 3.1"中的 "Windows"，但不匹配"Windows 2000"中的"Windows"。預測先行不佔用字符，即發生匹配後，下一匹配的搜索緊隨上一匹配以後，而不是在組成預測先行的字符後。
x|y	匹配 x 或 y。例如，'z|food' 匹配"z"或"food"。'(z|f)ood' 匹配"zood"或"food"。
[xyz]	字符集。匹配包含的任一字符。例如，"[abc]"匹配"plain"中的"a"。
[^xyz]	反向字符集。匹配未包含的任何字符。例如，"[^abc]"匹配"plain"中"p"，"l"，"i"，"n"。
[a-z]	字符範圍。匹配指定範圍內的任何字符。例如，"[a-z]"匹配"a"到"z"範圍內的任何小寫字母。
[^a-z]	反向範圍字符。匹配不在指定的範圍內的任何字符。例如，"[^a-z]"匹配任何不在"a"到"z"範圍內的任何字符。
\b	匹配一個字邊界，即字與空格間的位置。例如，"er\b"匹配"never"中的"er"，但不匹配"verb"中的"er"。
\B	非字邊界匹配。"er\B"匹配"verb"中的"er"，但不匹配"never"中的"er"。
\cx	匹配 x 指示的控制字符。例如，\cM 匹配 Control-M 或回車符。x 的值必須在 A-Z 或 a-z 之間。若是不是這樣，則假定 c 就是"c"字符自己。
\d	數字字符匹配。等效於 [0-9]。
\D	非數字字符匹配。等效於 [^0-9]。
\f	換頁符匹配。等效於 \x0c 和 \cL。
\n	換行符匹配。等效於 \x0a 和 \cJ。
\r	匹配一個回車符。等效於 \x0d 和 \cM。
\s	匹配任何空白字符，包括空格、製表符、換頁符等。與 [ \f\n\r\t\v] 等效。
\S	匹配任何非空白字符。與 [^ \f\n\r\t\v] 等效。
\t	製表符匹配。與 \x09 和 \cI 等效。
\v	垂直製表符匹配。與 \x0b 和 \cK 等效。
\w	匹配任何字類字符，包括下劃線。與"[A-Za-z0-9_]"等效。
\W	與任何非單詞字符匹配。與"[^A-Za-z0-9_]"等效。
\xn	匹配 n，此處的 n 是一個十六進制轉義碼。十六進制轉義碼必須正好是兩位數長。例如，"\x41"匹配"A"。"\x041"與"\x04"&"1"等效。容許在正則表達式中使用 ASCII 代碼。
\num	匹配 num，此處的 num 是一個正整數。到捕獲匹配的反向引用。例如，"(.)\1"匹配兩個連續的相同字符。
\n	標識一個八進制轉義碼或反向引用。若是 \n 前面至少有 n 個捕獲子表達式，那麼 n 是反向引用。不然，若是 n 是八進制數 (0-7)，那麼 n 是八進制轉義碼。
\nm	標識一個八進制轉義碼或反向引用。若是 \nm 前面至少有 nm 個捕獲子表達式，那麼 nm 是反向引用。若是 \nm 前面至少有 n 個捕獲，則 n 是反向引用，後面跟有字符 m。若是兩種前面的狀況都不存在，則 \nm 匹配八進制值 nm，其中 n 和 m 是八進制數字 (0-7)。
\nml	當 n 是八進制數 (0-3)，m 和 l 是八進制數 (0-7) 時，匹配八進制轉義碼 nml。
\un	匹配 n，其中 n 是以四位十六進制數表示的 Unicode 字符。例如，\u00A9 匹配版權符號 (©)。

42、Java數據結構

一、概念

數據之間存在的聯繫方式

二、java中的數據結構

1-    Bitset（位集合）

char（16bit）

2-    Vector（向量）

實現了一個動態的數組，可是不屬於集合框架中的

3-    Stack（棧）

實現了一個標準的後進先出的棧結構

4-    Dictionary（字典）

和map一致實現的是鍵值對存儲，已經徹底棄用

5-    Hashtable（哈希表）

Java2以後Hashtable被重構，實現了Map接口

6-    Properties（屬性）

繼承了Hashtable，是一個屬性集