Java 基礎總結

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　Java基礎總結


jdk:Java的開發環境與部署環境
jre:Java的運行環境


Java數據類型分爲:基本類型和引用類型
基本類型:①整數類型 byte   short   int   long 默認值: 0
  ②字符類型 char 默認值: 空格
  ③浮點類型 float  double 默認值: 0.0
  ④布爾類型 boolean 默認值: false
引用類型:①類
 ②接口
 ③數組
 ④ null 類型
Java中除基本類型以外的類型都被稱爲引用類型，默認值爲: null


八大基本數據類型: 
byte 字節型 1個字節 8位 -2^7~2^7-1
short 短整型 2個字節 16位 -2^15~2^15-1
int 整型 4個字節 32位 -2^31~2^31-1 默認
long 長整型 8個字節 64位 -2^63~2^63-1 使用時在數據最後加 L/l
float 單精度浮點型 4個字節 32位 使用時在數據最後加 F/f
double 雙精度浮點型 8個字節 64位 默認
char 字符型 2個字節 16位 0~65535
boolean 布爾型 1個字節 8位 false true
能夠給 char 型的變量直接賦 int 型的值，取值範圍是0~65535，可是不能直接賦整數的變量。
整數與小數(整型與浮點型)運算獲得的結果是一個浮點型的數。
整數與整數(或整型變量)運算獲得的是一個 int 型的值，但 long 與其餘整數進行運算獲得的是一個 long 型的值。


數據類型轉換: 字節小的能夠直接轉換成字節大的
強制類型轉換: 須要的數據類型 變量名=(須要的數據類型)要轉換的數據


Java運算符:
算術運算符: + - * / %  
賦值運算符: = += -= *= /= %= &= |= ^= <<= >>= >>>=
位運算符: &(按位與) |(按位或) ~(按位非) ^(按位異或) <<(左移運算符) >>(右移運算符) >>>(無符號右移運算符)
比較運算符: > < >= <= == !=
邏輯運算符: &&(邏輯與):二者爲真才爲真,只要一個爲假,結果則爲假 運算時如第一個運算結果爲假，則再也不進行後續運算 獲得結果爲假
||(邏輯或):一個爲真,結果就爲真 運算時，如第一個運算結果爲真，則後續運算再也不進行 獲得結果爲真
!(邏輯非): 把假變真，把真變假
&(不短路與)
|(不短路或)
^(異或):當兩個結果不一樣時才返回 true,當兩個結果相同時則返回 false;
自增自減: ++(自增): 前++: 先自增再運算  後++: 先運算再自增
  --(自減): 前--: 先自減再運算  後--: 先運算再自減
三目運算符: (先對邏輯表達式求值) ? (爲真返回結果) : (爲假返回結果);


&和&&的區別：
單&時，左邊不管真假，右邊都進行運算；
雙&時，若是左邊爲真，右邊參與運算，若是左邊爲假，那麼右邊不參與運算。
|和||的區別同理，雙或時，左邊爲真，右邊不參與運算。


==與=號的區別:
==判斷等號兩邊是否相等，==號判斷八大基本數據類型的時候是比較值是否相等，比較非八大基本數據類型的時候是比較引用地址是否相等
=號是賦值運算符，是將=號右邊的數值賦值給=號左邊;


條件語句: 
① if(條件表達式){
代碼塊;
   }
② if 嵌套:if(條件表達式1){
    if(條件表達式2){
     if(條件表達式n){
   代碼塊;
     }
    }
       }
③ if(條件表達式){
代碼塊1;
   }else {
 代碼塊2;
   }
④ if(條件表達式1){
代碼塊1;
   }else if(條件表達式2){
代碼塊2;
   }else if(條件表示式3){
代碼塊3;
   }else{
代碼塊4;
   }
⑤ switch(值或一個變量){
case 值1:
執行內容;
break;
case 值2:
執行內容;
break;
default:
默認內容;
break;
} 
switch 條件中能夠使用的類型:byte,short,int,char,枚舉,jdk1.7後能夠使用 String;


循環控制語句:
for 循環: for (初值表達式;終止條件;步長表達式){
語句塊;
 }
while 循環: while (循環條件){
循環體;
迭代語句;
   }
do while 循環: do{
循環體;
迭代語句;
  }while (循環條件);
do while 特色是條件不管是否知足，循環體至少被執行一次。

foreach 循環: Java1.5後纔出現
使用 foreach 循環遍歷數組和集合元素時，無須得到數組和集合長度，無須根據索引來訪問數組元素和集合元素


foreach 循環與普通循環的區別:無須循環條件，無須循環迭代語句;


九九乘法表:
for (int i=1;i<=9 ;i++ )
{
for (int j=1;j<=i ;j++ )
{
System.out.print(j+"*"+i+"="+i*j+"\t");
}
System.out.println();
}


百錢買百雞:100元錢買100只雞，其中公雞5元一隻，母雞3元一隻，小雞3只一元，問有多少方案？
for (int cock=1;cock<=20 ;cock++ )
{
for (int hen=1;hen<=33 ;hen++ )
{
for (int chick=3;chick<=99 ;chick+=3 )
{
if (cock*5+hen*3+chick/3==100) //百錢
{
if (cock+hen+chick==100) //百雞
{
System.out.println("公雞: "+cock+"\t母雞: "+hen+"\t雛雞: "+chick);
}
}
}
}
}


斐波那契數列:0、一、一、二、三、五、八、1三、2一、34....
①int[] arr = new int[20];  
arr[0] = arr[1] = 1;  
for (int i = 2; i < arr.length; i++) {  
arr[i] = arr[i - 1] + arr[i - 2];  
}  
System.out.println("斐波那契數列的前20項以下所示：");  
for (int i = 0; i < arr.length; i++) {  
System.out.print(arr[i] + "\t");  
} 
②int s=1;
int k=1;
int temp=0;
for (int i=0; i<20;i++ ){
temp=s+k;
s=k;
k=temp;
}
System.out.println("斐波那契數列的前20項"+temp);  


1~100之內的質數:
    for(int i=1;i<=100;i++) {
      for(int j=2;j<=i;j++){
       if(i%j==0)//素數是指除了1和自身外不能被任何數整除的數,所以遍歷每個小於i大於2的整數j
       //若是i可以被j整除
         if(i==j)
           //若是當i等於j的時候則知足i是素數的條件,即只能被1(j是從2計數的)和自身整除,所以i是素數
           System.out.println(i +"是素數");
         else
           //在若是存在一個小於i大於2的整數j能夠整除i,則i必不是素數,所以break操做.
           break;//若是i能夠被j整除且j不等於i,則跳出循環
      }
    }


打印正三角形:
for(int i=1;i<=10;i++){
for(int j=10-i;j>0;j--){
System.out.print(" ");
}
for(int j=1;j<=2*i-1;j++){
System.out.print("*");
}
System.out.println();
}


break:跳出當前循環語句(結束當前循環語句);
continue:結束本次循環，繼續執行下一次循環，而不是直接退出，
當使用 continue 時，此後的代碼將沒法運行，能夠控制循環什麼時候結束;
return:返回方法，後面不能再存在語句


數組:同一種數據類型的集合(下標從0開始~length-1結束)
格式:數據類型[] 數組名=new 數據類型[數組長度];
獲取數組長度: 數組名.length;
獲取數組元素: 數組名[下標號];
數組遍歷與數組增刪查改
二維數組:
格式:數據類型[][] 數組名=new 數據類型[行數][列數];
 數據類型[][] 數組名={{},{},{}};
