------- android培訓、java培訓、期待與您交流！ ----------

-Java面向物件程式設計知識點總結。

一：內部類。

將一個類定義在另一個類的裡面，就稱該類為內部類。

1.內部類的特點：1.內部類可以直接訪問外部類的成員，包括私有成員。

2.而外部類要訪問內部類要建立內部類的物件才能訪問。

3.之所以能直接訪問外部類中的成員是因為內部類持有一個外部類的引用。格式為（外部類.this）。

4.當內部類定義在外部類的成員位置上而且非私有，可以在外部類中直接建立對內部類的物件對其成員進行訪問。書寫格式為：

外部類名.內部類名 變數名 =new外部類物件（）.內部類物件（）。

5.當內部類在成員位置上，就可以被成員修飾符修飾。

比如：private將內部類在外部類中進行封裝。Static：內部類就具有了靜態特性。當內部類被static修飾後只能直接訪問外部類中的靜態成員。並且當內部類定義了靜態成員，則內部類也為靜態成員。

6．內部類的使用，當描述的事物，在事物的內部還有事物，該內部事物就用內部類來描述。因為內部事物在使用外部事物的內容，

7.區域性內部類（放在外部類成員函式中的內部類）不能用static修飾。不可以被成員修飾符修飾。

8.可以直接訪問外部類中的成員，持有外部類的引用，當是不可以直接訪問它所在的成員方法中的變數，只能訪問被final修飾的區域性變數。

二：匿名內部類。

匿名內部類其實就是內部類的簡寫格式。

1.定義匿名內部類的前提：1.匿名內部類必須是繼承一個類或者是實現自介面。2.匿名內部類的演變過程及書寫格式：

父類或介面（）{定義子類內容}.子類中的方法（）；

未使用內部匿名類的示例：

abstract class Father

{

public int age= 54;

abstract publicvoid eat();

}

class Outer

{

int age = 10;

class Inner extends Father//使用匿名的前提是繼承或實現。

{

publicvoid eat()

{

System.out.println("letme eat something"+age);

}

}

public voidfun()//在外部類中建立內部類的物件呼叫內部類的方法。

{

new Inner().eat();

Father f =new Father()//多型寫法。

//沒有名字的繼承自父類使用父類的名字

{

public void eat()

{

System.out.println("let me eat something"+age);

}

}.eat();//匿名內部類部分可以替代紅色字型部分。完成的步驟有：

1.先繼承自父類但沒有名字（使用父名）。2.大括號中重寫父類方法或增加自己的方法。3.通過“.”呼叫匿名內部類的方法。

}

}

class InnerClassDemo

{

public staticvoid main(String[] args)

{

newOuter().fun();//1.呼叫外部類的fun()>>2.在fun中建立內部類的物件並訪問其eat()方法。3.>>執行方法。

}

}

3.其實匿名內部類就是一個匿名子類物件，是把定義類和建立物件封裝為一體的一個表現形式。可以理解為帶內容的物件。5.定義方法不要超過三個為好。

三：異常概述。

異常就是程式在執行時出現的不正常情況。異常的由來：問題在生活中是一個具體的事物，也可以通過類的形式進行描述，並封裝成物件。

1.Java中對於問題的劃分：1.非常嚴重問題（error）。2.嚴重問題（Exception）。

2.對於問題的處理：1Java中對於非常嚴重的問題通過error類進行描述。對於error一般不編寫針對性的程式碼對其進行處理。2.對於嚴重的問題，Java通過exception類進行描述。對於Exception可以使用針對性的處理方式進行處理。

Throwable介面

|--Error類。

|--Exception類。

Publicstatic int fun(int a)

{intb =2;

return a/b;

}

public static void main(String[] args)

{

int x = fun(0);//當被除數為0時丟擲異常。

}

3.異常處理：Java提供了特殊的語句進行處理。格式為：

try

{

需要被檢測的程式碼

}

catch（異常類變數1）

{

處理異常程式碼1（即處理方式）

}

catch（異常類變數2）

{

處理異常程式碼2（即處理方式）

}

finally

{

一定會執行的語句

}

4.throw和throws的用法：

throw定義在函式內，用於丟擲異常物件。

throws定義在函式上，用於丟擲異常類，可以丟擲多個用逗號隔開。

當函式內有throw丟擲異常物件，並未進行try處理。必須要在函式上宣告，兩者都在編譯失敗。RuntimeException除外函式內如果丟擲的RuntimeExcpetion異常，函式上可以不用宣告。

5.對捕獲到的異常物件進行處理的兩種方法：

String e.getMessage();//返回異常類的資訊為字串。

String e.toString();獲取異常名稱，異常資訊。

