Java基礎：

Java資料型別：

基本資料型別：

            數值型：

整數型：

Int，byte,short，long

小數型：

float,double

非數值型：

char   boolean

引用資料型別：

陣列 array

介面 interface

類 class（String字串）

注：byte1個位元組，short2個位元組，long8個位元組，int4個位元組（一個位元組八位）

 Float單精度，32位   double雙精度64位   char單一的 16 位 Unicode 字元

資料的型別轉換

Char

Short --> int -->long--> float--> double

Byte

byte/char/short計算的時候自動轉換成int型別

自動型別升級：小轉大    強制型別轉換：大轉小     boolean不參與型別轉換

short i=3;

i=i+3; ①

i+=3; ②

①是錯誤的，②是正確的。①中因為i是short，參與運算時自動轉成了int,int>short,會出現強制型別轉換。②中因為+=是java的複合賦值運算子，它的底層程式碼實現了強制型別轉換。

i++與++i

i++先賦值後加   ++i先加後賦值

Switch語句的注意事項

Switch後面只能是byte，short，int，char     jdk1.7後可以有string

break和continue

break是跳出迴圈、結束迴圈(結束的是break所在那一層的迴圈)

continue沒有結束迴圈，進入下一次迴圈。後續程式碼不執行。

陣列的特點

陣列中可以存放進本資料型別，也可以存放引用資料型別

陣列的長度不能改變，陣列的插入刪除比較麻煩，但是查詢比較快

陣列的賦值

動態賦值

int[] arr=new int[6];

arr[0]=12;

arr[1]=57;

arr[2]=34;

arr[3]=23;

arr[4]=15;

arr[5]=49;

靜態賦值

int[] arr=new int[]{12,57,34,23,15,49};

簡寫方式：int[] arr={12,57,34,23,15,49};  推薦使用

二維陣列

 動態賦值：

       int [][] arr=new int[3][5];

       arr[0][0]=30;

       arr[0][1]=50;

       arr[0][2]= 0;

       arr[0][3]=15;

       arr[0][4]=8;

       arr[1][0]=30;

       arr[1][1]=50;

       arr[1][2]= 0;

       arr[1][3]=15;

       arr[1][4]=8;

靜態賦值：

    int[][] arr=new int[3][];

     arr[0]={1,2,3,4};

     arr[1]={2,3};

     arr[2]={0}

int[][] arr=new int[][]{{1,2,3,4},{2,3},{0}}; 標準寫法

簡寫形式：int[][] arr={{1,2,3,4},{2,3},{0}};

方法過載　overload:在同一個類中，允許出現一個以上同名方法

//方法名稱　引數列表不同(引數的個數，引數的資料型別的順序不同)　方法過載　和返回值沒有關係

//同名不同參  面向物件多型的一種體現　

//編譯時多型　　　執行時多型

同名不同參(方法的名字一樣，引數列表不一樣:引數的個數不同，資料型別的順序不同)

   和返回值沒有關係。

方法過載是面向物件多型性 靜態多型的一種體現

好處：方便使用者更靈活選擇

重寫:子類對父類方法的改造 :override   過載：overload

a. 發生在繼承關係中(子父類的關係中)

b. 方法名、引數列、返回值一樣

c. 子類重寫方法的訪問許可權修飾符>=父類被重寫方法的修飾符

d. private修飾的方法不能被重寫

class A{

    private void show(){}

}

class B extends A{

    public void show(){}

}

e. 父類被重寫方法丟擲了異常，如果子類重寫方法也選擇丟擲異常，子類重寫方法異常的異常一定要小於等於(<=)父類被重寫方法丟擲的異常。

成員變數和區域性變數的區別

1) 在類中的位置

區域性變數：方法中或者方法的引數列表

成員變數：類的裡面，方法的外面

2) 在記憶體中的位置

區域性變數：棧

成員變數：堆記憶體 new

3) 初始值不同

區域性變數：必須賦初始值

成員變數：有預設的初始值 int 0  double 0.0  Stirng null

4) 生命週期不同

區域性變數：隨著方法的呼叫而存在，隨著方法的結束而消失