冒泡排序法:把小的泡冒到上面，大的沉到下面，最值在中間與其餘值進行交換
for (int i=0;i<array.length-1 ;i++ )
{
for (int j=0;j<array.length-i-1 ;j++ )
{
if (array[j]>array[j+1])
{
int temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}

選擇排序法:
for (int i=0;i<array.length-1 ;i++ )
{
for (int j=i+1;j<array.length ;j++ )
{
if (array[i]>array[j])
{
int temp=array[i];
array[i]=array[j];
array[j]=temp;
}
}
}


從前日後刪除多個:
for (int i=0;i<count ;i++ )
{
if (del==array[i][0])
{
for (int j=i;j<count-1 ;j++ )
{
for (int k=0;k<array[i].length ;k++ )
{
array[i][j]=array[i+1][j];
}
}
count--;
i--;
}
}


------------------------------------- 面 向 對 象 --------------------------------------
數據結構
目的:增強類與對象的內存分配理解、增強操做能力、理解數據結構。
數據:計算機化的信息。
數據元素:數據的基本單位，即數據集中的個體，節點、記錄
數據項:有獨立含義的數據，數據域、字段
數據對象:具備相同特性的數據元素的集合。

結構:數據元素之間的關係
數據結構:帶有結構的數據對象
線性結構:各數據元素之間的邏輯能夠用一個線性序列簡單的表達出現，反之爲非線性結構
線性結構包括:線性表(數組，鏈式表(單鏈，雙鏈))、隊列，棧
非線性結構:樹(只有一個根結點)、圖
棧:限定只能從表一端進行插入和刪除的線性表
特色:First In Last Out(FILO) 先進後出
隊列:限定只能在表的一端進行插入運算，在表的另外一端進行刪除運算的線性表
特色:First In First Out(FIFO) 先進先出


數組與鏈表的區別:
①存儲空間的區別:數組是靜態分配內存空間的，全部元素時存放在一組地址連續的存儲單元中，一旦分配，不可更改，也就不便於擴展，
數據元素在數組中的順序號可肯定它在存儲單元中的位置，所以順序中不須要指針域，而鏈表是動態分配內存空間，存儲空間是不肯定的。
②數組便於查找和修改（由於是下標定位），可是不利於插入和刪除（刪除的時候數組要一個一個的移動，數據的移動量過大），也不便於擴充由於它是連續的地址，
是靜態的存儲結構，而鏈表不便於查找與修改（須要從鏈頭找到鏈尾數組量過大），但便於插入，刪除且速度快（由於能夠指針直接指向，刪除的時候直接脫鏈就能夠了）。


鏈表是否是二叉樹？
是，鏈表是左斜樹或右斜樹中的一種。
左斜樹：從根節點開始，全部節點都一直往左走。
右斜樹：從根節點開始，全部節點都一直往右走。


樹是N（N>0）個結點的有限集合，在一棵非空有限集合中，有且僅有一個特定的結點稱爲樹的根結點，根節點之下能夠有0個以上的子節點(也能夠沒有),而各子節點稱爲此樹的子樹。
根結點、葉子結點(終端結點)、父結點、兄弟結點、結點度(分支度)、樹的度(樹的分支度)、階層、高度(深度)、祖先、林、
根結點:一個樹當中沒有父結點的結點。
葉子結點(終端結點):一棵樹中沒有子結點的結點。
非終端結點:除葉子結點之外的全部結點。
兄弟結點:同一個父結點的全部結點。
結點度(分支度):每個結點擁有結點的個數。
樹的度(樹的分支度):一棵樹中最大的結點。
階層:結點特性值:將結點值設爲1，其子結點的值爲2。
高度和深度:一棵樹中最大階層值。
祖先:由某個結點X到根結點之路徑上的全部結點。


二叉樹也被稱爲二次樹或二分樹，是樹的一種，二叉樹的結點最多隻有兩個，所以二叉樹的結點度最大值是2。
二叉樹的定義: 由有限個結點所構成之集合，此集合能夠爲空。
二叉樹的結點能夠分爲兩棵子樹，稱左子樹和右子樹。同時左右子樹也是二叉樹。
在二叉樹的第I層最多有2的I減1次方個結點。（I>=1）。2^(I-1)
高度爲K的二叉樹中最多有2的K次方減1個結點。2^K-1

滿二叉樹：樹中全部結點均在同一階層而其它非終端結點度均爲「2」，且樹的高度是K，其結點爲2的K次方減1。2^k-1
徹底二叉樹：一棵樹中扣除最大階層，那層後一滿二叉樹，且階層最大層的階層均向左對齊。此樹稱爲徹底二叉樹。
一棵樹若是是滿二叉樹，那麼它必定是徹底二叉樹，一棵樹若是是徹底二叉樹，它不必定是滿二叉樹。


(小左大右)
二叉樹的遍歷:①先序:根 左 右 若二叉樹非空，則訪問根結點，按先序遍歷左子樹，再遍歷右子樹。
 ②中序:左 根 右 若二叉樹非空，按中序遍歷左子樹，再訪問根結點，再按中序遍歷右子樹。
 ③後序:左 右 根 若二叉樹非空，按後序遍歷左子樹，再遍歷右子樹，再訪問根結點。


二叉樹的刪除:①無左無右:分爲: 根結點 非根結點，可是是葉子結點(分爲:左葉子 右葉子)
 ②有左無右:分爲: 根結點 非根結點(分爲:左結點 右結點)
 ③有右無左:分爲: 根結點 非根結點(分爲:左結點 右結點)
 ④有左有右:分爲: 根結點 非根結點(分爲:左結點 右結點)(判斷是要上移左結點的最右邊或右結點的最左邊)


樹與二叉樹的比較：
二叉樹能夠爲空，而樹不能夠（至少要有根結點）。
二叉樹的子樹有順序關係，而樹沒有。
二叉樹的度必爲（0 ，1， 2）而樹的結點度能夠大於2。




定義Java中的方法:
訪問修飾符  返回值類型   方法名(參數列表){
方法體;
}
方法的優勢: (方法的命名以小寫字母開頭，遵循駝峯命名規則)
①使程序變得更簡短而清晰
②有利於程序的維護
③能夠提升程序開發的效率
④提升了代碼的複用性

class 類名{
屬性(成員變量): 數據類型 屬性名=初始值;
行爲(方法);
}
根據類來建立對象:
語法: 類型(數據類型)變量名=new 類名(); //類名與變量名不能一致
類的對象的調用: 
對象的變量名.方法名([參數]);
在同一個Java文件中能夠定義多個類，可是隻有一個類能夠用 public 修飾，而且類名要與 public 所修飾的類名保持一致。


成員變量(實例變量、全局變量):成員變量定義在類中，在整個類中均可以被訪問
 成員變量有默認初始化值，每 new 一次就開闢一次內存空間
成員變量隨着對象的創建而創建，存在於對象所在的堆內存中
局部變量:局部變量只定義在局部範圍內(函數內，語句內等)
 局部變量存在於棧內存中，做用範圍結束，變量空間將自動釋放
 局部變量沒有默認初始化值
類變量:使用 static 修飾，只開闢一次內存，定義在類中
   伴隨類的存在而存在，釋放內存較晚
成員變量與類變量的區別:
①存放位置: 類變量隨着類的加載而存在於方法區中，實例變量隨着對象的創建而存在於堆內存中、
②生命週期: 類變量生命週期最長，隨着類的消失而消失，實例變量生命週期隨着對象的消失而消失


靜態變量和實例變量的區別:
①在語法定義上的區別: 靜態變量前要加static關鍵字，而實例變量前則不加。
②在程序運行時的區別: 實例變量屬於某個對象的屬性，必須建立了實例變量，其中的實例變量纔會被分配空間，才能使用這個實例變量。
   靜態變量不屬於某個實例對象，而屬於類，因此也稱爲類變量，只要程序加載了類的字節碼，不用建立任何實例對象，靜態變量就會分配空間，靜態變量就能夠被使用了。
實例變量必須建立對象後才能夠經過這個對象來使用，靜態變量則能夠直接使用類名來引用。




面向對象開發通過 OOA(面向對象分析)、OOD(面向對象設計)和 OOP(面向對象編程) 三個階段
面向對象(OO): 將功能封裝進對象，強調具有了功能的對象
類與對象的關係: 類是對象的抽象，對象是類的實例
類的成員包括: 屬性(變量)和行爲(方法)
用來描述對象的動態特徵(行爲)的一個動做序列是對象的方法而非屬性，類的方法描述了該類的對象的行爲
使用對象的屬性形式是: 對象.屬性名
使用對象的方法形式是: 對象.方法名()
面向對象的三大(四大)特徵: 封裝、繼承、多態(抽象)
面向對象的思惟:
做爲面向對象的思惟來講，當考慮問題時，不該該再考慮第一步幹嗎，第二步幹嗎，而應該首先考慮，做爲這個問題來講，
在這個問題裏，應該有哪些類哪些對象；而後再考慮這些類和對象，每一種類和每一種對象，應該具備哪些屬性和方法；
再考慮類與類之間具有了什麼樣的關係。


Java中參數傳遞:
①傳值:方法調用時，實參把它的值傳遞給對應的形參，方法執行中形參值的改變不影響實參的值。(八大基本類型)
②傳引用(傳址):方法調用時，實參的引用(地址，而不是參數的值)被傳遞給方法中相對應的形參，
在方法執行中，對形參的操做實際上就是對實參的操做，方法執行中形參值的改變將會影響實參的值。(非八大基本類型,數組,對象)


權限修飾符: public 公共的 > protected 受保護的 > default 默認的、缺省的、友元 > private 私有的
全部類、全部包 > 本類、本包、子類  > 本包、本類 (包修飾符)        > 本類


 static 靜態修飾符
① static 修飾的方法是靜態方法，靜態方法不能直接訪問非靜態方法，靜態方法能夠直接訪問靜態方法和靜態屬性
②非靜態方法任什麼時候候均可以直接訪問靜態方法和靜態屬性
③靜態的方法和屬性能夠直接用類名.訪問(不一樣類中)
④ static 修飾的方法和屬性內存只分配一次，在內裝載器中開闢內存
⑤ static 修飾的變量是屬於類而不屬於對象， static 修飾的內容被對象所共享
⑥ static 不能以任何形式去訪問 this 和 super
⑦若是想在第一時間執行加載某段代碼，能夠使用靜態代碼塊(靜態代碼塊只會執行一次)
⑧ main 方法是程序的入口，必須使用 static 修飾
⑨ static 不能修飾類(內部類能夠使用 static 修飾)，不能修飾構造方法
靜態是在內裝載器中開闢內存，而非靜態是在 new 一個對象的時候纔在堆內存中開闢內存
靜態若是想要調用非靜態，必需要先 new 一個對象，而後使用對象調用
當成員被靜態修飾符修飾時，就多了一個調用方式，除了能夠被對象調用外，還能夠直接被類名調用，類名.靜態成員


是否能夠從一個static方法內部發出對非static方法的調用？
不能夠，由於非static方法是要與對象關聯在一塊兒的，必須建立一個對象後，才能夠在該對象上進行方法調用，而static方法調用時不須要建立對象，能夠直接調用。


重載( overload ): 在同一個類中，方法名相同，參數列表不一樣，與返回值及權限修飾符無關
參數列表不一樣的狀況: ①參數個數的不一樣
  ②參數個數相同，但參數類型不一樣
  ③參數個數與參數類型都相同時，參數類型的順序不一樣


封裝(private): 把一個對象的屬性私有化，同時提供一些能夠被外界訪問的屬性和方法， setter() 方法和 getter() 方法，this表明當前對象
封裝就是使用方法將類的數據隱藏起來，控制用戶對類的修改和訪問數據的程度。
隱藏對象的內部實現細節
private double money;
public void setMoney(double money){
this.money = money;
}
public double getMoney(){
return this.money;
}
封裝的好處: ① 類內部的結構能夠自由的修改
② 能夠對成員進行更精確的控制
③ 隱藏信息，實現細節


繼承(extends): 子類繼承父類除私有化修飾的屬性和方法 具備 "什麼什麼是一種什麼" 兩者之間就存在繼承關係
  關鍵字: extends (子類其實也繼承了父類私有化修飾的屬性和方法，可是子類沒有訪問父類中私有化修飾的屬性和方法的權限)
父類(超類、基類)(superclass) 子類(派生類) object 類是全部類的父類(祖宗類)
繼承的特色: Java只支持單一繼承，不支持多繼承 一個子類只能有一個直接父類，一個父類能夠有多個子類
繼承的優勢: 減小了代碼的冗餘，提升了代碼的複用性
繼承的目的: 讓子類能夠使用父類除私有化修飾的屬性和方法


重寫( override / overwrite )(方法覆蓋): 創建在繼承的基礎之上，子類與父類擁有相同的方法名，相同的參數列表，子類返回值權限小於等於父類返回值權限，而且子類方法訪問權限大於等於父類方法訪問權限
重寫遵循 兩同兩小一大 原則:
兩同: ①方法名相同 
  ②形參列表相同
兩小: ①子類方法返回值類型應比父類方法返回值類型更小或相等
  ②子類方法聲明拋出的異常類應比父類方法聲明拋出的異常類更小或相等
一大: 子類方法的訪問權限應比父類方法的訪問權限更大或相等
爲什麼須要重寫: 當父類方法不能知足子類的需求的時候，就須要重寫父類方法


重載與重寫的異同: 
同:都有相同的方法名
異:①重載是在同一個類中，而重寫是在繼承的基礎上，在子父類中
   ②重載是方法的參數列表不一樣，而重寫是子父類中方法參數列表一致
   ③重載與返回值無關，而重寫是子類方法返回值類型比父類方法返回值類型更小或相等
   ④重載與權限修飾符無關，而重寫是子類方法的訪問權限比父類方法的訪問權限更大或相等
Overload 和 Override 的區別。Overloaded的方法是否能夠改變返回值的類型？
Overload是重載的意思，Override是覆蓋的意思，也就是重寫。
重載Overload表示同一個類中能夠有多個名稱相同的方法，但這些方法的參數列表各不相同（即參數個數或類型不一樣）。
重寫Override表示子類中的方法能夠與父類中的某個方法的名稱和參數徹底相同，
子類覆蓋父類的方法時，只能比父類拋出更少的異常，或者是拋出父類拋出的異常的子異常，
子類方法的訪問權限只能比父類的更大，不能更小。
Override 能夠翻譯爲覆蓋，它是覆蓋了一個方法而且對其重寫，以求達到不一樣的做用，在覆蓋是要注意:
一、覆蓋的方法的標誌必需要和被覆蓋的方法的標誌徹底匹配，才能達到覆蓋的效果；
二、覆蓋的方法的返回值必須和被覆蓋的方法的返回一致；
三、覆蓋的方法所拋出的異常必須和被覆蓋方法的所拋出的異常一致，或者是其子類；
四、被覆蓋的方法不能爲private，不然在其子類中只是新定義了一個方法，並無對其進行覆蓋。
Overload對咱們來講可能比較熟悉，能夠翻譯爲重載，是指咱們能夠定義一些名稱相同的方法，經過定義不一樣的輸入參數來區分這些方法，
而後再調用時，VM就會根據不一樣的參數樣式，來選擇合適的方法執行，在使用重載要注意:
一、在使用重載時只能經過不一樣的參數樣式。例如，不一樣的參數類型，不一樣的參數個數，不一樣的參數順序(固然，同一方法內的幾個參數類型必須不同);
二、不能經過訪問權限、返回類型、拋出的異常進行重載；
三、方法的異常類型和數目不會對重載形成影響；
四、對於繼承來講，若是某一方法在父類中是訪問權限是private，那麼就不能在子類對其進行重載，若是定義的話，也只是定義了一個新方法，而不會達到重載的效果。
Overloaded的方法能夠改變返回值的類型，由於重載與返回值無關。

構造方法(構造器)( constructor ):
①方法名與類名同樣
②構造方法無返回類型，而且在new一個對象的時候，由JVM自動調用
③構造方法一樣聽從方法重載的原則
④在構造方法中調用另外一個構造方法， this 語句必須放在第一行，this(要調用的構造方法的參數)
⑤提早初始化類中的屬性和方法
⑥若是程序在類中有非空構造方法，那麼JVM不會自動生成空構造方法，不然會自動生成一個空構造方法
⑦ new 一個對象的時候，從這個對象開始到 object ，默認是最子類查找空構造方法直到 object ，
  途中若是有一個類缺乏空構造方法，則編譯不經過。
  查找是從最子類查找到最父類
  執行是從最父類執行到最子類
⑧ super 可調用父類的非空構造方法 super(要調用構造方法參數);要放在第一行。
  super 調用父類的屬性和方法
⑨不能使用 static 修飾構造方法


在同一個構造方法中，不能同時出現使用 super 與 this 調用構造函數，由於在構造函數中，
使用 super 與 this 調用構造方法，語句都須要放在程序的第一行！！！


構造器Constructor是否能夠被Override?
構造器Constructor不能被繼承，所以不能重寫Override，但能夠被重載Overload。


多態(動態綁定、遲綁定)( Polymorphism ): 使用 instanceof 判斷前一個對象是否爲後一個類的實例
指在執行期間(而非編譯期)判斷所引用對象的實際類型，根據其實際的類型調用其相應的方法。
多態是創建在繼承的基礎之上，在繼承機制的容許下，能夠將某個對象當作其所屬類，也能夠當作其超類，這樣就能夠將
 多個對象當作同一個類，當子類重寫父類的方法，由同一個對象調用，產生不一樣的行爲，這種現象就叫多態。
把子類的實例賦給父類的引用，父類的引用指向子類的實例。
多態存在的三個必要條件:①要有繼承
②要有重寫
③父類引用指向子類對象
三個條件知足，當你調用父類裏被重寫的方法時，實際中 new 的哪一個子類對象就調用哪一個子類對象的方法。
非靜態方法: 父有子有，調子類方法；父有子無，調父類方法；
靜態方法:父有子有，調父類方法；父有子無，調父類方法；
屬性:父有子有，調父類方法；父有子無，調父類方法；
父無子有 編譯失敗
引用類型變量 instanceof 類(接口)
instanceof 運算符前面操做數的編譯時，類型要麼與後面的類相同，要麼與後面的類具備父子繼承關係，不然會引發編譯錯誤。
instanceof 運算符的做用是: 在進行強制類型轉換以前，首先判斷前一個對象是否爲後一個類的實例，是否能夠成功轉換，從而保證代碼更加健壯。
 
final:
①能夠修飾類，可是不能被繼承（沒有子類， final 類中的方法默認是 final 的）
②能夠修飾方法，可是不能被重寫，能夠被繼承
③能夠修飾屬性，修飾的屬性值不能改變，是一個常量（常量命名規則，字母所有是大寫，兩個單詞以上的用"_"鏈接）
④能夠修飾參數，修飾的參數也不能改變
⑤不能修飾構造方法。


使用final 關鍵字修飾一個變量時，是引用不能變，仍是引用的對象不能變?
使用final 關鍵字修飾一個變量時，是引用變量不能變，引用變量所指向的對象中的內容仍是能夠改變的。


抽象類:abstract 抽象的就是看不懂的
抽象類的含義:逆着關係由下向上(從子類到父類)，類逐漸變得通用，變得抽象，越往上越通用、越抽象，越往下越具體實用
注意事項:
①抽象方法所在的類就是抽象類
②抽象方法:沒有方法體的方法就叫作抽象方法，抽象方法要用 abstract 修飾
③抽象類不能 new(不能實例化)
④抽象類能夠被繼承，可是子類要有兩種狀況(1.重寫父類的全部抽象方法 2.要麼子類用 abstract 修飾)
⑤抽象類能夠繼承抽象類，也能夠繼承普通類，普通類也能夠繼承抽象類
⑥抽象類裏面能夠有變量、常量、普通方法、構造方法
⑦抽象方法不能用 private 修飾(私有化)
⑧抽象方法不能用 static 修飾
⑨抽象類也不能用 final 修飾
⑩被 abstract 修飾的東西不能與 native 同時使用，也不能與 synchronized 同時使用
⑾抽象類中的方法要被使用，必須由子類重寫其全部的抽象方法後，創建子類對象調用
若是子類只覆蓋了部分抽象方法，那麼該子類仍是一個抽象類


接口:interface 擴展了程序的功能
概念:和類是同一種結構，可是比抽象類更加抽象
(能夠把接口理解爲一個純的抽象類，接口裏全部的方法都是抽象方法)
注意事項:
1.接口裏不能有構造方法、不能有普通方法、能夠有抽象方法
2.接口裏抽象方法能夠加 abstract 修飾，能夠不加，默認會是 public 、 abstract 修飾
3.接口裏面的抽象方法不能用 protected 和 private 修飾，能夠用 public 修飾
4.接口裏能夠有變量、常量、靜態常量，編譯後全部屬性都是靜態常量(默認爲:public static final 修飾)
5.接口能夠用來彌補Java裏面類單一繼承的缺陷
6.接口能夠繼承接口，而且能夠繼承多個接口(接口只能繼承接口，不能繼承類，繼承多個接口中間用","分隔)
7.類能夠實現多個接口(實現接口後必需要重寫全部的抽象方法),實現多個接口的時候用","分隔
8.接口不能實例化(不能 new)
9.實現接口關鍵字:implements
10.類實現接口語法是: class 類名 implements 接口名


類能夠繼承一個類的同時實現多個接口。


爲何Java不支持多繼承卻支持多實現?
由於多繼承的方法，都存在方法體，當子類重寫父類的方法時，會使JVM綁定規則變得更復雜，
而多實現的方法，不存在方法體，能夠由子類任意定義，只需重寫一次，故而不會增長JVM的綁定機制和複雜度。


抽象類與接口的區別: 
同: ①都是上層的抽象層
    ②都不能實例化
    ③都能包含抽象的方法，這些抽象的方法用於描述類具有的功能，可是沒必要提供具體的實現。
異: ①在抽象類中能夠寫非抽象的方法，從而避免在子類中重複書寫他們，這樣能夠提升代碼的複用性，這是抽象的優點；接口中只能有抽象的方法。
    ②一個類只能繼承一個直接父類，這個父類能夠是具體的類也能夠是抽象類；可是一個類能夠實現多個接口。
接口能夠繼承接口。抽象類能夠實現(implements)接口，抽象類能夠繼承具體類。抽象類中能夠有靜態的main方法。


abstract class類中定義抽象方法必須在具體(Concrete)子類中實現
接口（interface）能夠說成是抽象類的一種特例，接口中的全部方法都必須是抽象的
接口中的方法定義默認爲public abstract類型，接口中的成員變量類型默認爲public static final


抽象類與接口二者的語法區別:
1.抽象類能夠有構造方法，接口中不能有構造方法。
2.抽象類中能夠有普通成員變量，接口中沒有普通成員變量
3.抽象類中能夠包含非抽象的普通方法，接口中的全部方法必須都是抽象的，不能有非抽象的普通方法。
4. 抽象類中的抽象方法的訪問類型能夠是public，protected和（默認類型,雖然eclipse下不報錯，但應該也不行），但接口中的抽象方法只能是public類型的，而且默認即爲public abstract類型。
5. 抽象類中能夠包含靜態方法，接口中不能包含靜態方法
6. 抽象類和接口中均可以包含靜態成員變量，抽象類中的靜態成員變量的訪問類型能夠任意，但接口中定義的變量只能是public static final類型，而且默認即爲public static final類型。
7. 一個類能夠實現多個接口，但只能繼承一個抽象類。
二者在應用上的區別:
接口更多的是在系統架構設計方法發揮做用，主要用於定義模塊之間的通訊契約。
而抽象類在代碼實現方面發揮做用，能夠實現代碼的重用.
------------------------------------------------------------------------------------------------------------------------------------------
面向對象試卷知識點解析
1. Java是一種面向對象的語言，其核心概念即 類和對象，採用面向對象的設計思想能夠利用封裝、繼承和多態實現代碼的複用。
2. 所謂對象就是真實世界中的實體，對象與實體是一一對應的，類是具有某些共同特徵的實體的集合，它是一種抽象的概念。
   類是一種抽象的數據類型，它是對所具備相同特徵實體的抽象，類與對象的關係:類是對象的抽象，對象是類的實例。
3. 在Java中，一組有相同屬性、共同行爲和共同關係的對象的抽象稱爲類。
4. 類是對象的抽象，對象是類的實例。
5. 類的實例是對象，類是對現實世界中客觀事物的抽象。
6. 用來描敘對象的動態特徵的一個動做序列是對象的方法而非屬性。類的方法描述了該類的對象的行爲。
7. 使用對象的屬性形式是 對象.屬性，使用對象的方法形式是對象.方法名();屬性是對象所擁有的靜態特徵，方法是對象擁有的動態特徵。
8. 類的成員包括屬性和行爲。
9. 在Java中，定義一個類使用關鍵字 class ，而建立類的對象則使用 new 關鍵字。類能夠是 private 的也能夠是 public 的。
10.方法定義後，聲明爲 public 的方法，能夠被本類或其餘類調用，而若是被原本的其餘方法定義，不必定非要聲明爲 public 。
11.方法的調用，在本類中兩個普通方法的相互調用，能夠直接寫方法名便可，也能夠經過 this 關鍵字調用。
12.對象的方法除在main()中能夠調用外，也能夠在其餘位置調用。
13. Java中類的建立方式: 訪問修飾符  class  類名{}
14. Java中無參方法的建立方式: 訪問修飾符 返回值類型 方法名(){}
15.被 static 修飾的變量叫靜態變量或類變量，被 static 修飾的成員變量和成員方法獨立於該類的任何對象，也就是說，
   它不依賴類特定的實例，被類的全部實例共享，只要這個類被加載，Java虛擬機就能根據類名在運行時數據區的方法區內找到它們，
   所以， static 對象能夠在它的任何對象建立以前訪問，無需引用任何對象，用 public 修飾的 static 成員變量和成員方法本質是全局變量和全局方法，
   當聲明它類的對象的時候，不生成 static 變量的副本，而是類的全部實例共享同一個 static 變量。
16. 在類中，被 static 修飾的方法叫靜態方法，也叫類方法。類方法能夠被類名直接調用，也能夠被實例調用，在靜態方法中，
   只能調用靜態方法，不能夠直接調用非靜態方法。
17.使用 static 修飾的成員稱爲靜態成員或類成員，能夠使用類名直接訪問，而未使用 static 修飾的成員爲實例成員，只能使用類的對象訪問。
18.在靜態方法中，類的靜態成員變量能夠直接使用，而類的實例變量不能直接使用，必須先建立對象，再使用對象訪問。
19.實例方法能夠直接調用本類的方法，不能直接調用父類的實例方法和類方法，也不能調用其餘類的實例方法。
20.成員變量能夠和成員方法中的局部變量同名，在成員變量前加 this ，使用 this 訪問該成員變量。
21.一個成員方法中的局部變量不能在另外一個成員方法中直接訪問。
22.全局靜態變量在函數調用過程當中更改，離開函數後更改任然有效。
23.構造方法名必須和類名一致，而且沒有返回值，並非 void ，構造方法是在建立對象時調用，
   對其進行初始化工做，構造方法能夠在一個類中出現屢次，即 重載。
24.若是類中顯示定義了一個或多個構造方法，而且全部的構造方法都帶參數，那麼這個類就失去了默認的空構造方法。
25.實現封裝須要經過 private ，在開發中，每每將屬性私有化，這些使用 private 修飾的屬性或方法，
   只能在本類訪問，其餘類中不可直接調用，並且構造方法也能夠封裝。
26.在類中，私有方法(private)是不能夠被其餘類直接訪問的，訪問範圍僅限本類。
27.Java封裝的三個步驟:設置 private 屬性，生成 get、set 方法對屬性進行讀寫。
28.封裝可加強數據的訪問限制，下降各模塊之間的依賴程度，也能夠提升代碼的複用程度，
   加強程序的可維護性，與提升性能無關。
29.進行程序設計時，應儘可能避免一個模塊直接操做和訪問另外一個模塊的數據，模塊設計追求 高內聚、低耦合。
   高內聚:儘量把模塊的內部數據、功能實現細節隱藏在模塊內部獨立完成，不容許外部直接干預。
   低耦合:僅暴露少許的方法給外部使用。
30. String 類型的對象是不能被改變的。
31. return 語句以後不能再存在其餘語句，不然會引發編譯錯誤。
32.常量使用 final 關鍵字修飾，其值不能被修改，若是修改了，編譯器將不能經過。
33. abstract 修飾的類是抽象類，抽象類沒法實例化，可是能夠被繼承，自身的方法是能夠重載的。
34.多重繼承中，初始化順序爲:父類屬性-->父類構造方法-->子類屬性-->子類構造方法。
35.抽象類實現接口時，能夠不重寫接口內的方法。
36.接口用於描述系統對外提供的全部服務，所以接口中的成員常量和方法都必須是公開(public)類型的，
   確保外部使用者能訪問它們；接口僅僅描述系統能作什麼，但不知如何去作，因此接口中的方法都是抽象(abstract)方法；
   接口不涉及任何與實例相關的細節，所以接口沒有構造方法，不能實例化，沒有實例變量，只有靜態(static)常量(final)。
37.Java能夠經過實現接口，間接實現多重繼承。
38.接口不能被實例化，能夠有多個實現類，實現類實現接口必須實現接口方法，接口能夠被接口繼承。
39.Java中，面向接口編程的好處有:更加抽象，更加面向對象，提升編程的靈活性，提升可維護性，下降耦合。
40.在Java中，父類對象轉換爲子類類型是不安全的，子類對象轉換爲父類類型是安全的。
41.在Java中，若是被重載和重寫的方法相同，那麼重載的方法和重寫的方法不能夠放在相同的類中。
42.在Java中，若是被重載和重寫的方法不一樣，那麼重載的方法和重寫的方法能夠放在相同的類中。
43.在Java中，若是被重載和重寫的方法不一樣，那麼重載的方法和重寫的方法能夠放在不一樣的類中。
44.建立包的語句是 package ，該語句必須放在程序的第一行。
45.Java中方法綁定分爲: 編譯時刻綁定、運行時刻綁定。
46.在編譯時刻綁定的方法有: 靜態方法、 private 修飾的方法、 final 修飾的方法
-------------------------------------------------------------------------------------------------------------------------------------------------
API(application program interface): 應用程序編程接口


java.lang.*;


八大基本類型對象八大基本包裝類: byte   short   int   long   float   double   char    boolean
Byte   Short  Integer Long   Float   Double Character Boolean
Integer 與 int的區別:
int是java提供的8種原始數據類型之一。Java爲每一個原始類型提供了封裝類，Integer是java爲int提供的封裝類。
int的默認值爲0，而Integer的默認值爲null，即Integer能夠區分出未賦值和值爲0的區別，int則沒法表達出未賦值的狀況.
int不適合做爲web層的表單數據的類型

==號與equals的區別: 
== 比較八大基本類型是比較值是否相等，比較非八大基本類型的地址是否相等 ，
equals 是比較非八大基本類型的地址是否相等，可是equals能夠經過重寫從而知足比較非八大基本類型的值是否相等的要求
重寫equals() 方法 以知足判斷非八大基本類型值是否相等的要求
重寫toString() 方法 利用三目運算符 返回須要獲得的信息
==號與equals方法的區別:
==操做符專門用來比較兩個變量的值是否相等，也就是用於比較變量所對應的內存中所存儲的數值是否相同，
要比較兩個基本類型的數據或兩個引用變量是否相等，只能用==操做符。
equals方法是用於比較兩個獨立對象的內容是否相同。它比較的是兩個對象是獨立的。


常量池: 常量池在編譯期碰見String 字符串時，它會檢查該池內是否已經存在相同的String 字符串，若是找到，
就把新變量的引用指向現有的字符串對象，不建立任何新的String 常量對象，沒找到再建立新的。
因此對一個字符串對象的任何修改，都會產生一個新的字符串對象，原來的依然存在，等待垃圾回收。


變長參數: ...  在最後一個形參的類型後增長三點(...)，代表該形參能夠接受多個參數值。
個數可變的形參只能處於形參列表的最後，一個方法中最多隻能包含一個個數可變的形參。
個數可變的形參本質就是一個數組類型的形參，所以調用包含個數可變形參的方法時，
該個數可變的形參既能夠傳入多個參數，也能夠傳入一個數組。
當不明確參數個數的時候採用變長參數。


克隆: 三原則: ①必須 implements Cloneable 
②必須重寫
③調用的時候要捕獲異常
淺克隆:對象內部是八大基本類型和String ,原對象和克隆出的對象是兩個不一樣的對象，改變原對象數據，並不會改變克隆後對象的值。
深克隆:對象內部是自定義類型，改變的是地址，改變原對象數據，會影響到克隆後的數據的值。


寫clone()方法時，一般都有一行代碼，是什麼？
clone()有缺省行爲，代碼是: super.clone();由於首先要把父類中的成員複製到位，而後纔是複製自己的成員。


String 和 StringBuffer 的區別: 
String 類提供了數值不可改變的字符串，而StringBuffer 類提供的字符串能夠進行修改。
String 類覆蓋了equals方法和hashCode方法，而 StringBuffer 沒有覆蓋equals方法和hashCode方法，
因此，將 StringBuffer 對象存儲進Java集合類中時會出現問題


--------------------------------- 異常處理: Exception --------------------------------
異常: 運行期 出現的錯誤。程序中出現不正常的狀況。
錯誤是指在程序運行的過程當中，發生的一些異常事件(如: 除0溢出，數組下標越界，所要讀取的文件不存在等);
拋出(throw)異常:Java程序的執行過程當中如出現異常事件，能夠生成一個異常類對象，該異常對象封裝了異常事件的信息並提交給Java運行時的系統。
捕獲(catch)異常:當Java運行時系統接收到異常對象時，會尋找能處理這一異常的代碼，並把當前異常對象交給其處理。
Throwable : 可被拋出的  Java語言中全部錯誤或異常的超類。
Error: 嚴重問題：Error 咱們不處理。這種問題通常都是很嚴重的，由java虛擬機生成並拋出，好比說內存溢出、動態連接失敗、虛擬機錯誤等。
Exception: 編譯期異常（檢查性異常）: 必須進行處理的，由於你不處理，編譯就不能經過
RuntimeException: 運行期異常（非檢查性異常）:RuntimeException 這種問題咱們能夠不處理，由於是你的問題，並且這個問題出現確定是咱們的代碼不夠嚴謹，須要修正代碼的。


異常的分類:
Error: 稱爲錯誤-由java虛擬機生成並拋出，好比說內存溢出、動態連接失敗、虛擬機錯誤等。程序對其不作處理
Exception: 全部異常類的父類，其子類對應了各類各樣可能出現的異常事件，通常須要用戶顯示的聲明或捕獲。
RuntimeException: 一類特殊的異常，如被0除、數組下標越界等，其產生比較頻繁，處理麻煩，若是顯式的聲明或捕獲將會對其程序可讀性和運行效率影響很大。
所以由系統自動檢測並將它們交給缺省的異常處理程序（用戶可沒必要對其處理）


編譯時異常和運行時異常的區別:
 * 編譯期異常：Java程序必須顯示處理，不然程序就會發生錯誤，沒法經過編譯
 * 運行期異常：無需顯示處理，也能夠和編譯時異常同樣處理


經常使用異常：
ArithmeticException 算術異常
ArrayIndexOutOfBoundsException 下標越界
ArrayStoreException 數組存儲異常
ClassCastException 類轉換異常
ClassNotFoundException 找不到類異常
IllegalThreadStateException 非法線程異常
InterruptedException 中斷異常
NoSuchFieldException 沒有字段異常
NoSuchMethodException 沒有這個方法異常
CloneNotSupportedException 不支持克隆
NullPointerException 空對象異常
NumberFormatException 數字格式化異常
RuntimeException 運行時異常
UnsupportedOperationException 不支持當前操做異常


異常中要經常使用的幾個方法：
 public String getMessage():異常的消息字符串
 public String toString():返回異常的簡單信息描述
   此對象的類的 name(全路徑名)
   ": "（冒號和一個空格） 
   調用此對象 getLocalizedMessage()方法的結果 (默認返回的是getMessage()的內容)
 printStackTrace() 獲取異常類名和異常信息，以及異常出如今程序中的位置。返回值 void 。把信息輸出在控制檯


處理異常的方式: 
try catch finally 三都不能獨立存在， catch 和 finally 也不能組合使用，只能try 與 catch 或 try 與 finally 組合使用
A:try...catch...finally
B:try...catch
C:try...catch...catch...
D:try...catch...catch...finally
E:try...finally


若是 catch 裏面有 return 語句，請問 finally 裏面的代碼還會執行嗎?若是會，請問是在 return 前，仍是 return 後。
答： 會。前。準確的說，應該是在中間。


final,finally 和finalize的區別
 final ：最終的意思，能夠修飾類，成員變量，成員方法 修飾類，類不能被繼承 修飾變量，變量是常量 修飾方法，方法不能被重寫
 finally ：是異常處理的一部分，用於釋放資源。通常來講，代碼確定會執行，特殊狀況：在執行到finally以前jvm退出了
 finalize ：是 Object 類的一個方法，用於垃圾回收


異常處理第二種方式: 
格式: throws 異常類名
注意：這個格式必須跟在方法的括號後面。
throw:若是出現了異常狀況，咱們能夠把該異常拋出，這個時候的拋出的應該是異常的對象


注意：
儘可能不要在main 方法上拋出異常。


throws 和 throw 的區別(面試題)
throws
用在方法聲明後面，跟的是異常類名
能夠跟多個異常類名，用逗號隔開
表示拋出異常，由該方法的調用者來處理
throws 表示出現異常的一種可能性，並不必定會發生這些異常
throw
用在方法體內，跟的是異常對象名
只能拋出一個異常對象名
表示拋出異常，由方法體內的語句處理
throw 則是拋出了異常，執行 throw 則必定拋出了某種異常
throw 語句能夠單獨使用， throw 語句拋出的不是異常類，而是一個異常實例，並且每次只能拋出一個異常實例。


自定義異常類 自定義異常類名以 Exception 結尾
兩種方式: 
A:繼承 Exception-------編譯期異常類
B:繼承 RuntimeException-----運行期異常類


------------------------------------ 線程 Thread ------------------------------------
進程: 就是正在運行的程序。進程是系統進行資源分配和調用的獨立單位。
每個進程都有它本身的內存空間和系統資源。
同一時間CPU只能執行一個進程，線程上下文切換比進程上下文切換要快得多。
線程是依賴於進程而存在的，一個進程中至少有一個線程。
線程是程序的執行單元，執行路徑，是程序使用CPU的最基本單位。
單線程: 若是程序只有一條執行路徑。
多線程: 若是程序有多條執行路徑。
多線程的意義: 不是提升程序的執行速度，而是爲了提升應用程序的使用率。


併發(Concurrent): 一個處理器同時處理多個任務。  邏輯上的同時發生
併發(Parallel): 多個處理器或是多核的處理器同時處理多個不一樣的任務。   物理上的同時發生。
Java程序的運行原理: 
由java命令啓動JVM，JVM啓動就至關於啓動了一個進程。
接着由該進程建立了一個主線程去調用main方法。
JVM虛擬機的啓動是單線程仍是多線程的: 
JVM虛擬機的啓動時多線程的,緣由是垃圾回收線程也要先啓動，不然會很容易出現內存溢出。
垃圾回收線程加上主線程，最低啓動了兩個線程，故，JVM的啓動是多線程的。
線程的生命週期: 
新建: 建立一個線程對象
就緒: 調用start()方法後，線程有執行資格，但沒有獲取到執行權(也就是沒有獲取到CPU內存資源)
運行: 獲取到執行權(獲取到CPU內存資源)
阻塞: 沒有執行資格也沒有執行權，通常是調用方法 suspend() sleep() wait() join() 方法後線程進入阻塞狀態
死亡: run()方法結束，或線程被中斷(調用方法stop()或destroy())


如何實現多線程:
1.繼承 Thread 類。
A: 自定義類繼承 Thread 類。
B: 自定義類中重寫run()方法。
C: 建立自定義類對象
D: 啓動線程 使用start()方法
2.實現 Runnable 接口。
A: 自定義類實現 Runnable 接口。
B: 自定義類中重寫run()方法。
C: 建立自定義類對象
D: 建立 Thread 類對象，並把自定義類對象做爲構造參數傳遞。


爲何要將 Runnable 接口的子類對象傳遞給 Thread 類的構造函數:
由於自定義的run()方法所屬的對象是 Runnable 接口的子類對象，
因此要讓線程去執行指定對象的run()方法就必須明確該run()方法所屬對象。


兩種實現多線程的方法的區別: 
實現 Runnable 接口能夠避免Java中單一繼承的侷限性；
適合多個相同程序的代碼去處理同一個資源的狀況，把線程同程序代碼數據有效的分離。
增長程序的健壯性，代碼能夠被多個線程共享，代碼和數據獨立。
繼承 Thread : 線程代碼存放在 Thread 子類run()方法中
實現 Runnable : 線程代碼存放在 Runnable 接口的子類的run()方法中。
Thread 類中的run()方法，是用於存儲線程要運行的代碼。
重寫run()方法的目的是: 將自定義的代碼存儲在run()方法中，讓線程運行。
一個線程只能調用一次start()方法，若是調用屢次會出現: IllegalThreadStateException : 非法的線程狀態異常


run()和start()的區別: 
run() : 僅僅是封裝被線程執行的代碼，直接調用時普通方法
start() : 首先啓動了線程，而後再由JVM去調用該線程的run()方法




多線程安全問題的緣由(判斷一個程序是否有線程安全問題的依據)
A : 是否有多線程環境
B : 是否有共享數據
C : 是否有多條語句操做共享數據


線程同步: 
①線程同步就是線程排隊 
②只有共享資源的讀寫訪問才須要同步
③只有變量才須要同步訪問
④多個線程訪問共享資源的代碼有多是同一份代碼，也有多是不一樣的代碼。
解決線程安全問題: 
A : 同步代碼塊:
synchronized(對象){ 須要被同步的代碼; }
這裏鎖的對象是任意對象
B : 同步方法
把同步加在方法上。
這裏的鎖對象是 this
C : 靜態同步方法
把同步加在靜態方法上
這裏的鎖對象是 當前類的字節碼文件對象 文件名.class
同一對象共享數據不須要加 static ，多個不一樣對象共享數據要加 static


多線程有幾種實現方案，分別是哪幾種？
兩種  繼承 Thread 類,實現 Runnable 接口
擴展一種: 實現 Callable 接口，和線程池結合。重寫call()方法
同步有幾種方式？分別是什麼？
同步代碼塊，同步方法，同步靜態方法
sleep()和wait()方法的區別:
sleep() : 必須值時間；不釋放鎖；
wait() : 能夠不指定時間，也能夠指定時間；釋放鎖；
爲何wait(),notify(),notifyAll()等方法都定義在 Object 類中？
由於這些方法都調用是依賴於鎖對象的，而同步代碼塊的鎖對象是任意鎖。
而 Object 表明任意的對象，因此，定義在這裏面。


當一個線程進入一個對象的一個synchronized方法後，其它線程是否可進入此對象的其它方法?
分幾種狀況：
     1.其餘方法前是否加了synchronized關鍵字，若是沒加，則能。
     2.若是這個方法內部調用了wait，則能夠進入其餘synchronized方法。
     3.若是其餘個方法都加了synchronized關鍵字，而且內部沒有調用wait，則不能。
     4.若是其餘方法是static，它用的同步鎖是當前類的字節碼，與非靜態的方法不能同步，由於非靜態的方法用的是this。


簡述synchronized和java.util.concurrent.locks.Lock的異同？
主要相同點：Lock能完成synchronized所實現的全部功能
主要不一樣點：Lock有比synchronized更精確的線程語義和更好的性能。
synchronized會自動釋放鎖，而Lock必定要求程序員手工釋放，而且必須在finally從句中釋放。


守護線程:也叫精靈線程、後臺線程
特色:
A : 不具有生命週期，它隨着虛擬機的結束而結束
B : 若是想把線程轉換成精靈線程，必須在start()以前調用 setDaemon(boolean)方法
一旦線程變爲精靈線程就不能變爲用戶線程了。


守護線程和用戶線程的區別: 
守護線程是無生命週期的，伴隨着用戶線程存在，若是用戶線程執行完畢，守護線程尚未執行完畢，
那麼守護線程也將結束，守護線程在線程啓動前調用，setDaemon(true)


線程池: 根據自身的環境狀況，有效的限制執行線程的數量，使得運行效果達到最佳。
線程池的做用: 
減小建立和銷燬線程的次數，每一個工做線程能夠屢次使用
可根據系統狀況調整執行的線程數量，防止消耗過多內存。
使用:
ExecutorService pool = Executors.常見線程池；
常見線程池:
①newSingleThreadExecutor : 建立一個單線程的線程池
②newFixedThreadExecutor(n) : 建立固定大小的線程池
③newCacheThreadExecutor(推薦使用) : 建立一個可緩存的線程池
④newScheduleThreadExecutor : 大小無限制的線程池，支持定時和週期性的執行線程


1.線程同步的目的是爲了保護多個線程訪問一個資源時對資源的破壞。
2.線程同步方法是經過鎖來實現的，每一個對象都有且僅有一個鎖，這個鎖與一個特定的對象關聯，線程一旦獲取了對象鎖，
其餘訪問該對象的線程就沒法再訪問該對象的其餘同步方法。
3.對於靜態同步方法，鎖是針對這個類的，鎖對象是該類的Class對象。文件名.class 
靜態和非靜態方法的鎖互不干預。
一個線程得到鎖，當在一個同步方法中訪問另外對象上的同步方法時，會獲取這兩個對象鎖。
4.對於同步，要時刻清醒在哪一個對象上同步，這是關鍵。
5.編寫線程安全的類，須要時刻注意對多個線程競爭訪問資源的邏輯和安全做出正確的判斷，
對"原子"操做做出分析，並保證原子操做期間別的線程沒法訪問競爭資源。
6.當多個線程等待一個對象鎖時，沒有獲取到鎖的線程將發生阻塞。
7.死鎖是線程間相互等待鎖形成的，在實際中發生的機率很是的小。


線程組(ThreadGroup): 是指java.lang.ThreadGroup 類的對象


線程組與線程池的區別: 
①線程組存在的意義，首要緣由是 安全。
java默認建立的線程都是屬於系統線程組，而同一個線程組的數據是能夠相互修改對方的數據的。
線程組除安全外，最有用的一個地方就是 控制，只需用單個命令便可完成對整個線程組的操做。
②線程池存在的意義，首要做用是 效率。
線程的建立和結束都須要耗費必定的系統時間，不停建立和刪除線程會浪費大量的時間，
因此，在建立出一條線程並使其在執行完任務後不結束，而是使其進入休眠狀態，在須要用時再喚醒，
那麼 就能夠節省必定的時間
線程組和線程池共有的特色: 
1. 都是管理必定數量的線程
2. 均可以對線程進行控制---包括休眠，喚醒，結束，建立，中斷（暫停）--但並不必定包含所有這些操做。


------------------------------------java.util.*------------------------------------
數組和集合的區別: 
A : 長度區別 數組的長度是固定的，集合長度是可變的
B : 存儲內容不一樣 數組存儲的是同一種類型的元素，而集合能夠存儲不一樣類型的元素
C : 元素的數據類型問題 數組能夠存儲基本數據類型，也能夠存儲引用類型，而集合只能存儲引用類型。


public interface Collection<E> extends Iterable<E>
Collection 接口用於表示任何對象或元素組 這是一個超級接口 迭代器是 iterator() 實用add()進行存儲
<> 表明泛型，裏面只能放類名，裏面放的是什麼類型，那麼這個容器就只能存儲對應類型的數據。
集合必須只有對象，集合中的元素不能是基本數據類型
功能: 
1.添加功能: boolean add(Object obj) : 添加一個元素
boolean addAll(Collection c) : 添加一個集合的元素
2.刪除功能: void clear() : 移除全部元素
boolean remove(Object obj) : 移除一個元素
boolean removeAll(Collection c) : 移除一個集合的元素
3.判斷功能: boolean contains(Object obj) : 判斷集合中是否包含指定元素
boolean containsAll(Collection c): 判斷集合中是否包含指定的集合中全部元素
boolean isEmpty() : 判斷集合是否爲空
4.獲取功能: Iterator<E> iterator() : 返回在 Collection 的元素上進行迭代的迭代器
5.長度功能: int size() : 獲得集合中元素個數
6.交集功能: boolean retainAll(Collection c) : 兩個集合都有的元素
7.把集合轉換爲數組: Object[] toArray() : 將集合轉換成 Object[] 數組


public abstract class AbstractCollection<E> extends Object implements Collection<E>
AbstractCollection 繼承於 Collection 爲其減小工做負擔而存在的一個抽象類。


迭代器(Iterator)自己是一個對象，並且是輕量級的，它的工做就是：
     遍歷並選擇集合序列中的元素，而客戶端沒有必要知道底層的實現。
一個標準的、統一的來遍歷一個Collection的方式,它是一個迭代器
hasNext() 是否有下一個元素
next()必須重複調用這個方法直到hasNext()返回false
remove()；方法刪除由next方法返回的最後一個元素，每次調用next()方法後，只能調用一次該方法


public interface List<E>extends Collection<E>
List 集合表明一個有序的集合，集合中的每個元素都有其對應的順序索引。List集合容許使用重複的元素，能夠經過索引訪問指定位置的集合元素
簡述 實現 操做特性 成員要求
ArrayList 提供快速的基於索引的成員訪問，對尾部成員的增長和刪除支持較好
List 提供基於索引的對成員的隨機訪問 成員可爲任意 Object 子類的對象
LinkedList 對列表中任何位置的成員的增長和刪除支持較好，但對基於索引的成員訪問支持性能較差
List集合的特色： 有序(存儲和取出的元素一致)，可重複的。增長了下標了操做
List集合的特有功能：
 A：添加功能:
void add(int index,Object element):在指定位置添加元素
 B：獲取功能:
Object get(int index):獲取指定位置的元素
 C：列表迭代器:
ListIterator listIterator()：List集合特有的迭代器
 D：刪除功能:
Object remove(int index)：根據索引刪除元素,返回被刪除的元素
 E：修改功能:
Object set(int index,Object element):根據索引修改元素，返回被修飾的元素


public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>
AbstractList 使用鏈表進行存儲的一個抽象類，能最大的程度減小隨機訪問的數據，也有數組存儲，容許多個null，能夠重複，由於每一個值都有單獨的存儲空間


列表迭代器：
ListIterator listIterator()：List集合特有的迭代器
該迭代器繼承了Iterator迭代器，因此，就能夠直接使用hasNext()和next()方法。  
特有功能：
Object  previous():獲取上一個元素
Boolean  hasPrevious():判斷是否有前一元素 * 
注意：ListIterator能夠實現逆向遍歷，可是必須先正向遍歷，才能逆向遍歷，因此通常無心義，不使用
ArrayList,Vector集合應該使用隨機訪問方法(get)來遍歷集合元素，這樣性能最好，對於 LinkedList 集合，則應該採用迭代器來遍歷集合元素
若是要常常執行插入刪除操做來改變包含大量數據的 List 集合的大小，可考慮使用 LinkedList


public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable
Vector 是同步的，實用 Enumeration elements() 的迭代器， 這是以數組的形式存儲的。 
Vector 的特有功能：
1：添加功能
public  void  addElement(Object obj) add()
2：獲取功能
public  Object  elementAt(int index)  get()
public  Enumeration  elements() Iterator iterator()
boolean  hasMoreElements() hasNext()
Object  nextElement() next()


public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable
ArrayList 
這是一個異步的，它實現了 List 接口，是一個實用類，用數組進行儲存的，此類大體上等同於 Vector 類，除了此類是不一樣步的


ArrayList 與 Vector 區別: 
① Vector 是同步的， ArrayList 是異步的
② Vector 速度慢， ArrayList 速度快
這兩個類都實現了List接口（List接口繼承了Collection接口），他們都是有序集合，即存儲在這兩個集合中的元素的位置都是有順序的，至關於一種動態的數組.

同步性:
Vector是線程安全的，也就是說是它的方法之間是線程同步的，而ArrayList是線程序不安全的，它的方法之間是線程不一樣步的
若是隻有一個線程會訪問到集合，那最好是使用ArrayList，由於它不考慮線程安全，效率會高些；若是有多個線程會訪問到集合，那最好是使用Vector，由於不須要咱們本身再去考慮和編寫線程安全的代碼。
數據增加: 
 ArrayList與Vector都有一個初始的容量大小，當存儲進它們裏面的元素的個數超過了容量時，就須要增長ArrayList與Vector的存儲空間
 Vector默認增加爲原來兩倍，而ArrayList的增加策略在文檔中沒有明確規定（從源代碼看到的是增加爲原來的1.5倍）。
 Vector增加原來的一倍，ArrayList增長原來的0.5倍。
 
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, Serializable
LinkedList 是用鏈表進行存儲的，實用 ListIterator listIterator(int index)做爲迭代器，能夠從指定的位置開始循環，
由於是鏈表，因此這個方法方便插入和刪除，能夠快速找到開頭和結尾，這是雙向鏈表
LinkedList 的特有功能：
  A:添加功能
public void addFirst(Object e)
public void addLast(Object e)
B:獲取功能
public Object getFirst()
public Obejct getLast()
C:刪除功能
public Object removeFirst()
public Object removeLast()


public class Stack<E> extends Vector<E>
Stack 類表示後進先出（LIFO）的對象堆棧
這是以棧的形式進行存儲，它在 Vector 的基礎上進行了擴充，容許將容許將向量視爲堆棧。
 E push(E item) 壓入棧頂
List 總結
1. 數據增加到必定程度的時候， ArrayList 增加原來的一半，而 Vector 增加原來的一倍。 
2. ArrayList 底層以數組形式存儲數據（ Vector, Stack 也是以數組存儲數據的），且長度可變。 
3. LinkedList 底層以雙向鏈表的形式存儲數據。 
4. ListIterator 和 Iterator 的區別：前者雙向鏈表，後者是單向鏈表。 
5. ArrayList : 容許多個 null ，能夠放入不一樣種類型，也能夠放入相同的值。 
6. ArrayList 裏頭的remove()、indexOf()都要用equals()方法判斷，不然比較的是地址。 
7. ArrayList 和 Vector 區別: Vector 是同步的，一次一個數據，子類是 Stack ； ArrayList 是異步的，一次能夠來多個數據，速度快，安全性很差。
ArrayList : 底層數據結構是數組，查詢和修改快，增長刪除慢，線程不安全，效率高。異步的
Vector : 底層數據結構是數組，查詢和修改快，增長刪除慢，線程安全，效率低。
LinkedList : 底層數據結構是鏈表，查詢和修改慢，增長刪除快，線程不安全，效率高。


public interface Queue<E>extends Collection<E>
Queue 接口並未定義阻塞隊列的方法，實現一般不容許插入 null 元素。
remove() 和 poll() 方法可移除和返回隊列的頭


public abstract class AbstractQueue<E> extends AbstractCollection<E> implements Queue<E>
AbstractQueue 此類提供某些 Queue 操做的骨幹實現。此類中的實現適用於基本實現不容許包含 null 元素時。
它是以隊列的形式存儲，先進先出，不能有null，能夠快速進行判斷堆棧是否爲滿或空，這是一個抽象類


public interface Set<E> extends Collection<E>
一個不包含重複元素的 Collection 。更確切地講， Set 不包含知足 e1.equals(e2) 的元素對 e1 和 e2，而且最多包含一個 null 元素。
Set 集合的特色： 無序(存儲和取出的元素順序不一致)，不容許重複的


public abstract class AbstractSet<E> extends AbstractCollection<E> implements Set<E>
此類提供 Set 接口的骨幹實現，從而最大限度地減小了實現此接口所需的工做。


public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, Serializable
此類實現 Set 接口，由哈希表（其實是一個 HashMap 實例）支持。它不保證 Set 的迭代順序；特別是它不保證該順序恆久不變。此類容許使用 null 元素。
異步的，能夠有 null ，迭代器爲 Iterator iterator() ，實現 Set 接口，採用哈希算法存儲
A:底層數據結構是哈希表(是一個元素爲鏈表的數組)
B:哈希表底層依賴兩個方法：hashCode()和equals()
  執行順序：
首先比較哈希值是否相同
哈希值相同：繼續執行equals()方法
返回true：元素重複了，不添加
返回false：直接把元素添加到集合
哈希值不一樣：就直接把元素添加到集合
C:如何保證元素惟一性的呢?
由hashCode()和equals()保證的
D:自定義類若是想要元素的惟一性必須重寫hashCode()和equals()方法
HashSet 中元素無序，容許空，不容許重複
LinkedHashSet:底層數據結構由哈希表和鏈表組成。 哈希表保證元素的惟一性。鏈表保證元素有序。(存儲和取出是一致)
HashSet 集合判斷兩個元素相等的標準就是兩個對象經過equals方法確認相等，而且兩個對象的hashCode()方法返回值也相等。
HashSet之類的集合不能夠按索引號去檢索其中的元素，也不容許有重複的元素
重寫hashCode的規則：
【1】當兩個對象經過equals方法比較時返回true時，這兩個對象的hashCode應該相等。 
【2】對象中用做equals比較標準的屬性，都應該用來計算hashCode值。 




public class TreeSet<E> extends AbstractSet<E> implements NavigableSet<E> , Cloneable, Serializable
TreeSet 異步的，能夠進行排序；這是二叉樹，以鏈表形式進行存儲，實現 SortedSet 接口，默認是升序。
A:底層數據結構是紅黑樹(是一個自平衡的二叉樹)，是TreeMap的鍵
B:保證元素的排序方式
a:天然排序(元素具有比較性)
讓元素所屬的類實現 Comparable 接口 ，重寫compareTo()方法
b:比較器排序(集合具有比較性)
讓集合構造方法接收 Comparator 的實現類對象
提供比較器，重寫compare()方法和equals()（equals方法能夠使用Object中默認繼承的）方法
TreeSet 中元素不容許空，不容許重複，必須是同一種類型的數據，能夠實現元素排序
TreeSet 是 SortedSet 接口的實現類， TreeSet 能夠確保集合元素處於排序狀態。
hash(哈希、散列)算法的功能是，它能保證快速查找被檢索的對象，hash的價值在於速度。
重寫hashCode() 方法的基本規則: 
①在程序運行過程當中，同一個對象屢次調用hashCode()方法應返回相同的值。
②當兩個對象經過equals()方法比較返回true時，這兩個對象的hashCode()方法應返回相等的值。
③對象中用做equals()方法比較標準的實例變量，都應該用於計算hashCode()值。
LinkedHashSet 也是根據元素的hashCode值來決定元素的存儲位置，但同時使用鏈表維護元素的次序，當遍歷 LinkedHashSet 集合裏的元素時，
LinkedHashSet 將會按元素的添加順序來訪問集合裏的元素。


HashSet 的性能老是比 TreeSet 好(特別是最經常使用的添加查詢元素等操做)，由於 TreeSet 須要額外的紅黑樹算來維護集合元素的次序。
只有當須要一個保持排序的 Set 時，才應該使用 TreeSet ，不然都應該使用 HashSet;
對普通的插入、刪除操做， LinkedHashSet 比 HashSet 要略微慢一點，這是由維護鏈表所帶來的額外開銷形成的，但因爲有了鏈表，遍歷 LinkedHashSet 會更快。


public abstract class EnumSet<E extends Enum<E>> extends AbstractSet<E> implements Cloneable, Serializable
EnumSet : 是一個專爲枚舉類設計的集合類， EnumSet 中的全部元素都必須指定枚舉類型的枚舉值，該枚舉類型再建立 EnumSet 時顯式或隱式地指定。
EnumSet 的集合元素也是有序的， EnumSet 以枚舉值在 Enum 類內的定義順序來決定集合元素的順序。
EnumSet 集合不容許加入 null 元素，若是試圖插入 null 元素， EnumSet 將拋出 NullPointerException 異常
EnumSet 是全部 Set 實現類中性能最好的，但它只能保存同一個枚舉類的枚舉值做爲集合元素。
Set 的三個實現類 HashSet 、 TreeSet 和 EnumSet 都是線程不安全的。
若是有多個線程同時訪問同一個 Set 集合，而且超過了一個線程修改了該 Set 集合，則必須手動保證該 Set 集合的同步性，
一般能夠經過 Collections 工具類的 synchronizedSortedSet() 方法來"包裝"該 Set 集合;


Collection 總結 :
1. List :
集合表明一個有序集合，集合中每一個元素都有其對應的索引，因此List集合容許使用重複元素經過索引來訪問指定位置的集合元素。 
List默認按元素的插入順序設置元素的索引。 
List能夠根據索引插入、替換、刪除集合元素 
List最大特色是：可以自動根據插入數量動態改變容器大小。
2.ArrayList 和 Vector:
它們都是基於數組實現的類，因此它們封裝了一個動態分配的 Object[] 
區別： 
ArrayList :對線程不安全，當多線程訪問同一數據時，必須手動集合的同步性[synchronized] 
Vector :對多線程訪問安全，它自己就是同步的，因此效率要比 ArrayList 低 
3.LinkedList:
基於鏈表實現的 List 類，對順序訪問集合中的元素進行優化，特別是插入和刪除的速度特別塊 
4.Set 集合:
Set 集合和 Collection 基本上徹底同樣，它沒有提供任何額外的方法，實際上 Set 就是 Collection ,只是行爲不一樣， Set 不容許包括重複元素，集合裏多個元素之間無明顯順序。 
Set 集合判斷兩個對象相同，不是"=="而是"equals" 
5.HashSet :
按Hash算法來存儲集合中的元素， HashSet 會調用該對象的hashCode方法來獲得該對象的hashCode值，而後該hashCode值來決定該對象在hashCode中的存儲位置。 
它不能保證元素的排列順序，順序有可能發生變化。 
它不是同步的，若是多個線程同時訪問一個該集合時，必須經過代碼來保證其同步 
它的元素值能夠是 null 。
6.LinkedHashSet:
此類也是根據元素的hashCode值來決定元素位置，但它同時使用鏈表維護的順序元素看起來插入的順序保存的，它須要維護元素的插入順序，所以略低於 HashSet 的性能，但迭代訪問 Set 裏的所有元素時將有不少的性能，所以以鏈表來維護內部順序
7.TreeSet :
SortedSet 接口的惟一實現，能夠確保集合元素處於排序狀態，也就是元素是有序的，並非根據元素插入順序，而是根據元素實際值而進行排序的。 
它的兩種排序：一：定製排序 二：天然排序 
若是沒有比較器最多隻能插入一個元素，若是插入第二個元素，會拋一個[ClassCastException] 
8.如何選擇數據結構:
1>Array :讀快-寫慢
2>Linked:改快-讀慢
3>Hash :間於二者之間
數組：便於查詢和修改 不便於刪除和插入（有下標很快的找到和修改，插入刪除還要移位）
鏈表：便於刪除和插入 不便於查詢和修改（無下標 查找修改必從鏈頭開始，刪除和插入直接鏈接便可）


線性結構 有序集合 List 元素能夠重複，能夠有多個 null
LinkedList 使用鏈表做爲底層，方便插入和刪除
ArrayList 使用數組做爲底層，方便查詢和修改 異步
Vector 使用數組做爲底層， 同步
映像 無序集合 Set 元素不能夠重複，僅能夠有一個 null
HashSet 使用哈希表做爲底層，能夠有 null
TreeSet 使用鏈表做爲底層，二叉樹


若是訪問 List 集合中的元素，能夠直接根據元素的索引來訪問。
若是訪問 Map 集合中的元素，能夠根據每項元素的Key來訪問其value。
若是訪問 Set 集合中的元素，則只能根據元素自己來訪問(這也是 Set 集合中元素不容許重複的原則)


Map 集合 : 用於保存具備映射關係的數據 key --- value 
Map 的key不容許重複，即同一個 Map 對象的任何兩個key經過equals()方法比較老是返回false。
key 和 value 之間存在單向一對一關係，即經過指定的key，總能找到惟一的肯定的value。
Map 集合的特色 :
將鍵映射到值的對象，一個映射不能包含重複的鍵，每一個鍵最多隻能映射到一個值。
Map 集合和 Collection 集合的區別 : 
Map 集合存儲元素是成對出現的， Map 集合的鍵是惟一的，值是能夠重複的。
Collection 集合存儲元素是單獨出現的， Collection 的子類 Set 是惟一的， List 是可重複的。
Map 集合的功能 : 
1:添加功能
V put(K key,V value):添加元素。
若是鍵是第一次存儲，就直接存儲元素，返回null
若是鍵不是第一次存在，就用值把之前的值替換掉，返回之前的值
2:刪除功能
void clear():移除全部的鍵值對元素
V remove(Object key)：根據鍵刪除鍵值對元素，並把值返回
3:判斷功能
boolean containsKey(Object key)：判斷集合是否包含指定的鍵
boolean containsValue(Object value):判斷集合是否包含指定的值
boolean isEmpty()：判斷集合是否爲空
4:獲取功能
Set<Map.Entry<K,V>> entrySet();
V get(Object key):根據鍵獲取值
Set<K> keySet():獲取集合中全部鍵的集合
Collection<V> values():獲取集合中全部值的集合
5：長度功能
int size()：返回集合中的鍵值對的對數
Map 集合的鍵是惟一的，值是可重複的。
HashMap 集合的鍵是惟一的，值是可重複的，鍵容許空，值也容許空，鍵只容許一個null，值能夠容許多個空
Hashtable 鍵不容許空，值也不容許空。
TreeMap 鍵不容許空，值容許空，值能夠容許多個空。
HashMap 與 Hashtable 的區別 : 
HashMap 鍵能夠爲空，值也能夠爲空，而且值能夠有多個空， HashMap 是線程異步的。
Hashtable 鍵和值都不容許爲空， Hashtable 是線程同步的。
Hashtable 是 Dictionary<k,v> 接口的子類。
HashMap 和 Hashtable 的特色: 
a:HashMap和Hashtable不能排序，鍵不能重複，值能夠重複 


b:HashMap鍵僅容許一個null，值能夠是多個null; Map集合全是Map.Entry類型。（也能夠說Map集合爲Set集合）;HashTable不容許使用null做爲key或Value 


c:爲了成功的在HashMap和Hashtable上獲取對象，用做key的對象必須實現hashCode方法和equals方法。 


d:和HashSet同樣，HashMap和Hashtable也不能保證其中的key-value對的順序。 


e:使用HashMap和Hashtable判斷兩個key相等的標準也是：兩個key經過equals相等，那兩個key的hashCode值也相等。 


f:HashMap和Hashtable判斷集合中兩個值相等，只要equals相等便可。例如：containsValue方法。


g:若是HashMap和Hashtable使用可變對象做爲key，而且程序修改了做爲key的可變對象，也可能引起和HashSet相似的情形：程序在也沒法訪問到被修改過的key
Hashtable 是一個線程安全的 Map 實現，但 HashMap 是線程不安全的實現，因此 HashMap 比 Hashtable 的性能高一點，但若是有多個線程訪問同一個 Map 對象時，使用 Hashtable 實現類會更好。
Hashtable 不容許使用 null 做爲key 和value ,若是試圖把 null 值放進 Hashtable 中，將會引起 NullPointerException 異常，但 HashMap 能夠使用 null 做爲key或value


HashMap和Hashtable的區別:
HashMap是Hashtable的輕量級實現（非線程安全的實現），他們都完成了Map接口，主要區別在於HashMap容許空（null）鍵值（key）,因爲非線程安全，在只有一個線程訪問的狀況下，效率要高於Hashtable。
HashMap容許將null做爲一個entry的key或者value，而Hashtable不容許。
最大的不一樣是，Hashtable的方法是Synchronize的，而HashMap不是，在多個線程訪問Hashtable時，不須要本身爲它的方法實現同步，而HashMap就必須爲之提供外同步
三方面:
一.歷史緣由:Hashtable是基於陳舊的Dictionary類的，HashMap是Java 1.2引進的Map接口的一個實現
二.同步性:Hashtable是線程安全的，也就是說是同步的，而HashMap是線程序不安全的，不是同步的
三.值：只有HashMap可讓你將空值做爲一個表的條目的key或value


List 和 Map 區別:
一個是存儲單列數據的集合，另外一個是存儲鍵和值這樣的雙列數據的集合，List中存儲的數據是有順序，而且容許重複；Map中存儲的數據是沒有順序的，其鍵是不能重複的，它的值是能夠有重複的。


Collection和 Collections的區別:
Collection是集合類的上級接口，繼承與他的接口主要有Set和List.
Collections是針對集合類的一個幫助類，他提供一系列靜態方法實現對各類集合的搜索、排序、線程安全化等操做。


heap和stack有什麼區別:
Java的內存分爲兩類，一類是棧內存，一類是堆內存。
棧內存是指程序進入一個方法時，會爲這個方法單獨分配一塊私屬存儲空間，用於存儲這個方法內部的局部變量，當這個方法結束時，分配給這個方法的棧會釋放，這個棧中的變量也將隨之釋放
堆是與棧做用不一樣的內存，通常用於存放不放在當前方法棧中的那些數據
方法中的局部變量使用final修飾後，放在堆中，而不是棧中。


Date 時間，瞬間
public class Date extends Object implements Serializable, Cloneable, Comparable<Date>
Date在java.util包下
SimpleDateFormat在java.text包下
Date-->String
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String str = sdf.format(date);
System.out.println(str);
Date-->Long
Date date = new Date();
System.out.println(date.getTime());
String -->Date
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d = sdf1.parse("2013-01-01 10:09:03");
System.out.println(d);
String -->毫秒
String-->Date-->Long
毫秒-->Date
Date d = new Date();
long l = date.getTime();
System.out.println(new Date(l));
毫秒-->String
毫秒-->Date-->String


-------------------------------------java.IO.*------------------------------------
java.io.*;
File類是java.io包下表明與平臺無關的文件和目錄
File能新建、刪除和重命名文件和目錄，File不能訪問文件自己
\\ 表示 路徑分隔符 /
絕對路徑: 完整的路徑
相對路徑: 必須使用其它路徑的信息去解釋
Stream 數據在兩設備間的傳輸稱爲流， 流的本質是數據傳輸，根據數據傳輸特性將流抽象爲各類類，方便更直觀的進行數據操做
按照流的方向不一樣分爲：輸入流和輸出流[針對程序]
按處理單位不一樣分爲：字節流和字符流
按功能不一樣分爲：節點流和處理流 
輸入流與輸出流的區別: 
輸入流：只能從中讀取數據，而不能向其寫出數據 
輸出流：只能向其寫出數據，而不能從中讀取數據 
字節流兩個基類: 
InputStream OutputStream


字符流兩個基類: 
Reader Writer
字符流是字節流的包裝，字符流則是直接接受字符串。
字節流與字符流的區別: 
·讀寫單位不一樣：字節流以字節（8bit）爲單位，字符流以字符爲單位，根據碼錶映射字符，一次可能讀多個字節。 
·處理對象不一樣：字節流能處理全部類型的數據（如圖片、avi等），而字符流只能處理字符類型的數據。 
結論：只要是處理純文本數據，就優先考慮使用字符流。 除此以外都使用字節流.
節點流與處理流: 
節點流：從一個特定的數據源（節點）讀寫數據（文件，內存），也稱爲：低級流 
處理流：鏈接在已存在的流之上（節點流或處理流），經過此對數據的處理爲程序提供更強大的讀寫功能 
節點流:
1. InputStream 是全部的輸入字節流的父類，它是一個抽象類。
2. ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三種基本的介質流，
它們分別從Byte 數組、StringBuffer、和本地文件中讀取數據。
3. PipedInputStream 是從與其它線程共用的管道中讀取數據。
4. ObjectInputStream 和全部FilterInputStream 的子類都是裝飾流（裝飾器模式的主角）。
5. OutputStream 是全部的輸出字節流的父類，它是一個抽象類
6. ByteArrayOutputStream、FileOutputStream 是兩種基本的介質流，它們分別向Byte 數組、和本地文件中寫入數據。
7. PipedOutputStream 是向與其它線程共用的管道中寫入數據。
8. ObjectOutputStream 和全部FilterOutputStream 的子類都是裝飾流。
9. Reader 是全部的輸入字符流的父類，它是一個抽象類。 
10.CharReader、StringReader 是兩種基本的介質流，它們分別將Char 數組、String中讀取數據。
11.PipedReader 是從與其它線程共用的管道中讀取數據。
12.BufferedReader 很明顯就是一個裝飾器，它和其子類負責裝飾其它 Reader對象。 
13.FilterReader 是全部自定義具體裝飾流的父類，其子類PushbackReader 對Reader 對象進行裝飾， 會增長一個行號。 
14.InputStreamReader 是一個鏈接字節流和字符流的橋樑，它將字節流轉變爲字符流。
15.Writer 是全部的輸出字符流的父類，它是一個抽象類。
16.CharArrayWriter、StringWriter 是兩種基本的介質流，它們分別向Char 數組、String 中寫入數據。 
17.PipedWriter 是向與其它線程共用的管道中寫入數據。
18.BufferedWriter 是一個裝飾器爲Writer 提供緩衝功能。
19.PrintWriter 和PrintStream 極其相似，功能和使用也很是類似。
20.OutputStreamWriter 是OutputStream 到Writer 轉換的橋樑，它的子類FileWriter 其實就是一個 實現此功能的具體類（具體能夠研究一SourceCode）。功能和使用和OutputStream 極其相似。
處理流:
緩衝流: BufferedReader,BufferedWriter BufferedInputStream,BufferedOutputStream
過濾流: FilterReader,FilterWriter FilterInputStream,FilterOutputStream
合併流: SequenceInputStream
管道流: PipedReader,PipedWriter PipedInputStream,PipedOutputStream
數據流: DataInputStream,DataOutputStream
打印流: PrintStream PrintWriter 
對象序列化: 正序列化: ObjectOutputStream 反序列化: ObjectInputStream
須要實現  Serializable 接口，禁止序列化關鍵字: transient
處理流的好處: 
1)性能的提升：主要以增長緩衝的方式來提升輸入/輸出的效率
2)操做的便捷：處理流可能提供了系列便捷的方法來一次輸入/輸出大批量的內容，而不是輸入/輸出一個多個"水滴"。 
處理流的特點:1）能夠嫁接到任何流之上。 
轉換流的特色：
1.其是字符流和字節流之間的橋樑
2.可對讀取到的字節數據通過指定編碼轉換成字符
3.可對讀取到的字符數據通過指定編碼轉換成字節


