小结1:
package day19_Exception;
/*
* 异常:程序出现了不正常的情况。
*
* 举例:今天天气很好, 班长出去旅游,骑着自行车,去山里面呼吸新鲜空气
* 问题1:山路塌陷了,班长即使停住了,但是过不去了。严重的问题
* 问题2:班长出门推自行车,发现没气了,把气吹起来。出发前就应该检查的问题
* 问题3:班长骑着车在山路上惬意的行驶着,山路两边是有小石子的,中间是平坦的水泥路。
* 一直在水泥路上行驶是没有任何问题的。但是呢?他偏偏喜欢骑到小石子上,结果爆胎了。
* no zuo no die
* 程序的异常:Throwable
* 严重问题:Error 我们不处理,这种问题一般都是很严重的问题,比如说:内存溢出
* 问题:Exception
* 编译期问题:不是RuntimeException异常 必须进行处理的。因为如果不处理,编译就不能通过。
* 运气期问题:RuntimeException 这种问题我们也不处理,因为是你的问题,而且这个问题出现肯定是代码不够严谨,需要修正代码
* 如果程序出现了问题,我们没有做任何处理,最终jvm会做默认的处理。
* 把异常的名称,原因及出现的问题等信息输出的在控制台。
* 同时会结束程序。
*
* 我们如何处理异常呢?
* A:try...catch...finally
* try...catch...finally处理格式:
* try{
* 可能出现问题的代码;
* }catch(异常名变量){
* 针对问题的处理;
* }finally{
* 释放资源;
* }
*
* 变形格式:
* try{
* 可能出现问题的代码;
* }catch(异常名变量){
* 针对问题的处理;
* }
* 注意:
* 1.try里面的代码越少越好。
* 2.catch必须有内容,哪怕是给出一个简单的提示
* A:一个异常
* B:二个异常
* a:每一个写一个try...catch...
* b:写一个try{
* ...
* }catch(异常类名 变量名){
* ...
* }
* ...
* 注意事项:
* 1:能明确的尽量明确,不要用大的来处理。Exception,一旦Exception(包含所有异常)在最前面,后面的catch异常均无效。
* 2:平级关系的异常,谁前谁后,无所谓。如果出现子父关系,父必须在后面。
* 3:
* B:throws 抛出异常
* 注意:
* 一旦try里面除了问题,就会在这里把问题给抛出去,
* 然后和catch里面的的问题进行匹配,一旦有匹配的,
* 就执行catch里面的处理,然后结束try...catch
* 继续执行后面的语句。
* JDK7出现了一个新的异常处理方案:
* try{
*
* }catch(异常1 | 异常2 |....变量){
* ....
* }
* 注意:这个方法虽然简洁,但是也不够好
* A:处理方式是一直的(实际开发中,好多时候可能就是针对同类型的问题,给出同一个处理)。
* B:多个异常间必须是平级关系。
* 编译时异常和运行时异常的区别
* 编译期异常:Java程序必须显示处理,否则程序就会发生错误,无法通过编译
* 运行期异常:无需显示处理,也可以和编译时异常一样处理
*
* */
public class ExceptionDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
// A:一个异常
// method1();
// B:两个异常
// method2();
// 多个异常
//method3();
//JDK7新特性
//method4();
}
public static void method4() {
// TODO Auto-generated method stub
int a = 10;
int b = 0;
int[] arr = { 1, 2, 3 };
//JDK7的处理方案
try {
System.out.println(a / b);
System.out.println(arr[3]);
}catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
// TODO: handle exception
System.out.println("出问题了。");
}
System.out.println("over");
}
// 多个异常
public static void method3() {
// TODO Auto-generated method stub
int a = 10;
int b = 0;
int[] arr = { 1, 2, 3 };
try {
System.out.println(a / b);
System.out.println(arr[3]);
} catch (ArithmeticException e) {
// TODO: handle exception
System.out.println("除数不能为0");
} catch (ArrayIndexOutOfBoundsException e) {
// TODO: handle exception
System.out.println("指针越界");
}
System.out.println("over");
}
// 两个异常
public static void method2() {
// TODO Auto-generated method stub
int a = 10;
int b = 0;
try {
System.out.println(a / b);
} catch (ArithmeticException e) {
// TODO: handle exception
System.out.println("除数不能为0");
}
int[] arr = { 1, 2, 3 };
try {
System.out.println(arr[3]);
} catch (ArrayIndexOutOfBoundsException e) {
// TODO: handle exception
System.out.println("指针越界");
}
System.out.println("over");
}
// 一个异常
private static void method1() {
// TODO Auto-generated method stub
// 第一阶段
int a = 10;
int b = 0;
try {
System.out.println(a / b);
} catch (ArithmeticException ae) {
// TODO: handle exception
System.out.println("除数不能为0");
}
// 第二阶段
System.out.println("over");
}
}
小结2:
package day19_Exception;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
* finally:finally控制的语句体一定会执行
* 注意:如果在执行到finally之前jvm退出了(比如System.exit(0)),就不能执行了。
*
* A:格式
* try{}catch(){}finally{}
* B:用于释放资源,在IO流操作和数据库操作中会见到
*
* 面试题:
* 1:final,finally和finalize的区别
* final:最终的意思,可以修饰类,成员变量,成员方法
* 修饰类,类不能被继承
* 修饰变量,变量是常量
* 修饰方法,方法不能被重写
* finally:是异常处理的一部本,用于释放资源
* 一般来说,代码肯定会执行,特殊情况:在执行到finally之前jvm退出了
* finalize:是Object类的一个方法,用于垃圾回收
*
* 2:如果catch里面有return语句,请问finally里面的代码还会执行吗?
* 如果会,请问是在return前,还是return后。
* 会,前。
*
* 准确的说,应该是在中间。
*
* 3:try...catch...finally的变形格式
* A:try...catch...finally
* B:try...catch
* C:try...catch...catch...
* D:try...finally
* 这种做法的目的就是为了释放资源
* */
public class FinallyDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
//面试题1:
// String s="2014-11-29";
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// Date d=null;
// try{
// d= sdf.parse(s);
// }catch (ParseException e) {
// // TODO: handle exception
// e.printStackTrace();
// //System.exit(0);//jvm虚拟机退出,后面操作都不执行了
// }finally {
// System.out.println("这里的代码是可以执行的");
// }
// System.out.println(d);
//面试题2:
System.out.println(getInt());
}
public static int getInt(){
int a=10;
try{
System.out.println(a/0);
a=20;
}catch (Exception e) {
// TODO: handle exception
a=30;
return a;
/*
* return a在程序知道到这一步的时候,这里不是return a 而是return 30;这个返回路径就形成了
* 但是呢,它发现后面还有finally,所以继续执行finally的内容,a=40
* 再次回到从其那的返回路径,继续走return 30
* */
}finally{
a=40;
//return a;//如果这样,结果就是40了
}
return a;
}
}
小结3:
package day19_Exception;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
* 在try里面发现问题后,jvm会帮我们生成一个异常对象,然后把这个对象跑出,和catch里面的类进行匹配
* 如果该对象时某个类型的,就会执行该catch里面的处理信息
*
* 异常中要了解的几个方法
* public String getMessage():异常的消息字符串
* public String toString():返回异常的简单信息描述
* 对象的类的name(全路径名)
* ": "(冒号和一个空格)
* 调用此对象getLocalizedMessage()方法的结果(默认返回的是getMessage()的内容)
* printStackTrace()获取异常类名和异常信息,以及异常出现在程序中的位置,返回值void。把信息输出在控制台
* pirntStackTrace(PrintStream s)通常用该方法将异常内容保存在日志文件中,以便查阅。
* */
public class ExceptionDemo2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
String s="2014-12-03";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
Date d = sdf.parse(s);//创建一个ParseException对象,然后抛出去,和catch里面进行匹配。
System.out.println(d);
} catch (ParseException e) {//ParseException e=new ParseException()
//ParseException
//e.printStackTrace();
//getMessage()
//System.out.println(e.getMessage());
//Unparseable date: "2014-12-03"
//toString()
//System.out.println(e.toString());
//java.text.ParseException: Unparseable date: "2014-12-03"
e.printStackTrace();
//跳转到某个指定的页面(index.html)
}
}
}
小结4:
package day19_Exception;
/*
* 有些时候,我们是可以对异常进行处理的,但是又有时候,我们根本就没有权限去处理某个异常
* 或者说,我处理不了,我就不处理了。
* 为了解决出错问题,Java针对这种情况,就提供了另一种处理方案:抛出。
*
* 格式:
* throws 异常类名
* 注意:这个格式必须跟在方法的括号后面
*
* 注意:尽量不要再main方法上抛出异常
* 小结:
* 编译期异常抛出,将来调用者必须处理
* 运行期异常抛出,将来调用者可以不用处理
* throw:如果出现了异常情况,我们可以把该异常抛出,这个时候抛出的应该是异常的对象。
*
* throws和throw的区别(面试题)
* throws
* 用在方法声明后面,跟的是异常类名
* 可以跟多个异常类名,用逗号隔开
* 表示抛出异常,由该方法的调用者来处理
* throws表示出现异常的一种可能性,并不一定会发生这些异常
* throw
* 用在方法体内,跟的是 异常对象名
* 只能抛出一个异常对象名
* 表示抛出异常,由方法体内的语句处理
* throw则是抛出了异常,执行throw则一定是抛出了某种异常
*
* 我们到底该如何处理异常呢
* 原则:
* 如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws
* 区别:
* 如果后续程序需要继续运行就try
* 后续程序不需要继续运行就throws ·
* */
public class ExceptionDemo4 {
public static void main(String[] args) {
// method();
try {
method2();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void method() {
// TODO Auto-generated method stub
int a = 10;
int b = 0;
if (b == 0) {
throw new ArithmeticException();
} else {
System.out.println(a / b);
}
}
public static void method2() throws Exception {
// TODO Auto-generated method stub
int a = 10;
int b = 0;
if (b == 0) {
throw new Exception();
} else {
System.out.println(a / b);
}
}
}