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

原创 2015年07月08日 22:05:20

-----------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学习型技术博客、期待与您交流!------------



相关文章推荐

黑马程序员——java基础----面向对象(四) 异常处理

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------- 异常处理 1,什么是异常:            异常就是程序中出现的问题或者是非正常的情况。 ...

黑马程序员——JAVA基础之异常处理机制

------- android培训、java培训、期待与您交流! ----------      异常     异常的体系 •  Throwable                  ...

黑马程序员——java基础--多态、内部类、异常、包

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流----- 一、多态 1、概述   什么是多态?某一事物在不同时刻表现出来的不同状态。 如:猫可以是猫的类型。...

黑马程序员——Java基础:异常处理机制

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——- 1 异常 异常:是指程序在运行时出现的不正常情况。因为问题的产生有有问题的名称、有问题的描述、产生的原因、问...

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

 面向对象——异常 Java是面向对象的语言,当然也对异常包装成了对象(Throwable),方便了我们的使用 异常:就是程序在运行时出现不正常情况。 异常由来: ...

黑马程序员——Java基础(八)之异常处理、递归、IO流

-----------android培训、java培训、java学习型技术博客、期待与您交流!------------ 程序出现了不正常的情况称为异常,Throwable类是Java中所有错误或异常的...

黑马程序员——Java基础---多态、内部类、异常、包

第一讲     多态         多态可以理解为事物存在的多种体现形态。         例:动物中猫,狗。猫这个对象对应的类型是猫类型,如:猫 x = new猫(); 同时猫也是动物...

黑马程序员——Java基础--多态、内部类、异常

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------- 多态、内部类、异常 一、多态 1、多态:可以理解为事物存在的多种体现形态。 例:动物...

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

-----------android培训、java培训、java学习型技术博客、期待与您交流!------------    异常 程序在运行过程中所出现的问题,我们统一称为异常 (不正常)...
  • e_gulu
  • e_gulu
  • 2015年08月06日 01:15
  • 233

黑马程序员——Java基础---异常,IO流,File类

-----------android培训、java培训、java学习型技术博客、期待与您交流!------------ 一、异常 (一)异常概述 1. 异常:异常就是Java程序在运行过程中...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:黑马程序员——Java基础--异常
举报原因:
原因补充:

(最多只允许输入30个字)