什麼時候使用轉換流？
1.當字節和字符之間有轉換動做時；
2.流操做的數據須要編碼或解碼時。


具體的對象體現：
1.InputStreamReader:字節到字符的橋樑
2.OutputStreamWriter:字符到字節的橋樑
這兩個流對象是字符體系中的成員，它們有轉換做用，自己又是字符流，因此在構造的時候須要傳入字節流對象進來。


數據流:
1.DataInputStream和DataOutputStream 分別繼承自於InputStream和OutputStream，它屬於處理流。
分別須要套接到：InputStream和OutputStream類型的節點流上。
2.DataInputStream和DataOutputStream 提供了能夠存取和機器無關的原始Java數據類型（int,...）方法 


--------------------------------------集合與IO流考試易錯分析------------------------------
1.Map 接口存儲一組成對的鍵-值對象，其中key不要求有序，不容許重複，value不要求有序，但容許重複
2.Java集合框架中，HashMap 類是基於哈希表的Map接口的實現，此實現提供全部可選的映射操做，並容許使用null值和null鍵，
此類不保證映射的順序，特別是它不保證該順序恆久不變。
3.在Java中，List 集合能夠存儲多個null
4.以InputStream(輸入)/OutputStream(輸出) 爲後綴的是字節流;以Reader(輸入)/Writer(輸出) 爲後綴的是字符流。
5.在Java編程中，類對象使用完畢後，建議賦值爲null來釋放分配的內存，對於BufferedReader類對象來講，還要釋放分配的緩衝
區空間，在類方法中close()方法起這個做用。
6.Java的list接口有3個實現類，分別是 ArrayList、LinkedList、Vector,它們用於存放多個元素，維護元素的次序，並且
容許元素重複，ArrayList 是最經常使用的List實現類，內部是經過數組實現的，它容許對元素進行快速隨機訪問，Vector與ArrayList
同樣，也是經過數組實現的，不一樣的是它支持線程的同步，即某一時刻只有一個線程可以寫Vector，避免多線程同時寫而引發的不一致性，
但實現同步須要很高的花費，所以，訪問它要比訪問ArrayList慢。
7.Java的 HashSet 類是由哈希表支持，它不保證set的迭代順序，特別是它不保證該順序恆久不變，此類容許使用null元素，HashSet類
爲基本操做提供了穩定性能。
8.Java的 HashMap 和 Hashtable 都實現了Map接口，它們及其子類都採用Hash算法決定Map中key的存儲。
9.java.util.Collections 類包含不少有用的方法，使用swap()方法能夠在指定列表的指定位置處變換元素。
10.泛型的本質是參數化類型，也就是說所操做的數據類型被指定爲一個參數，這種參數類型能夠用在類、接口和方法的建立中，分班稱爲
泛型類、泛型接口、泛型方法。若是一個類或接口上有一個或多個類型變量，那它就是泛型。
11.在Java中，Hashtable和Vector是屬於線程安全的。
12.FileReader 是繼承自 InputStreamReader,在  Reader的方法read()中，其返回值爲-1的時候，表示當前讀取到文件
流的末尾，此時讀取完畢當前流(若是是文件操做，表示讀取到了文件末尾);
13.ArrayList 採用的是數組形式來保存對象的，這種方式將各元素存儲在連續的內存空間中，因此優勢是遍歷和隨機訪問比較方便，最大的
缺點是插入刪除時很是麻煩，由於都須要循環移位。
14.LinkedList 採用的是將各元素存放在獨立的內存空間中，並且在每一個空間中還保存下一個元素的連接索引，所以插入和刪除比較方便，
只需找到插入和刪除的位置，重置相應元素的連接索引，可是缺點就是查找很是麻煩，由於其各元素的存儲位置不是連續的。
15.ObjectOutputStream 是用於序列化輸出的類，transient用來屏蔽不想序列化的屬性。
16.在Java中，可以用來關閉流的方法是close();
17.Java的集合框架四個基本接口的區別:
Collection 接口是一組容許容許重複的對象;Set 接口繼承 Collection ,但不容許重複;List 接口繼承 Collection,
有序保存數據，容許出現重複的數據，並引入位置下標;Map 接口既不繼承Set 也不繼承 Collection,存取的是鍵值對。
TreeSet 類是 Set 接口的實現類，它有序的保存數據，但不能用對應的索引得到其中的數據，而HashMap 類是基於 Map 實現的，
HashMap存儲"鍵值對(key-value)"的散列表，系統將key-value當成一個總體進行處理，根據Hash算法來計算key-value的
存儲位置，經過key獲取相對應的value值。

