7.异常处理

目录

一、异常体系结构

面试题：常见的异常都哪些？举例说明

二、异常处理

        异常的处理：抓抛模型

        异常的处理：throws + 异常类型

 三、如何自定义异常类

---

一、异常体系结构

 *         java.lang.Throwable
 *             |---java.lang.Error:一般不编写针对性的代码进行处理
 *             |---java.lang.Exception:可以进行异常处理
 *                 |---编译时异常(checked)
 *                     |---IOException
 *                         |---FileNotFoundException
 *                     |---ClassNotFoundException
 *                 |---运行时异常(unchecked)
 *                     |---NullPointerException
 *                     |---ArrayIndexOutOfBoundsException
 *                     |---ClassCastException
 *                     |---NumberFormatException
 *                     |---InputMismatchException
 *                     |---ArithmeticException

编译时异常：执行javac.exe命令时，可能出现的异常
运行时异常：执行java.exe命令时，出现的异常

面试题：常见的异常都哪些？举例说明

    //NullPointerException(空指针异常)
    @Test
    public void test1(){
        //举例一
        int[] arr = null;
        System.out.println(arr[3]);
        //举例二
        String str = "abc";
        str = null;
        System.out.println(str.charAt(0));
    }
    
    //IndexOutOfBoundsException(越界异常)
    @Test
    public void test2(){
        //ArrayIndexOutOfBoundsException(数组下标越界异常)
        int arr[] = new int[10];
        System.out.println(arr[10]);
        //StringIndexOutOfBoundsException
        String str = "abc";
        System.out.println(str.charAt(3));
    }
    
    //ClassCastException(类型转换异常)
    @Test
    public void test3(){
        Object obj = new Date();
        String str = (String)obj;
    }
    
    //NumberFormatException(数值转换异常)
    @Test
    public void test4(){
        String str = "123";
        str = "abc";
        Integer.parseInt(str);        
    }
    
    //InputMismatchException(输入不匹配)
    @Test
    public void test5(){
        Scanner scanner = new Scanner(System.in);
        int score = scanner.nextInt();
        System.out.println(score);
        scanner.close();
    }
    
    //ArithmeticException(算术异常)
    @Test
    public void test6(){
        int a = 10;
        int b = 0;
        System.out.println(a / b);
    }
    
    //***************************************************
    
    @Test
    public void test7(){
//        File file = new File("hello.txt");
//        FileInputStream fis = new FileInputStream(file);
//        int data = fis.read();
//        while(data != -1){
//            System.out.print((char)data);
//            data = fis.read();
//        }
//        fis.close();
    }

二、异常处理

        异常的处理：抓抛模型

 *         过程一：“抛”：程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象并将此对象抛出。一旦抛出对象以后，其后的代码就不再执行。
           关于异常对象的产生：①系统自动生成的异常对象
 *                                             ②手动的生成一个异常对象，并抛出(throw)
 *         过程二：“抓”：可以理解为异常的处理方式：①try-catch-finally ②throws
 * 二、try-catch-finally的使用
 *         try{
 *             //可能出现异常的代码
 *         }catch(异常类型1 变量名1){
 *             //处理异常的方式1
 *         }catch(异常类型2 变量名2){
 *             //处理异常的方式2
 *         }catch(异常类型3 变量名3){
 *             //处理异常的方式3
 *         }
 *         ......
 *         finally{
 *             //一定会执行的代码
 *         }
 *     说明：
 *         1.finally是可选的
 *         2.使用try将可能出现异常的代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配
 *         3.一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的try-catch结构(在没有写finally的情况下)，继续执行其后的代码
 *         4.catch中的异常类型如果没有子父类关系，则声明顺序无所谓
 *            catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则报错
 *         5.常用的异常对象处理的方式：①String getMessage()  ②printStackTrace()
 *         6.在try结构中声明的变量，在出了try结构以后，就不能在被调用
 *         7.try-catch-finally结构可以嵌套
 *                 try-catch-finally中finally的使用
 *         1.finally是可选的
 *         2.finally中声明的是一定会被执行的代码。即使catch中又出现异常了，try中有return
 *             语句，catch中有return语句等情况
 *         3.像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动回收的，我们需要
 *             手动的进行资源的释放。此时的资源释放，就需要声明在finally中
 *
 * 体会1：使用try-catch-finally处理编译时异常，使得程序在编译时不再报错，但运行时仍可能报错，相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现
 * 体会2：开发中，由于运行时异常比较常见，所以我们通常不针对运行时异常编写try-catch-finally。针对编译时异常，我们一定要考虑异常的处理

