/*
* 一、异常的处理：抓抛模型
*
* 过程一：“抛”：程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象
* 并将此对象抛出。
* 一旦抛出对象以后，其后的代码就不再执行。
*
* 过程二：“抓”：可以理解为异常的处理方式：1.try - catch - finally 2.throws
*
*
* 二、try - catch - finally的使用
*
* try{
* //可能出现异常的代码
* }catch(异常类型1 变量名1){
*
* }
* catch(异常类型2 变量名2){
*
* }
* catch(异常类型3 变量名3){
*
* }
* ...
* finally{
*
* }
*
* 说明：
* 1.finally是可选的。
* 2.使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象
* 的类型，去catch中进行匹配
*
* 3.一旦try中异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的
* try-catch结构(在没有写finall的情况).继续执行其后的代码。
*
* 4.catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓
* catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则，报错
*
* 5.常用的异常对象处理的方式：1.String getMessage() 2.printStackTrace()
*
* 6.在try结构中声明的变量，再出了try结构以后，就不能再被调用.
*
* 7.try-catch结构可以嵌套
*
* 体会1：使用try-catch-finally处理编译时异常，使得程序在编译时就不在报错，但是运行时仍可能报错。
* 相当于我们使用try-catch-finally将编译时可能出现的异常，延迟到运行时出现
*
* 体会2：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了
* 针对于编译时异常，我们说一定要考虑异常的处理。
*/
public class ExceptionTest1 {
@Test
public void test1() {
String str = "123";
str = "abc";
try {
int num = Integer.parseInt(str);
System.out.println("Hello------------1");
}catch(NumberFormatException e) {
//System.out.println("出现数值转换异常了，不要着急");
//String getMessage();
System.out.println(e.getMessage());
//printStackTrace();
e.printStackTrace();
}catch(NullPointerException e) {
System.out.println("出现空指针异常了，不要着急");
}catch(Exception e) {
System.out.println("出现异常了，不要着急");
}
System.out.println("Hello------------2");
}
}
/*
* try-catch-finally中finally的使用；
*
* 1.finally是可选的
* 2.finally中声明的是一定会被执行的代码。即使catch中又出现异常了，try中有return语句，catch中有return语句等情况。
*
* 3.像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动的回收的，我们需要自己手动的进行资源的释放。
* 此时的资源释放，就需要声明在finally中。
*
*
*/
public class FinallyTest {
FileInputStream fis = null;
@Test
public void test2(){
try {
File file = new File("hello.txt");
fis = new FileInputStream(file);
int data = fis.read();
while(data != -1) {
System.out.print((char)data);
data = fis.read();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
try {
if(fis != null) {
fis.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
@Test
public void testMethod() {
int num = method();
System.out.println(num);
}
public int method() {
try {
int[] arr = new int[10];
System.out.println(arr[10]);
return 1;
}catch(ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
return 2;
}finally {
System.out.println("我一定会被执行");
}
}
@Test
public void test1() {
try {
int a = 10;
int b = 0;
System.out.println(a / b);
}catch(ArithmeticException e) {
//e.printStackTrace();
int[] arr = new int[10];
System.out.println(arr[10]);
}
// System.out.println("我好帅啊！！！！！！");
finally {
System.out.println("我好帅啊~~~~~~~");
}
}
}
/*
* Error:Java虚拟机无法解决的严重问题。如JVM系统内部错误、资源耗尽等严重情况。
* 一般不编写针对性的代码进行处理。
*/
public class ErrorTest {
public static void main(String[] args) {
//1.栈溢出：java.lang.StackOverflowError
//main(args);
//2.堆溢出：java.lang.OutOfMemoryError: Java heap space
//Integer[] arr = new Integer[1024 * 1024 * 1024];
}
}
/*
* 一、异常体系结构
* java.long.Throwable
* java.long.Error:一般不编写代码进行处理
* java.long.Exception:可以进行异常的处理
* 编译时异常(checked)
* IOException
* ClassNotFoundException...
*
*
* 运行时异常(unchecked)
* NullPointerException
* ArrayIndexOutOfBoundsException
* ClassCastException
* NumberFormatExcetpion
* InputMismatchException
* ArrayStoreException...
*/