------------------------------------ 泛型與反射 ---------------------------------------
泛型: 是一種把類型明確的工做推遲到創建對象或者調用方法的時候纔去明確的特殊的類型
泛型的本質是參數化類型
格式:
<數據類型>
此處的數據類型只能是引用類型。
好處: 
1.把運行時期的問題提早到了編譯期間。
2.避免了強制類型轉換
3.增長數據的安全性，提升了性能
定義泛型類，但不指定泛型類中的參數類型與Object的效果等同。
定義泛型類，並且指定泛型類中的參數類型，若是傳入的數據不是指定類型那麼編譯期間就會報錯。
通配符: ?  <?> 代替全部類型
泛型上限: 表示參數化的類型多是所指定類型，或其子類。 <? extends E>
泛型下限: 使用的泛型只能是本類及其父類類型。 <? super E>
泛型接口: 子類實現有兩種方法:
一.子類確定泛型的類型
二.子類繼續使用泛型
泛型只在編譯器有效。


類的加載:
當程序要使用某個類時，若是該類還未被加載到內存中，則系統會經過加載，鏈接，初始化三步來實現對這個類進行初始化。
加載-------連接-----------初始化
類加載器
負責將.class文件加載到內存中，併爲之生成對應的Class對象。
Bootstrap ClassLoader 根類加載器 也被稱爲引導類加載器，負責Java核心類的加載
Extension ClassLoader 擴展類加載器 負責JRE的擴展目錄中jar包的加載
Sysetm ClassLoader 系統類加載器 負責在JVM啓動時加載來自java命令的class文件，以及classpath環境變量所指定的jar包和類路徑
反射
JAVA反射機制是在運行狀態中，對於任意一個類，都可以知道這個類的全部屬性和方法；對於任意一個對象，都可以調用它的任意一個方法和屬性；
這種動態獲取的信息以及動態調用對象的方法的功能稱爲java語言的反射機制
getConstructors() 獲取全部公共的構造方法
getDeclaredConstructors() 獲取全部的構造方法
getConstructor() 獲取單個公共的構造方法
getDeclaredConstructor() 獲取單個(全部)的構造方法
newInstance() 創建對象
invoke() 方法調用
getName() 獲取名稱
方法.setAccessible(true) 暴力訪問(訪問私有方法屬性)
getMethods() 獲取全部公共的方法(包括父類中公共的方法)
getDeclaredMethods() 獲取全部的方法
getMethod() 獲取單個公共的方法(包括父類中公共的方法)
getDeclaredMethod() 獲取單個(全部)的方法
getFields() 獲取全部公共的屬性
getDeclaredFields() 獲取全部的屬性
getField() 獲取單個公共屬性
getDeclaredField() 獲取單個(全部)屬性
 