e.printStackTrace();異常名稱，異常資訊，異常出現位置。

6.異常的分類：

1.編譯時被檢測異常該異常在編譯時，如果沒有處理(沒有拋也沒有try)，編譯失敗。該異常被標識，代表這可以被處理。

7.異常的出現。

當在程式設計過程中，某些函式或語句可能出現異常的狀況，比如當a/b，b為0時，這種演算法是不被允許的，那麼該處就是程式的一個執行隱患，那麼此時我們就要把它標示出來。標示的方法是：

1.在該語句的後邊通過throw newException()標示，throw是異常類特有的程式跳轉關鍵字，throw用在函式的內部，new Exception()是在跳轉時傳遞的異常物件（異常類中封裝了各種異常物件，其各顯示功能也不同）。

2.當函式內出現了異常的標示，這時就必須在函式上也進行標示，標示的方法是在函式的引數列表後邊通過throws Exception進行標示。

3.當程式中包含了標示安全隱患的異常丟擲語句後，程式就不再像以前那種程式設計不管它有沒有安全隱患，都可以被編譯被執行的程式了。也就是說你標示出了存在安全隱患的函式或語句後，你標示的目的就更明確了。那目的是什麼，就是既然你把它標示出來了，你只是知道有安全隱患是沒有任何價值的，你需要處理它，需要為安全隱患寫預案，當出現除數為0時，程式應該怎麼這麼辦，當陣列的下標越界後，程式應該怎麼這麼做。

也就是強制處理。這時的程式在你不寫預案的情況下，會告訴你：程式丟擲異常，需要通過throws或try的方式處理才能夠編譯通過。

總結就是：假如你不理它，還是以前的那樣像一條船有一個小洞，不去管它船也不會沉。你是可以出海的（編譯通過的）。假如家人很關心打漁人，提醒了他（標示了），你就要必須不違背家人的意願處理它，否則家人是不讓你出海（通不過編譯）（RuntimeException除外）。

4.標示後（丟擲異常後），想通過編譯的兩種方法：1.異常處理不了或不想處理，就在主函式上也丟擲，這裡會把異常丟擲給虛擬機器的預設處理，就可以通過編譯了。2.通過catch捕獲異常，也就是你寫了預案。就可以通過寫的預案處理異常，可以通過編譯了。

例如：

int div(int a,int b)throwsAritchmeticException

{

returna/b;

}

try

{//1.執行函式如果發生異常丟擲異常給2跳轉到2。3不執行

intx =div(4,0);new AritchmeticException()

3.System.out.println(x);

}

//2.接受異常的物件。顯示處理結果

catch(Exceptione)Exception e = new AritchmeticException()

{

System.out.println(“除零”);

return；//當處理中有return時，4不會被執行。

}

//4.執行異常處理後的程式碼。

System.out.println(“over”);

5.多異常處理。

在出現多個異常的函式後寫上throws異常1，異常2。丟擲幾個異常就寫幾個catch（解決方案）。如果多個catch中存在異常的繼承關係，父類的catch塊要放在最後執行。

class Demo

{intdiv(inta,intb)throws

ArithmeticException,ArrayIndexoutofException

{

int arr[] = new int[a];

printlnI(arr[4]);

return a/b;

}

}

class Test

{

publicstatic void main(String[] args)

{

Demo d = new Demo();

try

{

int x = d.div(5,0);

println(x);

}

catch(ArithmeticException e)

{

prinln（e.toString()）;

}

catch(ArrayIndexoutofException e)

{

println(e.toString());

}

catch(Exception e)//Exception異常是父類要放在最後處理。

{

println（e.toString()）；

}

}

}

6.自定義異常。

因為專案中會出現特有的問題，這些問題並未被java所描述，所以對於這些問題可以按照java的對問題封裝的思想，將特有的問題進行自定義的異常封裝。

自定義異常的實現：

1.首先定義自定義類並繼承Exception。

2.呼叫父類的建構函式將自定義的異常資訊傳遞給父類。

3.在函式內通過throw手動丟擲自定義異常物件。

4.當在函式內使用手動丟擲異常時：要不在內部使用try解決，要不就在函式上進行throws丟擲給函式的呼叫者進行跳轉。一般情況下在函式內出現異常都要在函式上進行丟擲。丟擲後就與throws的處理方式相同，要麼throws給虛擬機器，要麼try。

class FuShu Exceptionextends Exception

{priavte String msg;

FuShu(String msg)

{//將異常資訊傳遞給父類的建構函式，達到顯示自定義異常的作用。

super(msg);

}

}

class Demo

