java异常的实例,Java实例-异常处理

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");// 抛出自定义的类

}

}

运行结果：