1.1 什么是异常

异常定义：导致程序的正常流程被中断的事件，叫做异常。

文件不存在异常

比如要打开d盘的LOL.exe文件，这个文件是有可能不存在的。

Java中通过 new FileInputStream(f) 试图打开某文件，就有可能抛出 文件不存在异常FileNotFoundException。如果不处理该异常，就会有编译错误。如下代码：


package exception
;

  


import java
.io
.File
;


import java
.io
.FileInputStream
;

  


public 
class 
TestException 
{

    
public 
static 
void 
main
(
String
[
] args
) 
{

          

        File f
= 
new 
File
(
"d:/LOL.exe"
)
;

        
//试图打开文件LOL.exe，会抛出FileNotFoundException，如果不处理该异常，就会有编译错误

        
new 
FileInputStream
(f
)
;  

    
}


}

1.2 异常处理

异常处理常见手段： try catch finally throws

try catch

将可能抛出FileNotFoundException 文件不存在异常的代码放在try里
如果文件存在，就会顺序往下执行，并且不执行catch块中的代码
如果文件不存在，try 里的代码会立即终止，程序流程会运行到对应的catch块中
e.printStackTrace(); 会打印出方法的调用痕迹，如此例，会打印出异常开始于TestException的第16行，这样就便于定位和分析到底哪里出了异常


package com
.company
;




import java
.io
.File
;


import java
.io
.FileInputStream
;


import java
.io
.FileNotFoundException
;




public 
class 
Main 
{



    
public 
static 
void 
main
(
String
[
] args
) 
{

     File f 
= 
new 
File
(
"d:/LOL.exe"
)
;



        
try
{

            System
.out
.
println
(
"试图打开 d:/LOL.exe"
)
;

            
new 
FileInputStream
(f
)
;

            System
.out
.
println
(
"成功打开"
)
;

        
}

        
catch 
(FileNotFoundException e
)
{

            System
.out
.
println
(
"d:/LOL.exe不存在"
)
;

            e
.
printStackTrace
(
)
;

        
}

    
}


}

可以正常运行完成：

使用异常的父类进行catch

FileNotFoundException是Exception的子类，使用Exception也可以catch住FileNotFoundException。

ackage exception
;

  


import java
.io
.File
;


import java
.io
.FileInputStream
;


import java
.io
.FileNotFoundException
;

  


public 
class 
TestException 
{

    
public 
static 
void 
main
(
String
[
] args
) 
{

          

        File f
= 
new 
File
(
"d:/LOL.exe"
)
;

        
try
{

            System
.out
.
println
(
"试图打开 d:/LOL.exe"
)
;

            
new 
FileInputStream
(f
)
;

            System
.out
.
println
(
"成功打开"
)
;

        
}

        
catch
(Exception e
)
{

            System
.out
.
println
(
"d:/LOL.exe不存在"
)
;

            e
.
printStackTrace
(
)
;

        
}

    
}


}

多异常捕捉办法1

有的时候一段代码会抛出多种异常，比如:


new 
FileInputStream
(f
)
;

Date d 
= sdf
.
parse
(
"2016-06-03"
)
;

这段代码，会抛出文件不存在异常 FileNotFoundException 和解析异常ParseException 解决办法之一是分别进行catch


package exception
;

 


import java
.io
.File
;


import java
.io
.FileInputStream
;


import java
.io
.FileNotFoundException
;


import java
.text
.ParseException
;


import java
.text
.SimpleDateFormat
;


import java
.util
.Date
;

 


public 
class 
TestException 
{

 

    
public 
static 
void 
main
(
String
[
] args
) 
{

 

        File f 
= 
new 
File
(
"d:/LOL.exe"
)
;

 

        
try 
{

            System
.out
.
println
(
"试图打开 d:/LOL.exe"
)
;

            
new 
FileInputStream
(f
)
;

            System
.out
.
println
(
"成功打开"
)
;

            SimpleDateFormat sdf 
= 
new 
SimpleDateFormat
(
"yyyy-MM-dd"
)
;

            Date d 
= sdf
.
parse
(
"2016-06-03"
)
;

        
} 
catch 
(FileNotFoundException e
) 
{

            System
.out
.
println
(
"d:/LOL.exe不存在"
)
;

            e
.
printStackTrace
(
)
;

        
} 
catch 
(ParseException e
) 
{

            System
.out
.
println
(
"日期格式解析错误"
)
;

            e
.
printStackTrace
(
)
;

        
}

    
}


}

