2. 程式人生 > >Java之異常處理，日期處理

Java之異常處理，日期處理

阿新 • • 發佈：2017-07-23
出了 指定 初始化 ring () next height 常見問題 自定義

Java異常處理

異常：異常就是Java程序在運行過程中出現的錯誤。

異常由來：問題也是現實生活中一個具體事務，也可以通過java 的類的形式進行描述，並封裝成對象。其實就是Java對不正常情況進行描述後的對象體現。

異常分類圖解：

技術分享

Throwable
　　1--Error 嚴重問題，我們不處理。
　　2--Exception
　　　　（1）--RuntimeException 運行期異常，我們需要修正代碼
　　　　（2）--非RuntimeException 編譯期異常，必須處理的，否則程序編譯不通過

Java虛擬機默認處理

public class ExceptionTest1 {
    
 
public static void main(String[] args) {
        int a=10;
        int b=0;
        System.out.println(a/b);
        System.out.println("通過！");
    }
}

技術分享

這是一個除數為0造成的典型的運行異常

這是Java虛擬機默認的處理，將異常的名稱，原因，出現的問題輸出在控制臺

同時也中斷程序

自己處理異常

try...catch...finally
　　自己編寫處理代碼,後面的程序可以繼續執行
throws
　　拋出，把自己處理不了的，在方法上聲明，告訴調用者，這裏有問題

註意：try裏面的代碼越少越好

將問題包在try中，程序可以運行，但是catch裏必須有代碼，不然只能是隱藏問題而不是處理異常

public class ExceptionTest1 {
    public static void main(String[] args) {
        int a=10;
        int b=0;
        try{
            System.out.println(a/b);
        }catch(ArithmeticException Ex){
            System.out.println(
 
"異常！除數不能為0");
        }
        System.out.println("通過！");
    }
}

技術分享

//多個異常的情況
public class ExceptionTest1 {
    public static void main(String[] args) {
        int a=10;
        int b=0;
        int i[]={0,1,2};
        try{
            System.out.println(i[3]);
            System.out.println(a/b);
        }catch(ArithmeticException Ex){
            System.out.println("異常！除數不能為0");
        }catch(ArrayIndexOutOfBoundsException Ex){
            System.out.println("異常！訪問無效！");
        }
        System.out.println("通過！");
    }
}

技術分享

我們可以看到並沒有輸出第一個catch中的異常處理語句，這是因為一旦try 裏出了問題就會把這個異常拋出去到 catch 中匹配異常，匹配到之後執行 catch 裏的語句，然後結束 try...catch 在執行下面的語句

public class ExceptionTest1 {
    public static void main(String[] args) {
        int a=10;
        int b=0;
        int i[]={0,1,2};
        try{
            System.out.println(i[3]);
            System.out.println(a/b);
            System.out.println("未知的異常！");
        }catch(ArithmeticException Ex){
            System.out.println("異常！除數不能為0");
        }catch(ArrayIndexOutOfBoundsException Ex){
            System.out.println("異常！訪問無效！");
        }catch(Exception Ex){//Exception可以匹配所有的異常類型
            System.out.println("異常！未知！");
        }
        System.out.println("通過！");
    }
}

在catch()中我們應該寫異常類型，能明確的盡量明確以節約資源，不能明確的也可以寫 Exception

註意：Exception 可以匹配所有異常，所有不能寫在前面，否則後面的無效，所以，平級關系的異常前後順序無所謂，父子關系的異常父類必須在後面。

try...catch...finally的格式變形
* A:try...catch...finally
* B:try...catch
* C:try...catch...catch...
* D:try...catch...catch...finally
* E:try...finally 這種做法的目前是為了釋放資源。

JDK7的新特性，可以再catch中將多個異常用 | 隔開

public class ExceptionTest1 {
    public static void main(String[] args) {
        int a=10;
        int b=0;
        int i[]={0,1,2};
        try{
            System.out.println(i[3]);
            System.out.println(a/b);
            System.out.println("未知的異常！");
        }catch(ArithmeticException | ArrayIndexOutOfBoundsException Ex){
            System.out.println("異常！");
        }
        System.out.println("通過！");
    }
}

這種方法的局限性，只能給出一個解決方案，多個異常要是平級關系

編譯期異常和運行期異常的區別?
　　編譯期異常 必須要處理的，否則編譯不通過
　　運行期異常 可以不處理，也可以處理

Throwable類的常見方法

getMessage

public String getMessage()
返回此 throwable 的詳細消息字符串。
返回：
此 Throwable 實例（可以為 null）的詳細消息字符串。

toString

