异常概述
String写成string不是异常,是错误。
Error
/*
* Error:
* Java虚拟机无法解决的严重问题。如:JVM系统内部错误、资源耗尽等严重情况。比如:StackOverflowError和OOM。
*
* 一般不编写针对性的代码进行处理。
*/
public class ErrorTest {
public static void main(String[] args) {
//1.栈溢出:java.lang.StackOverflowError
main(args);//它不断的调用自己,直到栈溢出
//2.堆溢出:java.lang.OutOfMemoryError
Integer[] arr = new Integer[1024*1024*1024];//1024*1024*1024太大了,堆里撑不开了。
}
}
Exception
编译时异常,
运行时异常
常见异常的举例
编译时异常 报红线
异常
package com.atguigu.java1;
import java.io.File;
import java.io.FileInputStream;
import java.util.Date;
import java.util.Scanner;
import org.junit.Test;
/*
* 一、异常体系结构
*
* java.lang.Throwable
* |-----java.lang.Error:一般不编写针对性的代码进行处理。
* |-----java.lang.Exception:可以进行异常的处理
* |------编译时异常(checked)
* |-----IOException输入或输出异常
* |-----FileNotFoundException文件不存在异常
* |-----ClassNotFoundException类找不到异常
* |------运行时异常(unchecked,RuntimeException)
* |-----NullPointerException空指针
* |-----ArrayIndexOutOfBoundsException数组越界
* |-----ClassCastException类转换异常
* |-----NumberFormatException数字转化异常
* |-----InputMismatchException 输入的类型错误
* |-----ArithmeticException算术运算异常
*
*
*
* 面试题:常见的异常都有哪些?举例说明↓
*/
public class ExceptionTest {
//******************以下是编译时异常***************************
@Test //编译异常不会生成字节码文件,可以执行javac命令 无误
public void test7(){
File file = new File("hello.txt");
FileInputStream fis = new FileInputStream(file);
int data = fis.read();//读一个字节
while(data != -1){//等于-1时就是到末尾了,就跳出了
System.out.print((char)data);
data = fis.read();
}
fis.close();//资源 fis流需要显式的关闭
}
//******************以下是运行时异常***************************
//ArithmeticException//数学运算错误
@Test
public void test6(){
int a = 10;
int b = 0;
System.out.println(a / b);//数学运算错误
}
//InputMismatchException//输入的类型错误
@Test
public void test5(){
Scanner scanner = new Scanner(System.in);
int score = scanner.nextInt();//输入78等数组类型没事,输入abc报错
System.out.println(score);
scanner.close();
}
//NumberFormatException//数据转换错误
@Test
public void test4(){
String str = "123";
str = "abc";
int num = Integer.parseInt(str);//转化为数字(这里字母不能转化为数字,数据转化错误)
}
//ClassCastException//类型转换异常
@Test
public void test3(){
Object obj = new Date();//先向上转型
String str = (String)obj;//再向下转型
}
//IndexOutOfBoundsException//越界异常
@Test
public void test2(){
//ArrayIndexOutOfBoundsException//数组越界
int[] arr = new int[10];
System.out.println(arr[10]);//数组越界
//StringIndexOutOfBoundsException//字符串越界
String str = "abc";
System.out.println(str.charAt(3));//字符串越界
}
//NullPointerException//空指针异常
@Test
public void test1(){
//空指针异常
int[] arr = null;
System.out.println(arr[3]);
String str = "abc";
str = null;//空指针异常
System.out.println(str.charAt(0));
}
}
异常处理方式概论
try-catch方式
6、在try结构中声明的变量,再出了try结构以后,就不能再被调用(改进见下面代码↓)
代码:
package com.atguigu.java1;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import org.junit.Test;
/*
* 一、异常的处理:抓抛模型
*
* 过程一:"抛":程序在正常执行的过程中,一旦出现异常,就会在异常代码处生成一个对应异常类的对象。
* 并将此对象抛出。
* 一旦抛出对象以后,其后的代码就不再执行。
*
* 关于异常对象的产生:① 系统自动生成的异常对象
* ② 手动的生成一个异常对象,并抛出(throw)
*
* 过程二:"抓":可以理解为异常的处理方式:① try-catch-finally ② throws
*
*
* 二、try-catch-finally的使用
*
* try{
* //可能 出现异常的代码
*
* }catch(异常类型1 变量名1){
* //处理异常的方式1
* }catch(异常类型2 变量名2){
* //处理异常的方式2
* }catch(异常类型3 变量名3){
* //处理异常的方式3
* }
* ....
* finally{
* //一定会执行的代码
* }
*
* 说明:
* 1. finally是可选的。
* 2. 使用try将可能出现异常代码包装起来,在执行过程中,一旦出现异常,就会生成一个对应异常类的对象,根据此对象
* 的类型,去catch中进行匹配
* 3. 一旦try中的异常对象匹配到某一个catch时,就进入catch中进行异常的处理。一旦处理完成,就跳出当前的
* try-catch结构(在没有写finally的情况)。继续执行其后的代码
* 4. catch中的异常类型如果没有子父类关系,则谁声明在上,谁声明在下无所谓。
* catch中的异常类型如果满足子父类关系,则要求子类一定声明在父类的上面。否则,报错
* 5. 常用的异常对象处理的方式: ① getMessage() 返回String类型的值 ② printStackTrace()
* 6. 在try结构中声明的变量,再出了try结构以后,就不能再被调用
* 7. try-catch-finally结构可以嵌套
*
* 体会1:使用try-catch-finally处理编译时异常,是得程序在编译时就不再报错,但是运行时仍可能报错。
* 相当于我们使用try-catch-finally将一个编译时可能出现的异常,延迟到运行时出现。
*
* 体会2:开发中,由于运行时异常比较常见,所以我们通常就不针对运行时异常编写try-catch-finally了。(因为就算是写异常,也是报出一堆异常,和不写异常区别没啥)
* 针对于编译时异常,我们说一定要考虑异常的处理。
*/
public class ExceptionTest1 {
//体会1:使用try-catch-finally处理编译时异常,是得程序在编译时就不再报错,但是运行时仍可能报错。
// 相当于我们使用try-catch-finally将一个编译时可能出现的异常,延迟到运行时出现。
@Test
public void test2(){
try{
File file = new File("hello.txt");
FileInputStream fis = new FileInputStream(file);
int data = fis.read();
while(data != -1){
System.out.print((char)data);
data = fis.read();
}
fis.close();
}catch(FileNotFoundException e){//如果真没hello.txt文件,还是会报异常。
e.printStackTrace();
}catch(IOException e){
e.printStackTrace();
}
}
@Test
public void test1(){//运行时异常
String str = "123";
str = "abc";
int num = 0;
try{
num = Integer.parseInt(str);
System.out.println("hello-----1");
}catch(NumberFormatException e){
// System.out.println("出现数值转换异常了,不要着急....");
//getMessage() 异常处理方式1:返回String类型的
System.out.println(e.getMessage());//获取异常信息
//printStackTrace() 异常处理方法2:打印整个堆栈的信息了
e.printStackTrace();
}catch(NullPointerException e){
System.out.println("出现空指针异常了,不要着急....");
}catch(Exception e){
System.out.println("出现异常了,不要着急....");
}
System.out.println(num);
System.out.println("hello-----2");
}
}
finally
public void test2()
如果fis = new FileInputStream(file);过了,那这个流就打开了,碰到int data = fis.read();出现异常,直接跳过fis.close();去catch (IOException e)那处理异常了,导致这个流没关,这是问题所在。解决方法在下面代码test2中。
package com.atguigu.java1;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import org.junit.Test;
/*
* try-catch-finally中finally的使用:
*
*
* 1.finally是可选的
*
* 2.finally中声明的是一定会被执行的代码。即使catch中又出现异常了,try中有return语句,catch中有
* return语句等情况。
*
* 3.像数据库连接、输入输出流、网络编程Socket等资源,JVM是不能自动的回收的,我们需要自己手动的进行资源的
* 释放。此时的资源释放,就需要声明在finally中。
*
*/
public class FinallyTest {
@Test
public void test2(){
FileInputStream fis = null;//声明放在外面,防止finally那的fis.close();说没有定义
try {
File file = new File("hello1.txt");
fis = new FileInputStream(file);//try声明了,现在是给fis赋值
int data = fis.read();
while(data != -1){
System.out.print((char)data);
data = fis.read();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
if(fis != null)//如果资源都没创建成功,那么都没new成功,就不需要关闭流
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Test
public void testMethod(){
int num = method();
System.out.println(num);
//输出
//我一定会被执行
//3(下面没加return 3时是返回2,加了return 3后返回3,return 3抢断了return 2)
}
public int method(){//此方法要求返回值是int型
try{
int[] arr = new int[10];
System.out.println(arr[10]);//异常,
// 执行catch(ArrayIndexOutOfBoundsException e)的语句,
// 输出堆栈异常信息,返回2,并执行finally的语句,
return 1;
}catch(ArrayIndexOutOfBoundsException e){
e.printStackTrace();
return 2;
}finally{
System.out.println("我一定会被执行");
return 3;//(没加return 3时是返回2,加了return 3后返回3,return 3抢断了return 2)
}
}
@Test
public void test1(){
try{
int a = 10;
int b = 0;
System.out.println(a / b);//异常
}catch(ArithmeticException e){
e.printStackTrace();
//下面两条语句会出异常,会跳出程序,但是仍然会执行finally中的我好帅啊,
//我好帅啊!!!~~"(被注释的)则不会执行
int[] arr = new int[10];
System.out.println(arr[10]);
}catch(Exception e){
e.printStackTrace();
}
//这个其实也能一直都执行(如果没有return的话)↓
// System.out.println("我好帅啊!!!~~");
finally{
System.out.println("我好帅啊~~");
}
}
}
throws方式
package com.atguigu.java1;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
* 异常处理的方式二:throws + 异常类型
*
* 1. "throws + 异常类型"写在方法的声明处。指明此方法执行时,可能会抛出的异常类型。
* 一旦当方法体执行时,出现异常,仍会在异常代码处生成一个异常类的对象,此对象满足throws后异常
* 类型时,就会被抛出。异常代码后续的代码,就不再执行!
*
* 2. 体会:try-catch-finally:真正的将异常给处理掉了。
* throws的方式只是将异常抛给了方法的调用者。调用者还能往上抛, 并没有真正将异常处理掉。
*
* 3. 开发中如何选择使用try-catch-finally 还是使用throws?(这个问题在本章后边有介绍)
* 3.1 如果父类中被重写的方法没有throws方式处理异常,则子类重写的方法也不能使用throws,意味着如果
* 子类重写的方法中有异常,必须使用try-catch-finally方式处理。
* 3.2 执行的方法a中,先后又调用了另外的几个方法,这几个方法是递进关系执行的。我们建议这几个方法使用throws
* 的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。
*
*/
public class ExceptionTest2 {
//统一解决是可以节省很多代码的,遇到一个当场解决,那代码量太大了,所以可以往上抛
public static void main(String[] args){
try{
method2();//method2中异常抛回来,在下面的catch(IOException e)就解决了
}catch(IOException e){
e.printStackTrace();
}
method3();//method3中要是有异常在method3方法中就解决了,
// 因此不需要在main()方法中提供解决办法。
}
//throws只是往上抛,并不解决问题,抛到main方法就必须要解决了,
// try-catch才能解决异常
public static void method3(){
try {
method2();//method2()往上抛,抛到method3这了
} catch (IOException e) {
e.printStackTrace();
}
}
public static void method2() throws IOException{
method1();//method1()往上抛,抛到method2这了
}
public static void method1() throws FileNotFoundException,IOException{//throws后边是异常类型
//以编译时异常举例
File file = new File("hello1.txt");
FileInputStream fis = new FileInputStream(file);
int data = fis.read();
while(data != -1){
System.out.print((char)data);
data = fis.read();
}
fis.close();
System.out.println("hahaha!");
}
}
重写方法异常抛出的规则
package com.atguigu.java1;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
* 方法重写的规则之一:
* 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
* //可知,如果父类没有抛异常,子类绝对不能抛异常。
*
*/
public class OverrideTest {
public static void main(String[] args) {
OverrideTest test = new OverrideTest();
test.display(new SubClass());//通过test调用display
}
public void display(SuperClass s){//多态SuperClass s=new SubClass()
try {
s.method();//调用的子类SubClass的重写方法
} catch (IOException e) {//如果此时子类抛出异常,父类那个异常处理应该能罩得住子类抛出的异常。
// 如果父类的异常罩不住子类的异常,那么异常就无法处理了。
//可知,如果父类没有抛异常,子类绝对不能抛异常。
e.printStackTrace();
}
}
}
//父类
class SuperClass{
public void method() throws IOException{
//父类抛出异常IOException
}
}
//子类
class SubClass extends SuperClass{
public void method()throws FileNotFoundException{
//子类抛出异常FileNotFoundException小于等于父类异常
}
}
开发中如何选择哪种方式处理异常
3、 开发中如何选择使用try-catch-finally 还是使用throws?
3.1 如果父类中被重写的方法没有throws方式处理异常,则子类重写的方法也不能使用throws,意味着如果子类重写的方法中有异常,必须使用try-catch-finally方式处理。
3.2 执行的方法a中,先后又调用了另外的几个方法,这几个方法是递进关系(第一个方法执行得出的结果作为参数给第二个方法用,第二个方法执行得出的结果作为参数给第三个方法用,即为递进方法(递进关系))执行的。我们建议这几个方法使用throws的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。(假设递进方法是方法1,2,3,如果方法1异常了,经过try-catch处理后,接着执行方法2,3,最后返回方法a的值可能都不能用了;或者方法1异常了,经过try-catch处理后,往下执行不动了,卡住了,返回不了了。所以不让他们用try-catch,而是用throws进行处理。)
一点理解:
如果没写异常处理,可能就展现一顿乱码;写了异常处理就很友好了,可能会说“开发人员忙碌中,请稍后!!”。处理异常也没解决问题,只是更友好了些。
手动抛出异常对象
在过程"抛"中:程序在正常执行的过程中,一旦出现异常,就会在异常代码处生成一个对应异常类的对象。
关于异常对象的产生:
① 系统自动生成的异常对象
② 手动的生成一个异常对象,并抛出(throw)
throw new RuntimeException(“您输入的数据非法!”);
//RuntimeException带形参的构造器RuntimeException(String message)
throw new Exception(“您输入的数据非法!”);
//Exception包括编译时异常和运行时异常,必须显式处理异常,
throw生成一个异常对象,通过 throws来异常处理
在主函数中如下处理。
结果:
附参考代码:
package com.atguigu.java2;
public class StudentTest {
public static void main(String[] args) {
try {
Student s = new Student();
s.regist(-1001);
System.out.println(s);
} catch (Exception e) {
// e.printStackTrace();
System.out.println(e.getMessage());
//getMessage输出的是throw new Exception("您输入的数据非法!");中的“您输入的数据非法!”
}
}
}
class Student{
private int id;
public void regist(int id) throws Exception {
if(id > 0){
this.id = id;
}else{
//手动抛出异常对象
throw new RuntimeException("您输入的数据非法!");
//↑RuntimeException带形参的构造器RuntimeException(String message)
//抛的异常是RuntimeException,运行时异常,所以在主方法中也可以不处理
throw new Exception("您输入的数据非法!");
//Exception包括编译时异常和运行时异常,必须处理异常,通过在
// 方法public void regist(int id)后加 throws Exception处理
throw new MyException("不能输入负数");//MyException是继承的RuntimeException(运
// 行时异常类)的,所以可以把public void regist(int id) 后的throws Exception去掉
//错误的
// throw new String("不能输入负数");
// String没有继承于异常,不是一个异常类,
// String父类是Object类,只能抛一个异常类的对象
}
}
@Override
public String toString() {
return "Student [id=" + id + "]";
}
}
如何自定义异常
MyException,java
package com.atguigu.java2;
/*
* 如何自定义异常类?
* 1. 继承于现有的异常结构:RuntimeException 、Exception
* 2. 提供全局常量:serialVersionUID
* 3. 提供重载的构造器
*
*/
//MyException是自定义异常类
public class MyException extends Exception{
//可查看Exception源码。
//serialVersionUID可唯一标识MyException这个类,这个数随便写一个可
static final long serialVersionUID = -7034897193246939L;
//构造器
public MyException(){
}
//含参构造器
public MyException(String message){
super(message);
}
}
StudentTest.java
结果:
异常的练习题
第一题
1、第一部分:
执行顺序:
结果:
2、第二部分
执行顺序
结果:
附参考代码:
package com.atguigu.java2;
public class ReturnExceptionDemo {
static void methodA() {
try {
System.out.println("进入方法A");
throw new RuntimeException("制造异常");
} finally {
System.out.println("用A方法的finally");
}
}
static void methodB() {
try {
System.out.println("进入方法B");
return;
} finally {
System.out.println("调用B方法的finally");
}
}
public static void main(String[] args) {
try {
methodA();
} catch (Exception e) {
System.out.println(e.getMessage());
}
methodB();
}
}
第二题大练习
题目
EcDef.java
package com.atguigu.exer;
//自定义异常类
public class EcDef extends Exception {
static final long serialVersionUID = -33875164229948L;
public EcDef() {
}
public EcDef(String message) {
super(message);
}
}
EcmDef.java
package com.atguigu.exer;
/*
* 编写应用程序EcmDef.java,接收命令行的两个参数,要求不能输入负数,计算两数相除。
对数据类型不一致(NumberFormatException)、缺少命令行参数(ArrayIndexOutOfBoundsException、
除0(ArithmeticException)及输入负数(EcDef 自定义的异常)进行异常处理。
提示:
(1)在主类(EcmDef)中定义异常方法(ecm)完成两数相除功能。
(2)在main()方法中使用异常处理语句进行异常处理。
(3)在程序中,自定义对应输入负数的异常类(EcDef)。
(4)运行时接受参数 java EcmDef 20 10 //args[0]=“20” args[1]=“10”
(5)Interger类的static方法parseInt(String s)将s转换成对应的int值。
如:int a=Interger.parseInt(“314”); //a=314;
*/
public class EcmDef {
public static void main(String[] args) {
try{
int i = Integer.parseInt(args[0]);
int j = Integer.parseInt(args[1]);
int result = ecm(i,j);
System.out.println(result);
}catch(NumberFormatException e){
System.out.println("数据类型不一致");
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("缺少命令行参数");
}catch(ArithmeticException e){
System.out.println("除0");
}catch(EcDef e){
System.out.println(e.getMessage());
}
}
public static int ecm(int i,int j) throws EcDef{
if(i < 0 || j < 0){
throw new EcDef("分子或分母为负数了!");
//throw 出一个异常对象,由throws EcDef做异常的处理
}
return i / j;
}
}
一点总结
throws 是 捕获,是异常处理的一种方式。
throw 是手动抛出一个异常对象,生成一个异常对象。
上游排污(throw),下游治污(throws),当然throws 的处理方式是往上报,并没有真正把水变清澈。