目录标题
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();
}
}
}