黑马程序员——Java基础--异常

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

异常

一、概述
        异常，我们在编程的时候可能会出现各种各样的异常，而这些异常都是常见的， 在Java程序在运行时期出现的不正常现象，Java对这种异常进行了对象封装， 对象是确实存在的实体，类是对象抽象描述。
二、继承体系
Java中一切异常和错误的父类java.lang.Throwable。
    Throwable:
        Error：程序中出现非常严重问题，不修改代码，运行不了；
        Exception：程序中出现了比较轻微的问题，处理掉后可以继续执行。
    Exception：
        是所有异常的父类；
    Throwable构造方法：
        空参数构造方法；
        传递字符串：传递字符串类型的异常信息；
    Throwable普通方法，三个。
        String toString()  返回异常信息的简短描述；
        String getMessage() 返回异常信息的详细描述；
        void printStackTrace() 异常信息将此 throwable 及其追踪输出至标准错误流 。
三、异常分类
        1、RuntimeException：运行时期异常，凡是RuntimeException的子类，或者自己也是运行时期异常，方法内部抛出异常，是运行时期异常，不需要throws声明出来，throw new RuntimeException()；不用throws，对于运行时期异常，一旦发生，请你不要处理，必须停下来修改源代码，也就是说不能发生。
        常见的运行时期子类异常有：
        NullPointerException 描述空指针异常
        ArrayIndexOutOfBoundsException 描述数组索引越界异常
        ClassCastException 类型转换异常
        StringIndexOutException 字符串越界异常
        IndexOutOfBoundsException 越界异常，出现集合中
        ArithmeticException 数学计算异常
       2、 非RuntimeException：编译时期异常 ， 当调用了抛出异常的方法，如果对方不处理，编译失败，处理方式，可以try...catch 继续throws;
       3、自定义异常
俩个步骤：
        1、定义类，类名后缀Exception，继承Exception或者继承RuntimeException；
        2、在异常类中定义构造方法，将异常信息传递给父类 。
注意：用户乱传递参数，应该使用运行时期异常；实际开发中，自定义异常，大多数都是基继承RuntimeException。
四、异常处理的俩种方式
1、 try...catch，格式可以分为
    （1）try{
        可能发送异常的代码，检测用的
    }catch(异常类名 变量){
        异常处理方法
        直接输出异常信息
        写循环，判断，调用方法
    }
例子：

package cn.itheima.exception;

/*
 * 异常的第一种处理方式
 *   try...catch处理
 *   
 * try{
 *   可能发送异常的代码
 *   检测用的
 *  }catch(异常类名    变量){
 *     异常处理方式
 *       直接输出异常信息
 *       写循环,判断,调用方法
 *  }
 */
public class ExceptionDemo1 {
	public static void main(String[] args) {
		try{
			//可能发送异常代码
	    	int result = div(3,0);
	    	System.out.println(result);
	    	System.out.println("aaa");
		}catch(Exception ex){
			//异常处理的代码
			System.out.println("toString " +ex);
			//System.out.println("getMessage "+ex.getMessage());
			ex.printStackTrace();
		}
		
		System.out.println("bbb");
	}
	
	public static int div(int a,int b){
		return a/b;
	}
}

toString java.lang.ArithmeticException: / by zero
java.lang.ArithmeticException: / by zero
    at cn.itheima.exception.ExceptionDemo1.div(ExceptionDemo1.java:34)
    at cn.itheima.exception.ExceptionDemo1.main(ExceptionDemo1.java:20)
bbb
    （2）、多个catch处理异常：
    try{
        可能发送异常的代码，检测用的
    }catch(异常类名 变量){
        异常处理方法
        直接输出异常信息
        写循环，判断，调用方法
    }catch(异常类名 变量){
        异常处理方法
        直接输出异常信息
        写循环，判断，调用方法
    }
例子1：

package cn.itheima.exception;

/*
 * 多个catch处理异常
 *  try{}
 *  catch(){}
 *  catch(){}
 *  
 * 异常的平级,出现的异常类,之间没有继承关系
 */
public class ExceptionDemo2 {
	public static void main(String[] args) {
		 try{
		   method(10);
		 }catch(NullPointerException ex){
			 ex.printStackTrace();
			 System.out.println("出现了空指针");
		 }catch(ArrayIndexOutOfBoundsException ex){
			 ex.printStackTrace();
			 System.out.println("出现了数组越界");
		 }
		 System.out.println("over");
	}
	/*
	 * 定义方法, 出异常
	 * 添加参数,如果传递的是0,出空指针异常,传递的不是0,出数组越界异常
	 */
	public static void method(int x){
		if(x==0){
			//出现空指针异常
			String s = null;
			System.out.println(s.length());
		}else{
			int[] arr = {1};
			System.out.println(arr[3]);
		}
	}
}

java.lang.ArrayIndexOutOfBoundsException: 3
出现了数组越界
over
    at cn.itheima.exception.ExceptionDemo2.method(ExceptionDemo2.java:35)
    at cn.itheima.exception.ExceptionDemo2.main(ExceptionDemo2.java:14)
例子2：

package cn.itcast.exception;
/*
 * 多个catch的处理
 *   try{}
 *   catch(){}
 *   catch(){}
 *   抛出的异常类,具有继承关系的类
 *   继承关系中,越是父类,写在最下面的catch
 *   
 *   ArrayIndexOutOfBoundsException 数组 extends IndexOutOfBoundsException集合
 */