public String toString()
返回此 throwable 的簡短描述。如果此 Throwable 對象是利用非空詳細消息字符串創建的，則結果是三個字符串的串聯：
  • 此對象的實際類的名稱
  • ": "（冒號和空格）
  • 此對象的 getMessage() 方法的結果
如果此 Throwable 對象利用 null 詳細消息字符串創建，則返回此對象的實際類的名稱。
覆蓋：
類 Object 中的 toString
返回：
該 throwable 的字符串表示形式。

printStackTrace

public void printStackTrace()
將此 throwable 及其追蹤輸出至標準錯誤流。此方法將此 Throwable 對象的堆棧跟蹤輸出至錯誤輸出流，作為字段 System.err 的值。輸出的第一行包含此對象的 toString() 方法的結果。剩余行表示以前由方法 fillInStackTrace() 記錄的數據。此信息的格式取決於實現，但以下示例是最常見的： 
 java.lang.NullPointerException
         at MyClass.mash(MyClass.java:9)
         at MyClass.crunch(MyClass.java:6)
         at MyClass.main(MyClass.java:3)
本示例通過運行以下程序生成： 
 class MyClass {
     public static void main(String[] args) {
         crunch(null);
     }
     static void crunch(int[] a) {
         mash(a);
     }
     static void mash(int[] b) {
         System.out.println(b[0]);
     }
 }
對於帶初始化非空 cause 的 throwable 的追蹤，通常應該包括 cause 的追蹤。此信息的格式取決於實現，但以下示例是最常見的： 
 HighLevelException: MidLevelException: LowLevelException
         at Junk.a(Junk.java:13)
         at Junk.main(Junk.java:4)
 Caused by: MidLevelException: LowLevelException
         at Junk.c(Junk.java:23)
         at Junk.b(Junk.java:17)
         at Junk.a(Junk.java:11)
         ... 1 more
 Caused by: LowLevelException
         at Junk.e(Junk.java:30)
         at Junk.d(Junk.java:27)
         at Junk.c(Junk.java:21)
         ... 3 more
註意，存在包含字符 "..." 的行。這些行指示此異常的椎棧跟蹤的其余部分匹配來自異常（由 "enclosing" 異常引起）的堆棧跟蹤底部的指定數量的幀。這種簡便方法可以大大縮短通常情況下的輸出長度，這裏拋出了包裝的異常，其方法與捕獲“作為 cause 的異常”的方法相同。上述示例通過運行以下程序生成： 
 public class Junk {
     public static void main(String args[]) { 
         try {
             a();
         } catch(HighLevelException e) {
             e.printStackTrace();
         }
     }
     static void a() throws HighLevelException {
         try {
             b();
         } catch(MidLevelException e) {
             throw new HighLevelException(e);
         }
     }
     static void b() throws MidLevelException {
         c();
     }   
     static void c() throws MidLevelException {
         try {
             d();
         } catch(LowLevelException e) {
             throw new MidLevelException(e);
         }
     }
     static void d() throws LowLevelException { 
        e();
     }
     static void e() throws LowLevelException {
         throw new LowLevelException();
     }
 }

 class HighLevelException extends Exception {
     HighLevelException(Throwable cause) { super(cause); }
 }

 class MidLevelException extends Exception {
     MidLevelException(Throwable cause)  { super(cause); }
 }
 
 class LowLevelException extends Exception {
 }
public class ExceptionTest1 {
    public static void main(String[] args) {
        int a=10;
        int b=0;
        int i[]={0,1,2};
        try{
            System.out.println(i[3]);
        }catch(Exception Ex){
            System.out.println(Ex.getMessage());  //異常的消息字符串
            System.out.println(Ex.toString());  //異常消息簡單描述
            Ex.printStackTrace();    //獲取異常類名和異常信息，以及異常出現在程序中的未知，void，把信息輸出在控制臺
        }
        System.out.println("通過！");
    }
}

throws