成員變數：隨著物件的建立而存在，隨著物件的消失而消失

this的使用

1) 可以呼叫本類的成員變數和成員方法

示例：

寫法：this.變數名     this.方法名()

2) 可以在調造方法中呼叫構造方法(也可以呼叫成員)

只能在構造方法中呼叫構造方法，普通方法不可以

而且只能寫在構造方法的第一行。

語法：this()呼叫無參構造   this(引數):呼叫帶引數的構造方法

3) this表示本類物件的引用

匿名物件

沒有名字的物件

1)如果物件的方法只想呼叫一次，可以使用匿名物件

使用語法方便，而且便於垃圾回收。

如果物件的方法想多次呼叫，不建議使用匿名物件。因為會浪費記憶體空間。

2)可以當作引數

垃圾回收機制

java的執行緒

前臺執行緒：使用者執行緒

後臺執行緒：(守護執行緒、精靈執行緒)  垃圾回收機制屬於後臺執行緒

java垃圾回收機制是java jvm(虛擬機器)內部 優先級別比較低的後臺執行緒

垃圾回收機制是和堆記憶體有關，和棧記憶體無關

垃圾回收機會 在不確定的時間 來回收垃圾。

物件變成垃圾有三種情況：

1) Student s=new Student();

s=null;  

2) 呼叫一次方法的匿名物件

new Student().show();

3) 迴圈中定義的物件

for(int i=1;i<=3;i++){

    Student s=new Student();

}

訪問許可權修飾符

public:一個專案中所有類 公開的、公共的

protected:受保護的： 同一個包中的類、本類、其他包的子類

default:預設的、友好的friendly   String name;   

      同一個包中的類、本類

private:私有的 本類

類的成員(成員變數和成員方法):4個

類的修飾符：public   default

super和this的區別

this:本類

可以呼叫本類的成員變數和成員方法(在普通方法、構造方法)

this.變數名   this.方法名

在構造方法呼叫本類的其他過載構造方法

this()第一行

this(引數)   只能在構造方法中使用，不能在普通方法中使用

super:父類 繼承關係中

可以呼叫父類的成員變數和成員方法(在普通方法、構造方法)

super.變數名  super.方法名

任何一個類(除了object)的構造方法的第一行都有一個系統預設的super()

super()呼叫父類的無參構造

super(引數)呼叫父類的有引數的構造方法

一個構造方法中，super()和this()不能同時使用

多型：

不同的物件針對同一個行為 作出不同的反應  多型：多種形態

1、要有繼承、實現

2、重寫

3、父類的引用指向了子類的物件  Aniaml a=new Dog();

static:靜態的

a) 特點：

1) 隨著類的載入而載入

2) 優先於物件存在

3) 被類的所有物件共有   比如：飲水機static   水杯private  國籍static

4) 可以通過類名.變數名(類名.方法名)來呼叫

b) static可以修飾成員變數

c) 

靜態變數、類變數

呼叫方式：

1) 物件名.變數名

2) 類名.變數名  è推薦使用    

d) static可以修飾成員方法，不能修飾區域性變數。

1) static修飾的方法(前提：不使用new物件)只能呼叫static修飾的成員

2) 在static修飾的方法中不能使用this.變數(this.方法)

3) 在普通方法中可以使用static修飾的成員

4) static不能修飾構造方法

原因：構造方法是用來建立物件的，而static是跟著類走的。

5) 靜態方法只能重寫靜態方法，不能重寫非靜態的方法。

e) static可以修飾程式碼塊   static{程式碼塊;}  :靜態程式碼塊

特點：隨著類的載入而載入，只執行一次。

不管new多少個物件，只執行一次

f) {}:構造程式碼塊，跟著物件  優先於構造方法執行，給物件成員初始化

靜態程式碼塊>構造程式碼塊>構造方法

構造程式碼塊：new多少個物件就執行多個構造程式碼塊，只不過，它優先於構造方法執行。

g) static類變數和成員變數的區別

1) 所屬不同

類變數：所屬於類  類變數、靜態變數

成員變數：所屬於物件  例項變數、全域性變數、屬性、欄位