多异常捕捉办法2

另一个种办法是把多个异常，放在一个catch里统一捕捉.

这种方式从 JDK7开始支持，好处是捕捉的代码 更紧凑，不足之处是，一旦发生异常， 不能确定到底是哪种异常，需要通过instanceof 进行判断具体的异常类型。


package exception
;

 


import java
.io
.File
;


import java
.io
.FileInputStream
;


import java
.io
.FileNotFoundException
;


import java
.text
.ParseException
;


import java
.text
.SimpleDateFormat
;


import java
.util
.Date
;

 


public 
class 
TestException 
{

 

    
public 
static 
void 
main
(
String
[
] args
) 
{

 

        File f 
= 
new 
File
(
"d:/LOL.exe"
)
;

 

        
try 
{

            System
.out
.
println
(
"试图打开 d:/LOL.exe"
)
;

            
new 
FileInputStream
(f
)
;

            System
.out
.
println
(
"成功打开"
)
;

            SimpleDateFormat sdf 
= 
new 
SimpleDateFormat
(
"yyyy-MM-dd"
)
;

            Date d 
= sdf
.
parse
(
"2016-06-03"
)
;

        
} 
catch 
(FileNotFoundException 
| ParseException e
) 
{

            
if 
(e 
instanceof 
FileNotFoundException
)

                System
.out
.
println
(
"d:/LOL.exe不存在"
)
;

            
if 
(e 
instanceof 
ParseException
)

                System
.out
.
println
(
"日期格式解析错误"
)
;

 

            e
.
printStackTrace
(
)
;

        
}

 

    
}


}

finally

无论是否出现异常，finally中的代码都会被执行


try
{

            System
.out
.
println
(
"试图打开 d:/LOL.exe"
)
;

            
new 
FileInputStream
(f
)
;

            System
.out
.
println
(
"成功打开"
)
;

        
}

        
catch
(FileNotFoundException e
)
{

            System
.out
.
println
(
"d:/LOL.exe不存在"
)
;

            e
.
printStackTrace
(
)
;

        
}

        
finally
{

            System
.out
.
println
(
"无论文件是否存在， 都会执行的代码"
)
;

        
}

throws

考虑如下情况：主方法调用method1，method1调用method2，method2中打开文件。

method2中需要进行异常处理，但是method2 不打算处理，而是把这个异常通过 throws抛出去**。那么method1就会 接到该异常。处理办法也是两种，要么是try catch**处理掉，要么也是抛出去。

method1选择本地try catch住一旦try catch住了，就相当于把这个异常消化掉了，主方法在调用method1的时候，就不需要进行异常处理了。


package exception
;

 


import java
.io
.File
;


import java
.io
.FileInputStream
;


import java
.io
.FileNotFoundException
;

 


public 
class 
TestException 
{

 

    
public 
static 
void 
main
(
String
[
] args
) 
{

        
method1
(
)
;

 

    
}

 //java学习交流:737251827  进入可领取学习资源及对十年开发经验大佬提问，免费解答！

    
private 
static 
void 
method1
(
) 
{

        
try 
{

            
method2
(
)
;

        
} 
catch 
(FileNotFoundException e
) 
{

            
// TODO Auto-generated catch block

            e
.
printStackTrace
(
)
;

        
}

 

    
}

 

    
private 
static 
void 
method2
(
) throws FileNotFoundException 
{

 

        File f 
= 
new 
File
(
"d:/LOL.exe"
)
;

 

        System
.out
.
println
(
"试图打开 d:/LOL.exe"
)
;

        
new 
FileInputStream
(f
)
;

        System
.out
.
println
(
"成功打开"
)
;

 

    
}


}

throw和throws的区别

throws与throw这两个关键字接近，不过意义不一样，有如下区别：

throws 出现在方法声明上，而throw通常都出现在方法体内。
throws 表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某个异常对象。

1.3 异常分类

