#千锋逆战班#

在千锋学习的第二十六天

越努力，越幸运！ 加油！

今天学习了异常的处理方法

1 

java 中的所有错误都继承自 Throwable 类

在该类的子类中 Error 类表示严重的底层错误

对于这类错误的方式 不处理

Exception 类表示例外，异常

2

1）异常类 java.rmi.AlreadyBoundException 从分类i闪光说该类属于 已检查异常

2）从处理上说，对这种异常，必须要处理

3)异常类 java.util.regex.PatternSyntaxException  从分类上说 该类属于 未检查异常

从处理上说 对这种异常，可处理可不处理  处理

 

3

package com.lichenchen.ti;

public class TestThrow {

	public static void main(String[] args) {
	throwExcrption(10);

	}

public static void throwExcrption(int n) {
		if(n==0){
			throw new NullPointerException();
		}else{
			throw new ClassCastException("类型转换错误");
			
		}
		
	}

4

package com.lichenchen.ti;
import java.io.*;
import java.sql.*;
public class TestCatchfianlly {

	public static void main(String[] args) {
		System.out.println("main 1");
		int n=4; 
		//读入n
		ma(n);
		System.out.println("main 2");
	}
	public static void ma(int n){
		try{
			System.out.println("ma1");
			mb(n);
			System.out.println("ma2");
		}catch (EOFException e){
			System.out.println("Catch EOFException");
			
		}catch(IOException e){
			System.out.println("Catch IOException");
		}catch(Exception e){
			System.out.println("Catch Exception");
		}finally{
			System.out.println("in finally");
		}
		
	}
	public static void mb(int n) throws Exception{
		System.out.println("mb1");
		if(n==1) throw new EOFException();
		if(n==2) throw new FileNotFoundException();
		if(n==3) throw new SQLException();
		if(n==4) throw new NullPointerException();
		System.out.println("mb2");
	}

}

n =1
main 1
ma1
mb1
Catch EOFException
in finally
main 2
n =2
main 1
ma1
mb1
Catch IOException
in finally
main 2
 n=3
main 1
ma1
mb1
Catch Exception
in finally
main 2
n =4
main 1
ma1
mb1
Catch Exception
in finally
main 2

7

package com.lichenchen.ti;

public class TestException {

	public static void main(String[] args) {
		ma();

	}
	public static int ma(){
		try{
			m();
			return 100;
		}catch(ArithmeticException e){
			System.out.println("ArithmeticException");
		}catch (Exception e){
			System.out.println("Exception");
		}
		return 0;
		}
		
		
	
	public static void m() throws MyException{
		throw new MyException();
	}

}
class MyException extends Exception{}


M有Exception 继承与Exception 类
Exception 类放后面
ma（）返回值

package com.lichenchen.ti;

public class TestTryCatch {

	public static void main(String[] args) {
		System.out.println(ma());
	}
	public static int ma(){
		int n ;
		try{
			n=10/0;
		}catch (Exception e){
			
		}
		return n;
	}
}
A

 

package com.lichenchen.ti;

public class TestFinally {

	public static void main(String[] args) {
		System.out.println(ma());

	}
	public static int ma(){
		int b;
		//
		b=100;
		try{
			int n =100;
			return n/b;
		}catch (Exception e){
			return 10;
		}finally{
			return 100;
		}
	}

}

在ma（） 中 当读入的b =100；时输出结果为100；
读入b=0；输出结果100

package com.lichenchen.ti;

public class TestTryFinally {

	public static void main(String[] args) {
		try{
			ma();
		}catch(Exception ex1){
			
		}

	}
	public static void ma() throws Exception{
		int n=10;
		int b =0;
		try{
			System.out.println("MA1");
			int result  =n/b ;
			System.out.println("ma1"+result);
		}finally{
			System.out.println("in Finally");
		}
	}

}

读入整数b =10 输出结果为MA1
ma11
in Finally
读入整数为0时 输出结果为MA1
in Finally

package com.lichenchen.ti;

import org.omg.Messaging.SyncScopeHelper;

public class TestException1 {

	public static void main(String[] args) {
		try{
			System.out.println("main1");
			ma();
			System.out.println("main2");
		}catch (Exception e){
			System.out.println("IN Catch");
		}
	}
	public static void ma(){
		System.out.println("ma1");
		throw new NullPointerException();
		System.out.println("ma2");
	}
}
A

package com.lichenchen.ti;
import java.io.*;
import java.sql.*;
public class TestException3 {

	public static void main(String[] args) {
	try{
		ma();
	}
	/*1*/
	//catch(NullPointerException npw){}
	catch(IOException ioe){}
	catch (Exception e){
		
	}

	}
	public static void ma() throws IOException{}

}

A B