Java Error类与Exception类的区别；异常处理的两种方式的区别；选取RuntimeException类的五个子类，编写其抛出、捕获类异常的程序；自定义一个异常类。

1. 简述Java Error类与Exception类的区别。

首先Error类和Exception类都是Throwable类的子类。

Throwable类：
详见：https://docs.oracle.com/javase/8/docs/api/java/lang/Throwable.html

区别：Exception类是所有异常类的祖先类，而Error类是所有错误类的祖先类。错误和异常的区别是：Error不是程序需要捕获和进行处理的，例如OutOfMemorryError（当Java虚拟机在为对象分配内存时，剩余的空间不够，同时也没有可以释放的内容时，将会发生这样的错误）不由程序进行捕获或处理，当Error发生时，程序将会停止。

2. 简述异常处理的两种方式，并举例说明区别。

● 声明抛出处理：
声明抛出处理——隐式抛出：异常类型是RuntimeException或是其子类，程序方法可以对异常不作任何声明抛出或处理，直接交给调用该方法的地方处理，程序能编译通过，不会对可能产生异常的代码给出提示。
例：

package homework.second;
import java.util.*;

public class TestEmptyStack {
	public static void main(String[] args) {
		Stack st=new Stack();
		Object ob=st.pop();
	}
}

EmptyStackException是RuntimeException的子类。

声明抛出处理——显示声明抛出：异常类型不是RuntimeException类或其子类时可以用显示声明抛出。
例：

package homework.second;
import java.io.*;

public class TestScreenIn {
	public static void main(String[] args) throws IOException{
		BufferedReader keyin=new BufferedReader(new InputStreamReader(System.in));
		String c1;
		int i=0;
		String[] e=new String[10];
		while(i<1000) {
			c1=keyin.readLine();
			e[i]=c1;
			i++;
			
		}System.out.println(e);
	}
}

IOException和RuntimeException是平行类，所以不能隐式抛出，如果没有“throws IOException”编译不能通过。

---

● 程序捕获处理：
将显示声明抛出改写成try-catch的形式就是捕获处理。
格式：

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

try语句块含有可能出现的异常程序代码，可能会抛出一个或多个异常，因此，try后面可跟一个或多个catch。需要指出的是：当try语句块没有异常发生时，紧跟其后的catch代码块并不被执行。

catch用来捕获异常参数ExceptionObject是ExceptionType类的对象，ExceptionType是Exception类或其子类，它指出catch语句中所要处理的异常类型。catch在捕获异常的过程中要和try语句抛出的异常类型进行比较。若相同，则在catch中进行处理；若不同，寻找其他的catch块再进行比较。

在多catch的情况下，异常类由上到下排布并遵循这样的规则：由子类到父类或为平行关系。

Finally是这个语句块的统一出口，一般用来进行一些善后操作，如释放资源、关闭文件等。

非嵌套：
例：

package homework.second;
import java.io.*;

public class TestScreenIn {
	public static void main(String[] args) {
		try{
			BufferedReader keyin=new BufferedReader(new InputStreamReader(System.in));
			String c1;
			int i=0;
			String[] e=new String[10];
			while(i<1000) {
				c1=keyin.readLine();
				e[i]=c1;
				i++;			
			}System.out.println(e);
		}
		catch(IOException e){
			e.printStackTrace();
		}
		System.out.println("123:");//不可执行
}

嵌套：
例：

package homework.second;
import java.io.*;

public class TestScreenIn {
	public static void main(String[] args) {
		try{
			try{
				BufferedReader keyin=new BufferedReader(new InputStreamReader(System.in));
				String c1;
				int i=0;
				String[] e=new String[10];
				while(i<1000) {
					c1=keyin.readLine();
					e[i]=c1;
					i++;			
				}System.out.println(e);
			}
			catch(IOException e){
				e.printStackTrace();
			}
		}
		System.out.println("123:");//可执行
		catch(Exception ee){
			ee.printStackTrace();
		}
}

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

3. 选取RuntimeException类的五个子类，编写抛出并捕获上述子类异常的程序。（例如算术异常，空指针异常，类转换异常，数组越界异常等）

EmptyStackException类：
抛出：

package homework.second;
import java.util.*;

public class TestEmptyStack {
	public static void main(String[] args) throws EmptyStackException{
		Stack st=new Stack();
		Object ob=st.pop();
	}
}

捕获：

package homework.second;
import java.util.*;

public class TestEmptyStack {
	public static void main(String[] args) {
		try {
			Stack st=new Stack();
			Object ob=st.pop();
		}
		catch(EmptyStackException e) {
			System.out.println("空栈异常");
		}
	}
}

---

ArithmeticException类:

抛出：

package homework.second;

public class TestArithmeticException {
	public static void main(String[] args) {
		int a,b,c;
		a=1;
		b=0;
		c=a/b;
		System.out.println(c);
	}
}

捕获：

package homework.second;

public class TestArithmeticException {
	public static void main(String[] args) {
		try{
			int a,b,c;
			a=1;
			b=0;
			c=a/b;
			System.out.println(c);
		}
		catch(ArithmeticException e) {
			System.out.println("除数为0");
		}
			
	}
}

---

NullPointerException类：
抛出：

package homework.second;

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

捕获：

package homework.second;

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

---

ArrayIndexOutOfBoundsException类：
抛出：

package homework.second;

public class TestArgs {
	public static void main(String[] args) {
		String foo=args[1];
		System.out.println("foo="+foo);
	}
}

捕获：

package homework.second;

public class TestArgs {
	public static void main(String[] args) {
		try{
			String foo=args[1];
			System.out.println("foo="+foo);
		}
		catch(ArrayIndexOutOfBoundsException e) {
			System.out.println("数组下标越界");
		}
	}
}

---

NegativeArraySizeException类：
抛出：

package homework.second;

public class TestNegativeArraySize {
	public static void main(String[] args) {
		int[] a;
		a=new int[-1];
	}
}

捕获：

package homework.second;

public class TestNegativeArraySize {
	public static void main(String[] args) {
		try{
			int[] a;
			a=new int[-1];
		}
		catch(NegativeArraySizeException e) {
			System.out.println("负数组长度异常");
		}
	}
}

---

4. 仿照例7.9，自定义一个异常类，并在某场景下抛出该异常对象。

package homework.second;

public class I_am_a_exception extends Exception{
	public I_am_a_exception(String msg) {
		super(msg);
	}
	
	static void throwOne() throws I_am_a_exception{
		boolean exception=true;
		if(exception) {
			throw new I_am_a_exception("哈哈哈，我是一个异常");
		}
	}
	
	public static void main(String[] args) {
		try {
			throwOne();
		}
		catch(I_am_a_exception e) {
			e.printStackTrace();
		}
	}
}