2) 記憶體的位置不同

類變數：方法區中的靜態區

成員變數：堆記憶體

3) 生命週期不同

類變數：隨著類的載入而載入，隨著類的消失而消失。生命週期最長。

成員變數：隨著物件的存在而存在。

4) 呼叫方式不同

類變數：兩種呼叫方式

        物件名.變數名

        類名.變數名(推薦使用)

成員變數：物件名.變數名

5) 

h) 不可以把專案中所有的成員變數全部設成static的。

因為static變數是隨著類的存在而存在，生命週期很長。如果專案中所有的成員變數全部是static的，會消耗記憶體。一般情況下，把共享的資料定義成static的，比如：飲水機、國籍。

i) 

final:最終的，終態的，不能被改變的

1) 可以修飾成員變數

常量(大寫)，值不能被改變 public staitc final double PI=3.14159;

2) 可以修飾方法

不能被重寫

3) 修飾類      final class Demo{}   

類不能被繼承

4) 小例題

final int arr[]={3,2,4};

arr[1]=5; 正確的 ,陣列中的值是可以被改變的

int brr[]=new int[3];

arr=brr; 錯誤的,因為陣列是final，地址不能被改變

5) 如果區域性內部類中呼叫它所在方法中的變數，此變數必須是final的。

抽象類和介面的區別？

a. 相同點：都不能new物件

b. 不同點：

1) 構造方法

抽象類：可以有。是為子類準備的。

介面：沒有，因為它是一個interface,不是一個類。

2) 變數

抽象類：變數的訪問修飾符可以任意：public /private/ default/ protected..

介面：只能是public static final

3) 方法

抽象類：可以有普通方法，也可以有抽象方法

介面：只能是抽象方法public abstract

4) 繼承關係：

抽象類：有關係(is a)的類才能繼承抽象類(類)

介面：無關的類可以實現同一個介面

Student學生       Feiji飛機      Dog狗

public interface Run{}

類和類：單繼承  

類和介面：多實現　　

介面和介面：多繼承

異常

Throwable(類):java.lang包

|--Error:嚴重的錯誤(JVM記憶體耗盡、堆疊溢位，不需要異常處理機制來處理)

|--Exception:異常

     |--檢查性異常:（異常處理機制針對的）:必須處理

        IOException為代表

     |--非檢查性異常(執行時異常)：編譯時不報錯，執行後才會出現異常

RuntimeException

以下是常見的幾種執行時異常：

ArrayIndexOutOfBoundsException 陣列下標越界

NullPointerException:空指標異常

ClassCastException:型別轉換異常

ArithmeticException:除數不能為0

可處理，可不處理    

Java高階

1、java的集合體系來說Collection是一個頂級介面，JDK並沒有直接提供實現類來實現介面，而是間接的提供了Set和List介面進行實現

2、List介面：ArrayList  LinkedList

1) ArrayList: 有序的，重複的集合可以通過索引進行資料的訪問，常用的API get  add remove clear contains ... 如果遍歷集合的長度使用size（）方法，陣列中的Length屬性區分。arraylist中有toArray方法，他的作用是將集合轉換為陣列的，（版本的不同7以下 classCastException，7以上的版本進行自動的拆箱裝箱）。

2) ArrayList:原始碼，ArrayList底層的實現是有陣列實現的，當我們使用ArrayList預設的構造方法的時候，底層會生出一個長度為10的Object型別的陣列，如果說長度超過10個，底層會生成新的陣列，陣列的長度（擴容）陣列*1.5+1（針對JDK6 JDK7是使用的自動擴容機制）。

3) 當我們直接列印List變數的時候，List中每個元素的toString()方法，在我們的實際開發中，我們通常都會重寫toString方法，方便我們後續的除錯

4) ArrayList：進行固定位置的新增和刪除的時候，儘量不要用remove和add(@,@)方法，如果進行新增和刪除，必須整體移動集合，代價是比較高的

5) LinkedList:對於LinkedList來說，也是List的實現類，我們建議使用add第二個方法過載進行資料的新增

6) LinkedList:原始碼：LinkedList底層是由連結串列實現的（雙向連結串列），原始碼中的Node元素就是我們演示中的Element元素，

