异常

异常含义

异常是正常情况以外的事件，具有不确定性。遇到异常后程序不能正常向下执行。 例如：用户输入错误、除数为0，需要的文件不存在或打不开、数组下标越界、传入参数为空或不符合指定范围。

异常分类

下图罗列了Java中异常类定义的层次关系

异常类和其他类的祖先一样都继承了Object类，第二个层次是Throwable类，第三个层次是Exception和Error，它们是平行类。Exception是所有异常类的祖先，Error是所有错误类的祖先。
异常和错误的区别：
Error不是程序需要捕获和进行处理的，例如OutOfMemorryError（当Java虚拟机在为对象分配内存时，剩余的空间不够，同时也没有可以释放的内容时，将会发生这样的错误）不由程序进行捕获或处理，当Error发生时，程序将会停止。

异常处理

1.声明抛出处理

1.隐式声明抛出

异常类型是RuntimeException或是其子类，程序方法可以对异常不作任何声明抛出或处理，直接交给调用该方法的地方处理，程序能编译通过，不会对可能产生异常的代码给出提示。
main()方法没有进行任何声明与处理，而直接交给调用main()方法的java虚拟机处理

package hai;
import java.util.*;
public class yinshi {
	public static void main(String[]args) {
		Stack s=new Stack();
		Object ob=s.pop();
	}
}

EmptyStackException是RuntimeException的子类

public class yinshi {
	private static int []x;
	public static void main(String[]args) {
		System.out.print(x[0]);
	}
}

NullPointerException是RuntimeException的子类

2.显式声明抛出

package hai;
import java.io.*;
public class xianshi {
	public static void main(String[]args) throws IOException {
		BufferedReader k=new BufferedReader(new InputStreamReader(System.in));
		String c;
		int i=0;
		String[]e=new String[3];
		while(i<3) {
			c=k.readLine();
			e[i]=c;
			i++;
		}
	}
}

2.异常捕获处理

将显示声明抛出改写成try-catch的形式就是捕获处理。
异常处理是由try －catch组成的一个异常处理块结构，最为完整的方式是try-catch-finally语句

try{
　 statements
}
catch (ExceptionType1 ExceptionObject){
　 Exception Handling 
}
catch(ExceptionType2 ExceptionObject) { 
　 Exception Handling
}……
finally{
　 Finally  Handling 
}

示例：

package hai;
import java.util.*;
public class capture {
	private static int []x;
	public static void main(String[]args){
		try {
			System.out.print(x[0]);
		}
		catch(NullPointerException ExceptionObject) {
			System.out.println("数组尚未分配空间");
			
		}
		catch(EmptyStackException ExceptionObject) {
			System.out.println("空栈异常");
		}
		finally {
			System.out.println("finish");
		}
	}
}
//数组尚未分配空间
//finish

try语句块含有可能出现的异常程序代码，可能会抛出一个或多个异常，因此，try后面可跟一个或多个catch。需要指出的是：当try语句块没有异常发生时，紧跟其后的catch代码块并不被执行。
catch用来捕获异常参数ExceptionObject是ExceptionType类的对象，ExceptionType是Exception类或其子类，它指出catch语句中所要处理的异常类型。catch在捕获异常的过程中要和try语句抛出的异常类型进行比较。若相同，则在catch中进行处理；若不同，寻找其他的catch块再进行比较。
在多catch的情况下，异常类由上到下排布并遵循这样的规则：由子类到父类或为平行关系。
Finally是这个语句块的统一出口，一般用来进行一些善后操作，如释放资源、关闭文件等。

异常嵌套

package hai;
import java.io.*;
public class capture{
	 public static void main(String[] args){
	    int a,b,c,d,e;
	    a=67; b=0;d=0;c=5; 
	    try{
	       try{
	          c=a/b;
	       }
	       catch(ArithmeticException ae){
	          b = 10;
	       }
	       System.out.println(a+"/"+b+"="+ a/b);
	       e=c/d;
	    }
	    catch(ArithmeticException ae){
	    	System.out.println(c);
	    	System.out.println("除数d为0");
	    }
	    catch(Exception f){
	      f.printStackTrace();
	    }
	  }
} 
//67/10=6
//5
//除数d为0

如果捕获了异常后还想执行后面的语句就可以用嵌套捕获；异常嵌套中最内层的try产生的异常对象，如果不能被对应的catch异常类声明引用，则转交给外层的catch处理

RuntimeException类的子类

1.空指针异常

package hai;
public class yinshi {
	private static int []x;
	public static void main(String[]args) {
		System.out.print(x[0]);
	}
}

package hai;
public class paochu {
	public static void main(String[] args) {
		 int []x;
		System.out.println(x[0]);
		try {
			System.out.println(x[0]);
		}
		catch(NullPointerException e) {
			System.out.println("空指针异常");
		}
	}
}

2.空栈异常

package hai;
import java.util.*;
public class yinshi {
	public static void main(String[]args) {
		Stack s=new Stack();
		Object ob=s.pop();
	}
}

package hai;
import java.util.*;
public class capture{
	 public static void main(String[] args){
	    try {
	    	Stack s=new Stack();
			Object ob=s.pop();
	    }
	    catch(EmptyStackException ae){
	          System.out.print("空栈");
	    }
	} 
}

3.算数异常

package hai;
public class second {
	public static void main(String[] args) {
		int a,b,c;
		a=5;b=0;
		c=a/b;
		System.out.print(c);
	}
}

package hai;
public class capture{
	 public static void main(String[] args){
	    int a,b,c,d,e;
	    a=67; b=0;d=0;c=5; 
	    try {
	          c=a/b;
	    }
	    catch(ArithmeticException ae){
	          System.out.print("除数为零");
	    }
	} 
}

4.数组下标越界

package hai;
public class second {
	public static void main(String[] args) {
		Integer []x=new Integer[5];
		System.out.print(x[6]);
	}
}

package hai;
public class capture{
	 public static void main(String[] args){
		 Integer []x=new Integer[5];
	    try {
	    	System.out.print(x[6]);
	    }
	    catch(ArrayIndexOutOfBoundsException ae){
	          System.out.print("数组下标越界");
	    }
	} 
}

5.数组长度异常

package hai;
public class yinshi {
	public static void main(String[]args) {
		Integer []x=new Integer[-1];
	}
}

package hai;
public class capture{
	 public static void main(String[] args){
	    try {
	    	Integer []x=new Integer[-1];
	    }
	    catch(NegativeArraySizeException ae){
	          System.out.print("数组长度异常");
	    }
	} 
}

等等还有很多……

自定义异常

package hai;
public class myexception extends Exception{
	   myexception(String msg){
	       super(msg);   //调用Exception的构造方法
	   }
	   static void throwOne() throws myexception{
	       //如果a为1就认为在特定应用下存在异常，改变执行路径，抛出异常
	       throw new myexception("我是珊珊的异常，嘿嘿");
	   }
	   public static void main(String args[]){
	    try{
	       throwOne();
	    }
	    catch(myexception e){
	      e.printStackTrace();
	    }
	  }
}