java===Exception异常处理

时间  2019-11-25
标签 java exception 异常 处理 栏目 Java 繁體版
原文   原文链接 
package cn.china;
/**
 * 异常：在运行时期发生的不正常状况。
 * 问题不少，意味着描述的类也不少，
 * 将其共性进行向上抽取，造成异常体系。
 * 最终问题就分红两大类：
 * throwable:不管是Error，仍是异常，都是问题，就应该能够抛出，让调用者知道并处理。
 * 该体系的特色就在于throwable及其全部子类都具备可抛性。
 * 如何体现可抛性？
 * 实际上是经过两个关键字体现的，throws,throw;凡是能够被这两个关键字操做的类和对象都具备可抛性。
 *    一、通常不可处理的，Error
 *    特色：是由JVM抛出的严重性问题，已经影响到咱们程序的执行；这种问题发生通常不针对性处理，直接修改程序
 *    二、能够处理的，Exception
 *     特色：子类的后缀名都是用其父类名做为后缀，阅读性很强。
 *     
 *     异常分类：
 *     一、编译时被检测异常：只要是Exception和其子类都是，除了RunTimeException和其子类
 *     这种问题一旦出现，但愿在编译时就进行检测，让这种问题有对应的处理方式。
 *     这样的问题均可以针对性的处理
 *     二、编译时不检测异常（运行时异常）：RunTimeException和其子类。
 *     这样的问题的发生，没法让功能继续，运算没法进行，更可能是由于调用的缘由致使的或者引起了内部状态的改变致使的。
 *     这种问题通常不处理，直接编译经过，在运行时，让调用者调用时的程序强制中止，让调用者对代码进行调整。
 *     
 *     throw 和 throws区别？
 *     throws 使用在函数上  抛出的是异常类，能够抛出多个能够用逗号隔开
 *     throw 使用在函数内   抛出的是异常对象*/
class FuShuIndexException extends Exception//因此这里能够继承RunTimeException,就不须要声明或者捕捉异常，编译不会失败
{
    public FuShuIndexException(String meg) {
        super(meg);
        // TODO Auto-generated constructor stub
    }
}
class D{
    public int method(int arr[],int index)throws FuShuIndexException
    {
        if(arr==null)
            throw new NullPointerException("数组的引用不能为空！");
        if(index>=arr.length)
            throw new ArrayIndexOutOfBoundsException("数组越界了！"+index);
        if(index<0)//准备用负数角标异常来表示，可是这种异常在java中并无定义过。按照java异常的建立思想，将负数角标进行自定义描述，并封装成对象
            throw new FuShuIndexException("数组的角标不能为负数"+index);
        return arr[index];
    }
}
public class Demo {

    public static void main(String[] args) throws FuShuIndexException
    {
        int[]arr=new int[3];
        D d=new D();
        int num= d.method(arr, -30);
       
    }
    

}
package cn.china;
/**异常处理的捕捉形式
 * 具体格式：
 * try
 * {须要被检测异常的代码}
 * catch(异常类  变量)  //该变量用于接收发生异常的对象
 * {处理异常的代码}
 * finally
 * {必定会被执行的代码}
 * 
 * 
 * 异常处理原则：
 * 一、函数内部若是抛出须要检测的异常，那么函数上必需要声明，不然必须在函数内必需要用trycatch捕捉，不然编译失败。
 * 二、若是调用到了声明异常的函数，要么trycatch要么throws,不然编译失败。
 * 三、何时catch,何时throws呢？
 * 功能内部能够解决，用catch;
 * 解决不了用throws，告诉调用者，调用者解决；
 * 四、一个功能若是抛出多个异常，那么调用时必须由对应多个catch进行针对性处理。
 * 内部有几个要检测的异常，就抛几个异常，抛出几个，就catch几个；*/
class FuShuIndexException extends Exception//因此这里能够继承RunTimeException,就不须要声明或者捕捉异常，编译不会失败
{
    public FuShuIndexException(String meg) {
        super(meg);
    }
}
class C{
    public int method(int arr[],int index)throws FuShuIndexException
    {
        if(arr==null)
            throw new NullPointerException("数组的引用不能为空！");
        if(index>=arr.length)
            throw new ArrayIndexOutOfBoundsException("数组越界了！"+index);
        if(index<0)//准备用负数角标异常来表示，可是这种异常在java中并无定义过。按照java异常的建立思想，将负数角标进行自定义描述，并封装成对象
            throw new FuShuIndexException("数组的角标不能为负数"+index);
        return arr[index];
    }
}
public class Demo1 {