7) 集合轉換為陣列使用集合的toArray方法，陣列轉換為集合使用Arrays.asList(可變引數)，可變引數可以使用陣列賦值。

8) ArrayList 適合於讀取資料，LinkedList適合於操作資料（新增 刪除等）

9) 使用LinkedList實現Stack的資料的存取

10) ArrayList和LinkedList的比較：

3、當使用HashSet時，hashcode()就會呼叫，hashset判斷已經儲存在集合中的物件的hashcode值是否與新新增的hashcode值一致，不一致，直接新增。如果一樣，再進行equals方法的比較，如果equals方法返回true,說明物件存在了，就不會新增新的元素，否則新增進去。

4 、TreeSet是一個遵循自然排序的集合，我們需要在宣告TreeSet的時候必須定義一個規範，而這個規範就是Compator介面的實現類

5、Set的遍歷，我們使用Iterator進行遍歷  hashNext  next

   1）第一種使用While去遍歷Iterator hashnext判斷是否有下一個值，next方法進行值的讀取

   2）for迴圈，進行set元素的獲取

6、Collections常用的方法max min shuffle  sort copy就是一個集合的輔助類

7、Vector同ArrayList使用，Vector是執行緒同步的，安全，而ArrayList是非執行緒安全的，但是ArrayList的效率要高

8 、Map(對映)：K,V鍵值對的對映，在Map結構中Key是不允許重複的，Value是可以重複的，每一個鍵最多隻能對映一個值

9、HashMap中的key的集合可以使用Set介面進行表示，Value的集合可以使用CollectionList表示

10、HashMap遍歷的方式有兩種

1）思路：通過map中keyset()方法獲取所有的Set集合，遍歷Set集合，通過map.get(key)獲取到value

2)、Map中的內部類Entry物件，Entry物件維護了HashMap中的k v鍵值對，也就是說KV組成了一個Entry物件，所以我在遍歷HashMap的時候，我們hashMap中的所有的Entry物件遍歷出來，然後利用Entry物件的getKey  getValue方法獲取到KV值

3）、HashMap和HashTable比較:arraylist vector   Map執行緒不安全 效能高 Table執行緒安全 效率低，properties KV  DB.properties

11 泛型：就是變數型別的引數化，目標：編譯時候不報錯，執行的時候一定不會報錯

  泛型是實現通用框架的基礎,定義一個類的時候<>定義當前類的變數的型別A T,宣告這個類的物件的時候，你傳具體的變數的型別。

12 補充：HashSet底層的實現是由HashMap實現的，當我們呼叫HashSet中的add方法時，本質上是往HashMap中的Key放入了我們新增的值，而HashMap中的Value永遠常量值，Object

13 對於Java中常量的命名規範：所有的單詞都是大寫的，如果有多個單詞，那麼每個單詞之間使用下劃線連線

 public static final String JAVA_CLASS_TEST=100

Lesson4

14 字元流：如何 將位元組流轉換為字元流

1）InputstreamReader  將輸入位元組流轉換為輸入字元流

2)  OutputStreamWriter 將輸出的字元流轉換為輸出的位元組流

3）FileReader   以字元的方法進行檔案的讀取（輸入）Fileinputstream

4）FileWriter    將字元寫入到目標檔案 FileOutputStream

15 ByteArrayInputstream: CharArrayReader
16 原始碼：當我們使用inputStream方法的read方法讀取位元組的時候，Java並沒有提供read方法的實現，而是交由底層作業系統來實現的。

17 inpustream outputstream reader writer

位元組：Fileinputstream  bytearrayInpustream

處理流：bufferedinputstrem datainputstream

18 System.in out在流系統中稱為標準的輸入和輸出  鍵盤就是標準的輸入  控制檯就是標準的輸出

19 序列化：將物件轉換為位元組儲存起來，然後再以後還原這個物件，這種機制就做物件的序列化。

20 一個類的物件要想實現序列化必須實現Serializable介面。

21 流：ObjectInputStream ObjectOutputStream