异常分类：可查异常，运行时异常和错误3种。其中，运行时异常和错误又叫非可查异常。

可查异常

可查异常： CheckedException；可查异常即 必须进行处理的异常，要么try catch住,要么往外抛，谁调用，谁处理，比如 FileNotFoundException。 如果不处理，编译器，就不让你通过。


package exception
;

  


import java
.io
.File
;


import java
.io
.FileInputStream
;


import java
.io
.FileNotFoundException
;

  


public 
class 
TestException 
{

  

    
public 
static 
void 
main
(
String
[
] args
) 
{

        File f
= 
new 
File
(
"d:/LOL.exe"
)
;

          

        
try
{

            System
.out
.
println
(
"试图打开 d:/LOL.exe"
)
;

            
new 
FileInputStream
(f
)
;

            System
.out
.
println
(
"成功打开"
)
;

        
}

        
catch
(FileNotFoundException e
)
{

            System
.out
.
println
(
"d:/LOL.exe不存在"
)
;

            e
.
printStackTrace
(
)
;

        
}

          

    
}


}

运行时异常

运行时异常RuntimeException指： 不是必须进行try catch的异常. 常见运行时异常: 除数不能为0异常:ArithmeticException 下标越界异常:ArrayIndexOutOfBoundsException 空指针异常:NullPointerException 在编写代码的时候，依然可以使用try catch throws进行处理，与可查异常不同之处在于， 即便不进行try catch，也不会有编译错误。 Java之所以会设计运行时异常的原因之一，是因为下标越界，空指针这些运行时异常 太过于普遍，如果都需要进行捕捉，代码的可读性就会变得很糟糕。


package exception
;

  


public 
class 
TestException 
{

  

    
public 
static 
void 
main
(
String
[
] args
) 
{

        
//任何除数不能为0:ArithmeticException

        int k 
= 
5
/
0
;

         

        
//下标越界异常：ArrayIndexOutOfBoundsException

        int j
[
] 
= 
new 
int
[
5
]
;

        j
[
10
] 
= 
10
;

         

        
//空指针异常：NullPointerException

        String str 
= 
null
;

        str
.
length
(
)
;

   
}


}

错误

错误Error，指的是 系统级别的异常，通常是内存用光了. 在 默认设置下，一般java程序启动的时候，最大可以使用16m的内存；如例不停的给StringBuffer追加字符，很快就把内存使用光了；抛出 OutOfMemoryError。与运行时异常一样，错误也是不要求强制捕捉的。


package exception
;


public 
class 
TestException 
{

    
public 
static 
void 
main
(
String
[
] args
) 
{

     StringBuffer sb 
=
new 
StringBuffer
(
)
;

     
for 
(int i 
= 
0
; i 
< Integer
.
MAX_VALUE
; i
++
) 
{

 sb
.
append
(
'a'
)
;

 
}

    
}


}

三种分类

总体上异常分三类：错误、运行时异常、可查异常。

//java学习交流:737251827 进入可领取学习资源及对十年开发经验大佬提问，免费解答！

运行时异常：都是 RuntimeException类及其子类异常，如 NullPointerException(空指针异常)、 IndexOutOfBoundsException(下标越界异常)等，这些异常是 不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是 由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用 try-catch语句捕获它，也没有用 throws子句声明抛出它，也会编译通过。

非运行时异常（编译异常）：是 RuntimeException以外的异常，类型上都属于 Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果 不处理，程序就不能编译通过。如 IOException、 SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。

1.4 异常处理

Throwable

Throwable是类，Exception和Error都继承了该类；所以在捕捉的时候，也可以使用Throwable进行捕捉。如图：异常分 Error和 Exception，Exception里又分 运行时异常和 可查异常。


package exception
;


import java
.io
.File
;


import java
.io
.FileInputStream
;

 


public 
class 
TestException 
{

    
public 
static 
void 
main
(
String
[
] args
) 
{

        File f 
= 
new 
File
(
"d:/LOL.exe"
)
;

 

        
try 
{

            
new 
FileInputStream
(f
)
;

            
//使用Throwable进行异常捕捉

        
} 
catch 
(Throwable t
) 
{

            
// TODO Auto-generated catch block

            t
.
printStackTrace
(
)
;

        
}

    
}


}

