java===Exception异常处理

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());

    }

}