-----------------------------------XML-------------------------------------------
 XML有兩個先驅--SGML和HTML  
  SGML（Standard Generalized Markup Language）的全稱是標準通用置標語言，
  它爲語法置標提供了異常強大的工具，同時具備極好的擴展性，所以在分類和索引數據中很是有用。
  可是，SGML很是複雜，而且價格昂貴，在網上傳播遇到了很大障礙
  超文本置標語言HTML（HyperText Markup Language）免費、簡單，在世界範圍內獲得了普遍的應用
*XML：
     可擴展標記語言 
*標記： 
     指計算機所能理解的信息符號。 
*標記語言：
     協調一致用來定義整套語法和文法的標記集 
*XML的官方定義
     SGML的子集，其目標是容許普通的SGML在WEB上以目前HTML的方式被服務、接收和處理。
     XML易於實現，且可在SGML和HTML之間互相操做。 
 XML的優點:
  1) 可擴展的標記
2) 數據共享和重用
3) XML遵循嚴格的語法要求
4) XML便於不一樣系統之間信息的傳輸
5) 數據存儲格式不受顯示格式的制約
6) 包含語義的文檔格式
7) 對面向對象（OOP）的支持  dom
8) 內容與形式的分離。
9) 具備較好的保值性。
 XML的缺點:
  1)語義表達能力上略顯不足
