Java修炼笔记6

Java Error类与Exception类的区别：

Error是所有错误类的祖先类，而Exception类是所有异常类的祖先类。
错误和异常的区别是：
Error不是程序需要捕获和进行处理的，当Error发生时，程序将会停止。当异常发生时，虚拟机系统根据异常的类型，产生相应的异常对象，程序中应对这些相应的异常进行处理。

Java异常处理的两种方式：

捕获处理
捕获处理是由try-catch-finally组成的一个异常处理块构成，其格式为：

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

例：

import java.io.*;
public class TestScreenIn {
	public static void main(String[] args) {
			BufferedReader keyin = new BufferedReader(new InputStreamReader(System.in));
			String c1;
			int i = 0;
			String[] e = new String[10];
			try {
				while(i<10) {
					c1 = keyin.readLine();//可能产生异常
					e[i] = c1;
					i++;
				}
			}
			catch(IOException t) {
				//t.printStackTrace();
				System.out.println("系统IO有错误");
			}
	}
}

当readLine发生输入异常的时候（注意此处有可能发生异常，而不是一定能发生异常），产生的异常对象将赋值给catch块中的参数t，此后可对t进行操作，如通过“t.printStackTrace()”输出异常信息。

1.隐式声明抛出：

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

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

栈对象st在栈中没有任何对象引用情况下使用了pop方法仅会在运行时发生空栈异常，而代码写好后不会给出错误提示。

2.显式声明抛出
除RunTimeException外的异常都不能隐式抛出。只需将方法进行如下改动就实现了显式声明抛出：

public static void main(String[] args)修改为
public static void main(String[] args) throw ExceptionType

其含义是：如果mian中发生ExceptionType类型的异常，mian不负责异常处理，由调用main方法的地方去处理异常，而调用main方法的Java虚拟机，因此由Java虚拟机进行默认处理。

RuntimeException异常实例：

1.算术异常

public class ExampleException {

	public static void main(String[] args) {
		int a,b,c = 0;
		a = 67; b = 0;
		try {
			c = a/b;//除零异常
		}
		catch(RuntimeException e) {
			e.printStackTrace();
		}
		System.out.println(a + "/" + b + "=" + c);
	}
}

2.空指针异常

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

3.数组越界异常

public class TestArgs {
	public static void main(String[] args) {
		String foo = null;
		try {
			foo = args[1];//数组越界异常
		}
		catch(RuntimeException e) {
			e.printStackTrace();
		}
		System.out.println("foo = " + foo);
	}
}

4.试图将错误类型的对象存储到一个对象数组时抛出的异常

class A extends B{
	int a;
}
class B {
	int b;
}
public class ArrayStoreException {

	public static void main(String[] args) {
		A[] s = new A[10];
		B[] b = s;
		try {
			b[1] = new B();//试图将错误类型的对象存储到一个对象数组时抛出的异常
		}
		catch(RuntimeException e) {
			e.printStackTrace();
		}
	}
}

5.类转换异常

class A extends B{
	int a;
}
class B {
	int b;
}
public class ClassTransformationException {

	public static void main(String[] args) {
		try {
			B b = new B();
			A a = (A)b;//类转换异常
		}
		catch(ClassCastException e) {
			e.printStackTrace();
		}
	}
}

自定义异常类实例：

public class SelfGenerateException extends Exception{
	SelfGenerateException(String msg){
		super(msg);
	}
	static void throwOne(int a, int b) throws SelfGenerateException{
		if(a != b) {
			throw new SelfGenerateException("a不等于b");
		}
	}
	public static void main(String[] args) {
		try {
			throwOne(1,2);
		}
		catch(SelfGenerateException e) {
			System.out.print("发生“a不等于b”异常");
		}
	}
}