1.5 自定义异常

创建自定义异常

一个英雄攻击另一个英雄的时候，如果发现另一个英雄已经挂了，就会抛出EnemyHeroIsDeadException。创建一个类EnemyHeroIsDeadException，并继承Exception，提供两个构造方法。

无参的构造方法
带参的构造方法，并调用父类的对应的构造方法


class 
EnemyHeroIsDeadException 
extends 
Exception
{

    
public 
EnemyHeroIsDeadException
(
)
{

         

    
}

    
public 
EnemyHeroIsDeadException
(
String msg
)
{

        
super
(msg
)
;

    
}


}

抛出自定义异常

在Hero的attack方法中，当发现敌方英雄的血量为0的时候，抛出该异常：

创建一个EnemyHeroIsDeadException实例
通过 throw 抛出该异常
当前方法通过 throws 抛出该异常

在外部调用attack方法的时候，就需要进行捕捉，并且捕捉的时候，可以通过e.getMessage() 获取当时出错的具体原因。


package com
.company
;




public 
class 
Hero 
{

    
public String name
;

    
protected float hp
;

//java学习交流:737251827  进入可领取学习资源及对十年开发经验大佬提问，免费解答！

    
public 
void 
attackHero
(Hero h
) throws EnemyHeroIsDeadException
{

        
if 
(h
.hp 
== 
0
)
{

            
throw 
new 
EnemyHeroIsDeadException
(h
.name 
+ 
"已经挂了,不需要施放技能" 
)
;

        
}

    
}



    
public String 
toString
(
)
{

        
return name
;

    
}



    
class 
EnemyHeroIsDeadException 
extends 
Exception
{

        
public 
EnemyHeroIsDeadException
(
)
{
}

        
public 
EnemyHeroIsDeadException
(
String msg
)
{

            
super
(msg
)
;

        
}

    
}



    
public 
static 
void 
main
(
String
[
] args
) 
{

        Hero garen 
=  
new 
Hero
(
)
;

        garen
.name 
= 
"盖伦"
;

        garen
.hp 
= 
616
;



        Hero teemo 
=  
new 
Hero
(
)
;

        teemo
.name 
= 
"提莫"
;

        teemo
.hp 
= 
0
;



        
try
{

            garen
.
attackHero
(teemo
)
;

        
}
catch 
(EnemyHeroIsDeadException e
)
{

            
// TODO Auto-generated catch block

            System
.out
.
println
(
"异常的具体原因:"
+e
.
getMessage
(
)
)
;

            e
.
printStackTrace
(
)
;

        
}

    
}


}

练习-自定义异常

对 MyStringBuffer的插入和删除方法中的边界条件判断，用抛出异常来解决例: insert(int pos, String b) , 当pos 是负数的时候，抛出 自定义异常，需要实现自定义两种异常。 IndexIsNagetiveException 下标为负异常 IndexIsOutofRangeException 下标超出范围异常以下是需要调用这些异常的场景：

pos<0 抛出 IndexIsNagetiveException

pos>length 抛出 IndexIsOutofRangeException

null==b 抛出 NullPointerException

start<0 抛出 IndexIsNagetiveException

start>length 抛出 IndexIsOutofRangeException

end<0 抛出 IndexIsNagetiveException

end>length 抛出 IndexIsOutofRangeException

start>=end 抛出 IndexIsOutofRangeException

1.6 异常处理综合练习

异常综合练习1

这是一个类图 Account类：银行账号属性： balance 余额方法： getBalance() 获取余额方法： deposit() 存钱方法： withdraw() 取钱 OverdraftException：透支异常，继承Exception 属性： deficit 透支额

异常综合练习2

类： CheckingAccount 支票账户，具备透支额度，继承Account 属性：overdraftProtection 透支额度

//java学习交流:737251827 进入可领取学习资源及对十年开发经验大佬提问，免费解答！

ITPub博客

JAVA中级教程 - 第一讲异常处理

1.1 什么是异常

最新文章

ITPub博客

JAVA中级教程 - 第一讲 异常处理

1.1 什么是异常

最新文章

JAVA中级教程 - 第一讲异常处理