1、Java 实例 - 异常处理方法：使用 System 类的 System.err.println() 来展示异常的处理方法。
public class Exception_Error {
public Exception_Error() {
try {
throw new Exception("My Exception");
}catch (Exception e) {
System.err.println("Caught Exception");
System.err.println("getMessage():" + e.getMessage());
System.err.println("getLocalizedMessage():" + e.getLocalizedMessage());
System.err.println("toString():" + e);
System.err.println("printStackTrace():");
e.printStackTrace();
}
}
}
运行结果：
2、Java 实例 - 多个异常处理（多个catch）：
声明异常时，建议声明更为具体的异常，这样可以处理的更具体
对方声明几个异常，就对应几个catch块， 如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面
public class Exception1 {
public int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException
//在功能上通过throws的关键字声明该功能可能出现问题
{
int []arr =new int [a];
System.out.println(arr[4]);//制造的第一处异常
return a/b;//制造的第二处异常
}
}
·····································································································
public class ExceptionTest1 {
public ExceptionTest1()//throws Exception
{
Exception1 d =new Exception1();
try
{
int x = d.div(4,0);//程序运行截图中的三组示例 分别对应此处的三行代码
//int x = d.div(5,0);
//int x = d.div(4,1);
System.out.println("x="+x);
}
catch (ArithmeticException e)
{
System.out.println(e.toString());
}
catch (ArrayIndexOutOfBoundsException e)
{
System.out.println(e.toString());
}
catch (Exception e)//父类 写在此处是为了捕捉其他没预料到的异常 只能写在子类异常的代码后面
//不过一般情况下是不写的
{
System.out.println(e.toString());
}
System.out.println("Over");
}
}
运行结果：
3、Java 实例 - Finally的用法：
Java 中的 Finally 关键一般与try一起使用，在程序进入try块之后，无论程序是因为异常而中止或其它方式返回终止的，finally块的内容一定会被执行 。
public class ExceptionTest2 {
public ExceptionTest2() {
doTheWork();
}
public void doTheWork() {
Object o =null;
for (int i=0; i<5; i++) {
try {
o = makeObj(i);
}
catch (IllegalArgumentException e) {
System.err.println
("Error: ("+ e.getMessage()+").");
return;
}
finally {
System.err.println("都已执行完毕");
if (o==null)
System.exit(0);
}
System.out.println(o);
}
}
public Object makeObj(int type)
throws IllegalArgumentException {
if (type ==1)
throw new IllegalArgumentException
("不是指定的类型： " + type);
return new Object();
}
}
运行结果：
4、Java 实例 - 使用catch 处理异常：使用 catch 来处理异常的方法。
public class Exception_Catch {
public Exception_Catch() {
int array[]={20,20,40};
int num1=15,num2=10;
int result=10;
try{
result = num1/num2;
System.out.println("结果为 " +result);
for(int i =5;i >=0; i--) {
System.out.println ("数组的元素值为 " +array[i]);
}
}
catch (Exception e) {
System.out.println("触发异常 : "+e);
}
}
}
运行结果：
5、Java 实例 - 多线程异常处理：
public class Threadsextends Thread{
public void run(){
System.out.println("Throwing in " +"MyThread");
throw new RuntimeException();
}
}
··············································································
public class Exception_Threads {
public Exception_Threads(){
Threads t =new Threads();
t.start();
try{
Thread.sleep(1000);
}
catch (Exception x){
System.out.println("Caught it" + x);
}
System.out.println("Exiting main");
}
}
运行结果：
6、Java 实例 - 获取异常的堆栈信息：
public class Exception_GetStack {
public Exception_GetStack(){
int array[]={20,20,40};
int num1=15,num2=10;
int result=10;
try{
result = num1/num2;
System.out.println("The result is" +result);
for(int i =5; i>=0; i--) {
System.out.println("The value of array is" +array[i]);
}
}
catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果：
7、Java 实例 - 重载方法异常处理：
public class Exception_Overload {
public Exception_Overload() {
try{
System.out.println(method(10,20.0));
System.out.println(method(10.0,20));
System.out.println(method(10.0,20.0));
System.out.println(method(10));
}
catch (Exception ex){
System.out.println("exception occoure: "+ ex);
}
}
double method(int i)throws Exception{
return i/0;
}
boolean method(boolean b) {
return !b;
}
static double method(int x,double y)throws Exception {
return x + y ;
}
static double method(double x,double y) {
return x + y -3;
}
}
运行结果：
8、Java 实例 - 链试异常：使用多个 catch 来处理链试异常。
public class Exception_ChainTest {
public Exception_ChainTest()throws Exception {
int n=20,result=0;
try{
result=n/0;
System.out.println("结果为"+result);
}
catch(ArithmeticException ex){
System.out.println("发算术异常: "+ex);
try {
throw new NumberFormatException();
}
catch(NumberFormatException ex1) {
System.out.println("手动抛出链试异常 : "+ex1);
}
}
}
}
运行结果：
9、Java 实例 - 自定义异常：通过继承 Exception 来实现自定义异常。
public class Exception2extends Exception{
public Exception2(String s) {
super(s);
}
}
···········································································
public class ExceptionTest3 {
public ExceptionTest3(){
try {
method();
}
catch(Exception2 e) {
System.out.println(e.getMessage());
}
}
void method()throws Exception2 {
throw new Exception2("Wrong input");// 抛出自定义的类
}
}
运行结果：
