return finally語句也會執行
finally代碼塊:定義執行的代碼,通常用於關閉資源.
第一格式:
try{
}catch{
}
第二格式:
try{
}catch{
}finally{
}
第三格式:
try{
}finally{
}
記住一點:
catch是用於處理異常,如果該catch,就代表異常沒被處理,
如果該異常時檢測時異常,必須作出對應的處理
/*
異常測試
*/
class Demo1
{
public static void main(String[] args)
{
/*
//有沒有用catch處理,編譯失敗
try
{
new Test().show(-11);
}
finally
{
System.out.print("一定會執行的語句");
}
*/
//
try
{
new Test().show(-11);
}
catch(Exception e)
{
e.printStackTrace();
// return;//finaly也一定會執行g
System.exit(0);//jvm退出了,finally就不會執行了
}finally{
System.out.println("這是一定會執行的語句");
}
}
}
class Test
{
public void show(int a)throws Exception{
if(a<0)
throw new Exception("出現非法數值");
}
}
異常在子父類覆蓋中的體現:
1.子類的覆蓋父類,如果父類時,如果父類的方法拋出異常,
那麼覆蓋的方法只能拋出父類的異常(自己)或者該異常的子類
2.如果父類方法拋出多個異常,那麼子類在覆蓋該方法時,只能拋出該
父類異常的子集.
3.如果父類或者接口方法中,沒有異常拋出,那麼子類在覆蓋時,
也不可以拋出異常
如果子類方法發生了異常,就必須進行try處理,絕對不能拋
異常總結:
異常是什麼?
是對問題的描述,將問題進行對象的封裝
異常體系:
throwable
|--Error
|--Exception
|--RuntimeExcepetion
異常體系的特點:
異常體系中所有的類以及建立的對象都具有可拋性,也就是說
可以被throw和throws關鍵字所操作,只有異常體系具備這個特點
throw和throws的用法:
throw定義在函數內,用於拋出異常對象
throws定義在函數上,用於拋出異常類,可以拋出多個,用逗號隔開
當函數內throw拋出對象,並未進行try處理,必須要在函數上聲明,否則就
編譯失敗,注意:RuntimeException除外,也就是說,函數內拋出的RuntimeException
及其子類在函數上不用聲明.
當在函數上聲明瞭異常,調用者需要進行處理,處理方法可以throws
,可以try
異常分兩種:
1.編譯時被檢測異常
該異常在編譯時,如果沒有處理,編譯失敗
該異常被標識,代表這可以被處理
2.運行時異常(編譯時不檢測)
在編譯時,不需要處理,編譯器不檢查
該異常發生,建議不處理,讓程序停止,需要對代碼進行改正
注意:
1.finally中定義通常的是關閉資源代碼,因爲資源必須要釋放
2.當System.exit(0);這種情況發生時,finally不會執行
自定義異常:
定義類繼承Exception或RuntimeException
1.爲了讓該自定義異常具備可拋性
2.讓該類具備操作異常的共性方法
當要定義自定義異常信息時,可以使用父類已經定義好的功能
,異常信息傳參給父類的構造函數
class MyException extends Exception
{
public MyException(String ms){
super(ms);
}
}
自定義異常:
按照java的面向對象思想,將程序出現的特有問題進行封裝
異常的好處:
1.將問題進行封裝
2.將正常流程代碼和問題代碼相分離,方便與閱讀
異常的處理原則:
1.處理方式有兩種:try或者throws
2.調用拋出異常功能時,拋出幾個,就處理幾個
一個try對應多個catch塊
3.多個catch塊,父類的catch放到最下面
4.catch內,需要定義針對性的處理方式,不要簡單的定義printStackTrace
,輸出語句,也不要不寫.當捕獲到異常,本功能處理不了時,可以 繼續
在catch中拋出
如果該異常處理不了,但並不屬於該功能出現的異常,可以將異常轉換後
在拋出和該功能相關的異常或者異常可以處理.就需要將異常產生的和本
功能相關的問題提供出去.當調用者知道,並處理,也可以將捕獲的異常處理
後,轉換新的異常:比如:匯款的例子
異常注意事項:
在子父類覆蓋時:
1.子類拋出的異常必須是父類的異常後者子集
2.如果是父類或者接口沒有拋出異常時,子類覆蓋中出現異常只能try不能拋
/*
異常在子父類中覆蓋的特點
*/
class Demo2
{
public static void main(String[] args)
{
Fu f=new Zi();
try
{
f.show();
}
catch (Exception e)
{
}
}
}
class AException extends Exception
{
}
class BException extends AException
{
}
class CException extends Exception
{
}
class DException extends Exception
{
}
class Fu
{
public void show()throws AException,CException{
System.out.println("fu");
throw new AException();
}
}
class Zi extends Fu
{ //子類覆蓋父類方法時,只能拋出父類的異常或者異常子類,或者子集
public void show()throws BException{
System.out.println("zi");
}
}
/*接口中不拋異常,子類只能try*/
interface Inter
{
public abstract void show();
}
class Test2 implements Inter
{ //繼承或者實現接口,子類覆蓋函數內容發生異常之後不能拋,只能try
public void show(){
try
{
throw new Exception();
}
catch (Exception e)
{
}
}
}
/*
注意事項:
*/
class Demo3
{
public static void main(String[] args)
{
Test t=new Test();
try
{
t.show(15); //異常被封裝在函數內,可能不會發生異常的情況
System.out.println("這裏可能還會執行到");
throw new Exception();//單獨throw存在,後面不能跟語句,否則編譯失敗
//System.out.print("這裏不允許有語句,因爲執行不到");
}
catch (AException e)
{
e.printStackTrace();
}catch(Exception e){
e.printStackTrace();
}
}
}
class AException extends Exception
{
public AException(String msg){
super(msg);
}
}
class Test
{
public void show(int a)throws AException{
if(a<0)
throw new AException("出現非法數值");
}
}
靜態方法只能覆蓋靜態方法
覆蓋要注意(參數類型,參數個數),還有權限
注意:
showExce();//後面可以跟語句,異常被封裝在函數內
throw new Exception();//後面不能跟語句,會編譯失敗的
throw單獨存在,不要定義語句在後面
/*
需求:
對有一個長方形 和圓形 都可以獲取面積
如果獲取面積輸入非法數值,則拋出異常
*/
class Demo4
{
public static void main(String[] args)
{
Circle c=new Circle(1.5);
System.out.println(c.getArea());
Rec r=new Rec(-4,5);//傳入非法數值就會報錯
System.out.println(r.getArea());
}
}
/*
圖形接口 擴展功能 或者自身的面積
*/
interface Shape
{
public abstract double getArea();
}
/*
非法數值異常
*/
class FeiFaArugmentException extends RuntimeException
{
public FeiFaArugmentException(String msg){
super(msg);
}
}
/*長方形類*/
class Rec implements Shape
{
private double chang;
private double kuan;
public Rec(double chang,double kuan){
if(chang<=0 || kuan<=0)
throw new FeiFaArugmentException("非法數值異常");
this.chang=chang;
this.kuan=kuan;
}
public double getArea(){
return chang*kuan;
}
}
/*圓形類*/
class Circle implements Shape
{
public static final double PI=3.14;
private double radius;
public Circle(double radius){
this.radius=radius;
}
public double getArea(){
return Math.pow(radius,2)*PI;
}
}
包(package)
1.對類文件進行處理
2.給類提供層命名空間
3.寫在程序文件第一行
4.類名的全稱是包名.類名
5.包也是一種封裝形式
cmd命令:
javac -d 文件夾 類名 //會自動將package語句生成文件夾形式
package com.it;//創建包 com.it
import com.it2.Demo6;//導入com.it包
public class Demo5 extends Demo6
{
public static void main(String[] args)
{
Demo5 t=new Demo5();
t.publicMethod();
/*繼承之後就能訪問了*/
t.protectedMethod();//不繼承不能訪問
//t.defaultMethod(); //不同包中不能訪問
//t.privateMethod(); //不同包不能放訪問
}
}
package com.it2; //創建包com.it
/*權限必須爲public*/
public class Demo6
{
public void publicMethod(){
System.out.println("publicMethod");
}
protected void protectedMethod(){
System.out.println("protectedMethod");
}
void defaultMethod(){
System.out.println("defaultMethod");
}
private void privateMethod(){
System.out.println("privateMethod");
}
}
總結:
1.包與包之間進行訪問,只能訪問public的類及類中的成員
需要被public所修飾
2.不同包中,子類可以訪問父類中被protected修飾的成員
public protected default private
同一個類中 ok ok ok ok
同包中 ok ok ok no
子類 ok ok no no
不同包中 ok no no no
導入(import)
爲了簡化類名的書寫,使用一個關鍵字,import
import導入的是包中的類
開發建議用到那個類,就導入那個類,不要寫*
建議包名不要重複,可以使用url來完成定義,url是唯一的
jar包
cmd命令如下:
-c是創建文件夾 v是查看詳細信息 f是指定文件名
jar -cvf 文件名.jar [包文件夾] [包文件夾]//多個用空格隔開
jar -tvf 文件名.jar > d:/1.txt //-t列出目錄 重定向到1.txt文件中
jar -tvf 文件.jar > d:/1.txt
—————————— ASP.Net+Android+IOS開發、.Net培訓、期待與您交流！——————————