1.面向?qū)ο蟮娜齻€基本特征是：封裝、繼承、多態(tài)
封裝
封裝，也就是把客觀事物封裝成抽象的類，并且類可以把自己的數(shù)據(jù)和方法只讓可信的類或者對象操作，對不可信的進行信息隱藏。
簡單的說，一個類就是一個封裝了數(shù)據(jù)以及操作這些數(shù)據(jù)的代碼的邏輯實體。在一個對象內(nèi)部，某些代碼或某些數(shù)據(jù)可以是私有的，不能被外界訪問。通過這種方式，對象對內(nèi)部數(shù)據(jù)提供了不同級別的保護，以防止程序中無關(guān)的部分意外的改變或錯誤的使用了對象的私有部分。
在Java中類中成員的屬性有：public， protected， <default>， private，這四個屬性的訪問權(quán)限依次降低。
封裝主要在于實現(xiàn)了我們能修改自己實現(xiàn)的代碼，而不用調(diào)用修改程序的片段
封裝的優(yōu)點：良好的封裝能夠減少耦合，類內(nèi)部結(jié)構(gòu)可以自由修改，可以對成員變量進行準(zhǔn)確控制，隱藏信息實現(xiàn)細節(jié)。
為了實現(xiàn)良好的封裝，將類的成員聲明為priviate,通過public方法對變量進行訪問，對一個變量的操作，一般有讀取和賦值的2個操作，為了實現(xiàn)這兩個操作，一個是getXX(XX表示成員要訪問變量的名字）用來讀取成員變量，另一個是setXX()用來對變量賦值
多態(tài)
多態(tài)是同一個行為具有不同表現(xiàn)形式或形態(tài)能力
多態(tài)是同一個接口，使用不同實例而執(zhí)行不同操作
多態(tài)是面向?qū)ο笳Z言重要特性，類似指針或引用派生類的對象，在具體訪問時實現(xiàn)方法的動態(tài)綁定
多態(tài)存在三個必要條件
繼承，重寫，父類引用指向子類對象
2.重寫和重載的區(qū)別
重寫:
重寫（Override）是父類與子類之間多態(tài)性的一種表現(xiàn)。如果在子類中定義某方法與其父類有相同的名稱和參數(shù)，我們說該方法被重寫 (Override)。子類的對象使用這個方法時，將調(diào)用子類中的定義，對它而言，父類中的定義如同被“屏蔽”了。
重載：
重載（Overload）是一個類中多態(tài)性的一種表現(xiàn)。如果在一個類中定義了多個同名的方法，它們參數(shù)列表不同，則稱為方法的重載(Overload)
區(qū)別：重載實現(xiàn)于一個類中;重寫實現(xiàn)于子類中。
重載(Overload)：是一個類中多態(tài)性的一種表現(xiàn)，指同一個類中不同的函數(shù)使用相同的函數(shù)名，但是函數(shù)的參數(shù)個數(shù)或類型不同?？梢杂胁煌姆祷仡愋?可以有不同的訪問修飾符;可以拋出不同的異常。調(diào)用的時候根據(jù)函數(shù)的參數(shù)來區(qū)別不同的函數(shù)。
重寫（Override): 是父類與子類之間的多態(tài)性，是子類對父類函數(shù)的重新實現(xiàn)。函數(shù)名和參數(shù)與父類一樣，子類與父類函數(shù)體內(nèi)容不一樣。子類返回的類型必須與父類保持一致；子類方法訪問修飾符的限制一定要大于父類方法的訪問修飾（public>protected>default>private）；子類重寫方法一定不能拋出新的檢查異常或者比被父類方法申明更加寬泛的檢查型異常。
重載
package com.etime09;
public class Goods { //創(chuàng)建一個商品類
private String ID;
private int price;
private String name;
private String manufactureDate;
//實現(xiàn)構(gòu)造函數(shù)的重載 參數(shù)個數(shù)或類型不同
public Goods() {
super();
// TODO Auto-generated constructor stub
}
public Goods(String iD) {
super();
ID = iD;
}
public Goods(String iD, int price) {
super();
ID = iD;
this.price = price;
}
public Goods(String iD, int price, String name) {
super();
ID = iD;
this.price = price;
this.name = name;
}
public Goods(String iD, int price, String name, String manufactureDate) {
super();
ID = iD;
this.price = price;
this.name = name;
this.manufactureDate = manufactureDate;
}
}
重寫
package com.etime09;
public class Person { //創(chuàng)建一個父類Person
private String name;
private int age;
//父類中寫一個eat()方法
public void eat() {
System.out.println("人都要吃飯");
}
}
---------------------------------------------
package com.etime09;
public class Student extends Person { //Student子類繼承Person父類
@Override
//重寫eat()方法 方法名，參數(shù)，返回類型相同；方法體內(nèi)容不同
public void eat() {
System.out.println("學(xué)生喜歡吃肉");
}
}
多態(tài)
多態(tài)是同一個行為具有多個不同表現(xiàn)形式或形態(tài)的能力。
多態(tài)就是同一個接口，使用不同的實例而執(zhí)行不同操作。
多態(tài)存在的三個必要條件：繼承，重寫，父類引用指向子類對象
當(dāng)使用多態(tài)方式調(diào)用方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤；如果有，再去調(diào)用子類的同名方法。
多態(tài)的好處：可以使程序有良好的擴展，并可以對所有類的對象進行通用處理。
是否可以繼承string類? 不可以
3.JAVA 類支持多繼承嘛？ 可以實現(xiàn)多接口嘛？ JAVA不支持多繼承，但類可以實現(xiàn)多個接口，間接實現(xiàn)多繼承，也可以通過內(nèi)部類
抽象類
抽象類必須用 abstract 修飾，子類必須實現(xiàn)抽象類中的抽象方法，如果有未實現(xiàn)的，那么子類也必須用 abstract 修飾。抽象類默認的權(quán)限修飾符為 public，可以定義為 public 或 procted，如果定義為 private，那么子類則無法繼承。抽象類不能創(chuàng)建對象
抽象類和普通類的區(qū)別
抽象類必須用public、procted 修飾(如果為private修飾，那么子類則無法繼承，也就無法實現(xiàn)其抽象方法）。默認缺省為 public
抽象類無法創(chuàng)建對象
如果一個子類繼承抽象類，那么必須實現(xiàn)其所有的抽象方法。如果有未實現(xiàn)的抽象方法，那么必須定義為 abstract
接口
接口中的變量隱式的使用 public static final 修飾，并且需要給出初始值。方法隱式的使用 public abstract 修飾(并且只能是 public ，如果是 private，procted，那么就編譯報錯)。接口中的方法默認不能有具體的實現(xiàn)（JDK1.8開始可以有默認的實現(xiàn)）
4.接口和抽象類的區(qū)別
1.抽象類只能繼承一次，但是可以實現(xiàn)多個接口
接口和抽象類必須實現(xiàn)其中所有的方法，抽象類中如果有未實現(xiàn)的抽象方法，那么子類也需要定義為抽象類。抽象類中可以有非抽象的方法
2.接口中的變量必須用 public static final 修飾，并且需要給出初始值。所以實現(xiàn)類不能重新定義，也不能改變其值。
3.接口中的方法默認是 public abstract，也只能是這個類型。不能是 static，接口中的方法也不允許子類覆寫，抽象類中允許有static 的方法。
接口和抽象都是繼承樹的上層，共同點如下：
1.都是上層的抽象層
2.都不能實現(xiàn)實例化
3.都能包含抽象的方法，這些抽象的方法，用于描述類具備的功能
區(qū)別如下：
1.在抽象類中可以寫非抽象的方法，從而避免在子類中重復(fù)書寫他們，這樣可以代碼的復(fù)用性，這是抽象類的優(yōu)勢，接口中只能有抽象方法
2.抽象級別（從高到低），接口》抽象類》實現(xiàn)類
3.接口的設(shè)計目的，是對類的行為進行約束，側(cè)重與動作，而抽象類的設(shè)計目的是代碼復(fù)用，
4.抽象類是 is a 關(guān)系，而接口是 has a 關(guān)系（實現(xiàn)多接口）
5.簡要敘述下Java中修飾符的作用域及可見性？
public：修飾的成員可以在任何范圍內(nèi)直接訪問，只是一種最寬松的訪問控制等級。需要注意的，所謂的直接訪問仍需要先創(chuàng)建或獲得一個相應(yīng)類的對象然后才可以使用”對象名.成員“的方式訪問其屬性或調(diào)用其方法，但是出于信息封裝和隱藏的需要一般不提倡把成員聲明為public的，而構(gòu)造方法和需要外界直接調(diào)用的普通方法則適合聲明為public.
protected：修飾的成員可以在其所在類中、同一包中及子類中（無論子類在不在同一個包）被直接訪問，但不能在位于不同包中的非子類中被直接訪問，這里需要特別聲明：在位于不同包的子類中必須是子類的對象才能直接訪問其父類的protected成員，而父類自身的對象反而不能訪問其所在類中聲明的protected成員。
default：缺省訪問修飾符的成員只能在其所在類中或包中直接訪問，在不同包中即使是不同包的子類也不能直接訪問。
private：成員只能在所在類中被直接訪問，是4種訪問等級最高的一個。
equals() 和 “==” 操作用于對象的比較，檢查對象的相等性，前者是方法，后者是操作符。
總結(jié)：
1.一般使用==比較原生類型如：boolean,int,char等等，使用equals()比較對象
2.如果兩個引用指向相同的對象==返回true,equals()的返回依賴于具體業(yè)務(wù)實現(xiàn)，一般重寫equals方法，同樣重寫hashcode方法，默認的equals實現(xiàn)是與“==”一樣的
3.字符串的使用對比使用equals()代替==操作符
6.一個static 方法內(nèi)可以調(diào)用非static方法嘛？
不可以，因為非static要與關(guān)聯(lián)對象關(guān)聯(lián)在一起，必須創(chuàng)建一個對象后，才能在對象上進行方法調(diào)用，當(dāng)一個static方法被調(diào)用時，可能還沒有創(chuàng)建任何實例對象，如果從一個static方法中，發(fā)出對非static方法的調(diào)用,static方法是靜態(tài)方法，是屬于類的方法，非static方法是屬于對象的方法，所以在static方法中想要調(diào)用非static方法，要先創(chuàng)建一個對象，再有這個對象來調(diào)用非static方法。
7.Java靜態(tài)變量與實例變量的區(qū)別
(1) 在語法定義上區(qū)別：靜態(tài)變量前要加static關(guān)鍵字，而實例變量前則不加
(2) 程序運行時的區(qū)別：實例變量屬于某個對象屬性，必須創(chuàng)建了實例對象，其中實例變量才會被分配空間，才能使用這個實例變量。靜態(tài)變量不屬于某個實例對象，而屬于類，所以稱為類變量，只要程序加載了類的字節(jié)碼，不用創(chuàng)建任何實例對象，靜態(tài)變量就會被分配空間，只分配一次，靜態(tài)變量就可以被使用?？傊瑢嵗兞勘仨殑?chuàng)建對象后才能通過這個對象使用，靜態(tài)變量可以直接使用類來引用。
8.int和Integer的區(qū)別
1、Integer是int的包裝類，int則是java的一種基本數(shù)據(jù)類型
2、Integer變量必須實例化后才能使用，而int變量不需要
3、Integer實際是對象的引用，當(dāng)new一個Integer時，實際上是生成一個指針指向此對象；而int則是直接存儲數(shù)據(jù)值
4、Integer的默認值是null，int的默認值是0
9. StringBuilder,StringBuffer和String區(qū)別
1.三者在執(zhí)行速度方面的比較：StringBuilder > StringBuffer > String
（為啥字符串是最低的工作效率呢？String類型是不可改變的對象了，由于這種機制，每當(dāng)用String操作字符串時，實際上是在不斷的創(chuàng)建新的對象，而原來的對象就會變?yōu)槔唬牵没厥盏?，可想而知這樣執(zhí)行效率會有多底。）
- StringBuilder：線程非安全的
StringBuffer：線程安全的
(當(dāng)我們在字符串緩沖去被多個線程使用時候，JVM不能保證StringBuilder的操作是安全的，雖然他的速度最快，但是可以保證StringBuffer是可以正確操作的。當(dāng)然大多數(shù)情況下就是我們是在單線程下進行的操作，所以大多數(shù)情況下是建議用StringBuilder而不用StringBuffer的，就是速度的原因。）
對于三者使用的總結(jié)：
1.如果要操作少量的數(shù)據(jù)用 = String
2.單線程操作字符串緩沖區(qū) 下操作大量數(shù)據(jù) = StringBuilder
3.多線程操作字符串緩沖區(qū) 下操作大量數(shù)據(jù) = StringBuffer
StringBuffer和StringBuilder的相同點就是，他們都是可變長度 的字符串，他們兩者之間的方法使用幾乎可以互通。而且相比于字符串來說，StringBuffer和StringBuilder的執(zhí)行效率要高出很多。
StringBuffer和StringBuilder的不同點我們可以從以下幾個方面來談
首先，兩者的英文名稱就不一樣，StringBuffer是字符串緩沖，StringBuilder是字符創(chuàng)生成器
其次，StringBuffer是線程安全的，StringBuilder是非線程安全。正因為他們有這樣的線程不同點，所以導(dǎo)致StringBuilder的執(zhí)行效率遠比StringBuffer要強悍很多。StringBuffer起始于jdk 1.0、StringBuilder起始于jdk 1.5
當(dāng)然了，這也需要分場景和業(yè)務(wù)需求，若果單線程下面操作字符串緩沖的話，我建議使用StringBuilder。若果是多線程下字符串緩沖操作，我建議使用StringBuffer。因為StringBuffer使用了線程同步，他會對當(dāng)前的線程進行一個小小的檢查，保證其安全運行。雖然執(zhí)行速度不高，但是換回來了安全也是值得的，畢竟我們都知道，Java語言把安全看的比什么都要重要。
10. JAVA 初始化原則
使用場景
在java程序中，當(dāng)實例化對象時，對象的所在類的所有成員變量首先要進行初始化，只有當(dāng)所有類成員完成初始化后，才會調(diào)用對象所在類的構(gòu)造函數(shù)創(chuàng)建對象。
原則
變量優(yōu)先于塊、靜態(tài)優(yōu)先于非靜態(tài)。
父類優(yōu)先于派生類初始化。
按照成員變量定義的順序來進行初始化，即使變量定義散布于方法定義之中，它們?nèi)匀辉谌魏畏椒ǎò?gòu)造器）被調(diào)用前初始化。
初始化順序
父類靜態(tài)變量
父類靜態(tài)代碼塊
子類靜態(tài)變量
子類靜態(tài)代碼塊
父類非靜態(tài)變量
父類非靜態(tài)代碼塊
父類構(gòu)造函數(shù)
子類非靜態(tài)變量
子類非靜態(tài)代碼塊
子類構(gòu)造函數(shù)
11. 當(dāng)try,catch中有return返回時，finally中代碼會執(zhí)行嘛
一、無論有沒有異常，finally中的代碼都會執(zhí)行
二、當(dāng)try、catch中有return時，finally中的代碼依然會繼續(xù)執(zhí)行
三、finally是在return后面的表達式運算以后執(zhí)行的，此時并無返回運算以后的值，而是把值保存起來，無論finally對該值作任何的改變，返回的值都不會改變，依然返回保存起來的值。也就是說方法的返回值是在finally運算以前就肯定了的。
四、若是return的數(shù)據(jù)是引用數(shù)據(jù)類型，而在finally中對該引用數(shù)據(jù)類型的屬性值的改變起做用，try中的return語句返回的就是在finally中改變后的該屬性的值。
五、finally代碼中最好不要包含return，程序會提早退出，也就是說返回的值不是try或catch中的值測試
先執(zhí)行try中的語句，包括return后面的表達式，
有異常時,先執(zhí)行catch中的語句，包括return后面的表達式,
而后執(zhí)行finally中的語句,若是finally里面有return語句，會提早退出，
最后執(zhí)行try中的return，有異常時執(zhí)行catch中的return。指針
在執(zhí)行try、catch中的return以前必定會執(zhí)行finally中的代碼（若是finally存在），若是finally中有return語句，就會直接執(zhí)行finally中的return方法，因此finally中的return語句必定會被執(zhí)行的。編譯器把finally中的return語句標(biāo)識為一個warning.
11. final,finally和finalizie的區(qū)別
1.簡單區(qū)別：
final用于聲明屬性，方法和類，分別表示屬性不可交變，方法不可覆蓋，類不可繼承。
finally是異常處理語句結(jié)構(gòu)的一部分，表示總是執(zhí)行。
finalize是Object類的一個方法，在垃圾收集器執(zhí)行的時候會調(diào)用被回收對象的此方法，供垃圾收集時的其他資源回收，例如關(guān)閉文件等。
2.中等區(qū)別：
雖然這個單詞在Java中都存在，但是并沒太多關(guān)聯(lián)：
final：java中的關(guān)鍵字，修飾符。
A).如果一個類被聲明為final，就意味著它不能再派生出新的子類，不能作為父類被繼承。因此，一個類不能同時被聲明為abstract抽象類的和final的類。
B).如果將變量或者方法聲明為final，可以保證它們在使用中不被改變.
1)被聲明為final的變量必須在聲明時給定初值，而在以后的引用中只能讀取，不可修改。
2)被聲明final的方法只能使用，不能重載。
finally：java的一種異常處理機制。
finally是對Java異常處理模型的最佳補充。finally結(jié)構(gòu)使代碼總會執(zhí)行，而不管無異常發(fā)生。使用finally可以維護對象的內(nèi)部狀態(tài)，并可以清理非內(nèi)存資源。特別是在關(guān)閉數(shù)據(jù)庫連接這方面，如果程序員把數(shù)據(jù)庫連接的close()方法放到finally中，就會大大降低程序出錯的幾率。
finalize：Java中的一個方法名。
Java技術(shù)使用finalize()方法在垃圾收集器將對象從內(nèi)存中清除出去前，做必要的清理工作。這個方法是由垃圾收集器在確定這個對象沒被引用時對這個對象調(diào)用的。它是在Object類中定義的，因此所的類都繼承了它。子類覆蓋finalize()方法以整理系統(tǒng)資源或者執(zhí)行其他清理工作。finalize()方法是在垃圾收集器刪除對象之前對這個對象調(diào)用的。
12. JAVA遇到的異常錯誤
Java.lang.NullPointerException
這個異常大家肯定都經(jīng)常碰到，異常的解釋是"程序遇上了空指針"，簡單地說就是調(diào)用了未經(jīng)初始化的對象或者是不存在的對象，這個錯誤經(jīng)常出現(xiàn)在創(chuàng)建圖片，調(diào)用數(shù)組這些操作中，比如圖片未經(jīng)初始化，或者圖片創(chuàng)建時的路徑錯誤等等。對數(shù)組操作中出現(xiàn)空指針，很多情況下是一些剛開始學(xué)習(xí)編程的朋友常犯的錯誤，即把數(shù)組的初始化和數(shù)組元素的初始化混淆起來了。數(shù)組的初始化是對數(shù)組分配需要的空間，而初始化后的數(shù)組，其中的元素并沒有實例化，依然是空的，所以還需要對每個元素都進行初始化（假如要調(diào)用的話）
2. java.lang.ClassNotFoundException
這個異常是很多原本在JB等開發(fā)環(huán)境中開發(fā)的程序員，把JB下的程序包放在WTk下編譯經(jīng)常出現(xiàn)的問題，異常的解釋是"指定的類不存在"，這里主要考慮一下類的名稱和路徑是否正確即可，假如是在JB下做的程序包，一般都是默認加上Package的，所以轉(zhuǎn)到WTK下后要注重把Package的路徑加上。
3. java.lang.ArithmeticException
這個異常的解釋是"數(shù)學(xué)運算異常"，比如程序中出現(xiàn)了除以零這樣的運算就會出這樣的異常，對這種異常，大家就要好好檢查一下自己程序中涉及到數(shù)學(xué)運算的地方，公式是不是有不妥了。
4. java.lang.ArrayIndexOutOfBoundsException
這個異常相信很多朋友也經(jīng)常碰到過，異常的解釋是"數(shù)組下標(biāo)越界"，現(xiàn)在程序中大多都有對數(shù)組的操作，因此在調(diào)用數(shù)組的時候一定要認真檢查，看自己調(diào)用的下標(biāo)是不是超出了數(shù)組的范圍，一般來說，顯示（即直接用常數(shù)當(dāng)下標(biāo)）調(diào)用不太輕易出這樣的錯，但隱式（即用變量表示下標(biāo)）調(diào)用就經(jīng)常出錯了，還有一種情況，是程序中定義的數(shù)組的長度是通過某些特定方法決定的，不是事先聲明的，這個時候，最好先查看一下數(shù)組的length，以免出現(xiàn)這個異常。
5. java.lang.IllegalArgumentException
這個異常的解釋是"方法的參數(shù)錯誤"，很多J2ME的類庫中的方法在一些情況下都會引發(fā)這樣的錯誤，比如音量調(diào)節(jié)方法中的音量參數(shù)假如寫成負數(shù)就會出現(xiàn)這個異常，再比如g.setColor(int red,int green,int blue)這個方法中的三個值，假如有超過２５５的也會出現(xiàn)這個異常，因此一旦發(fā)現(xiàn)這個異常，我們要做的，就是趕緊去檢查一下方法調(diào)用中的參數(shù)傳遞是不是出現(xiàn)了錯誤。
6. java.lang.IllegalAccessException
這個異常的解釋是"沒有訪問權(quán)限"，當(dāng)應(yīng)用程序要調(diào)用一個類，但當(dāng)前的方法即沒有對該類的訪問權(quán)限便會出現(xiàn)這個異常。對程序中用了Package的情況下要注重這個異常。
13. JAVA中的異常框架
Throwable
Throwable是 Java 語言中所有錯誤或異常的超類。
Throwable包含兩個子類: Error 和 Exception。它們通常用于指示發(fā)生了異常情況。
Throwable包含了其線程創(chuàng)建時線程執(zhí)行堆棧的快照，它提供了printStackTrace()等接口用于獲取堆棧跟蹤數(shù)據(jù)等信息。
Exception
Exception及其子類是 Throwable 的一種形式，它指出了合理的應(yīng)用程序想要捕獲的條件。
RuntimeException
RuntimeException是那些可能在 Java 虛擬機正常運行期間拋出的異常的超類。
編譯器不會檢查RuntimeException異常。例如，除數(shù)為零時，拋出ArithmeticException異常。RuntimeException是ArithmeticException的超類。當(dāng)代碼發(fā)生除數(shù)為零的情況時，倘若既"沒有通過throws聲明拋出ArithmeticException異常"，也"沒有通過try…catch…處理該異常"，也能通過編譯。這就是我們所說的"編譯器不會檢查RuntimeException異常"！
如果代碼會產(chǎn)生RuntimeException異常，則需要通過修改代碼進行避免。例如，若會發(fā)生除數(shù)為零的情況，則需要通過代碼避免該情況的發(fā)生！
Error
和Exception一樣，Error也是Throwable的子類。它用于指示合理的應(yīng)用程序不應(yīng)該試圖捕獲的嚴(yán)重問題，大多數(shù)這樣的錯誤都是異常條件。
和RuntimeException一樣，編譯器也不會檢查Error。比如說內(nèi)存溢出
Java異常分類：
1 被檢查的異常(Checked Exception)，
2 運行時異常(RuntimeException)，
3 錯誤(Error)。
(01) 運行時異常
定義: RuntimeException及其子類都被稱為運行時異常。
特點: Java編譯器不會檢查它。也就是說，當(dāng)程序中可能出現(xiàn)這類異常時，倘若既"沒有通過throws聲明拋出它"，也"沒有用try-catch語句捕獲它"，還是會編譯通過。例如，除數(shù)為零時產(chǎn)生的ArithmeticException異常，數(shù)組越界時產(chǎn)生的IndexOutOfBoundsException異常，fail-fail機制產(chǎn)生的ConcurrentModificationException異常等，都屬于運行時異常。
雖然Java編譯器不會檢查運行時異常，但是我們也可以通過throws進行聲明拋出，也可以通過try-catch對它進行捕獲處理。
如果產(chǎn)生運行時異常，則需要通過修改代碼來進行避免。例如，若會發(fā)生除數(shù)為零的情況，則需要通過代碼避免該情況的發(fā)生！
(02) 被檢查的異常
定義: Exception類本身，以及Exception的子類中除了"運行時異常"之外的其它子類都屬于被檢查異常。
特點: Java編譯器會檢查它。此類異常，要么通過throws進行聲明拋出，要么通過try-catch進行捕獲處理，否則不能通過編譯。例如，CloneNotSupportedException就屬于被檢查異常。當(dāng)通過clone()接口去克隆一個對象，而該對象對應(yīng)的類沒有實現(xiàn)Cloneable接口，就會拋出CloneNotSupportedException異常。
被檢查異常通常都是可以恢復(fù)的。
(03) 錯誤
定義: Error類及其子類。
特點: 和運行時異常一樣，編譯器也不會對錯誤進行檢查。
當(dāng)資源不足、約束失敗、或是其它程序無法繼續(xù)運行的條件發(fā)生時，就產(chǎn)生錯誤。程序本身無法修復(fù)這些錯誤的。例如，VirtualMachineError就屬于錯誤。
按照Java慣例，我們是不應(yīng)該是實現(xiàn)任何新的Error子類的！
14. JAVA中的異常框架
Java GC（Garbage Collection，垃圾收集，垃圾回收）機制，是Java與C++/C的主要區(qū)別之一，在使用JAVA的時候，一般不需要專門編寫內(nèi)存回收和垃圾清理代 碼。這是因為在Java虛擬機中，存在自動內(nèi)存管理和垃圾清掃機制。
電腦的內(nèi)存大小的不變的，當(dāng)我們使用對象的時候，如使用New關(guān)鍵字的時候，就會在內(nèi)存中生產(chǎn)一個對象，但是我們在使用JAVA開發(fā)的時候，當(dāng)一個對象使用完畢之后我們并沒有手動的釋放那個對象所占用的內(nèi)存，就這樣在使用程序的過程中，對象越來越多，當(dāng)內(nèi)存存放不了這么多對象的時候，電腦就會崩潰了，JAVA為了解決這個問題就推出了這個自動清除無用對象的功能，或者叫機制，這就是GC，有個好聽是名字叫垃圾回收，其實就在用來幫你擦屁股的，好讓你安心寫代碼，不用管內(nèi)存釋放，對象清理的事情了。
