码迷,mamicode.com
首页 > 编程语言 > 详细

java===Exception异常处理

时间:2017-03-18 20:03:41      阅读:175      评论:0      收藏:0      [点我收藏+]

标签:类方法   import   如何   格式   length   auto   运行时异常   main   练习   

package cn.china;
/**
 * 异常:在运行时期发生的不正常情况。
 * 问题很多,意味着描述的类也很多,
 * 将其共性进行向上抽取,形成异常体系。
 * 最终问题就分成两大类:
 * throwable:无论是Error,还是异常,都是问题,就应该可以抛出,让调用者知道并处理。
 * 该体系的特点就在于throwable及其所有子类都具有可抛性。
 * 如何体现可抛性?
 * 其实是通过两个关键字体现的,throws,throw;凡是可以被这两个关键字操作的类和对象都具有可抛性。
 *    1、一般不可处理的,Error
 *    特点:是由JVM抛出的严重性问题,已经影响到我们程序的执行;这种问题发生一般不针对性处理,直接修改程序
 *    2、可以处理的,Exception
 *     特点:子类的后缀名都是用其父类名作为后缀,阅读性很强。
 *     
 *     异常分类:
 *     1、编译时被检测异常:只要是Exception和其子类都是,除了RunTimeException和其子类
 *     这种问题一旦出现,希望在编译时就进行检测,让这种问题有对应的处理方式。
 *     这样的问题都可以针对性的处理
 *     2、编译时不检测异常(运行时异常):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
 * {一定会被执行的代码}
 * 
 * 
 * 异常处理原则:
 * 1、函数内部如果抛出需要检测的异常,那么函数上必须要声明,否则必须在函数内必须要用trycatch捕捉,否则编译失败。
 * 2、如果调用到了声明异常的函数,要么trycatch要么throws,否则编译失败。
 * 3、什么时候catch,什么时候throws呢?
 * 功能内部可以解决,用catch;
 * 解决不了用throws,告诉调用者,调用者解决;
 * 4、一个功能如果抛出多个异常,那么调用时必须由对应多个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 组合特点
 * 1、 try  catch  finally
 * 2、try  catch(多个当没有必要资源需要释放时,可以不用定义finally)
 * 3、 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;
/**异常的注意事项
 * 1、子类在覆盖父类方法时如果父类的方法抛出异常,那么子类的方法只能破案出父类的异常,或者该异常的子类
 * 2、如果父类抛出多个异常,那么子类子还能抛出父类异常的子集
 * 
 * 简单说:子类覆盖父类,只能抛出父类的异常,或者子集;如果父类没有抛出异常,那么子类覆盖时绝对不能抛出异常,但是可以用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());

    }

}

 

java===Exception异常处理

标签:类方法   import   如何   格式   length   auto   运行时异常   main   练习   

原文地址:http://www.cnblogs.com/wangyinxu/p/6575747.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!