Java IO流中的异常处理以及自定义异常实例

Myth丶恋晨 2022-04-17 00:39 149阅读 0赞

### 文章目录 ###

*   *   *   *  异常
             *  自定义异常实例
             *  finally中特殊情况实例

#### 异常 ####

1、 Throwable类  
 a) 严重问题：Error，比如说内存不够，一般程序中不进行处理  
 b) 问题：Exception  
  i. 编译期问题：不是RunTimeException的异常，不处理编译不能通过，因此必须处理  
  ii. 运行期问题：是RunTimeException，代码中不够严谨导致  
  iii. 编译期异常和运行期异常区别：  
   1. 编译期异常：Java程序必须显示处理，否则程序就会发生错误，无法通过编译.  
   2. 运行期异常：无需显示处理，也可以和编译时异常一样处理  
 c) 如果程序出现问题，但是不进行任何处理，JVM会默认进行处理，将异常的名称，  
  原因及出现的问题等信息输出在控制台，同时会结束程序，不再运行下面的程序。  
 d) 如何处理异常？  
  i. 单个异常  
   try…catch…finally  
   格式  
    try \{可能出现问题的代码（越少越好）\}  
    catch(异常名变量）\{针对问题的处理\}  
    finally\{释放资源\}  
  ii. 多个异常  
   1、格式  
    try \{可能出现问题的代码（越少越好）\}  
    catch(异常名变量）\{针对问题的处理\}  
    catch(异常名变量）\{针对问题的处理\}  
    catch(异常名变量）\{针对问题的处理\}  
    …  
    finally\{释放资源\}  
    注意事项  
    a、一旦try里面出现第一个异常就会把此异常抛出去，和catch里面的异常进行匹配，  
     当匹配成功后执行完此catch内部的语句，继续执行try… catch…finally后面的语句。  
    b、当只知道出现异常，但不具体知道什么异常时可以用catch（Exception e） 来进行匹配，  
     这时无论任何异常都可以处理，但是如果可以明确就别这样用。  
   2、格式：try \{可能出现问题的代码（越少越好）\}  
     catch(异常名变量|异常名变量|异常名变量|…）\{针对问题的处理\}  
     finally\{释放资源\}  
     注意事项  
      a、针对catch后面的所有异常，处理方式都是一致的，  
      b、多个异常必须是平级关系。

2、 throws异常  
 a) 将自己处理不了的异常代码在方法上声明，告诉调用者，此处程序有问题  
 b) 格式：  
  i. throws 异常类名，异常变量名，…可以跟一个异常，也可以跟多个异常  
  ii. 注意此格式必须跟在方法的括号后面。  
  iii. 注意尽量不要在main方法上抛出异常，  
 c) 如果是编译期异常的抛出，必须要通过throws来抛出  
  如果是运行期异常的抛出，可以通过throws抛出，也可以不抛出。  
3、 throws和throw的区别  
 a) throws  
  i. 用在方法声明后，跟的是异常类名  
  ii. 可以抛出多个异常名，用逗号隔开  
  iii. 表示抛出异常，由该方法的调用者处理  
  iv. throws表示出现异常的一种可能性，并不一定会发生这些异常。  
 b) throw  
  i. 用在方法体内部，跟的是异常对象名  
  ii. 只能抛出一个异常对象名  
  iii. 表示抛出异常，由方法体内的语句处理  
  iv. throw抛出异常，执行throw则一定抛出了某种异常  
4、 异常应该如何处理  
 a) 如果该功能内部可以将问题处理，用try  
 b) 如果处理不了，交由调用者处理，这时用throws  
 c) 区别  
  i. 后续程序需要继续运行用try  
  ii. 后续程序不需要运行了就用throws  
5、 异常中的常用方法:  
 a) public String getMessage() 获取异常信息，返回字符串，并打印。  
 b) public String toString() 获取异常类名和异常信息，返回字符串并打印。  
 c) public void printStackTrace()获取异常类名和异常信息，以及异常在程序中的位置，  
   并在控制台打印出来。  
 d) public void printStackTrace(PrintStream s)用此方法将异常内容保存在文件中。  
