Home

韧桂

思考,总结

处理异常的第二种方式

  • 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 + "]";
	}

}

韧桂 2020-01-01