异常处理3

package c;
/*     异常处理
 *   Java内置的所有异常类都继承于java.lang.Throwable类,Throwable类包含Error和Exception类两个子类
 *   (1)Error类用于描述严重的系统错误，无法通过调节代码本身来解决问题
 *   (2)Exception类用于描述可以在程序中捕获并处理的异常，在平常的异常处理主要是针对该类。
 *   该类中的RuntimeException子类用来描述运行时的异常，这类异常通常事先无法预料发生，因此
 *   编译程序并不强制要求程序中对该类异常进行捕获或者处理
 *   除了RuntimeException,Exception还包的子类属于受检异常类。
 *   Java中利用try...catch语句来捕获异常
 */
 

//例一：
/*抛出异常
 * Exception in thread "main" java.lang.ArithmeticException: / by zero
    at c.Chu.division(Exceptions.java:14)
    at c.Exceptions.main(Exceptions.java:21)
 */
/*class Chu{
    void division(int p1,int p2){
        int result;
        result=p1/p2;
        System.out.println(result);
    }
}
public class Exceptions {
    public static void main(String args[]){
Chu s=new Chu();
s.division(2,0);
   }}*/


//修改后
/*class Chu{
    void division(int p1,int p2)
    {
        int result;
        try{
            result=p1/p2;
            System.out.println(result);
        }catch(ArithmeticException e){
            System.out.println("除数不可以为0");        
        }
        System.out.println("程序执行成功！");
    }
}
public class Exceptions {
    public static void main(String args[]){
     Chu s=new Chu();
     s.division(2,0);
            }   
       }*/


//例2 输入数据类型不符
/*import java.util.*;
public class Exceptions{
    public static void main(String args[]){
        Scanner read=new Scanner(System.in);
        int sum=0;
        int count=0;
        int number;
        while(count<3){
            try{
                number=read.nextInt();
                sum=sum+number;
                count++;
            }catch(InputMismatchException e){
                System.out.println("输入错误，请输入整数");
                read.next();//略过错误的数据
            }
        }
        System.out.println("sum="+sum);
    }
}
/* 注释:
 * (1)try语句表示可能出现异常的代码，catch语句后面指明要捕获的异常，catch语句块中是异常处理代码
   (2)若try语句块中的某行代码出现异常，程序流程将从产生异常的那行代码直接跳转到catch语句，
   如果与catch语句中要捕获的异常匹配，则执行catch语句块中的语句。否则的话，将异常交由JVM处理。
   (3)一个try语句后面可以跟多个catch语句，这主要因为try语句块中的代码可能抛出多个异常，可以
   使用每个catch语句捕获一个异常。但是catch捕获的异常之间有异常关系，必须子类异常在前，父类异常在后
 
 
 如果用于捕获不同异常的多个catch语句块中的异常处理语句块中的异常处理代码如果相同，在JDK7中提供了多重捕获
 语句，其一般的语法如下：
 try{
 可能出现异常代码}
 catch(异常类1|异常类2|异常类3...){
 }
 若多个异常之间有继承关系，必须保证子类在前
 例如：
 try{
 }
 catch(NumberFormatException|Exception e){
 }
*/

//异常处理大致分为三种
/*
 * (1)如果方法本身能够完成异常处理，则在catch语句块中编写异常处理代码，可以使用异常类中的方法
 * 来获取异常信息，如用printStackTrace()方法来获得异常堆栈跟踪信息，查看异常的根源；另外，
 * getMessage()方法可以提供异常的基本描述信息；
 * (2)如果方法本身无法处理异常，需要向上抛出异常，由方法的调用者来处理，方法内部就可以不用
 * try...catch语句捕获、处理异常。例子如下：
 */
public class Exceptions{
    void division(int p1,int p2)throws ArithmeticException{
        int result;
        if(p2==0)
        {
            throw new ArithmeticException("除数不可以为零");
        }
        result=p1/p2;
        System.out.println(result);
    }
    public static void main(String args[]){
        Exceptions s=new Exceptions();
        try{
            s.division(5, 0);
        }
        catch(ArithmeticException e){
            e.printStackTrace();//打印错误追踪信息
        }
    }
}

//如果方法本身需要处理或能够处理异常的部分内容，然后再向上抛出异常也可以，此时在方法内部
//内部使用try...catch语句捕获并处理异常，在catch语句块最后使用throw抛出异常即可。
/*
public class tt{
void division(int p1,int p2)throws ArithmeticException{
int result;
try{
result=p1/p2;
System.out.println(result);
}
catch(ArithmetException e)
{
System.out.println("本方法无法处理全部异常只能向上抛出");
throw e;
}
}
public static void main(String arg[]){
 tt s=new tt();
 try{
 s.division(5，0);
 }
 catch(ArithmeticException e)
 {
 e.printStackTrace();
 System.out.println("异常在主方法中解决");
 }
 }
 }
}