{

int div(int a, int b)throws FuShuException

{//throw是手動丟擲異常關鍵字丟擲一個自定義異常物件。

if(b<0)throw FuShuException(“the numis fault”);

}

}

class test

{public static void main(String[] args)

{

try

{

int x = new Demo().div（4,-1）；

println(x);

}

catch(FuShu Exception e)

{

println(e.toString()+e.getMessage()+e.printStackTrace());

}

}

}

7.異常體系：

因為異常類和異常物件都要被丟擲，它們都具備可拋性。這個可拋性是Throwable這個體系獨有的特點，只有這個類中的體系或者物件才能被throw和throws操作。

8．Runtime異常。

如果在函式內丟擲該異常，函式上可以不用宣告，編譯一樣可以通過。如果在函式上聲明瞭該異常，呼叫者可以不處理也可以編譯通過。之所以不用在函式上宣告該異常,異常發生時，希望程式停止，因為在執行時出現了無法繼續運算的情況，希望停止修正。Runtime丟擲的是不能解決的問題，需要修改程式碼，而Exception是可以處理的問題，就去寫預案，比如：人造衛星的對接，在對接過程中可能會出現多種外界因素干擾，當有小行星撞擊怎麼辦，你可以躲，當太陽能電池沒有存滿電可以等。但在對接時，你的對接裝置和另一個衛星的對接裝置不相容，這個是被Runtime標示為解決不了的問題，那還是讓衛星返回地球，重新設計對接裝置吧。這就是Runtime類是在編譯時不用檢測的，你也不用寫預案，因為檢查到也處理不了，就讓對接任務停止了（程式停止）。是自身出了問題，需要程式設計師對其內部程式進行修改滿足執行條件。Exception則是在編譯時檢測，就是在製造衛星時就要考慮好的問題。寫好預案，在對接時便可以順利完成任務。

9.Try...catch...finally的使用。

如果catch語句中出現了return語句，這時程式會在執行完finally後跳出函式，不再執行finally後邊的語句，如下：

public void demo ()

{

catch(Exception e)

{

println(“a”);1

return//使用return程式會執行完2後跳出函式不執行3

}

finally

{

println(“b”);2

}

println(“c”);3

}

輸出：a，b。

異常在子父類覆蓋中的體現；

1，子類在覆蓋父類時，如果父類的方法丟擲異常，那麼子類的覆蓋方法，只能丟擲父類的異常或者該異常的子類。

2，如果父類方法丟擲多個異常，那麼子類在覆蓋該方法時，只能丟擲父類異常的子集。

3，如果父類或者介面的方法中沒有異常丟擲，那麼子類在覆蓋方法時，也不可以丟擲異常。

如果子類方法發生了異常。就必須要進行try處理。絕對不能拋。

class AException extends Exception

{

}

class BException extends AException

{

}

class CException extends Exception

{

}

Exception

|--AException

|--BException

|--CException

class Fu

{

voidshow()throws AException

{

}

}

class Test

{

voidfunction(Fu f)

{

try

{

f.show();

}

catch(AException e)

{

}

}

}

class Zi extends Fu

{//父類中沒有c異常，這裡的重寫方法只能try，下面書寫不正確。

voidshow()throws CException

{

}

}

class

{

publicstatic void main(String[] args)

{

Testt = new Test();

t.function(newZi());

}

}

10.異常練習；

有一個圓形和長方形。

都可以獲取面積。對於面積如果出現非法的數值，視為是獲取面積出現問題。問題通過異常來表示。現有對這個程式進行基本設計。

Exception的寫法：

//建立自定義異常

class FaultException extends Exception

{privateString msg;

FaultException(Stringmsg)

{

super(msg);

}

}

class GetSquare

{privateint r;

privatefinal float PI =3.14f;

privateint h;

privateint l;

publicvoid yuan (int r)throws FaultException

{if(r <0)

thrownew FaultException("傳入的半徑值為負數");

floatseq;

seq= r*PI;

System.out.println("圓面積："+seq);

}

publicvoid fang(int h,int l)throws FaultException

{if(h<0||l<0)

thrownew FaultException("傳入的長寬高為負數");

floatseq = h*l;

System.out.println("方面積："+seq);

}

}

class ExecptionDemo

{

publicstatic void main(String[] args)

{

try

{

//newGetSquare().yuan(-10);

newGetSquare().fang(-10,10);

}

catch(Exception f)

{

System.out.println(f.toString());

}

}

}

RuntimeException類的寫法：

class FaultException extendsRuntimeException

{

FaultException(Stringmsg)

{

super(msg);

}

}

class GetSquare

{privateint r;

privatefinal float PI =3.14f;

privateint h;

相關推薦