22 序列化的過程中，static型別的變數是無法序列化的，如果在序列化的過程中，A包含了對B的引用，那麼B也會同A一併的序列化，如果B不予許序列化，那麼這時當A序列化的時候，就會發生異常，這時候必須將B型別的變數使用transient關鍵字進行標註

23 當我們進行序列化和反序列化的時候，如果我們實現了

privatevoid writeObject

privatevoid readObject

那麼序列化來說可以讓我們更加隨心所欲的定義那些屬性需要序列化和反序列化。

執行緒與程序

1 、程序：執行中的程式。（程式是靜態的概念，程序是動態的概念）。獨立性、動態性、併發性

2、進行是由執行緒來組成的。

3、目的：最大化的使用CUP，提高當前應用的效能。

4、

5、優點：

1）多執行緒共享記憶體，節約系統 資源成本

2）充分利用CPU，執行併發任務，效率高

3）Java內建多執行緒程式設計

6、Java如何實現多執行緒？

1）Thread類

2）Runnable

3)  Calable介面

4）Futrue介面

7、對於我們的Java系統來說都是針對於多執行緒執行的，我們的main方法就是一個主執行緒

8、執行緒的實現有兩種方式：1）繼承Thread類2）實現Runnable介面  run方法就是執行緒執行的 程式碼  start()才是真正的執行執行緒的方法

9、Thread類和Runnable介面的區別：

1）Thread類也實現了Runnable介面，因此他實現了Runnable介面中的run方法

2）Thread類中有Runnable介面的引用，這個變數名字 叫做target,

3）當我們使用第一種方式生成執行緒的時候，我們需要重寫run方法，因為Thread類繼承了Runnable介面，而且run方法中如果沒有傳遞實現了Runnable介面的實現類的話，run方式就是個空方法，什麼都不做。

4）使用第二種方式建立執行緒的時候，我們需要實現Runnable介面，然後將實現了Runnable介面的實現類以引數的方式傳遞到Thread類中，那麼當呼叫Thread類中的run方法的時候，我們就是呼叫的實現了Runnable介面的那個run方法

10、對於執行緒的執行是不可控的，那麼我通常會通過一些手段來控制執行緒

1）迴圈

11、多執行緒對同一資源進行訪問的注意點：

1）如果一個類中的變數是一個全域性變數，多執行緒對這個物件的變數進行操作的時候，他們對成員變數的操作會影響到其他的執行緒（如果說一個執行緒修改了全域性變數，那麼其他執行緒訪問該變數的時候，一定會受到影響，比如A a=1   a=1,對於成員變數來說，執行緒是共享成員變數的

2）如果一個類的變數是區域性變數，多執行緒對這個物件的區域性變數進行訪問的時候，每一個執行緒都會對區域性變數進行一次賦值（copy）,換句話說，每一個執行緒都有自己的一份區域性變數，對於區域性變數的改變不會影響到其他執行緒。

12、執行緒的同步：

我們使用Synchronized關鍵字進行執行緒的同步，Synchronized就是一個鎖。

13、synchronized：當使用多執行緒訪問同一個資源的時候，有可能會發生執行緒的同步問題，那麼我使用Synchronized關鍵字進行同步的解決

14、Java中每一個物件都有一個預設的鎖或者是監視器（monitor）,當訪問某個物件的Synchronized方法的時候，表示將該物件上鎖，這時候任何的執行緒都無法方法這個Synchronized方法方法了，直到該執行緒執行完畢或者發生異常的時候，該執行緒會釋放鎖。

15、任何一個類不管生成多少個物件，JVM他們永遠只對於一個Class物件

16、使用Static 和Synchronized關鍵字修飾方法的時候，他上鎖的物件是當前物件的Class物件。因此當執行緒分別訪問同一個類的兩個物件的Static \synch方法時，他們執行的是順序。

用synchronized關鍵字宣告的靜態方法，同時只能被一個執行執行緒訪問，但是其他執行緒可以訪問這個物件的非靜態方法。即：兩個執行緒可以同時訪問一個物件的兩個不同的synchronized方法，其中一個是靜態方法，一個是非靜態方法。

在一個物件被某個執行緒鎖