package com.example;
import java. util .Scanner ;
public class AllDemo{
    public static void main (String [] args ){
        System . out. println( "----歡迎使用命令行除法計算器----" ) ;
        CMDCalculate ();
    }
    public static void CMDCalculate (){
        Scanner scan = new Scanner ( System. in );
        int num1 = scan .nextInt () ;
        int num2 = scan .nextInt () ;
        int result = devide (num1 , num2 ) ;
        System . out. println( "result:" + result) ;
        scan .close () ;
    }
    public static int devide (int num1, int num2 ){
        return num1 / num2 ;
    }
}
/*****************************************
----歡迎使用命令行除法計算器----
0
Exception in thread "main" java.lang.ArithmeticException : / by zero
     at com.example.AllDemo.devide( AllDemo.java:30 )
     at com.example.AllDemo.CMDCalculate( AllDemo.java:22 )
     at com.example.AllDemo.main( AllDemo.java:12 )
----歡迎使用命令行除法計算器----
r
Exception in thread "main" java.util.InputMismatchException
     at java.util.Scanner.throwFor( Scanner.java:864 )
     at java.util.Scanner.next( Scanner.java:1485 )
     at java.util.Scanner.nextInt( Scanner.java:2117 )
     at java.util.Scanner.nextInt( Scanner.java:2076 )
     at com.example.AllDemo.CMDCalculate( AllDemo.java:20 )
     at com.example.AllDemo.main( AllDemo.java:12 )
*****************************************/

@Test
public void testException() throws IOException
{
    //FileInputStream的構(gòu)造函數(shù)會拋出FileNotFoundException
    FileInputStream fileIn = new FileInputStream("E:\\a.txt");
    int word;
    //read方法會拋出IOException
    while((word =  fileIn.read())!=-1) 
    {
        System.out.print((char)word);
    }
    //close方法會拋出IOException
    fileIn.close()
}

try{
     //try塊中放可能發(fā)生異常的代碼。
     //如果執(zhí)行完try且不發(fā)生異常，則接著去執(zhí)行finally塊和finally后面的代碼（如果有的話）。
     //如果發(fā)生異常，則嘗試去匹配catch塊。
}catch(SQLException SQLexception){
    //每一個catch塊用于捕獲并處理一個特定的異常，或者這異常類型的子類。Java7中可以將多個異常聲明在一個catch中。
    //catch后面的括號定義了異常類型和異常參數(shù)。如果異常與之匹配且是最先匹配到的，則虛擬機將使用這個catch塊來處理異常。
    //在catch塊中可以使用這個塊的異常參數(shù)來獲取異常的相關信息。異常參數(shù)是這個catch塊中的局部變量，其它塊不能訪問。
    //如果當前try塊中發(fā)生的異常在后續(xù)的所有catch中都沒捕獲到，則先去執(zhí)行finally，然后到這個函數(shù)的外部caller中去匹配異常處理器。
    //如果try中沒有發(fā)生異常，則所有的catch塊將被忽略。
}catch(Exception exception){
    //...
}finally{
    //finally塊通常是可選的。
   //無論異常是否發(fā)生，異常是否匹配被處理，finally都會執(zhí)行。
   //一個try至少要有一個catch塊，否則， 至少要有1個finally塊。但是finally不是用來處理異常的，finally不會捕獲異常。
  //finally主要做一些清理工作，如流的關閉，數(shù)據(jù)庫連接的關閉等。 
}

public static void main(String[] args){
    try {
        foo();
    }catch(ArithmeticException ae) {
        System.out.println("處理異常");
    }
}
public static void foo(){
    int a = 5/0;  //異常拋出點
    System.out.println("為什么還不給我漲工資!!!");  //////////////////////不會執(zhí)行
}

public void foo() throws ExceptionType1 , ExceptionType2 ,ExceptionTypeN
{ 
     //foo內(nèi)部可以拋出 ExceptionType1 , ExceptionType2 ,ExceptionTypeN 類的異常，或者他們的子類的異常對象。
}

public void save(User user)
{
      if(user  == null) 
          throw new IllegalArgumentException("User對象為空");
      //......
}

public class Throwable implements Serializable {
    private Throwable cause = this;
    public Throwable(String message, Throwable cause) {
        fillInStackTrace();
        detailMessage = message;
        this.cause = cause;
    }
     public Throwable(Throwable cause) {
        fillInStackTrace();
        detailMessage = (cause==null ? null : cause.toString());
        this.cause = cause;
    }
    //........
}

