异常

  

   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      五个关键字  和两个结构
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      两个结构：
     
    
   

    

     

    
    

     
	1. Throwable
     
    
   

    

     

    
    

     

      			Error		表示错误
     
    
   

    

     

    
    

     

      			Exception	异常
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
	2.
     
    
   

    

     

    
    

     

      		Exception
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			RuntimeException(包括其子类)
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      			非RuntimeException（Checked异常）
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      5个关键字:
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	try, catch, finally,  throws , throw
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	处理异常的结构:
     
    
   

    

     

    
    

     
	try
     
    
   

    

     

    
    

     

      	{
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     
	catch(异常类型 变量)
     
    
   

    

     

    
    

     

      	{
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	try{
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	}finally{
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	try{
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		//存放可能出现异常代码
     
    
   

    

     

    
    

     

      	}catch(异常类 变量)
     
    
   

    

     

    
    

     

      	{
     
    
   

    

     

    
    

     

      		处理异常
     
    
   

    

     

    
    

     

      	}finally{
     
    
   

    

     

    
    

     
		//最后会执行的代码
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	异常的分类:
     
    
   

    

     

    
    

     
		1. RuntimeException(包括其子类)
     
    
   

    

     

    
    

     

      			特点:  编译时不检查,在运行期才去检查
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
		2. 非RuntimeException（Checked异常）
     
    
   

    

     

    
    

     

      			特点:  编译时就会检查,
     
    
   

    

     

    
    

     

      						处理方式:
     
    
   

    

     

    
    

     
							1.  在该代码所在方法上 声明跑出异常  throws
     
    
   

    

     

    
    

     
							2.  把该代码try{ // here //}catch(Exception e){}
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      	在方法上 声明抛出异常:
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		方法后的圆括号后面   throws 异常类A,异常类B
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		表明该方法不处理A,B异常,而是交给该方法的调用者去处理;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		JVM默认的处理方式:
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      			Throwable:
     
    
   

    

     

    
    

     
				void printStackTrace();//获取异常信息和 异常类型 异常的位置
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     

      				System.out.println(printStackTrace());//ERROR
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     

      				String getMessage();//得到的异常信息
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     

      				String toString(); //获取异常信息和 异常类型
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     
	throw:
     
    
   

    

     

    
    

     
		throw  异常对象;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	若 throw 抛出的是 runtime异常:  所在的方法上不需要声明抛出
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	若 throw 抛出的是  非runtime异常:  所在的方法上必须声明抛出异常;
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    throw&throws
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    throws用于在方法上声明该方法不需要处理的异常类型。
     
    
   

    

     

    
    

     
    throw用于抛出具体异常类的对象。
     
    
   

    

     

    
    

     
    throws与throw的区别：
     
    
   

    

     

    
    

     

          thorws用在方法上，后面跟异常类名,可以是多个异常类。
     
    
   

    

     

    
    

     
    throw用在方法内，后面跟异常对象,只能是一个。
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	注意:
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      		方法复写:
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      			原则:  一同两小一大:
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      						一同:方法签名相同
     
    
   

    

     

    
    

     

      						两小:
     
    
   

    

     

    
    

     
							1. 子类方法返回的类型可是父类方法返回类型的子类或相同类
     
    
   

    

     

    
    

     
							2. 子类不能抛出新的异常,子类不能抛出更多的异常;(有特殊的)
     
    
   

    

     

    
    

     
							
     
    
   

    

     

    
    

     

      						一大: 子类方法的访问修饰符大于等于父类方法的访问修饰符
     
    
   

    

     

    
    

     
						
     
    
   

    

     

    
    

     
	finally:
     
    
   

    

     

    
    

     

      		特点:  最终都会执行的语句块
     
    
   

    

     

    
    

     

      			特殊情况:  退出JVM,  System.exit(1);//系统退出
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	..main..
     
    
   

    

     

    
    

     

      	{
     
    
   

    

     

    
    

     

      		System.out.println(show());// 1 还是 2
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	public static int show(){
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		int i = 1;
     
    
   

    

     

    
    

     
		try
     
    
   

    

     

    
    

     

      		{
     
    
   

    

     

    
    

     
			return i;
     
    
   

    

     

    
    

     

      		}finally{
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			return i++;
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	自定义异常:
     
    
   

    

     

    
    

     

      		新建一个类继承与  Exception或 其子类
     
    
   

    

     

    
    

     

      		提供一个无参构造方法和一个带一个String参数的构造方法
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      class MyException2 extends RuntimeException{
     
    
   

    

     

    
    

     
	public MyException2() {
     
    
   

    

     

    
    

     
		super();
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     
	/**
     
    
   

    

     

    
    

     

       * 
     
    
   

    

     

    
    

     

       * @param message 表示异常描述 getMesasge();
     
    
   

    

     

    
    

     

       */
     
    
   

    

     

    
    

     
	public MyException2(String message) {
     
    
   

    

     

    
    

     
		super(message);
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      class MyException1 extends Exception{
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	public MyException1() {
     
    
   

    

     

    
    

     
		super();
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     
	/**
     
    
   

    

     

    
    

     

       * 
     
    
   

    

     

    
    

     

       * @param message 表示异常描述 getMesasge();
     
    
   

    

     

    
    

     

       */
     
    
   

    

     

    
    

     
	public MyException1(String message) {
     
    
   

    

     

    
    

     
		super(message);
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     

      public class MyExceptionDemo {
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	public static  void divide(int a, int b){
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		if(b == 0){
     
    
   

    

     

    
    

     
			throw new MyException2("亲,除数不能为0");
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	public static void main(String[] args) {
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		try{
     
    
   

    

     

    
    

     

      		divide(1,0);
     
    
   

    

     

    
    

     

      		}catch(Exception e){
     
    
   

    

     

    
    

     
			String msg = e.getMessage();
     
    
   

    

     

    
    

     

      			System.out.println("msg= " + msg);
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		实际开发中,更加喜欢使用 RuntimeException
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	
     
    
  
 

文章来源: brucelong.blog.csdn.net，作者：Bruce小鬼，版权归原作者所有，如需转载，请联系作者。

原文链接：brucelong.blog.csdn.net/article/details/81664415