第7篇-JAVA面向?qū)ο螈?/h1>

• 每篇一句 ：任何值得去的地方，都沒有捷徑
• 初學(xué)心得： 溫故而知新
• (筆者：JEEP/711)[JAVA筆記 | 時間:2017-04-09| JAVA面向?qū)ο?Ⅲ]

目錄導(dǎo)航

[TOC]

1.JAVA基本包裝類型

| 基本數(shù)據(jù)類型 | 包裝類 |
| :-------- | --------: |
| byte | Byte |
| short | Short |
| int | Integer |
| char | Character |
| float | Float |
| double | Double |
| long | Long |
| boolean | Boolean |
除了Integer和Character定義的名稱和對應(yīng)的基本類型差異大，其他六種都是將首字母大寫

2.JAVA基本數(shù)據(jù)類型和包裝類相互轉(zhuǎn)換

<br> 把基本數(shù)據(jù)類型 → 包裝類：通過對應(yīng)包裝類的構(gòu)造方法實現(xiàn)
<br> 除了Character外，其他包裝類都可以傳入一個字符串參數(shù)構(gòu)建包裝類對象
<br> 包裝類 → 基本數(shù)據(jù)類型，包裝類的實例方法xxxValue();    // xxx表示包裝類對應(yīng)的基本數(shù)據(jù)類型
<br> 代碼：
<br> boolean bool = false;
<br> Boolean b2 = new Boolean(bool);
<br> Integer i = new Integer(3);
<br> int i2 = i.intValue();
<br> Boolean b1 = new Boolean("TRue");  //true
<br> boolean b2 = b1.booleanValue();
<br> Float f = new Float("3.14");   //3.14
<br> Integer i2 = new Integer("123s");  //NumberFormatException
<br> ```
<br> **基本類型和String之間的轉(zhuǎn)換**
<br> String → 基本類型，除了Character外所有的包裝類提供parseXxx(String s)靜態(tài)方法，
<br> 用于把一個特定的字符串轉(zhuǎn)換成基本類型變量；
<br> 基本類型 → String，String 類有靜態(tài)方法valueOf()，用于將基本類型的變量轉(zhuǎn)換成String類型
<br> 代碼：
<br> ```
<br> String str = "66;
<br> int i = Integer.parseInt(str);     //String  --& 基本類型
<br> String s1 = String.valueOf(i);    //基本類型  --&  String
<br> ```

3.JAVA自動裝箱與自動拆箱

什么是自動裝箱？：可把一個基本類型變量直接賦給對應(yīng)的包裝類對象或則Object對象
什么是自動拆箱？：允許把包裝類對象直接賦給對應(yīng)的基本數(shù)據(jù)類型
代碼：

Integer i = 3; //裝箱
int i1 = i; //拆箱
Object flag = new Boolean(false);
if(flag instanceof Boolean){
Boolean b = (Boolean)flag;
boolean b2 = b;
}


4.JAVA Object類

什么是Object類？
所有類的公共父類，一旦一個類沒有顯示地繼承一個類則其直接父類一定是Object
一切數(shù)據(jù)類型都可用Object接收，class A extends Object{}等價于class A {}
代碼：常見方法

public boolean equals(Object obj)：對象比較
public int hashCode()：取得該對象的Hash碼
public String toString()：對象描述


Object類的 toString()方法：“對象的描述”
筆者建議所有類都覆寫此方法，直接打印輸出對象時，會調(diào)用該對象的toString()方法
打印對象的時候,實際調(diào)用的對象實際指向的類的自我描述：
全限定類名+@+十六進制的hashCode值，等價于 全限定類名+@+IntegertoHexString(該對象.hashCode);
equals也是判斷是否指向同一個對象，沒有實際意義，有必要可以重寫

public boolean equals(Object obj) {}
String 覆寫了 Object的equals方法：只比較字符的序列是否相同
==用于判斷兩個變量是否相等
基本類型：
引用類型：必須指向同一個對象，才true
只能比較有父子或平級關(guān)系的兩個對象
new String("1") == new String("1"); ？


5.JAVA代碼塊

什么是代碼塊？
代碼塊指的是使用"{}"括起來的一段代碼，根據(jù)代碼塊存在的位置可以分為4種:
(1)普通代碼塊; (2)構(gòu)造代碼塊; (3)靜態(tài)代碼塊; (4)線程同步代碼塊;
代碼塊里變量的作用域：只在自己所在區(qū)域(前后的{})內(nèi)有效；

(1)普通代碼塊：普通代碼塊就是直接定義在方法或語句中定義的代碼塊
代碼：

.....main.....{
{
int x = 1;
System.out.println("普通代碼塊" + x);
}
int x = 99;
System.out.println("代碼塊之外" + x);
}



(2)構(gòu)造代碼塊：直接寫在類中的代碼塊，優(yōu)先于構(gòu)造方法執(zhí)行，每次實例化對象之前都會執(zhí)行構(gòu)造代碼塊
代碼：

public class Demo1 {
System.out.println("我是構(gòu)造代碼塊");
}
public Demo2(){
System.out.println("我是構(gòu)造方法");
}
public static void main(String[] args) {
Demo1 d1 = new Demo1();
Demo2 d2 = new Demo2();
}
}



(3)靜態(tài)代碼塊：使用static 修飾的構(gòu)造代碼塊：優(yōu)先于主方法執(zhí)行，優(yōu)先于構(gòu)造代碼塊執(zhí)行，不管有創(chuàng)建多少對象，靜態(tài)代碼塊只執(zhí)行一次，可用于給靜態(tài)變量賦值；
代碼：

public class Demo3 {
System.out.println("我是構(gòu)造代碼塊");
}
public Demo()4{
System.out.println("我是構(gòu)造方法");
}
static {
System.out.println("我是靜態(tài)代碼塊");
}
public static void main(String[] args) {
System.out.println("Main");
new Demo3();
new Demo4();
}
}



(4)線程同步代碼塊：在后面文章中筆者將詳細提到這個問題!

6.JAVA構(gòu)造方法的私有化

有的時候我們?yōu)榱吮苊馔饨鐒?chuàng)建某類的實例，就將某類的構(gòu)造方法私有化，將它的構(gòu)造方法用private修飾：
私有化后外界就再也不能創(chuàng)建實例了，那內(nèi)部呢？
其實即使將某類的構(gòu)造方法私有化起來，外界也是可以創(chuàng)建它的實例的，此時就需要用到反射技術(shù)
代碼：

class A{
private A(){}
public void show(){
System.out.println("A");
}
}
public class Demo {
public static void main(String[] args) throws Exception{
Class<A& clz = A.class;
Constructor<A& c = clz.getDeclaredConstructor();
c.setAccessible(true);
A a = c.newInstance();
a.show();
}
}


7.JAVA抽象類(abstract)

什么是抽象類？
(1).使用abstract關(guān)鍵字聲明的類為抽象類
(2).很多具有相同特征和行為的對象可以抽象為一個類，很多具有相同特征和行為的類可以為一個抽象類
(3).抽象類規(guī)則：
1.抽象類可以沒有抽象方法，有抽象方法的類必須是抽象類
2.非抽象類繼承抽象類必須實現(xiàn)所有有抽象方法
3.抽象類可以有方法實現(xiàn)和屬性
4.抽象類不能被實例化
5.抽象類不能聲明為final

6.抽象類可以有普通方法

抽象類的語法格式：

//聲明一個抽象類
public abstract class Wonmen{
private String name;
public abstract void say();//抽象方法
}


JAVA語言中使用abstract class來定義抽象類代碼如下：

/**
*定義一個抽象類
**/
public abstract class Demo5{
private String name; //定義私有成員變量屬性
private String address; //定義私有成員變量屬性
private int number; //定義私有成員變量屬性
//定義構(gòu)造方法
public Demo5(String name, String address, int number){
this.name = name;
this.address = address;
this.number = number;
}
public double computePay(){
System.out.println("這是 computePay");
return 0.0;
}
public void mailCheck(){
System.out.println("這是 " + this.name+ " " + this.address);
}
//定義toString方法
public String toString(){
return name + " " + address + " " + number;
}
//取得getName方法
public String getName(){
return name;
}
//getAddress方法
public String getAddress(){
return address;
}
//取得getNumber方法
public int getNumber(){
return number;
}
//設(shè)置Address方法
public void setAddress(String newAddress){
address = newAddress;
}
}

該類是抽象類，但是它仍然有3個成員變量，7個成員方法和1個構(gòu)造方法

抽象方法：abstract關(guān)鍵字同樣可以用來聲明抽象方法，抽象方法只包含一個方法名，而沒有方法體
抽象方法沒有定義，方法名后面直接跟一個分號，而不是花括號

public abstract class Demo6{
private String name;
private String address;
private int number;
public abstract double computePay();
//其余代碼
}

聲明抽象方法會造成以下兩個結(jié)果：
● 如果一個類包含抽象方法，那么該類必須是抽象類
● 任何子類必須重寫父類的抽象方法，或者聲明自身為抽象類

8.JAVA接口(interface)

什么是JAVA接口？：
(1).接口是一組行為的規(guī)范，定義，沒有實現(xiàn)
使用接口，可以讓我們的程序更加利于變化
接口是面向?qū)ο缶幊腆w系中的思想精髓之一
面向?qū)ο笤O(shè)計法則：基本接口編程
在JAVA編程語言中是一個抽象類型，是抽象方法的集合
接口通常以interface來聲明。一個類通過繼承接口的方式，從而來繼承接口的抽象方法
接口并不是類，編寫接口的方式和類很相似，但是它們屬于不同的概念
類描述對象的屬性和方法。接口則包含類要實現(xiàn)的方法
接口無法被實例化，但是可以被實現(xiàn)
一個實現(xiàn)接口的類，必須實現(xiàn)接口內(nèi)所描述的所有方法，否則就必須聲明為抽象類

(2).JAVA接口的定義格式：
代碼：

接口實現(xiàn):
interface 接口名稱{ }
class Girl implements Hit{
//抽象方法;
public void cry(){
//方法體
}
}

(3).JAVA接口的使用規(guī)則：
1.接口可以繼承多個接口
2.一個類可以實現(xiàn)多個接口，實現(xiàn)多個接口用逗號隔開
3.抽象類實現(xiàn)接口可以不實現(xiàn)方法
4.接口中的所有方法的訪問權(quán)限都是public
5.接口中定義的屬性都是常量

(4).JAVA接口與類相似點：
● 一個接口可以有多個方法
● 接口文件保存在 .java 結(jié)尾的文件中，文件名使用接口名
●接口的字節(jié)碼文件保存在 .class 結(jié)尾的文件中

(5).JAVA接口與類的區(qū)別：
● 接口不能用于實例化對象
● 接口沒有構(gòu)造方法
● 接口中所有的方法必須是抽象方法
● 接口不能包含成員變量，除了 static 和 final 變量
● 接口不是被類繼承了，而是要被類實現(xiàn)
● 接口支持多重繼承
● 接口相應(yīng)的字節(jié)碼文件必須在與包名稱相匹配的目錄結(jié)構(gòu)中

(6).JAVA接口特性
●接口中每一個方法也是隱式抽象的,接口中的方法會被隱式的指定為 public abstract（只能是 public abstract，其他修飾符都會報錯）
●接口中可以含有變量，但是接口中的變量會被隱式的指定為 public static final 變量（并且只能是 public，用 private 修飾會報編譯錯誤
●接口中的方法是不能在接口中實現(xiàn)的，只能由實現(xiàn)接口的類來實現(xiàn)接口中的方法


(7).JAVA抽象類和接口的區(qū)別
● 1. 抽象類中的方法可以有方法體，就是能實現(xiàn)方法的具體功能，但是接口中的方法是不可行的
● 2. 抽象類中的成員變量可以是各種類型的，而接口中的成員變量只能是 public static final 類型
● 3. 接口中不能含有靜態(tài)代碼塊以及靜態(tài)方法(用 static 修飾的方法)，而抽象類是可以有靜態(tài)代碼塊和靜態(tài)方法
● 4. 一個類只能繼承一個抽象類，而一個類卻可以實現(xiàn)多個接口

JAVA接口的實現(xiàn)：
代碼：

public class MammalInt implements Animal{
public void eat(){
System.out.println("Mammal eats");
}
public void travel(){
System.out.println("Mammal travels");
}
public int noOfLegs(){
return 0;
}
public static void main(String args[]){
MammalInt m = new MammalInt();
m.eat();
m.travel();
}
}

## 9.接口與抽象類

接口與抽象類相同點:
都位于繼承的頂端,用于被其他實現(xiàn)或繼承;
都不能實例化;
都包含抽象方法,其子類都必須覆寫這些抽象方法;
接口與抽象類區(qū)別:
抽象類為部分方法提供實現(xiàn),避免子類重復(fù)實現(xiàn)這些方法,提供代碼重用性;接口只能包含抽象方法;
一個類只能繼承一個直接父類(可能是抽象類),卻可以實現(xiàn)多個接口;(接口彌補了Java的單繼承)
二者的選用:
優(yōu)先選用接口,盡量少用抽象類，需要定義子類的行為,又要為子類提供共性功能時才選用抽象類;

| NO. | 比較 | 抽象類 | 接口 |
| :-------- | --------:| :------: | :------: |
| 1 | 關(guān)鍵字 | 使用abstract class 聲明 | 使用interface聲明 |
| 2 | 定義 | 包含抽象方法的類 | 抽象方法和全局常量的集合 |
| 3 | 組成 | 屬性、方法、構(gòu)造方法、抽象方法、常量 | 全局常量、抽象方法 |
| 4 | 權(quán)限 | 抽象方法的權(quán)限可以任意 | 只能是public權(quán)限 |
| 5 | 使用 | 通過extends關(guān)鍵字繼承抽象類 | 通過implements關(guān)鍵字實現(xiàn)接口 |
| 6 | 局限 | 抽象類存在單繼承局限 | 沒有局限，一個子類可以實現(xiàn)多個接口 |
| 7 | 順序 | 一個子類只能先繼承抽象類再實現(xiàn)多個接口

| 8 | 設(shè)計模式 | 模板設(shè)計 | 工廠設(shè)計模式、代理設(shè)計模式 |
| 9 | 實際作用 | 只能做一個模板使用 | 作為標準、表現(xiàn)能力 |

| 10 | 使用 | 兩者沒有什么本質(zhì)上的區(qū)別，但是從實際上來看，如果 一個程序中抽象類和接口都可以使用的話，則一定要優(yōu)先考慮接口，因為接口可以避免單繼承所帶來的局限
| 11 | 實例化 | 都是依靠對象多態(tài)性，通過子類進行對象實例化 |

10.JAVA內(nèi)部類

什么是內(nèi)部類？：
內(nèi)部類就是在類里面的類就是內(nèi)部類，內(nèi)部類就是一個在類的內(nèi)部定義的類
類中有類：內(nèi)部類：嵌套類或者是外部類：宿主類
把內(nèi)部類隱藏在外部類之內(nèi)，不許同包的其他類訪問該類
內(nèi)部類可以訪問外部類的私有數(shù)據(jù)，外部類不能訪問內(nèi)部類的實現(xiàn)細節(jié)，比如字段；
觀察編譯后的字節(jié)碼文件
非靜態(tài)內(nèi)部類；靜態(tài)內(nèi)部類,局部內(nèi)部類，匿名內(nèi)部類適合于僅使用一次使用的類

成員內(nèi)部類格式：

//聲明一個類
class Outer{
//聲明一個內(nèi)部類
class Inner(){}
}

編譯上述代碼會產(chǎn)生兩個文件 Outer.class和Outer$Inner.class

為什么要使用內(nèi)部類？內(nèi)部類的作用？
1.內(nèi)部類可以很好的實現(xiàn)隱藏
一般的非內(nèi)部類，是不允許有 private 與protected權(quán)限的，但內(nèi)部類可以
2.內(nèi)部類擁有外圍類的所有元素的訪問權(quán)限
3.可是實現(xiàn)多重繼承
4.可以避免修改接口而實現(xiàn)同一個類中兩種同名方法的調(diào)用


JAVA中的內(nèi)部類共分為四種：
靜態(tài)內(nèi)部類static inner class (also called nested class)
成員內(nèi)部類member inner class
局部內(nèi)部類local inner class
匿名內(nèi)部類anonymous inner class


(1).JAVA非靜態(tài)內(nèi)部類
若外部類字段，內(nèi)部類字段，內(nèi)部類方法變量同名，則其訪問方式分別是：
訪問外部類的字段：外部類類名.this.字段
訪問內(nèi)部類字段：this.字段
訪問內(nèi)部類方法的局部變量：字段
代碼：

//內(nèi)部類訪問字段方法
//聲明一個類
public class Neibulei{
public static void main(String [] args){
new Snake().show();//調(diào)用內(nèi)部類方法
}
}
//聲明一個類
class Snake{
private String name = "外部類屬性";//定義一個私有屬性
//聲明一個內(nèi)部類
private class Node{
public String name = "內(nèi)部類屬性";
//定義一個方法
public void add2Tall(){
String name = "局部變量";
System.out.println("把"+name+"添加到尾巴");
System.out.println("把"+this.name+"添加到尾巴");
System.out.println("把"+Snake.this.name+"添加到尾巴");
}
}
//定義方法
public void show(){
new Node().add2Tall();//開辟內(nèi)部類的方法
}
}



(2).外部類以外訪問非靜態(tài)內(nèi)部類：
內(nèi)部類不能是private修飾，否則不能訪問，外部類以外的地方定義內(nèi)部類變量
非靜態(tài)內(nèi)部類對象是存放在外部類的對象里的，因此在創(chuàng)建非靜態(tài)內(nèi)部類對象之前，必須先創(chuàng)建其外部類的對象
代碼：

//在外部類以外訪問非靜態(tài)內(nèi)部類
//聲明一個類
public class FangwenNeibu{
public static void main(String [] args){
Outer out = new Outer();//實例化外部對象，創(chuàng)建外部對象
Outer.Inner in = out.new Inner();//根據(jù)外部類對象創(chuàng)建內(nèi)部類對象
in.show();//調(diào)用方法
}
}
//聲明一個外部類
class Outer{
//聲明一個內(nèi)部類
class Inner{
//定義一個方法
public void show(){
System.out.println("非靜態(tài)內(nèi)部方法");
}
}
}


　
(3).靜態(tài)內(nèi)部類:
使用static修飾內(nèi)部類，該內(nèi)部類屬于其外部類，而不屬于外部類的實例；
靜態(tài)內(nèi)部類可包括靜態(tài)成員也可包括非靜態(tài)成員。根據(jù)靜態(tài)成員不能訪問非靜態(tài)成員的規(guī)定，所以靜態(tài)內(nèi)部類不能訪問外部類實例成員，只能訪問外部類的靜態(tài)成員；
代碼：

//靜態(tài)內(nèi)部類
//聲明一個類
public class JingTai{
public static void main(String [] args){
new Outer().test();//創(chuàng)建外部類對象并調(diào)用方法test
}
}
//聲明一個外部類
class Outer{
private String name = "will";//聲明一個私有屬性并賦值給name
private static int age = 17;//聲明一個私有靜態(tài)整形常量布置給age
//定義一個靜態(tài)內(nèi)部類
static class StaticInner{
private String s = "ooxx";//定義一個私有的屬性并把值賦值給s變量
private static int num = 13;//定義一個私有的屬性并把值賦給整形num
//定義方法
public void show(){
//System.out.println(name);//不能訪問
System.out.println(age);//可訪問
System.out.println(new Outer().name);//開辟外部類并調(diào)用外部屬性
}
}
//定義方法
public void test(){
//System.out.println(s);//訪問不到
//System.out.println(num);//訪問不到
System.out.println(StaticInner.num);//可以訪問
System.out.println(new StaticInner().s);//可以訪問
new StaticInner().show();//創(chuàng)建內(nèi)部類對象并調(diào)用內(nèi)部類方法show
}
}






(4).外部以訪問靜態(tài)類內(nèi)部：
代碼：

//在外部以訪問靜態(tài)類內(nèi)部
//聲明一個類
public class WaiFangNei{
public static void main(String [] args){
Outer.StaticInner.staticShow();//調(diào)用靜態(tài)內(nèi)部類靜態(tài)方法
new Outer.StaticInner().show();//調(diào)用靜態(tài)內(nèi)部類實例方法
}
}
//聲明一個外部類
class Outer{
//聲明一個靜態(tài)內(nèi)部類
static class StaticInner{
//定義一個show方法
public void show(){
System.out.println("靜態(tài)內(nèi)部類實例方法");//輸出
}
//靜態(tài)方法
public static void staticShow(){
System.out.println("靜態(tài)內(nèi)部類靜態(tài)方法");//輸出
　　 }
　}
　}





(5).局部內(nèi)部類：
局部內(nèi)部類:定義在方法里的內(nèi)部類;
特點：不能在宿主類以外的地方使用,局部內(nèi)部類也不能使用訪問修飾符和static修飾;
局部內(nèi)部類只能訪問方法中final修飾的局部變量:因為final修飾的變量相當(dāng)于一個常量,其生命周期超出了方法運行的生命周期;
代碼：

//局部內(nèi)類
//聲明一個類
public class JuBu{
String name = "will";//定義屬性
//定義主方法
public static void main(String [] args){
new JuBu().show();
}
}
//聲明一個方法
public void show(){
final int num = 10;//final修飾局部變量
//定義一個內(nèi)部類
class localClass{
//定義方法
public void test(){
System.out.println(name+"--&"+num);
}
}
new localClass().test();//調(diào)用
}







(6).局部內(nèi)部類：
局部內(nèi)部類:定義在方法里的內(nèi)部類;
特點:不能在宿主類以外的地方使用,局部內(nèi)部類也不能使用訪問修飾符和static修飾;
局部內(nèi)部類只能訪問方法中final修飾的局部變量:因為final修飾的變量相當(dāng)于一個常量,其生命周期超出了方法運行的生命周期;
適合只使用一次的類,不能是抽象類，因為系統(tǒng)在創(chuàng)建匿名內(nèi)部類的時候，會立即創(chuàng)建匿名內(nèi)部類的對象
匿名內(nèi)部類不能定義構(gòu)造器，因為匿名內(nèi)部類沒有類名
匿名內(nèi)部類格式：

new 父類構(gòu)造器([實參列表]) 或 接口(){
//匿名內(nèi)部類的類體部分
}

注意：匿名內(nèi)部類必須繼承一個父類或者實現(xiàn)一個接口，但最多只能一個父類或?qū)崿F(xiàn)一個接口；






(7).枚舉類(enum)：
什么是枚舉？：
枚舉就是要讓各種類型的變量的取值只能為若干個固定值得一個
枚舉就是要讓某個類型的變量的取值只能為若干個固定值中的一個，否則編譯器就會報錯
枚舉可以讓編譯器在編譯時就控制源程序賦給的非法值，使用普通變量的方式在開發(fā)階段無法實現(xiàn)這一目標
在JDK1.5之后，使用關(guān)鍵字enum定義一種新的類型，稱為枚舉類型
使用enum聲明,默認直接繼承了java.lang.Enum類，而不是Object類；
枚舉類的對象是固定的,實例個數(shù)有限,枚舉對象后可以跟()
枚舉元素必須位于枚舉類體中的最開始部分,枚舉元素后要有分號與其他成員分隔
枚舉類的構(gòu)造方法的權(quán)限修飾符默認是private
一旦枚舉對象后面加上{},那么該對象實際是枚舉匿名內(nèi)部類對象;
所有枚舉類都提供一個靜態(tài)的values()方法(返回該枚舉類所有對象組成的數(shù)組),便于遍歷所有枚舉對象；
所有枚舉類都提供一個靜態(tài)的valueOf(String name)方法, 返回枚舉類中對象名等于 name的對象
Enum是一個抽象類,是所有枚舉類的直接父類；
Enum常見方法：

String name(); // 返回枚舉實例名稱;
int ordinal(); // 返回枚舉實例在枚舉類中的索引,從0開始;
String toString(); // 返回枚舉對象的"自我描述";

在switch語句中使用枚舉對象；
在枚舉類中使用toString方法；
使用for-each中操作枚舉對象；
枚舉類的構(gòu)造方法；
枚舉類覆寫接口抽象方法的兩種方式；注意:匿名內(nèi)部類，枚舉實現(xiàn)單例模式；
代碼：

//枚舉類
//聲明一個類
public class Meiju{
//定義主方法
public static void main(String [] args){
RnumDemo rnON = RnumDemo.ON;
System.out.println(rnON);
}
}
//聲明一個枚舉類
enum RnumDemo{
ON,OFF;
}



(8).枚舉類的構(gòu)造方法：

enum Colors {
RED("紅"),GREEN("綠"),BLUE("藍");
private String name;
private Color(String name){
this.name = name;
}
public String getName(){
return name;
}
public String toString() {
return this.name;//this表示誰 ？
}
}


11.JAVA異常及異常處理機制

什么是異常？：
在程序中異常是阻止當(dāng)前方法或作用域繼續(xù)執(zhí)行的問題，在程序中導(dǎo)致程序中斷運行的一些指令
通俗的說，異常就是程序在運行時出現(xiàn)的不正常情況;
編寫的程序不可能一帆風(fēng)順,若異常產(chǎn)生,卻沒進行正確的處理。則可能導(dǎo)致程序的中斷,造成損失,所以我們在開發(fā)中要考慮到各種異常的發(fā)生,并對其作出正確的處理,確保程序的正常執(zhí)行

JAVA異常體系：
Throwable
Error
通常指JVM出現(xiàn)重大問題如：運行的類不存在或者內(nèi)存溢出
不需要編寫針對代碼對其處理，程序無法處理
Exception
在運行時運行出現(xiàn)的一些情況，可以通過try,catch,finally處理
Exception 和 Error的子類名大都是以父類名作為后綴
JAVA異常其實是對不正常情況的一種描述,并將其封裝成對象
JAVA在 設(shè)計異常體系時，將容易出現(xiàn)的異常情況都封裝成了對象


JAVA 內(nèi)置異常類
JAVA語言定義了一些異常類在 java.lang 標準包中
標準運行時異常類的子類是最常見的異常類。由于 java.lang 包是默認加載到所有的 Java 程序的，所以大部分從運行時異常類繼承而來的異常都可以直接使用，Java 根據(jù)各個類庫也定義了一些其他的異常，下面的表中列出了 Java 的非檢查性異常

| 異常 | 描述 |
| :-------- | --------:|
| ArithmeticException | 當(dāng)出現(xiàn)異常的運算條件時，拋出此異常。例如，一個整數(shù)"除以零"時，拋出此類的一個實例 |
| ArrayStoreException | 將錯誤類型的對象存儲到一個對象數(shù)組時拋出的異常 |
| ArrayIndexOutOfBoundsException | 用非法索引訪問數(shù)組時拋出的異常。如果索引為負或大于等于數(shù)組大小，則該索引為非法索引 |
| ClassCastException | 將對象強制轉(zhuǎn)換為不是實例的子類時，拋出該異常 |
| IllegalMonitorStateException | 拋出的異常表明某一線程已經(jīng)試圖等待對象的監(jiān)視器，或者試圖通知其他正在等待對象的監(jiān)視器而本身沒有指定監(jiān)視器的線程 |
| IllegalArgumentException | 拋出的異常表明向方法傳遞了一個不合法或不正確的參數(shù) |
| IllegalStateException | 在非法或不適當(dāng)?shù)臅r間調(diào)用方法時產(chǎn)生的信號，換句話說，即 Java 環(huán)境或 Java 應(yīng)用程序沒有處于請求操作所要求的適當(dāng)狀態(tài)下 |
| IllegalThreadStateException | 線程沒有處于請求操作所要求的適當(dāng)狀態(tài)時拋出的異常 |
| IndexOutOfBoundsException | 指示某排序索引（例如對數(shù)組、字符串或向量的排序）超出范圍時拋出 |
| NegativeArraySizeException | 應(yīng)用程序創(chuàng)建大小為負的數(shù)組，則拋出該異常 |
| NullPointerException | 應(yīng)用程序在需要對象的地方使用 null 時，拋出該異常 |
| NumberFormatException | 應(yīng)用程序試圖將字符串轉(zhuǎn)換成一種數(shù)值類型，但該字符串不能轉(zhuǎn)換為適當(dāng)格式時，拋出該異常 |
| SecurityException | 由安全管理器拋出的異常，指示存在安全侵犯 |
| StringIndexOutOfBoundsException | 異常由 String 方法拋出，指示索引或者為負，或者超出字符串的大小 |
| UnsupportedOperationException | 不支持請求的操作時，拋出該異常 |
| ClassNotFoundException | 應(yīng)用程序試圖加載類時，找不到相應(yīng)的類，拋出該異常 |
| CloneNotSupportedException | 當(dāng)調(diào)用Object類中的 clone 方法克隆對象，但該對象的類無法實現(xiàn) Cloneable 接口時，拋出該異常 |
| IllegalAccessException | 拒絕訪問一個類的時，拋出該異常 |
| InstantiationException | 使用 Class 類中的 newInstance 方法創(chuàng)建一個類的實例，而指定的類對象因為是一個接口或是一個抽象類而無法實例化時，拋出該異常 |
| InterruptedException | 一個線程被另一個線程中斷，拋出該異常 |
| NoSuchFieldException | 請求的變量不存在 |
| NoSuchMethodException | 請求的方法不存在 |




演示有異常程序的代碼

public class Demo7 {
public static void main(String[] args){
System.out.println("begin");
divide(17/0);
System.out.println("ending");
}
publc static void divide(int a,int b){
int c= a/b;
}
}

一旦出現(xiàn)異常，程序會立即終止


看完上面得異常程序，讀者思考，將如何處理異常程序呢？
異常處理過程分析：
一旦產(chǎn)生異常，則系統(tǒng)會自動產(chǎn)生一個異常類的實例化對象
此時如果存在于try語句，則會自動找到匹配的catch語句執(zhí)行
如果沒有異常處理，則程序?qū)⑼顺?，并由系統(tǒng)報告錯誤
所有的catch根據(jù)方法的參數(shù)匹配異常類的實例化對象，如果匹配成功，則表示由此catch進行處理
下面筆者將詳細介紹JAVA處理異常的5個關(guān)鍵字
JAVA異常處理的5個關(guān)鍵字

try 與 catch
finally
throw 與 throws

捕獲異常：先捕獲小異常再捕獲大異常
程序是調(diào)出來的，不是立馬編寫出來的；多測試是程序員的必修課之一


JAVA異常處理格式：

try{
//可能出異常的代碼
} catch(異常類型 對象){
//處理該異常類型的語句
}
finally {
//異常的統(tǒng)一出口
//一定會執(zhí)行的代碼
//catch塊使用System.exit(1);除外
}

當(dāng)try語句塊出現(xiàn)異常，程序會自動跳到catch語句塊去找匹配的異常類型，并執(zhí)行異常處理語句，finally語句塊是異常的統(tǒng)一出口，異常處理后，程序不會因為出現(xiàn)異常而退出


異常處理代碼：

//異常處理
//聲明一個類
public class Yichang{
//方法
public static void main(String [] args){
int a = 10;//定義一個常量
int b = 0;//定義一個常量
int c = 0;
//把有可能發(fā)生異常的代碼塊段放到try塊中，通過catch語句進行異常捕獲
try{
c = a/b;
}catch(ArithmeticException ex){
System.out.println("算數(shù)運算異常");
}
System.out.println(c);
}
}







Throwable中的方法
String getMessage(); 獲取異常信息，返回字符串
String toString(); 獲取異常類名和異常信息，返回字符串
void printStackTrace(); 打印異常在堆棧中的跟蹤信息;
獲取異常類名和異常信息，以及異常出現(xiàn)在程序中的位置
方便程序開發(fā)階段的調(diào)試(一般要打開)，JVM默認的異常處理機制;




JAVA多異常處理：
聲明異常時盡可能聲明具體異常類型,方便更好的處理;
方法聲明幾個異常就對應(yīng)有幾個catch塊;
若多個catch塊中的異常出現(xiàn)繼承關(guān)系,父類異常catch塊放在最后;
在catch語句塊使用Exception類作為異常類型時
所有子類實例都可以使用父類接收(向上轉(zhuǎn)型)，即所有的異常對象都可以使用Exception接收;
注：在java處理多異常時捕獲小范圍的異常必須放在大范圍異常之前
JAVA多異常處理格式：

try{
//可能出異常的代碼
} catch(異常類A 對象){
//處理異常類型A的語句
}catch(異常類B 對象){
//處理異常類型B的語句
}.....
finally {
//一定會執(zhí)行的代碼
//catch塊使用System.exit(1);除外
}

當(dāng)try語句塊出現(xiàn)異常，程序會自動跳到catch語句塊去找匹配的異常類型，并執(zhí)行異常處理語句，finally語句塊是異常的統(tǒng)一出口，異常處理后，程序不會因為出現(xiàn)異常而退出




JAVA異常的分類：
(1).編譯時被檢查異常; ---& Checked異常，在程序中必須使用try...catch處理
Checked異常特點：JAVA編譯器會檢查它,也就說程序中一旦出現(xiàn)這類異常,要么是沒有try-catch語句捕獲,或throws語句沒有聲明拋出它,編譯就不會通過,也就說這種異常,程序要求必須處理

(2).編譯時不被檢測的異常; ---& Runtime異常，可以不使用try...catch處理，但一旦出現(xiàn)異常就將由JVM處理
Runtime異常特點:這種異常Java編譯器不會檢查它,也就說程序中出現(xiàn)這類異常的時候,即使不處理也沒有問題,但是一旦出現(xiàn)異常,程序?qū)惓＝K止,若采用異常處理,則會被相應(yīng)的程序執(zhí)行處理




throw關(guān)鍵字：
自行拋出一個異常對象，拋出異常類的對象；若throw拋出的是Runtime異常：
程序可以顯示使用try...catch來捕獲并處理，也可以不管，直接交給方法調(diào)用者處理；若throw拋出Checked異常
要么放在try里自己處理，要么放在一個throws聲明的方法里面，交給調(diào)用者處理




throws 與 throw關(guān)鍵字
throws用于在方法上聲明該方法不需要處理的異常類型
throw用于拋出具體異常類的對象
throws與throw的區(qū)別：
thorws用在方法上，后面跟異常類名,可以是多個異常類
throw用在方法內(nèi)，后面跟異常對象,只能是一個


聲明拋出一個 RemoteException 異常代碼：

如果一個方法沒有捕獲一個檢查性異常，那么該方法必須使用 throws 關(guān)鍵字來聲明。throws 關(guān)鍵字放在方法簽名的尾部。
也可以使用 throw 關(guān)鍵字拋出一個異常，無論它是新實例化的還是剛捕獲到的。
import java.io.*;
public class className{
public void deposit(double amount) throws RemoteException{
throw new RemoteException();
}
}
一個方法可以聲明拋出多個異常，多個異常之間用逗號隔開。
例如，下面的方法聲明拋出 RemoteException 和 InsufficientFundsException：
import java.io.*;
　public class className{
public void withdraw(double amount) throws RemoteException,
InsufficientFundsException
{
}





finally關(guān)鍵字：
異常的統(tǒng)一出口：不管try塊程序是否異常，也不管哪個catch執(zhí)行，finally塊總會執(zhí)行
try語句塊或會執(zhí)行的catch語句塊使用了JVM系統(tǒng)退出語句例外;//System.exit(1);
try塊必須和 catch塊或和finally同在，不能單獨存在，二者必須出現(xiàn)一個
不要在finally中使用return 或throw語句，否則將會導(dǎo)致try、catch中的return或throw失效

初學(xué)(面向?qū)ο蠼A段) Ⅲ 難點: ★★★★★★★

希望每一篇文章都能夠?qū)ψx者們提供幫助與提升，這乃是每一位筆者的初衷

感謝您的閱讀 歡迎您的留言與建議

• 新浪官方微博: @中國熱點影視傳媒
• Github博客: <https://github.com/jeep711/jeep711.github.io>;
• Blog Garden：<http://www.cnblogs.com/JEEP711/>;
• W3C/Blog：<http://o2fo.com/jeep711blog/>;
• CSDN/Blog：<http://blog.csdn.net/jeep911>;
• 51CTO/Blog：<http://jeep711.blog.51cto.com/>;
• 碼云：<http://git.oschina.net/JEEP711/jeep711.github.io>;
• 郵箱: <jeep711@qq.com>，<JEEP-711@outlook.com>