定義功能方法時，需要把出現的問題暴露出來讓調用者去處理。那麽就通過throws在方法上標識。

    public void show() throws ParseException  {
        String s="2017-07-23";
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d=sdf.parse(s);
        System.out.println(sdf.format(d));
    }
        try {
            d.show();
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

註意：編譯期異常拋出將來調用者必須處理

運行期異常拋出，將來調用者可以不處理

throws後也可以跟多個異常

throw

在功能方法內部出現某種情況，程序不能繼續運行，需要進行跳轉時，就用throw把異常對象拋出。這時拋出的應該是異常的對象。

        int a=10;
        int b=0;
        if(b==0){
            throw new ArithmeticException();
        }else{
            System.out.println(a/b);
        }

throws和throw的區別
throws
用在方法聲明後面，跟的是異常類名
可以跟多個異常類名，用逗號隔開
表示拋出異常，由該方法的調用者來處理
throws表示出現異常的一種可能性，並不一定會發生這些異常
throw
用在方法體內，跟的是異常對象名
只能拋出一個異常對象名
表示拋出異常，由方法體內的語句處理
throw則是拋出了異常，執行throw則一定拋出了某種異常

總結

如果該功能內部可以將問題處理,用try,如果處理不了,交由調用者處理,這是用throws
區別:
後續程序需要繼續運行就try
後續程序不需要繼續運行就throws
舉例:
感冒了就自己吃點藥就好了,try
吃了好幾天藥都沒好結果得了H7N9,那就的得throws到醫院
如果醫院沒有特效藥就變成Error了

finally

特點：

被finally控制的語句體一定會執行
特殊情況：在執行到finally之前jvm退出了(比如System.exit(0))

作用：用於釋放資源 

        String s="2017-07-23";
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d=null;
        try{
            d=sdf.parse(s);
        }catch(ParseException ex){
            ex.printStackTrace();
        }finally{
            System.out.println("!這裏的語句一定會執行！");
        }
        System.out.println(d);

常見問題：

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

如果catch裏面有return語句，finally裏面的代碼還會執行嗎?
如果會，是在return前，還是return後。
會。前。
準確的說，應該是在中間。

    public static int getInt() {
        int a = 10;
        try {
            System.out.println(a / 0);
            a = 20;
        } catch (ArithmeticException e) {
            a = 30;
            return a;
            /*
             * return a在程序執行到這一步的時候，這裏不是return a而是return 30;這個返回路徑就形成了。
             *它發現後面還有finally，所以繼續執行finally的內容，a=40
             * 再次回到以前的返回路徑，繼續走return 30;
             */
        } finally {
            a = 40;
            return a;//如果這樣結果就是40了。
        }
        return a; //這裏的語句不會執行

自定義異常

Java中定義了很多常見的異常類，但是在實際運行中也需要我們自己定義異常類。

自定義的異常類需要繼承自繼承自Exception或者RuntimeException,只需要提供無參構造和一個帶參構造即可

//自定義異常類
public class MyException extends Exception {
    public MyException() {
    }

    public MyException(String message) {
        super(message);
    }
}
//老師類
public class Teacher {
    public void check(int score) throws MyException {
        if (score > 100 || score < 0) {
            throw new MyException("分數必須在0-100之間");
        } else {
            System.out.println("分數沒有問題");
        }
    }
}
//主方法
import java.util.Scanner;
public class StudentDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入學生成績：");
        int score = sc.nextInt();

        Teacher t = new Teacher();
        try {
            t.check(score);
        } catch (MyException e) {
            e.printStackTrace();
        }
    }
}

技術分享

如果繼承自RuntimeException