6、 finally  
 a) finally控制的语句体一定会执行，但是如果在执行到finally之前Jvm退出了，就不会执行了，  
  常用于释放资源  
 b) final、finally、finalize的区别  
  i. final：最终的意思，可以修饰类，成员变量，成员方法  
   1. 修饰类：类不能被继承  
   2. 修饰成员变量：变量是常量  
   3. 修饰方法：方法不能被重写  
  ii. finally：异常处理的一部分，用于释放资源  
   一般来说，此处的代码肯定执行，但是如果在执行到finally之前Jvm退出了则不会执行  
  iii. finalize：Object类的一个方法，用于垃圾回收  
 c) 如果catch里面有return语句，finally里面的代码还会执行吗？  
  finally里面的代码会执行，且执行完之后再执行catch中的return语句，  
  注意：当运行到catch时catch中的return语句已经形成，里面的值不会因为finally语句而更改。  
  finally运行时特殊情况的实例在下面给出  
7、 自定义异常  
 a) 自定义异常类必须是继承自Exception或者RuntimeException  
 b) 自定义异常的实例在下面给出  
8、 异常的注意事项  
 a) 子类重写父类方法时，子类的方法必须与父类抛出相同的异常或者父类异常的子类。  
 b) 如果父类抛出了多个异常，子类重写父类时，只能抛出相同的异常或者父类异常的子集。  
 c) 如果被重写的方法没有异常抛出，那么子类的方法绝对不可以抛出异常，  
  如果子类方法内有异常发生，那么子类只能使用try，不能使用throws

#### 自定义异常实例 ####

**测试代码**

package test01_exception;
    
    import java.util.Scanner;
    
    public class Demo {
        
    	public static void main(String[] args) {
        
    		Scanner sc=new Scanner(System.in);
    		System.out.println("请输入一个数");
    		int i=sc.nextInt();
    		sc.close();
    		Teacher t=new Teacher();
    		try {
        
    			t.check(i);
    		} catch (MyException e) {
        
    	
    			e.printStackTrace();
    		}
    		System.out.println();
    		System.out.println("您输入的是："+i);
    		
    	}
    
    }

package test01_exception;
    //如果是MyException继承的是Exception需要通过throws抛出
    public class Teacher {
        
    	public void check(int score) throws MyException {
        
    		if(score<0||score>100) {
        
    			System.out.println("输入不合法");
    			throw new MyException("你输入的值不在规定范围内");
    			
    		}else {
        
    			System.out.println("输入合法");
    		}
    	}
    }
    //如果是运行期异常（MyException继承的是RuntimeException）不需要抛出
    //public class Teacher {
        
    //	public void check(int score){
        
    //		if(score<0||score>100) {
        
    //			throw new MyException();
    //			
    //		}else {
        
    //			System.out.println("请继续输入");
    //		}
    //	}
    //}

**自定义异常**

package test01_exception;
    
    public class MyException extends Exception{
        
    	/**
    	 * 
    	 */
    	//此处有两个构造方法，如果抛出异常时创建带参构造方法对象，字符串s会被显示在控制台异常处理结果
    	private static final long serialVersionUID = 1L;
    	public MyException() {
        
    		
    	}
    	public MyException(String s) {
        
    		super(s);
    	}
    	
    	
    }
    //public class MyException extends RuntimeException{
        
    //
    //}

**输出样式**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pmbGl1OTY_size_16_color_FFFFFF_t_70]

#### finally中特殊情况实例 ####

**代码**  
主要是测试了finally语句块中不同位置return的返回情况

package test15_finally;
    
    public class FinallyDemo {
        
    	public static void main(String[] args) {
        
    		System.out.println(test());
    	}
    
    	private static int test() {
        
    		int a=10;
    		try {
        
    			a=a/0;
    		} catch (ArithmeticException e) {
        
    			
    			a=100;
    //如果此处有退出的话则不会进入finally语句
    			//System.exit(0);			
    	
    //此处虽然有return但是由于有finally需要先执行finally语句再进行返回操作
    //但是此处的return语句在执行catch语句块时就已经确定了return的值，
    //运行finally并不影响此处的return值
    			return a;
    			
    		}finally {
        
    			
    			System.out.println(a);
    			a=20;
    			System.out.println(a);
    
    //如果此处有return的话就直接返回了，不会再进入catch中的return语句
    			//return a;
    		}
    		
    		return a;
    	}
    }

**输出样式**  
![在这里插入图片描述][20181110161533605.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pmbGl1OTY_size_16_color_FFFFFF_t_70]: /images/20220417/3186a1e36aaf4d2e86c120ef7cb0dc9a.png
[20181110161533605.png]: /images/20220417/2f992ff7fbe1471ab16ae632bcfdbb6b.png