异常类

异常中的关键字
1.throw 在方法内部，抛出异常对象
2.throw 后面必须写new 对象，对象必须是异常的对象
方法中声明关键字
throws 在方法的声明声明上，表明此方法可能出现异常
请调用者处理
throws 后面必须写异常的类名
调用了一个抛出异常方法调用者就必须处理
不处理编译失败

public class ExceptionDemo {
     public static void main(String args[]) throws Exception{
       
         int[] arr = null;
         int i = getArray(arr);
         System.out.println(i);
   }
     public static int getArray(int[] arr) throws Exception
     {
         //判断方法参数的合法性
         if(arr==null)
         {
             //抛出异常的形式
             //关键字throw
             throw new Exception("传递数组不存在");
         }
         //判断数组是不是有元素
         if(arr.length==0)
         {
             throw new Exception("数组中没有任何元素");
         }
         int i = arr[arr.length-1];
         return i*2;
     }
}

异常处理方式:
try..catch..finally
格式
try{
被检测的代码
可能出现异常的代码
}catch(异常类名变量){
异常的处理
}finally{
必须要实行的代码
}

public class ExceptionDemo1 {
   public static void main(String args[])
   {
       int[] arr = new int[0];                     //throw new              NullPointerException("数组不存在");
       try{                               //try 检测到了有异常发生，捕获到一个异常对象，将异常抛给catch代码块处理这个异常
           
           int i = getArray(arr);
           System.out.println(i);
           
       }catch(NullPointerException ex) {    //throw new NullPointerException("数组不存在");
           System.out.println(ex);         //NullPointerException ex = new NullPointerException("数组不存在");
       }catch(ArrayIndexOutOfBoundsException ex){
           System.out.println(ex);
       }
       finally{
           System.out.println("Gome over");
       }
   }

定义方法，抛出异常
调用者使用try catch

public static int getArray(int[] arr)throws NullPointerException,ArrayIndexOutOfBoundsException
    {
        //对数组判空
        if(arr==null)
        {
            //手动抛异常，抛出空指针异常
            throw new NullPointerException("数组不存在");
        }
        //对数组的索引进行判断
        if(arr.length<3) 
        {
            throw new ArrayIndexOutOfBoundsException("数组没有索引");
        }
        return arr[3]+1;
    }   
}

多catch写在一起
细节
catch小括号中写的是异常类名
有没有顺序的概念，有
平级异常：抛出的异常类之间，没有继承关系
NullPointerException extends Exception
NoSuchElementException extends Exception
ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException extends Exception
按等级从上往下级别越来越大，如果顺序相反则上面的父类会抓住下面所有子类的异常，那么下面的子类就没有用了

import java.util.NoSuchElementException;
import javax.naming.NameAlreadyBoundException;
import javax.naming.NoPermissionException;
public class ExceptionDemo2 {

   public static void main(String[] args) {
       
       try{
           
       }catch(NoSuchElementException ex){
           
       }catch(NullPointerException ex){
           
       }

   }
   public static void fun(int a)throws NullPointerException,NoSuchElementException {
       
        if(a==0)
        {
            throw new NullPointerException();
        }
        if(a==1)
        {
            throw new NoSuchElementException();
        }
   }
}

异常分为编译异常和运行时期异常
编译异常：调出了抛出异常的方法，不处理编译失败（处理方式try throws）
运行异常：抛出的异常是RuntimeException类，或者是他的子类
运行异常的特点：
方法内部抛出的是运行异常， new XXXException
方法的声明上，不需要throws语句，调用者也不要要处理
设计原因：运行异常，不能发生，但如果发生了，需要程序人员停止程序 修改源代码
运行异常一旦发生，不要处理，请你修改源代码，运行异常一旦发生，后面代码没有执行意义

public class Exceptiondemo3 {
         
    public static void main(String args[])
    {
        //fun();//此函数内时运行异常，不需要处理
        /*try{
            fun2();      //此函数抛出了异常，调用该函数时需要捕获异常
        }catch (Exception e) {
            
        }*/
        
        System.out.println(getArea(5));//测试正常的
        System.out.println(getArea(-1));//测试异常的
         
    }
    /*
     * 举个例子
     * 定义方法，计算圆形面积
     * 传递的值为0或者负数 计算的时候没有问题
     * 但是，违反了真实情况
     * 参数<= 0,停止程序，不要再计算了
     * */
    public static double getArea(double r)
    {
        if(r<=0)
            throw new RuntimeException("园形不存在");
        return r*r*Math.PI;
    }
    
    public static void fun()  //运行时异常，不需要用throws抛出异常
    { 
        
            throw new RuntimeException("运行时异常");
        
    }
    
    public static void fun2() throws Exception //编译时异常，需要抛出异常
    {
        
            throw new Exception("运行时异常");
        
    }
    
}

结论 ：
父类的方法，如果抛出异常，子类重写后可以不抛异常
亦可以抛异常，但是，如果子类再抛异常，抛出的异常不能大于父类的 异常
大于是指继承关系，父类和子类抛出的异常是平行关系也不行
父类不抛，子类不能抛，如果子类调用了抛异常的方法只能自己用try..catch处理

public class ExceptionDemo4 {
         public static void main(String args[])
         {
             
         }
}
class fu{
   public void function(){
       
   }
}
class zi extends fu {
   public void function()
   {
       try {                     
           math();                      //子类调用了抛出异常的math方法，但是由于子类继承的父类没有抛出异常，所以子类也不能抛只能自己用try..catch 处理
       } catch (Exception e) {         
           e.printStackTrace();
       }
   }
   public static void math()throws Exception
   {
       throw new Exception();
   }
}

/*

• Throwable 类中的方法
• 三个方法，都和异常的信息有关系
• String getMessage() 对异常信息的描述
• String toString（） 对异常信息的简短描述
• void printStackTrace() 将异常信息追踪到标准错误刘
• 传递成绩计算成绩平均数

*/

public class ExceptionDemo5 {
     public static void main()
     {  
         try {
             int ang = getAvg(50,60,-19,57);

        } catch (FuShuException e) {
              e.printStackTrace();
        }
         
     }
     public static int getAvg(int...source) 
     {
         int sum = 0;
         for(int s:source)
         {
             if(s<0)
             {
                 throw new FuShuException("异常了！");
             }
             sum+=s;
         }
         return sum/source.length;
     }
}
/*
 *  自定义异常
 *  继承Exception或者继承RuntimeException
 *  调用父类构造方法将字符串传给父类
 */ 
 class FuShuException extends RuntimeException{
     public FuShuException(String s)   
     {
         super(s);
     }
     public FuShuException()//无参的构造方法
     {
         
     }
 }