2)XML的有些技術還沒有造成統一的標準
3)應用程序\瀏覽器對XML的支持也是有限的
XML聲明： 
<?xml version = "1.0" encoding = "GB2312" standalone = "no"?>
其形式是：
        <標記>數據內容</標記>
XML和HTML的主要區別: 
XML是被設計用來描述數據的，重點是:什麼是數據，如何存放數據。
HTML是被設計用來顯示數據的，重點是:顯示數據以及如何更好顯示數據。
@Test 執行指定的方法 導入JUnit4包
DOM 是用與平臺和語言無關的方式表示 XML 文檔的官方 W3C 標準。DOM 是以層次結構組織的節點或信息片段的集合。
DOM xml文件的建立: 
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();//獲取 DocumentBuilderFactory 的新實例。
DocumentBuilder db = dbf.newDocumentBuilder();//使用當前配置的參數建立一個新的 DocumentBuilder 實例。
Document doc = db.newDocument();//獲取 DOM Document 對象的一個新實例來生成一個 DOM 樹。
Element root = doc.createElement("root"); //建立根結點

TransformerFactory tf = TransformerFactory.newInstance();// 獲取 TransformerFactory 的新實例。
Transformer t = tf.newTransformer();//此抽象類的實例可以將源樹轉換爲結果樹。
t.transform(new DOMSource(root), new StreamResult("xml文件路徑"));


