异常中的关键字
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()//无参的构造方法
{
}
}
