Java基础--异常处理

来源：互联网发布：linux文件给用户权限编辑：程序博客网时间：2024/05/18 13:11

凌风博客原创作品。转载请注明出处http://blog.csdn.net/q549130180/article/details/45220847

异常：就是程序在运行时出现不正常情况

异常的由来：问题也是现实生活中一个具体的事物，也可以同java的类的形式进行描述。并封装成对象
其实就是java对不正常情况进行描述后的对象体现。

对于问题的划分为两种：一种是严重的问题，一种是非严重的问题

对于严重的：java通过Error类进行描述。
对于Error一般不编写针对性的代码对其进行处理

对于非严重的：java通过Exception类进行描述
对于Exception可以使用针对性的处理方式进行处理

无论Error或者Exception都具有一些共性内容
比如：不正常情况的信息，印发原因等。

Throwable
|--Error
|--Exception

2.异常的处理
java提供了特有的语句进行处理。
try{
需要被检测的代码；
}catch(异常类变量){
处理异常的代码：(处理方式)
}finally{
一定会执行的语句；
}

3.对捕获到的异常对象进行常见方法操作
String getMessage();

对多异常的处理
1.声明异常时，建议声明更为具体的异常，这样可以处理的更具体
2.对方声明几个异常，就对应有几个catch块，不要定义多余的catch块
如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。

建立在进行catch处理时，catch中一定要定义具体处理方式。
不要简单定义一句e.printStrackTrace()

也不要简单的就书写一条输出语句。

[java] view plaincopy
lass Demo  
{  
    int div(int a,int b)throws Exception{  //在功能上通过throws的关键字声明了该功能有可能会出现异常  
        return a/b;  
    }  
}  
  
class ExceptionDemo  
{  
    public static void main(String[] args)   
    {  
        Demo d = new Demo();  
        try{  
            int x = d.div(4,0);  
            System.out.println("x="+x);    
        }catch(Exception e){   //Exception e = new ArithmeticException();  
                System.out.println("除零了");  
                System.out.println(e.getMessage());  //  /by zero  
                System.out.println(e.toString());//异常名称：异常信息。  
                  
                e.printStackTrace();  //异常名称,异常信息,异常出现的位置。  
                                        //其实jvm默认的异常处理机制，就是在调用printStackTrace方法  
                                        //打印异常的堆栈的跟踪信息。  
        }  
    }  
}  

自定义异常

因为项目中会出现特有的问题，
而这些问题并未被java所描述并封装对象
所以对于这些特有的问题可以按照java的对问题封装的思想，
将特有的问题，进行自定义的异常封装。

需求：在本程序中，对于除数是负数，也视为是错误的是无法进行运算的
那么就需要对这个问题进行自定义的描述

当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。
要么在内部try catch处理
要么在函数上声明让调用者处理。

一般情况在，函数内出现异常，函数上需要声明。

发现打印的结果中只有异常的名称，缺没有异常的信息。
因为自定义的异常并未定义信息

如何定义异常信息呢？
因为父类中已经把异常信息的操作都完成了
所以子类只要在构造时，将异常信息传递给父类通过super语句
那么就可以直接通过getMessage方法获取自定义的异常信息。

自定义异常：
必须是自定义类继承Exception

继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都被抛出。
他们都具备可抛性，这个可抛性是Throwable这个体系中独有特点。
只有这个体系中的类和对象才可以被throws和throw操作。

throws和theow的区别
throws使用在函数上，throw使用在函数内。
throws后面跟的异常类，可以跟多个，用逗号隔开。
throw后跟的是异常对象。

[java] view plaincopy
class FuShuException extends Exception  
{  
    FuShuException(String msg){  
        super(msg);  
    }  
}  
  
class Demo   
{  
    int div(int a,int b)throws FuShuException{  
        if (b<0)  
        {  
            throw new FuShuException("出现了除数是负数的情况");  //手动通过throw关键字抛出一个自定义异常对象。  
        }  
        return a/b;  
    }  
}  
  
  
class ExceptionDemo1  
{  
    public static void main(String[] args)   
    {  
        Demo d = new Demo();  
        try{  
            int x = d.div(4,0);  
            System.out.println("x="+x);    
        }catch(FuShuException e){    
            System.out.println(e.toString);   
            System.out.println("除数出现负数了");   
        }  
    }  
}  
  
/* 
手动抛出异常时throw单独存在，下面不要定义语句，因为执行不到所以会编译失败 
*/  
class Demo  
{  
    public static void func(){  
        try  
        {  
            throw new Exception();  
            System.out.println("A");  
        }  
        catch (Exception e)  
        {  
            System.out.println("B");  
        }  
    }  
}  

RunTimeException

Exception中有一个特殊的子类异常RuntimeException运行时异常

如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过

如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过

之所以不用在函数声明，是因为不需要让调用者处理。
当该异常发生，希望程序停止，因为在运行时，出现了无法继续运行的情况，希望停止程序后
对代码进行修正

自定义异常时：如果该异常的发生，无法再继续进行运算
就让自定义异常继承RunTimeException

对于异常分两种：
1.编译时被检测的异常
2.编译时不被检测的异常(运行时异常，RunTimeException以及其子类)

[java] view plaincopy
class Demo   
{  
    int div(int a,int b)//throws ArithmeticException  
    {  
        if (b==0)  
            throw new ArithmeticException("被零除了");  
        return a/b;  
    }  
}  
  
  
class ExceptionDemo2  
{  
    public static void main(String[] args)   
    {  
        Demo d = new Demo();  
      
            int x = d.div(4,0);  
            System.out.println("x="+x);    
          
    }  
}  

0 0