Java 异常及处理

异常的分类

Exception称为异常类，它表示程序本身可以处理的错误。在Java程序开发中进行的异常处理，都是针对Exception类及其子类的

在Exception的子类中，除了RuntimeException类及其子类外，其他子类都是编译时异常。

ERROR称为错误，表示Java运行时产生的系统内部错误或资源耗尽的错误，是比较严重的，仅靠修改程序本身是不能恢复执行的，例如系统崩溃，虚拟机错误等

常见的异常类

异常类名称	异常类说明
ArithmeticException	算术异常
IndexOutOfBoundsException	角标越界异常
ClassCastException	类型转换异常
NullPointerException	空指针异常
NumberFormatException	数字格式化异常

Throwable 中常用方法

方法声明	功能概述
String getMessage()	返回throwable的详细消息字符串
void printStackTrace()	将此throwable及其追踪输出至标准错误流
void printStackTrace(PrintStream s)	将此throwable及其追踪输出到指定的输出流
String getMessage()	返回此throwable的详细消息字符串

异常的处理

抛出异常：throw，throws
捕获异常：try，catch，finally

throw抛出对象

用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结 束当前方法的执行。
程序执行在throw语句之后立即停止；后面的任何语句不被执行。
若需抛出多个异常对象，需要用判断语句进行操作
使用的格式：

 throw new 异常类名(参数)；

new运算符被用来生成一个异常类的实例对象。例如：
throw new ArithmeticException();

示例：

public class DemoThrow {
    public static void main(String[] args) {
      int a =   DemoThrow.demo(4,0);
      System.out.println(a);
    }
 
   public static int demo(int a,int b)
      {
            if(b==0)
              throw new ArithmeticException("异常信息：除数不能为0");//抛出具体问题，编译时不检测，或者用try catch进行处理这里抛出对象
            return a/b;
     }
}

声明抛出异常throws

throws关键字用在方法声明中用来指明此方法有可能抛出多个异常表示当前方法不处理异常，而是提醒该方法的调用者来处理异常。
使用格式：

修饰符 返回值类型 方法名（参数） throws 异常类名1，异常类名2 ... { }

重点所需要注意的在下面的代码注释中
示例:

 
public class DemoThrows {
 
 
    public static void main(String[] args){//在主方法解决问题，就不用继续throws抛出了
      Student s=new  Student();
		    try{ //可能会出现问题返回异常的代码
		    	s.calculate();
		    	}
		    catch(ArrayIndexOutOfBoundsException ab)
			{//解决问题，进行相应处理
				System.out.println("数组下标越界");
			System.out.println(ab.toString());//输出
			}
		     Person p=new Person();
		   try{  
			   p.calculate(3, 0);
		   }
		   catch(Exception e)
		   {
			   System.out.println("分母不能为零");
			System.out.println(e.getMessage());
			e.printStackTrace();
			
		   }
    }
}
class Person
{
public int calculate(int a,int b) throws Exception
{
int result =0;
result=a/b;
return result;
}

//重写方法的修饰符要比被重写方法的修饰符大或者相等，这和抛出恰好相反
class Student extends Person//若有子类继承父类
{
public void calculate() throws ArrayIndexOutOfBoundsException{//子类重写的方法不能抛出比父类范围大的错误类，此方法抛出类是Exception的子类，所以成立
int a[]={1,2,3,4,5};
		System.out.println(" "+a[5]);//数组下标越界

}
}
若不出现问题方法进行处理直接抛出的运行结果:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
	at javaError.Student.calculate(Demo1.java:27)
	at javaError.Demo1.main(Demo1.java:7)
出现错误会直接终止运行，以至于下面的错误无法显示


对可能出现的异常进行处理后的结果:
数组下标越界
java.lang.ArrayIndexOutOfBoundsException: 5
分母不能为零
/ by zero
java.lang.ArithmeticException: / by zero
	at javaError.Person.calculate(Demo1.java:35)
	at javaError.Demo1.main(Demo1.java:17)

try catch 异常捕获

在try{}代码块中，发生异常语句后面的代码是不会被执行的。在程序中，如果希望有些语句无论程序是否发生异常都要执行，这时就可以在try…catch语句后，加一个finally{}代码块。

try {
   ...  //监视代码执行过程，一旦返现异常则直接跳转至catch，
        // 如果没有异常则直接跳转至finally
} catch (Exception e) {
    ... //可选执行的代码块，如果没有任何异常发生则不会执行；
        //如果发现异常则进行处理或向上抛出。
} finally {
    ... //必选执行的代码块，不管是否有异常发生，
        // 即使发生内存溢出异常也会执行，通常用于处理善后清理工作。
}
//简单理解
 try {
         // 可能发生异常的语句
    } catch(Exception类或其子类 e){
         // 对捕获的异常进行相应处理
    } finally {
         // 无论是否发生异常，此代码块代码总会执行
}

示例代码请看上方代码。

自定义异常

Java允许用户自定义异常，但自定义的异常类必须继承自Exception或其子类。

class MyException extends Exception//自定义异常首先需要继承Exception类
{
	private int id;
	public MyException(String message,int id)//构造方法
	{
		super(message);
		this.id=id;
	}
	public int getId()
	{
		return id;
	}
}
class TestMyException{
  public void register(int num) throws MyException{
      if(num<0)
	throw new MyException("人数不能为负值",3);
      else
	System.out.println("登记的人数为："+num);	
  }
  public static void main(String args[]){
      TestMyException my=new TestMyException();
      try{
	my.register(-5);
       }catch (MyException e){
	System.out.println(e.getMessage());
	System.out.println("错误类型为："+e.getId());
       }
  }}