    public static void main(String[] args) {
        int[]arr=new int[3];
        C c=new C();
        try
        {
        int num= c.method(arr, -30);
        System.out.println("num"+num);//num是局部变量 因此这两句话要放在同一个代码块
        }
        catch(NullPointerException e){//多catch格式
            e.printStackTrace();
        }
        catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
        catch(FuShuIndexException e)
        {
            e.printStackTrace();//JVM默认的异常处理机制就是调用异常对象的这个方法。
            System.out.println("Message"+e.getMessage());
            System.out.println("String"+e.toString());
            System.out.println("负数角标异常！");
        }
        catch(Exception e){//父类须要放在最下面，否则编译失败，由于Exception跟全部异常都匹配，
            e.printStackTrace();
        }
        System.out.println("over!");

    }

}
package cn.china;
/**try  catch  finally 组合特色
 * 一、 try  catch  finally
 * 二、try  catch(多个当没有必要资源须要释放时，能够不用定义finally)
 * 三、 try  finally
 * 例：void show()throws Exception //由于没有catch因此必须声明异常
 * {
 *  try{
 *  //开启资源
 *  throw new Exception
 *  }
 *  finally{
 *  //关闭资源
 *  }
 * }*/
class E{
    public int method(int  index)
    {
        int[]arr=new int[3];
        if(index>=arr.length)
            throw new ArrayIndexOutOfBoundsException();
        return arr[index];
    }
}
public class Demo2 {

    public static void main(String[] args) {
        E e=new E();
        try{int num=e.method(3);
        System.out.println(num);
        }catch(ArrayIndexOutOfBoundsException c)
        {
            System.out.println(c.toString());
            return;
            //System.exit(0); 退出JVM只有这种状况不会执行finally语句；
        }
        finally {//必定会被执行的语句,主要用于关闭或者释放资源
            System.out.println("finally");
        }
        System.out.println("over!");

    }

}
package cn.china;

import java.time.format.TextStyle;

/**
 * 毕老师用电脑上课，
 * 分析其中问题：
 * 电脑蓝屏，冒烟*/
class LanPingException extends Exception
{
    LanPingException(String msg){
        super(msg);
    }
}
class MaoYanException extends Exception
{
    MaoYanException(String msg){
        super(msg);
    }
}
class NoPlanException extends Exception{
    NoPlanException(String msg){
        super(msg);
    }
}
class Computer{
    private int state=0;
    public void run()throws LanPingException,MaoYanException
    {
        if(state==1)
          throw new LanPingException("蓝屏啦");
        if(state==2)
            throw new MaoYanException("电脑冒烟了");
        System.out.println("电脑运行");
    }
    public void reset(){
        state=0;
        System.out.println("电脑重启了");
    }
}
class Teacher{
    private String  name;
    private Computer comp;
    Teacher(String name){
        this.name=name;
        comp=new Computer();
    }
    public void prelect()throws NoPlanException
    {
        try
        {
            comp.run();
            System.out.println("讲课");
        }catch(LanPingException e){
            System.out.println(e.toString());
            comp.reset();
            prelect();
        }catch(MaoYanException e){
            System.out.println(e.toString());
            test();
            throw new NoPlanException("课时没法进行"+e.getMessage());
            //能够对电脑进行维修
            //throw e;
        }
    }
    public void test(){
        System.out.println("你们练习");
    }
}
public class Demo3 {

    public static void main(String[] args) {
        Teacher teacher=new Teacher("毕老师");
        try
        {
            teacher.prelect();
        }
        catch(NoPlanException e)
        {
            System.out.println(e.toString()+"......");
            System.out.println("换人");
        }


    }

}
/**
 * class NoAddException extends Exception{}
 * void addData(Data d)throws NoAddException
 * {
 *    连接数据库
 *    try{
 *    添加数据库，出现异常 SQLException();
 *    }catch(SQLException e)
 *    {
 *        //处理代码
 *        throw new NoAddException();
 *    }finally
 *    {
 *         
 *    关闭数据库
 *    }
 * }*/
 
package cn.china;
/**异常的注意事项
 * 一、子类在覆盖父类方法时若是父类的方法抛出异常，那么子类的方法只能破案出父类的异常，或者该异常的子类
 * 二、若是父类抛出多个异常，那么子类子还能抛出父类异常的子集
 * 
 * 简单说：子类覆盖父类，只能抛出父类的异常，或者子集；若是父类没有抛出异常，那么子类覆盖时绝对不能抛出异常，可是能够用try;*/
class A extends Exception 
{
}
class B extends A
{}
class C extends Exception
{}
class Fu{
    void show()throws A{}
}
class Zi extends Fu{
    void show()throws B{}//只能抛出A或者B 
}
class Test{
    void method(Fu f){
        try{
            f.show();
        }catch(A a){}
    }
}
public class Demo4 {

    public static void main(String[] args) {
        Test t=new Test();
        t.method(new Zi());

    }

}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程