面试题：final、finally、finalize三者的区别？
类似：throw和throws
         Collection和Collections
         String、StringBuffer、StringBuilder
         ArrayList、LinkedList
         HashMap、LinkedHashMap
         重写、重载
结构不相似的：
         抽象类、接口
         ==、equals()
         sleep、wait()

public class ExceptionTest1 {

	@Test
	public void test1(){
		String str = "123";
		str = "abc";
		int num = 0;
		try{
			num = Integer.parseInt(str);
			System.out.println("hello---1");
		}catch(NullPointerException e){
			System.out.println("出现空指针异常了!");
		}catch(NumberFormatException e){
//			System.out.println("出现数值转换异常了!");
			//常用1
			//String getMessage();
//			System.out.println(e.getMessage());
			//常用2
			//printStackTrace();
//			e.printStackTrace();
		}catch(Exception e){
			System.out.println("出现异常了!");
		}
		System.out.println(num);
		System.out.println("hello---2");
	}
	
	@Test
	public void test2(){
		try{
		File file = new File("hello.txt");
		FileInputStream fis = new FileInputStream(file);
		int data = fis.read();
		while(data != -1){
			System.out.print((char)data);
			data = fis.read();
		}
		fis.close();
		}catch(FileNotFoundException e){
			e.printStackTrace();
		}catch(IOException e){
			e.printStackTrace();
		}
	}
	
	//*********************************************************
	
	
	@Test
	public void test3(){
		try{
			int a = 10;
			int b = 0;
			System.out.println(a / b);
		}catch(ArithmeticException e){
//			e.printStackTrace();
			int[] arr = new int[10];
			System.out.println(arr[10]);
		}catch(Exception e){
			e.printStackTrace();
		}
//		System.out.println("hello!!");
		finally{
			System.out.println("hello~~");
		}
	}
	
	@Test
	public void testMethod(){
		int num = method();
		System.out.println(num);
	}
	public int method(){
		try{
			int[] arr = new int[10];
			System.out.println(arr[10]);
			return 1;
		}catch(ArrayIndexOutOfBoundsException e){
			e.printStackTrace();
			return 2;
		}finally{
			System.out.println("我一定会被执行");
		}
	}
	
	@Test
	public void test4(){
		FileInputStream fis = null;
			try {
				File file = new File("hello.txt");
				fis = new FileInputStream(file);
				int data = fis.read();
				while(data != -1){
					System.out.print((char)data);
					data = fis.read();
				}
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}finally{
				try{
					if(fis != null)
						fis.close();
				}catch (IOException e){
					e.printStackTrace();
				}
			}
	}
	
}

        异常的处理：throws + 异常类型

 *         1."throws + 异常类型"写在方法的声明处。指明此方法执行时，可能会抛出的异常类型
 *              一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时，就会被抛出。异常代码后续的代码，就不再执行！
 *         2.体会：try-catch-finally：真正的将异常给处理掉了。
 *                 throws的方式只是将异常抛给了方法的调用者。并没有真正将异常处理掉。
 *         3.开发中如何选择使用try-catch-finally还是使用throws？
 *             3.1如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws意味着如果子类重写的方法中有异常，必须使用try-catch-finally方式处理
 *             3.2执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用throws的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。

 * 补充：
 * 方法重写的规则之一：
 *         子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

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

手动抛出异常对象：
1.使用说明：
        在程序执行中，除了自动抛出异常对象的情况之外，我们还可以手动的throw一个异常类的对象
2.面试题：
        throw和throws的区别
            throw表示抛出一个异常类的对象：生成异常对象的过程。声明在方法体内。
            throws属于异常处理的一种方式，声明在方法的声明处。
3.例题
class Student{
    int id;
    public void regist(int id) throws Exception{
        if(id > 0){
            this.id =id;
        }else{
            //手动抛出异常对象
            //1.
//            throw new RuntimeException("您输入的数据非法！");
            //2.
            throw new Exception("您输入的数据非法！");
//            throw new MyException("不能输入负数");
        }
    }
    @Override
    public String toString() {
        return "Student [id=" + id + "]";
    }
}

 三、如何自定义异常类

 *         1.继承于现的异常结构：RuntimeException、Exception
 *         2.提供全局常量：serialVersionUID
 *         3.提供重载的构造器

public class MyException extends RuntimeException{
    static final long serialVersionUID = -3387516993794229948L;
    public MyException(){
    }
    public MyException(String message){
        super(message);
    }
}