SAX解析
基於推模式的事件的方式來解析xml，較少佔用內存，速度比DOM解析更快，適應於大文件。
只能讀，不能寫


SAXParserFactory saxp=SAXParserFactory.newInstance();
SAXParser sp=saxp.newSAXParser();
sp.parse(new File("xml文件路徑"),new LxitDefaultHandler());


自定義 類 繼承 DefaultHandler ,
重寫如下五個方法:
startDocument() 接收文檔開始通知
endDocument() 接收文檔結束通知
startElement() 接收節點開始通知
endElement() 接收節點結束通知
characters()  接收元素中字符數據的通知。


DOM4j解析
建立xml文件
String fileName = "xml文件路徑";
Document doc = DocumentHelper.createDocument(); //建立document對象
Element cla = doc.addElement("root"); //創建根結點
XMLWriter writer = new XMLWriter(new FileWriter(fileName));
writer.write(doc);
writer.close();
將字符串轉化爲XML
String text = "<root><stu>值</stu></root>";
Document doc = DocumentHelper.parseText(text);
查詢
SAXReader sr = new SAXReader();
Document doc = sr.read("xml文件路徑");
List<Element> list = doc.selectNodes("根結點/子結點");
for(Element element : list) { System.out.println(element.selectSingleNode("字節點名").getText()); }


增長
String fileName = "xml文件路徑";
Document doc = DocumentHelper.createDocument(); //建立document對象
Element cla = doc.addElement("root"); //創建根結點
Element stu = root.addElement("stu");
Element id = stu.addElement("id");
Element name = stu.addElement("name");
Element sex = stu.addElement("sex");
Element age = stu.addElement("age");
id.setText("要增長進入的屬性值");
name.setText("要增長進入的屬性值");
sex.setText("要增長進入的屬性值");
age.setText("要增長進入的屬性值");
XMLWriter writer = new XMLWriter(new FileOutputStream(fileName));
writer.write(doc);
writer.close();
刪除，修改同上。。。。。。。。。


-------------------------------------- HTML試題解析 -------------------------------------------
1.type 爲 password 是 密碼框 type 爲 radio 是 單選框
  type 爲 hidden 是 隱藏域 type 爲 reset 是重置按鈕
2.避免用戶拖動框架的顯示邊框，能夠使用的是 noresize = "noresize";
3.框架以百分比表示， * 表明其他的百分比。
4.同行單元格高度一致，且水平對齊。
5.HTML 中的特殊符號: &copy; 顯示的是版權符號 &reg; 顯示的是註冊符號
   &times; 顯示的是乘號 X