import java.util.*;
public class ExceptionDemo3 {
	public static void main(String[] args) {
	  try{	
		 method(0);
	  }
	  catch(ArrayIndexOutOfBoundsException  ex){
		  ex.printStackTrace();
		  System.out.println("数组越界异常");
	  }
	  catch(IndexOutOfBoundsException ex){
		  ex.printStackTrace();
		  System.out.println("集合越界");
	  }
	}
	/*
	 * 定义方法,根据参数传递抛出异常
	 *   参数传递是0,抛出集合越界异常
	 *   参数传递不是0.抛出数组越界异常
	 */
	public static void method(int x){
		if(x==0){
			ArrayList<String> array = new ArrayList<String>();
			System.out.println(array.get(10));
		}else{
			int[] arr = {1};
			System.out.println(arr[3]);
		}
	}
}

java.lang.IndexOutOfBoundsException: Index: 10, Size: 0
    at java.util.ArrayList.rangeCheck(ArrayList.java:635)
    at java.util.ArrayList.get(ArrayList.java:411)
    at cn.itcast.exception.ExceptionDemo3.method(ExceptionDemo3.java:35)
    at cn.itcast.exception.ExceptionDemo3.main(ExceptionDemo3.java:16)
集合越界
注：
    a、异常的平级，出现的异常类，之间没有继承关系；
    b、抛出的异常类具有继承关系，先抓子类。
2、throw ：在方法的内部使用，表明方法中会抛出异常，又叫手动抛出异常。
    a、try{
    }catch(Exception e){throw new Exception();}
    b、使用关键字throws暴露出异常，写在方法定义上，定义部分的最后，
        格式： throws 异常类类名 ；
例子：

package cn.itheima.exception;

/*
 * 异常的第二种处理方式, 抛出方式
 *   throw throws
 *   
 *   throw 使用方式,用于在方法的内部使用
 *   表明方法中,会抛出异常, 手动抛出异常
 *   throw 跟随异常对象
 *   
 *   方法method有异常,自己不处理,让调用者去处理这个异常
 *   在方法的声明上,暴露有异常,请调用者处理
 *   
 *   使用关键字throws 暴露出异常
 *   写在方法的定义上 ,定义部分的最后
 *   throws 异常类类名
 */
public class ExceptionDemo5 {
	public static void main(String[] args) throws Exception{
		
		//有异常,main不想处理,我的调用者处理
		method(15);
	}
	/*
	 * 传递月份,计算四季
	 */
	public static void method(int month)throws Exception{
		//对变量,判断以下
		if(month < 0 || month >12){
			//传递的参数不合法,后面不用计算,利用异常告诉调用者
			//手动抛出异常		
			throw new Exception("异常了");
		}
	}
}

Exception in thread "main" java.lang.Exception: 异常了
    at cn.itheima.exception.ExceptionDemo5.method(ExceptionDemo5.java:32)
    at cn.itheima.exception.ExceptionDemo5.main(ExceptionDemo5.java:22)
五、应用举例
1、

package cn.itheima.exception;
/* 
 *  定义方法,计算圆形的面积
 *    半径平方*圆周率
 */
public class ExceptionDemo7 {
	public static void main(String[] args) {
		double d = 0;
		d = getArea(-1);
		System.out.println(d);
		
	}
	//定义方法,传递半径,计算圆周率
	public static double getArea(double r){
		if(r <= 0)
			throw new RuntimeException("半径非法");
		return r*r*Math.PI;
	}

}

Exception in thread "main" java.lang.RuntimeException: 半径非法
    at cn.itheima.exception.ExceptionDemo7.getArea(ExceptionDemo7.java:16)
    at cn.itheima.exception.ExceptionDemo7.main(ExceptionDemo7.java:9)
2、

package cn.itheima.exception;

import cn.itheima.exception.ScoreException;
/*
 * 自定义异常类
 *   考试成绩 0-100之间
 *   JAVA规定好了很多异常,从来没有规定过0-100之间的异常
 *   
 * 定义异常2个步骤
 *   定义类,类名后缀Exception  继承 Exception 或者继承RuntimeException
 *     入伙   JAVA中只有异常类,才能抛
 *   异常类中,定义构造方法,将异常信息传递给父类即可
 *   
 *  实际开发中,自定义异常,大多数都是继承RuntimeException
 */

class ScoreException extends RuntimeException{
	 ScoreException(String message) {
		 super(message);
	}
}
public class ExceptionDemo8 {
	public static void main(String[] args) {
		 
		score(150);
	 
	}	
	public static void score(int s){
		if(s < 0 || s > 100)
			throw new ScoreException("成绩无效,超过范围");
	}
}

Exception in thread "main" cn.itheima.exception.ScoreException: 成绩无效,超过范围
    at cn.itheima.exception.ExceptionDemo8.score(ExceptionDemo8.java:30)
    at cn.itheima.exception.ExceptionDemo8.main(ExceptionDemo8.java:25)
3、finally

package cn.itheima.finally1;
/*
 *  finall代码块
 *    try{}
 *    catch(){}
 *    finally{
 *      代码,必须执行
 *    }
 *  finally作用,释放资源使用
 */
public class FinallyDemo2 {
	public static void main(String[] args) {
		try {
			method(0);
			System.out.println("+++++++++++");
		} catch (Exception e) {		
			System.out.println("----------"+e.toString());
			e.printStackTrace();
			System.out.println("----------");
			System.out.println("----------"+e.getMessage());
		}finally{
			System.out.println("finally 必须执行");
		}
		
	}
	public static void method(int x) throws Exception{
		if(x==0){
			throw new Exception("异常了！！！");
		}
	}
}

----------java.lang.Exception: 异常了！！！
java.lang.Exception: 异常了！！！
    at cn.itheima.finally1.FinallyDemo2.method(FinallyDemo2.java:28)
    at cn.itheima.finally1.FinallyDemo2.main(FinallyDemo2.java:14)
----------
----------异常了！！！
finally 必须执行

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------