public static void main(String[] args)
{
    System.out.println("請輸入2個加數(shù)");
    int result;
    try
    {
        result = add();
        System.out.println("結(jié)果:"+result);
    } catch (Exception e){
        e.printStackTrace();
    }
}
//獲取輸入的2個整數(shù)返回
private static List<Integer> getInputNumbers()
{
    List<Integer> nums = new ArrayList<>();
    Scanner scan = new Scanner(System.in);
    try {
        int num1 = scan.nextInt();
        int num2 = scan.nextInt();
        nums.add(new Integer(num1));
        nums.add(new Integer(num2));
    }catch(InputMismatchException immExp){
        throw immExp;
    }finally {
        scan.close();
    }
    return nums;
}
//執(zhí)行加法計算
private static int add() throws Exception
{
    int result;
    try {
        List<Integer> nums =getInputNumbers();
        result = nums.get(0)  + nums.get(1);
    }catch(InputMismatchException immExp){
        throw new Exception("計算失敗",immExp);  /////////////////////////////鏈化:以一個異常對象為參數(shù)構(gòu)造新的異常對象。
    }
    return  result;
}
/*
請輸入2個加數(shù)
r 1
java.lang.Exception: 計算失敗
    at practise.ExceptionTest.add(ExceptionTest.java:53)
    at practise.ExceptionTest.main(ExceptionTest.java:18)
Caused by: java.util.InputMismatchException
    at java.util.Scanner.throwFor(Scanner.java:864)
    at java.util.Scanner.next(Scanner.java:1485)
    at java.util.Scanner.nextInt(Scanner.java:2117)
    at java.util.Scanner.nextInt(Scanner.java:2076)
    at practise.ExceptionTest.getInputNumbers(ExceptionTest.java:30)
    at practise.ExceptionTest.add(ExceptionTest.java:48)
    ... 1 more
*/

public class IOException extends Exception{
    static final long serialVersionUID = 7818375828146090155L;
    public IOException()
    {
        super();
    }
    public IOException(String message)
    {
        super(message);
    }
    public IOException(String message, Throwable cause)
    {
        super(message, cause);
    }
    public IOException(Throwable cause)
    {
        super(cause);
    }
}

class Father{
    public void start() throws IOException
    {
        throw new IOException();
    }
}
class Son extends Father{
    public void start() throws Exception
    {
        throw new SQLException();
    }
}
/**********************假設上面的代碼是允許的（實質(zhì)是錯誤的）***********************/
class Test{
    public static void main(String[] args){
        Father[] objs = new Father[2];
        objs[0] = new Father();
        objs[1] = new Son();
        for(Father obj:objs)
        {
        //因為Son類拋出的實質(zhì)是SQLException，而IOException無法處理它。
        //那么這里的try。。catch就不能處理Son中的異常。
        //多態(tài)就不能實現(xiàn)了。
            try {
                 obj.start();
            }catch(IOException)
            {
                 //處理IOException
            }
         }
   }
}

public static void main(String[] args){
    int re = bar();
    System.out.println(re);
}
private static int bar() {
    try{
        return 5;
    } finally{
        System.out.println("finally");
    }
}
/*輸出：
finally
*/

public static void main(String[] args){
    int result;
    result  =  foo();
    System.out.println(result);     /////////2
    result = bar();
    System.out.println(result);    /////////2
}
@SuppressWarnings("finally")
public static int foo(){
    trz{
        int a = 5 / 0;
    } catch (Exception e){
        return 1;
    } finally{
        return 2;
    }
}
@SuppressWarnings("finally")
public static int bar()
{
    try {
        return 1;
    }finally {
        return 2;
    }
}

class TestException{
    public static void main(String[] args){
        int result;
        try{
            result = foo();
            System.out.println(result);           //輸出100
        } catch (Exception e){
            System.out.println(e.getMessage());    //沒有捕獲到異常
        }
        try{
            result  = bar();
            System.out.println(result);           //輸出100
        } catch (Exception e){
            System.out.println(e.getMessage());    //沒有捕獲到異常
        }
    }
    //catch中的異常被抑制
    @SuppressWarnings("finally")
    public static int foo() throws Exception
    {
        try {
            int a = 5/0;
            return 1;
        }catch(ArithmeticException amExp) {
            throw new Exception("我將被忽略，因為下面的finally中使用了return");
        }finally {
            return 100;
        }
    }
    //try中的異常被抑制
    @SuppressWarnings("finally")
    public static int bar() throws Exception
    {
        try {
            int a = 5/0;
            return 1;
        }finally {
            return 100;
        }
    }
}

class TestException{
    public static void main(String[] args){
        int result;
        try{
            result = foo();
        } catch (Exception e){
            System.out.println(e.getMessage());    //輸出：我是finaly中的Exception
        }
        try{
            result  = bar();
        } catch (Exception e){
            System.out.println(e.getMessage());    //輸出：我是finaly中的Exception
        }
    }
    //catch中的異常被抑制
    @SuppressWarnings("finally")
    public static int foo() throws Exception
    {
        try {
            int a = 5/0;
            return 1;
        }catch(ArithmeticException amExp) {
            throw new Exception("我將被忽略，因為下面的finally中拋出了新的異常");
        }finally {
            throw new Exception("我是finaly中的Exception");
        }
    }
    //try中的異常被抑制
    @SuppressWarnings("finally")
    public static int bar() throws Exception
    {
        try {
            int a = 5/0;
            return 1;
        }finally {
            throw new Exception("我是finaly中的Exception");
        }
    }
}