异常是程序在“编译”或者“执行”的过程中可能出现的问题,比如:数组索引越界、空指针异常、 日期格式化异常,等…
注意: 语法错误不算在异常体系中。
为什么要学习异常?异常一旦出现了,如果没有提前处理,程序就会退出JVM虚拟机而终止,研究异常并且避免异常,然后提前处理异常,体现的是程序的安全, 健壮性。
异常体系Error
系统级别问题、JVM退出等,代码无法控制。
Exception
java.lang包下,称为异常类,它表示程序本身可以处理的问题;
RuntimeException及其子类
运行时异常,编译阶段不会报错。 (空指针异常,数组索引越界异常)
除RuntimeException之外所有的异常
编译时异常,编译期必须处理的,否则程序不能通过编译。 (日期格式化异常)。
编译时异常和运行时异常
什么是异常?
异常是程序在"编译"或者"执行"的过程中可能出现的问题。
异常是应该尽量提前避免的。
异常可能也是无法做到绝对避免的,异常可能有太多情况了,开发中只能提前干预!!
异常一旦出现了,如果没有提前处理,程序就会退出JVM虚拟机而终止,开发中异常是需要提前处理的。
研究异常并且避免异常,然后提前处理异常,体现的是程序的安全, 健壮性!!!
Java会为常见的代码异常都设计一个类来代表。
异常的体系:
Java中异常继承的根类是:Throwable。
Throwable(根类,不是异常类)
/
Error Exception(异常,需要研究和处理)
/
编译时异常 RuntimeException(运行时异常)
Error : 错误的意思,严重错误Error,无法通过处理的错误,一旦出现,程序员无能为力了,
只能重启系统,优化项目。
比如内存奔溃,JVM本身的奔溃。这个程序员无需理会。
Exception:才是异常类,它才是开发中代码在编译或者执行的过程中可能出现的错误,
它是需要提前处理的。以便程序更健壮!
Exception异常的分类:
1.编译时异常:继承自Exception的异常或者其子类,编译阶段就会报错,
必须程序员处理的。否则代码编译就不能通过!!
2.运行时异常: 继承自RuntimeException的异常或者其子类,编译阶段是不会出错的,它是在
运行时阶段可能出现,运行时异常可以处理也可以不处理,编译阶段是不会出错的,
但是运行阶段可能出现,还是建议提前处理!!
小结:
异常是程序在编译或者运行的过程中可能出现的错误!!
异常分为2类:编译时异常,运行时异常。
-- 编译时异常:继承了Exception,编译阶段就报错,必须处理,否则代码不通过。
-- 运行时异常:继承了RuntimeException,编译阶段不会报错,运行时才可能出现。
异常一旦真的出现,程序会终止,所以要研究异常,避免异常,处理异常,程序更健壮!!
常见运行时异常
直接继承自RuntimeException或者其子类,编译阶段不会报错,运行时可能出现的错误。
运行时异常示例
public class ExceptionDemo {
public static void main(String[] args) {
System.out.println("程序开始。。。。。。");
int[] arr = {1, 2, 3};
System.out.println(arr[2]);
// System.out.println(arr[3]); // 运行出错,程序终止
String name = null;
System.out.println(name); // null
// System.out.println(name.length()); // 运行出错,程序终止
Object o = 23;
// String s = (String) o; // 运行出错,程序终止
//int c = 10 / 0;
//String number = "23";
String number = "23aabbc";
Integer it = Integer.valueOf(number); // 运行出错,程序终止
System.out.println(it + 1);
System.out.println("程序结束。。。。。");
}
}
常见编译时异常
不是RuntimeException或者其子类的异常,编译阶就报错,必须处理,否则代码不通过。
编译时异常
继承自Exception的异常或者其子类,编译阶段报错,必须处理,否则代码不通过。
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ExceptionDemo {
public static void main(String[] args) throws ParseException {
String date = "2015-01-12 10:23:21";
// 创建一个简单日期格式化类:
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
// 解析字符串时间成为日期对象
Date d = sdf.parse(date);
//
System.out.println(d);
}
}
2.异常的默认处理流程
1.默认会在出现异常的代码那里自动的创建一个异常对象:ArithmeticException;
2.异常会从方法中出现的点这里抛出给调用者,调用者最终抛出给JVM虚拟机;
3.虚拟机接收到异常对象后,先在控制台直接输出异常栈信息数据;
4.直接从当前执行的异常点干掉当前程序;
5.后续代码没有机会执行了,因为程序已经结束。
小结:
异常一旦出现,会自动创建异常对象,最终抛出给虚拟机,虚拟机,只要收到异常,就直接输出异常信息,干掉程序。
默认的异常处理机制并不好,一旦真的出现异常,程序立即结束。
public class ExceptionDemo {
public static void main(String[] args) {
System.out.println("程序开始。。。。。。。。。。");
chu(10, 0);
System.out.println("程序结束。。。。。。。。。。");
}
public static void chu(int a , int b){
System.out.println(a);
System.out.println(b);
int c = a / b;
System.out.println(c);
}
}
3.编译时异常的处理机制
编译时异常是编译阶段就出错的,所以必须处理,否则代码根本无法通过。
编译时异常的三种处理形式1.出现异常直接抛出去给调用者,调用者也继续抛出去;
2.出现异常自己捕获处理;
3.前两者结合,出现异常直接抛出去给调用者,调用者捕获处理;
throws:
用在方法上,可以将方法内部出现的异常抛出去给本方法的调用者处理。
这种方式并不好,发生异常的方法自己不处理异常,如果异常最终抛出去给虚拟机将引起程序结束。
抛出异常格式
方法 throws 异常1 ,异常2 ,异常3 ..{
//方法体
}
//Exception代表可以抛出一切异常。
方法 throws Exception{
}
代码示例
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ExceptionDemo01 {
// public static void main(String[] args) throws ParseException, FileNotFoundException {
// System.out.println("程序开始。。。。。");
// parseTime("2011-11-11 11:11:11");
// System.out.println("程序结束。。。。。");
// }
//
// public static void parseTime(String date) throws ParseException, FileNotFoundException {
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
// Date d = sdf.parse(date);
// System.out.println(d);
//
// InputStream is = new FileInputStream("E:/meinv.jpg");
// }
public static void main(String[] args) throws Exception {
System.out.println("程序开始。。。。。");
parseTime("2011-11-11 11:11:11");
System.out.println("程序结束。。。。。");
}
public static void parseTime(String date) throws Exception {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d = sdf.parse(date);
System.out.println(d);
InputStream is = new FileInputStream("E:/meinv.jpg"); //多个异常遇到其中一个就结束了
}
}
异常处理方式2 —— try…catch…
监视捕获异常,用在方法内部,可以将方法内部出现的异常直接捕获处理,发生异常的方法自己独立完成异常的处理,程序可以继续往下执行。
语法格式
try{
// 监视可能出现异常的代码!
}catch(异常类型1 变量){
// 处理异常
}catch(异常类型2 变量){
// 处理异常
}...
//建议格式
try{
// 可能出现异常的代码!
}catch (Exception e){
e.printStackTrace(); // 直接打印异常栈信息
}
//Exception可以捕获处理一切异常类型!
代码示例
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ExceptionDemo02 {
public static void main(String[] args) {
System.out.println("程序开始。。。。");
parseTime("2011-11-11 11:11:11");
System.out.println("程序结束。。。。");
}
public static void parseTime(String date) {
try {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
Date d = sdf.parse(date);
System.out.println(d);
InputStream is = new FileInputStream("E:/meinv.jpg");
} catch (Exception e) {
e.printStackTrace(); // 打印异常栈信息
}
}
// public static void parseTime(String date) {
// try {
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
// Date d = sdf.parse(date);
// System.out.println(d);
//
// InputStream is = new FileInputStream("E:/meinv.jpg");
// } catch (FileNotFoundException|ParseException e) {
// e.printStackTrace(); // 打印异常栈信息
// }
// }
// public static void parseTime(String date) {
// try {
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
// Date d = sdf.parse(date);
// System.out.println(d);
//
// InputStream is = new FileInputStream("E:/meinv.jpg");
// } catch (FileNotFoundException e) {
// e.printStackTrace(); // 打印异常栈信息
// } catch (ParseException e) {
// e.printStackTrace();
// }
// }
// public static void parseTime(String date) {
// try {
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
// Date d = sdf.parse(date);
// System.out.println(d);
// } catch (ParseException e) {
// // 解析出现问题
// System.out.println("出现了解析时间异常哦,走点心!!");
// }
//
// try {
// InputStream is = new FileInputStream("E:/meinv.jpg");
// } catch (FileNotFoundException e) {
// System.out.println("您的文件根本就没有啊,不要骗我哦!!");
// }
// }
}
异常处理方式3
1.方法直接将异通过throws抛出去给调用者;
2.调用者收到异常后直接捕获处理;
在开发中按照规范来说第三种方式是最好的:底层的异常抛出去给最外层,最外层集中捕获处理。
实际应用中,只要代码能够编译通过,并且功能能完成,那么每一种异常处理方式似乎也都是可以的。
代码示例
import java.io.FileInputStream;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ExceptionDemo03 {
public static void main(String[] args) {
System.out.println("程序开始。。。。");
try {
parseTime("2011-11-11 11:11:11");
System.out.println("功能操作成功~~~");
} catch (Exception e) {
e.printStackTrace();
System.out.println("功能操作失败~~~");
}
System.out.println("程序结束。。。。");
}
public static void parseTime(String date) throws Exception {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy、MM-dd HH:mm:ss");
Date d = sdf.parse(date);
System.out.println(d);
InputStream is = new FileInputStream("D:/meinv.jpg");
}
}
4.运行时异常的处理机制
运行时异常编译阶段不会出错,是运行时才可能出错的,所以编译阶段不处理也可以。
建议在最外层调用处集中捕获处理即可。
代码示例
public class Test {
public static void main(String[] args) {
System.out.println("程序开始。。。。。。。。。。");
try {
chu(10, 0);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("程序结束。。。。。。。。。。");
}
public static void chu(int a , int b) { // throws RuntimeException{
System.out.println(a);
System.out.println(b);
int c = a / b;
System.out.println(c);
}
}
5.自定义异常
自定义异常的必要
1.Java无法为这个世界上全部的问题提供异常类;
2.如果企业想通过异常的方式来管理自己的某个业务问题,就需要自定义异常类了;
自定义异常的好处
1.可以使用异常的机制管理业务问题,如提醒程序员注意;
2.同时一旦出现bug,可以用异常的形式清晰的指出出错的地方;
1.定义一个异常类继承Exception;
2.重写构造器;
3.在出现异常的地方用throw new 自定义对象抛出;
作用
编译时异常是编译阶段就报错,提醒更加强烈,一定需要处理。
1.定义一个异常类继承RuntimeException;
2.重写构造器;
3.在出现异常的地方用throw new 自定义对象抛出;
作用
提醒不强烈,编译阶段不报错!!运行时才可能出现。
ExceptionDemo.java
public class ExceptionDemo {
public static void main(String[] args) {
// try {
// checkAge(-34);
// } catch (ItheimaAgeIlleagalException e) {
// e.printStackTrace();
// }
try {
checkAge2(-23);
} catch (Exception e) {
e.printStackTrace();
}
}
public static void checkAge2(int age) {
if(age < 0 || age > 200){
// 抛出去一个异常对象给调用者
// throw :在方法内部直接创建一个异常对象,并从此点抛出
// throws : 用在方法申明上的,抛出方法内部的异常
throw new ItheimaAgeIlleagalRuntimeException(age + " is illeagal!");
}else {
System.out.println("年龄合法:推荐商品给其购买~~");
}
}
public static void checkAge(int age) throws ItheimaAgeIlleagalException {
if(age < 0 || age > 200){
// 抛出去一个异常对象给调用者
// throw :在方法内部直接创建一个异常对象,并从此点抛出
// throws : 用在方法申明上的,抛出方法内部的异常
throw new ItheimaAgeIlleagalException(age + " is illeagal!");
}else {
System.out.println("年龄合法:推荐商品给其购买~~");
}
}
}
ItheimaAgeIlleagalException.java
public class ItheimaAgeIlleagalException extends Exception{
public ItheimaAgeIlleagalException() {
}
public ItheimaAgeIlleagalException(String message) {
super(message);
}
}
ItheimaAgeIlleagalRuntimeException.java
public class ItheimaAgeIlleagalRuntimeException extends RuntimeException{
public ItheimaAgeIlleagalRuntimeException() {
}
public ItheimaAgeIlleagalRuntimeException(String message) {
super(message);
}
}