public class Teacher {
    public void check(int score) throws MyException {
    //針對MyException繼承自RuntimeException
    public void check(int score) {
    if (score > 100 || score < 0) {
        throw new MyException();
    } else {
        System.out.println("分數沒有問題");
    }
    }
}
public class MyException extends RuntimeException {

}

異常的註意
A:父的方法有異常拋出,子的重寫方法在拋出異常的時候必須要小於等於父的異常
B:父的方法沒有異常拋出,子的重寫方法不能有異常拋出
C:父的方法拋出多個異常,子的重寫方法必須比父少或者小

Java之異常處理，日期處理

相關推薦

Java之異常處理，日期處理

出了 指定 初始化 ring () next height 常見問題 自定義 Java異常處理 異常：異常就是Java程序在運行過程中出現的錯誤。 異常由來：問題也是現實生活中一個具體事務，也可以通過java 的類的形式進行描述，並封裝成對象。其實就是Java對不正常情

java之異常處理

init value etc .com level dem com ini war AboutException的測試： 1 package test; 2 import javax.swing.*; 3 4 class AboutException { 5

Java之異常處理具體使用總結

導讀： 1、異常的分類； 2、Java的異常處理機制：  2.1、異常try catch finally；  2.2、異常宣告：throws；  2.3、人工丟擲異常； 3、異常處理原則； 4、自定義異常； 5、throw和throws的區別。 1、異常的分類：   Ja

java之異常捕獲及處理

一、處理異常 try{ //有可能出異常的語句 } [catch (異常型別 物件) { //異常處理 } catch (異常型別 物件) { //異常處理 } catch (異常型別 物件) { //異常處理 }...] [finally { //不管

Java之異常處理與工具類

異常處理 ①   Error(錯誤) Error（錯誤） 一般指比較嚴重的問題，不做針對性處理，無法挽救；            OutOfMemoryError  記憶體溢位 ②   Exc

java工具包一：日期處理

div 方便 開始 .text simple nor atd blog param 作者：NiceCui 本文謝絕轉載，如需轉載需征得作者本人同意，謝謝。 本文鏈接：http://www.cnblogs.com/NiceCui/p/7846812.html 郵箱：

java之集合總結，異常（try...catch...finally，丟擲throws）

一. 集合總結 1. 單列集合 (Collection) 1.1 執行緒不安全的 jdk1.2 ArrayList 查詢快 增刪慢(相對) LinkedList 查詢慢 增刪快(相對) HashSet 去重 TreeS

Java中斷異常 InterruptedException 的正確處理方式

你看到這篇檔案可能是因為你已經呼叫了一個丟擲 InterruptedException 異常的方法，並且需要以某種方式處理它。 首先，需要了解為一個方法為啥會 throws InterruptedException, 是這個方法丟擲中斷異常作為方法簽名的一部分以及呼叫正在呼叫的方法的可能結果。因此，首先

go語言基礎語法：異常處理，文字檔案處理，JSON處理，檔案操作

一、異常處理 1.err介面的使用 err1 := fmt.Errorf("%s", "this is normal error") fmt.Println("err1=", err1) err2 := errors.New("this is normal error,

python下的日期與時間（時間格式轉換、時間戳處理，時間差處理）

python下的日期與時間 一、在Python中，時間主要有三種表示形式， 1.時間戳（TimeStamp）：1970年1月1日之後的秒 2.時間元組格式化形式 包含了：年、日、星期 得到time.struct_time（tm_year=2017, tm_mo

SQL之to_date()以及關於日期處理的詳解

日期例子： SELECT TO_DATE('2006-05-01 19:25:34', 'YYYY-MM-DD HH24:MI:SS') FROM DUAL SELECT TO_DATE('2006-05-01 19:25', 'YYYY-MM-DD HH24:MI') FROM DUAL SELECT

Java之線程，常用方法，線程同步，死鎖

時間 imp log 沖突 根據 oms adl 無法 誰的 1, 線程的概念 進程與線程 進程：每個進程都有獨立的代碼和數據空間（進程上下文），進程間的切換會有較大的開銷，一個進程包含1--n個線程。（進程是資源分配的最小單位） 線程：同一類線程共享代碼和數據空間，每個線

分析數據, 缺失值處理 ,去重處理， 噪音處理

異常 str 超過 基礎 基於 center st2 describe 是否 分析數據, 缺失值處理 ,去重處理， 噪音處理 看了charlotte的博客分析數據, 缺失值處理 學習總結，很受用，如是將她的畫圖的部分代碼添加完整，可以運行，這樣學起來更直觀. 1.分析數

java之LineNumberReader類，裝飾者模式，列印流，合併流（檔案合併和分割）和第三方工具類（FileNameUtils）

一.LineNumberReader類 public class Kll { public static void main(String[] args) throws IOException { File file = new File("

python手記（四）：pillow（一）GIF處理，RGBA處理，Image例項屬性總結

GIF儲存方法： 上次我們說到了gif動態圖片怎樣一張張將它分解，這次我們來說下怎樣把幾張單的gif組合成動態圖片。 im.save(out, save_all = True, append_images=[im1, im2......]) 基本的方法就

Java之Date類，DateFormat類，SimpleDateFormat詳解

java.util.Date Date 日期類 不過很多方法都已經過時了 1.構造方法有兩種 有參(Long) 無參 2.方法主要有兩種 setTime 和 getTime兩種 import java.util.Date; public class Demo

Java的Date類，日期的比較（筆記）

import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Date;/** * 字串轉為日期前形式，直接用程式碼+註釋了 * @author helloX007 */p

Java8利用stream對集合的複雜操作（順序處理，並行處理）

又是一個很平常的週六，習慣性地來到公司，中午看了會Java8實戰，發現其中講到Stream實現集合的複雜操作，於是自己動手寫了個Demo，並測試了下效率。 結果是並行處理的效率遠遠高於順序處理。可能與我在公司用的電腦有關（我用的是8核）。 話不多說，直接放程式碼： pa

java之異常java.net.MalformedURLException解決辦法

1、問題日誌列印 System.err W java.net.MalformedURLException W at

java之位元組流，字元流，轉換流

1.使用位元組的輸入流和輸出流來進行復制 位元組流不但可以寫文字還可以寫圖片，音訊 public static void main(String[] args){ FileInputStream f = new FileInputStream("/Us