处理异常的第二种方式

• Java提供的是异常处理的抓抛模型。
• Java程序的执行过程中如出现异常，会生成一个异常类对象，该异常对象将被提交给Java运行时系统，这个过程称为抛出(throw)异常。
• 异常对象的生成
  • 由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，如果在当前代码中没有找到相应的处理程序，就会在后台自动创建一个对应异常类的实例对象并抛出——自动抛出
  • 由开发人员手动创建：Exception exception = new ClassCastException();——创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样

package twelve;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
 * 异常处理的方式二：在方法的声明处，显式的抛出该异常对象的类型
 * 格式：如：public static  void method2() throws FileNotFoundException,IOException{}
 * 当在此方法内部出现异常的时候，会抛出一个异常类的对象，抛给方法的调用者。
 * 异常的对象可以逐层向上抛，直至main中。当然在向上抛的过程中，可以再通过try-catch-finally进行处理。
 * 
 * java的异常处理：抓抛模型
 * 1.抓：异常的处理，有两种方式(①try-catch-finally② throws + 异常的类型)
 * 2.抛：一旦执行过程中，出现异常，会抛出一个异常类的对象。（自动的抛出  vs 手动的抛出（throw + 异常类的对象））
 *     >异常类，既可以是现成的异常类，也可以是自己创建的异常类
 */

public class TestException {
	public static void main(String[] args){
		try{
		method2();
		}catch(FileNotFoundException e){
			System.out.println(e.getMessage());
		}catch(IOException e){
			e.printStackTrace();
		}
		
		method3();
	}
	
	public static void method3(){
		try{
		method1();
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	
	public static  void method2() throws FileNotFoundException,IOException{
		method1();
	}
	
	public static void method1() throws FileNotFoundException,IOException{
		FileInputStream fis = new FileInputStream(new File("hello1.txt"));
		int b;
		while((b = fis.read()) != -1){
			System.out.print((char)b);
		}
		fis.close();
	}
}

手动抛出一个异常对象

1. package twelve;
   //1.手动的抛出一个异常的例子
   //2.抛出的异常类型：若是RuntimeException，可以不显式的处理
   //若是一个Exception,必须要显式的处理。
   public class TestCircle {
   public static void main(String[] args) {
       Circle c1 = new Circle(2.1);
       Circle c2 = new Circle(2.1);
       try {
           System.out.println(c1.compareTo(c2));
           System.out.println(c1.compareTo(new String("AA")));
       } catch (Exception e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
   }
   }
   class Circle{
   private double radius;
   
   public double getRadius() {
       return radius;
   }
   
   public void setRadius(double radius) {
       this.radius = radius;
   }
   
   public Circle(double radius) {
       super();
       this.radius = radius;
   }
   //比较两个圆的半径的大小。
   public int compareTo(Object obj) throws Exception{
       if(this == obj){
           return 0;
       }
       else if(obj instanceof Circle){
           Circle c = (Circle)obj;
           if(this.radius > c.radius){
               return 1;
           }else if(this.radius == c.radius){
               return 0;
           }else{
               return -1;
           }
       }else{
           //return -2;
           //手动的抛出一个异常
           //throw new Exception("传入的类型有误！");
           //throw new String("传入的类型有误！");
           //throw new RuntimeException("传入的类型有误！");
           throw new MyException("传入的类型有误！");//导入自定义异常类
       }
   }
   }
   

2. package twelve;
   //如何自定义一个异常类
   //1.自定义的异常类继承现有的异常类
   //2.提供一个序列号，提供几个重载的构造器
   public class MyException extends Exception{
   	
   static final long serialVersionUID = -70348975766939L;
   	
   public MyException(){
   		
   }
   public MyException(String msg){
       super(msg);
   }
   }
   

//导入自定义异常类

package twelve;

public class TestStudent {
	public static void main(String[] args) {
		Student s = new Student();
		try {
			s.regist(-12);
			System.out.println(s);
		} catch (MyException e) {
			System.out.println(e.getMessage());
		}
	}
}

class Student {
	int id;

	public void regist(int id) throws MyException {
		if (id > 0) {
			this.id = id;
		} else {
			throw new MyException("传入的学号有误！");
		}
	}

	@Override
	public String toString() {
		return "Student [id=" + id + "]";
	}

}