6.submit 是提交按鈕， reset 是重置按鈕， image 是圖片按鈕。
7.HTML中的列表分爲 : 無序列表 ul、有序列表 ol、定義列表 dl; 其中帶圓點的是 無序列表 ul.
8.form 標籤的type 屬性用於規定input 元素的類型，checkbox 定義複選框，image 定義圖像形式的提交按鈕，
submit 定義提交按鈕，該按鈕會把表單數據發送到服務器，text 定義單行輸入字段。
9.電子郵箱必須包含 @ 符號，，而且以 .com 結尾。


-------------------------------------- Java基礎試題解析  -------------------------------------------
0.面向對象的封裝性，即將對象封裝成一個高度自治和相對封閉的個體，對象狀態（屬性）由這個對象本身的行爲（方法）來讀取和改變。
把對同一事物進行操做的方法和相關的方法放在同一個類中，把方法和它操做的數據放在同一個類中.
1.每一個類都使用 Object 做爲超類，全部對象(包括數組)都實現這個類的方法。
2.在不明確給出超類的狀況下，Java會自動把 Object 做爲要定義類的超類，能夠使用類型爲 Object 的變量指向任意類型的對象。
3.Object 類有一個默認構造方法 public Object(),在構造子類實例的時候，都會先調用這個默認構造方法。
4.Object 類的變量只能用做各類值的通用持有者，要求他們進行任何專門的操做，都須要知道他們的原始類型並進行類型轉換。
5.建立對象格式: 類名 對象名 = new 類名();
6.接口中只能定義靜態常量。
7.類是對象的集合，對象是類的實例。
8.try —— catch —— finally 中，從上往下的catch 塊，其參數類型必須按照從子類到父類的順序，由於一旦匹配到一個類型，catch 塊
捕獲這個超類及其全部子類的異常，而後忽略日後的catch，也就意味着排在後面的子類永遠不會到達，Java中不可到達的代碼被認爲是錯誤的。
9.多態中  父類引用指向子類對象，是沒法調用子類獨有的方法的 子有父無 編譯報錯。
10.抽象類不能使用私有訪問修飾符修飾；抽象方法不能使用final 進行修飾；
11.Java集合框架中，有些類是線程同步安全的類，它們是 Vector、Hashtable、Stack、Enumeration，除了這些以外，其餘的都是非線程安全的類和接口。
線程安全類的方法是同步的，每次只能一個訪問，它們是重量級對象，效率低。
12.Map接口存儲一組成對的鍵——值對象，其中key 不要求有序，不容許重複，value不要求有序，但容許重複。
13.Java中，java.util.Collections 類屬於 無實例類，由於Collections 類提供的方法都是 static 的，因此能夠直接使用
類名.  調用執行，不須要實例化對象。
14.對 HashMap 而言，系統將key-value 當成一個總體進行處理，根據 Hash算法來計算key-value 的存儲位置，這樣就能夠保證能快速存取
Map的key-value 對，HashMap 採用一種所謂的"Hash算法"來決定每一個元素的存儲位置。
15.String 類中substring() 方法用於字符串的截取，返回截取後的新字符串，但原字符串不會發生變化。
16.JavaAPI中，集合Set接口的特色:無序的，元素是惟一的。
17.Java中，String的值是不可變的，這就致使每次對String 的操做都會生成新的String 對象，不只效率低下，並且大量浪費有限的內存空間。
因爲StringBuffer 的內部實現方式和String不一樣， 因此StringBuffer在進行字符串處理時，不生成新的對象，在內存使用上要優於
String類，對StringBuffer對象的每次修改都會改變對象自身。
18.String 既屬於引用類型也屬於基礎數據類型，並且內容是靜態的，在一般狀況效率高些，但若是涉及到鏈接字符串時，對於String 每次鏈接都要從新
分配內存，所以從StringBuffer好。
19.String經過方法操做字符串時，字符串自己沒有變化，操做的是該字符串的副本；
而StringBuffer操做的是字符串的自己，所以StringBuffer 在操做字符串的時更高效.
20.ArrayList 採用的是數組形式來保存對象的，這種方式將各元素存儲在連續的內存空間中，因此優勢是遍歷和隨機訪問比較方便，最大的缺點是插入
刪除時很是麻煩，由於都須要循環移位。
21.LinkedList 採用的將各元素存放，在獨立的內存空間中，並且在每一個空間中還保存下一個元素的連接索引，所以插入和刪除比較方便，只需找到
插入和刪除的位置，重置相應的元素的連接索引，可是缺點是查找很是麻煩，由於其各元素的存儲位置不是連續的。
22.Java的集合框架四個基本接口的區別:
Collection 接口是一組容許重複的對象.
Set 接口繼承Collection,但不容許重複.
List 接口繼承Collection,有序保存數據,容許出現重複的數據,並引入位置下標.
Map 接口既不繼承 Set,也不繼承 Collection,存取的是鍵值對.
23.TreeSet 類是 Set接口的實現類，它有序保存的數據，但不能用對應的索引得到其中的數據。
24.Java集合框架中，HashMap 類是基於哈希表的 Map 接口的實現，此實現提供全部可選的映射操做，並容許使用null值和null鍵，此類不保證映射
的順序，特別是不保證該順序恆久不變。
25.進行數據寫入文件時，並非write()方法，而是flush()方法，進行刷新，將buffer中的數據寫入到存儲目標中。
26.Java的Data類表示特定的瞬間，精確到毫秒，使用Data類的默認構造方法建立出的對象就能夠得到當前時間，要得到當前時間的精確值，在Java中還
能夠經過System.currentTimeMillis()或System.nanoTime()方法得到。
27.FileInputStream類中讀取數據，read()方法讀取字符獲得的ASCII碼值。
28.使用流是爲了簡化數據的讀寫操做，讓程序員能專一在有效合理的數據處理上，而不是底層的數據寫入對應的物理地址、磁盤驅動器的狀態等方面。
29.要進行方法重寫，前提條件是必須繼承了類或實現了一個接口，其次是有能夠重寫的方法，最後纔是符合重寫要求。
30.方法裏不能使用static修飾臨時變量。
31.在靜態方法中，不能直接使用類的非靜態成員，不然編譯不經過。須要先建立類的對象，使用 對象名.屬性 或 對象名.方法 的方式調用。
32.對字符串而言， == 用來比較兩個值的地址是否相等，而 equals 是比較兩個值的內容是否相等。
33.構造方法名必須和類名一致，而且沒有返回值，構造方法是在建立對象時調用，對其進行初始化工做，構造方法通常使用public 修飾，但在單例模式中，
也能夠使用private 修飾。
34.在類中定義的的變量是類的成員變量，但非靜態的普通成員變量，不能夠在別的類中直接使用，而須要經過建立對象來調用，並且和變量的訪問修飾符也有關係。
在使用別的類的方法時，若是該方法是非private 的，能夠被調用，普通方法須要經過 對象名調用，靜態方法經過 類名調用。
35.使用static 修飾的成員變量稱爲靜態成員或類成員，能夠使用 類名直接訪問，也能夠使用 類的對象訪問，而未使用static修飾的成員爲實例成員，
只能使用 類的對象訪問。
36.多重繼承中，初始化順序爲 1.父類屬性 2.父類構造方法 3.子類屬性 4.子類構造方法
37.關鍵字super()明確顯式地指出一個類能夠使用它父類的構造函數、方法和變量，如父類和子類屬性名稱相同，不使用super則執行子類屬性。
38.子類對象賦值給父類引用，此時調用的方法是被子類重寫的方法。
39.當建立子類對象時，若是存在父類，將先調用父類的無參或有參構造，再執行子類的構造方法。
40.方法重寫是在兩個類存在繼承關係時，子類能夠重寫父類中的同名方法，要求參數列表相同，訪問權限不能嚴於父類，返回值類型與被重寫方法相同或是其子類。
41.面向對象三大特性是 封裝、繼承、多態，其中Java的類是 單繼承的，不支持多繼承，即extends關鍵字後只能有一個類的名稱，即直接父類。
Java的類繼承關係造成一個樹型結構，而不是網狀結構。
42.Java的非檢查異常(編譯器不要求強制處置的異常): 包括 運行時異常(RuntimeException及其子類)和錯誤(Error);
Java編譯器不要求必定要把它捕獲或者必定要繼續拋出，可是對checked exception(檢查異常)要求必需要在方法裏面捕獲或者繼續拋出。
43.try 塊中代碼量太多，過於龐大，會提升程序的複雜度，若是程序發生異常，排查錯誤，分析問題代碼會須要較長的時間。
44.父類對象轉換爲子類類型是不安全的，子類對象轉換爲父類類型是安全的。
45.throw 用於手動拋出異常，除Java語言中定義的異常類型外，還可拋出自定義異常。
throws 用於聲明方法中可能發生的異常，說明知道方法中可能有異常但不想立刻處理，而但願拋出給上級處理。
46.throw 指拋出的一個具體的異常類型; throwable 類是Java語言中全部錯誤或異常的超類，只有當對象是此類(或其子類之一)的實例時，才能經過
Java虛擬機或者關鍵字拋出異常; throws 是用來聲明一個方法可能拋出的全部異常信息。
47.抽象類實現某個接口，能夠不實現全部接口的方法，能夠由它的子類實現，而普通類即非抽象，則必須實現接口裏的所有方法，接口不能夠進行實例化。
48.接口裏變量只能是靜態常量，必須賦值，方法必須爲抽象方法，接口只能使用public 進行修飾或省略。
49.多態的實現方式: 使用父類做爲方法形參實現，使用父類做爲返回值實現。
50.Object 類的toString()方法，將返回一個此對象相關信息的字符串，具體信息爲:
包名.類名 + @ +此對象哈希碼的無符號十六進制表示。
51.抽象類中能夠有構造方法，其構造方法雖然不能用作實例化對象，可是能夠被子類調用，抽象類中能夠有實例方法，被子類繼承，抽象類中的抽象方法能夠是
public、protected、默認類型。接口中只有public型靜態常量和public型抽象方法。
52.在繼承父類的子類中要訪問父類public修飾符的屬性和方法，能夠用this或者super調用。
53.break 只能跳出內層循環，不能跳出外層循環。
54.編寫Java程序時，package要在import以前。
55.JavaSE 標準版和JavaEE 企業版是可以與C# 和 .NET 技術平分天下的應用軟件開發技術和平臺。
56.main()方法是整個Java程序的入口，Java程序中能夠包含多個Java類，但只能有一個類包含main()方法。
57.JDK 目錄結構: Bin 目錄下有編譯器、解釋器和各類工具。
  Jre 目錄是Java程序運行環境的根目錄，其下有bin子目錄，包括平臺使用全部工具和庫的可執行文件和DLL文件，
   lib子目錄包括Java運行環境的代碼庫。
  lib 目錄下都是庫文件。
  Demo 目錄下有各類演示例子。
  Include 目錄下是win32子目錄，都是本地方法文件。
58.Java是由Sun Microsystems 公司於1995年5月推出的Java面向對象程序設計語言和Java平臺的總稱。
59.Java依賴於JVM(Java虛擬機)，解釋字節碼文件並運行，能夠實現一次編寫，到處運行，即其跨平臺性。
Java是一種面向對象的編程語言，支持多線程機制，多線程機制使得Java程序可以並行處理多項任務。
60.Java中一個項目只能有一個main方法，而且在main內部無論有沒代碼都必須使用{}括起來。
61.在Eclipse開發Java程序的順序爲:建立項目、編寫源程序保存爲.java文件、執行編譯命令生成的.class文件、運行。
62.變量名的要求和規範，變量名首先不能以數字開頭，可是能夠包含數字，只能包含"_","$"兩個特殊符號，能夠以"_","$"開頭，通常是以字母開頭。
63.在Java中使用Scanner 實現控制檯的輸入，使用System.out實現控制檯的輸出，實現控制檯的輸入時，須要傳遞參數，實現換行輸入須要使用
System.out.println實現換行輸出，System.out.print輸出不換行。
64.使用javac 命令才能夠編譯.java 文件，經過java 命令運行.class文件。
65.Java標識符能夠由字母、下劃線、$及數字組成，可是不能夠以數字開頭，且區分大小寫，不能夠使用Java的關鍵字。
66.在Java中，byte類型佔1個字節，float和double 分別爲單精度及雙精度浮點數，二者都是能夠有符合的。
67.Java中的訪問控制關鍵字爲:public、protected、private以及默認，其中public爲公共的，其訪問控制保護最弱，
private爲私有的，其訪問控制保護最強。
68.Java中三種註釋:單行註釋(行註釋): //
   多行註釋(段落註釋): /*...*(/)
文檔註釋: /**...*(/)
69.使用DOM4j解析XML文檔，其解析步驟爲:
獲取SAXReader 對象、讀取須要解析的XML文檔、開始解析。
70.addFirst()方法爲LinkedList集合特有的方法。
71.與序列化和反序列化有關的是:Serializable 序列化接口、FileOutputStream 字節輸出流、ObjectOutputStream 序列化輸出的類
transient 屏蔽不想序列化的屬性
72.ASCII編碼中 65——‘A’; 97——‘a’;
73.使用DOM4j解析XML文件時，Element 對象的attribute() 方法用來獲取節點的屬性。
74.局部變量前不能放置任何訪問修飾符 (private，public，和protected)。final能夠用來修飾局部變量(final如同abstract和strictfp，
都是非訪問修飾符，strictfp只能修飾class和method而非variable)。
75.abstract的methods不能以private修飾。abstract的methods就是讓子類implement(實現)具體細節的，怎麼能夠用private把abstract
method封鎖起來呢? (同理，abstract method前不能加final)。


------------------------------------------- Java 基礎 完結 ----------------------------------------