java 异常

异常指的是在程序运行过程中发生的异常事件，通常是由外部问题（如硬件错误、输入错误）所导 致的。在Java等面向对象的编程语言中异常属于对象。

try catch finally throw theows

try{}catch(){}

try{}catch(){}finally{}

try{}catch(){ }catch(){}catch(){}

try{}catch(){ }catch(){}catch(){}finally{}

final 常量

finally 在异常处理时，代表最终有没有异常，有没有return continue break 都要执行代码段

异常类型

异常类型	说明
Exception	异常层次结构的根类
RuntimeException	运行时异常，多数 java.lang 异常的根类
ArithmeticException	算术谱误异常，如以零做除数
ArraylndexOutOfBoundException	数组大小小于或大于实际的数组大小
NullPointerException	尝试访问 null 对象成员，空指针异常
ClassNotFoundException	不能加载所需的类
NumberF ormatException	数字转化格式异常，比如字符串到 float 型数字的转换无效
IOException	I/O 异常的根类
FileNotFoundException	找不到文件
EOFException	文件结束
InterruptedException	线程中断
IllegalArgumentException	方法接收到非法参数
ClassCastException	类型转换异常
SQLException	操作数据库异常
UnknownException	应用程序发生异常

抛出异常（谁调用谁处理）

如：调用Thread.sleep(1000);线程休眠时，必须处理异常

public static void main(String[] args) throws InterruptedException {
   System.out.println("输出1");
   Thread.sleep(1000);
   System.out.println("输出2");
}

处理异常

使用

try{}catch(){} 来捕获异常

如果try中程序有异常，会按照catch中的异常类型运行catch中程序，最后运行finally程序（finall程序一定运行）

Scanner sc = new Scanner(System.in);
System.out.println("输入整数a：");
try {
   int a = sc.nextInt();
   if (a == 6) {
       int[] n = new int[1];
       int m = n[3];
   }
   System.out.println("输入整数a：");
   int b = sc.nextInt();
   System.out.printf("%d %d  = %d", a, b, a / b);
} catch (ArithmeticException e) {
   System.out.println("b为0异常");
} catch (InputMismatchException e) {
   System.out.println("输入非整数异常");
} catch (Exception e) {
   //e.printStackTrace();
   System.out.println("未知错误");
   //        ArithmeticException  b为0异常
   //        InputMismatchException  输入非整数异常

} finally {
   //最终处理块
   System.out.println("程序结束");
}

输入 a=0.5

输入a =6

输入a=2，b=0

捕获异常的执行顺序

执行顺序为

try - 异常处 - catch - finally，如果执行过程中有return，正常执行return

如text2()，return i =1，再执行finally，多重return，按后一个值运行（被重新赋值了）。

public class Ex2 {
   public static void main(String[] args) {
       System.out.println("输出i：" + text1());
       System.out.println("输出i：" + text2());
       System.out.println("输出i：" + text3());
   }

   static int text1() {
       System.out.println("text1");
       int i = 0;
       try {
           i++;
           int n = 3 / 0;
           System.out.printf("i = %d\n", i);
           return i;
       } catch (Exception e) {
           System.out.println("有异常");
       } finally {
           i++;
           System.out.printf("i2 = %d\n", i);
       }
       return i;
   }

   static int text2() {
       System.out.println("text2");
       int i = 0;
       try {
           i++;
           int n = 3 / 0;
           System.out.printf("i = %d\n", i);
           return i;
       } catch (Exception e) {
           System.out.println("有异常");
           return i;
       } finally {
           i++;
           System.out.printf("i2 = %d\n", i);

       }

   }

   static int text3() {
       System.out.println("text3");
       int i = 0;
       try {
           i++;
           int n = 3 / 0;
           System.out.printf("i = %d\n", i);
           return i;
       } catch (Exception e) {
           System.out.println("有异常");
           return i;
       } finally {
           i++;
           System.out.printf("i2 = %d\n", i);
           return i;
       }

   }
}

try with 语句

java 1.7之后的语法

try(只能写自动关闭资源对象的声明初始化语句){

}

static void fwTryWith() {
   //1.7之后的新写法
   //自动关闭文件
   //
   try (FileWriter fw1 = new FileWriter("b.txt");FileWriter fw2 = new FileWriter("c.txt")) {
       fw1.write("ashdadsad1");
       fw1.write("ashdadsad2");
       int a = 2 / 0;
       fw1.write("ashdadsad3");
       fw1.write("ashdadsad4");
   } catch (IOException e) {
       throw new RuntimeException(e);
   }
}

static void fwOld() {
   //传统写法
   //打开文件，写入内容，关闭文件
   //如果中间出现异常，则文件不能正常关闭
   //需要在catch中重新关闭
   FileWriter fw = null;
   try {
       fw = new FileWriter("a.txt");
       fw.write("ashdadsad1");
       fw.write("ashdadsad2");
       int a = 2 / 0;
       fw.write("ashdadsad3");
       fw.write("ashdadsad4");
       fw.close();
   } catch (IOException e) {
       e.printStackTrace();
   } finally {
       try {
           fw.close();
       } catch (IOException e) {
           throw new RuntimeException(e);
       }
   }
}

会创建文件，写入内容

finalize()方法

是Object的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，供垃圾收集时的其他资源回收，例如关闭文件等。

final、finally与finalize的区别

1.简单区别：

final用于声明属性，方法和类，分别表示属性不可交变，方法不可覆盖，类不可继承。

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，供垃圾收集 时的其他资源回收，例如关闭文件等。

2.中等区别：

虽然这个单词在Java中都存在，但是并没太多关联：

final：java中的关键字，修饰符。

A).如果一个类被声明为final，就意味着它不能再派生出新的子类，不能作为父类被继承。因此，一个 类不能同时被声明为abstract抽象类的和final的类。

B).如果将变量或者方法声明为final，可以保证它们在使用中不被改变.

​ 1)被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。

​ 2)被声明final的方法只能使用，不能重载。

finally：java的一种异常处理机制。

​ finally是对Java异常处理模型的最佳补充。finally结构使代码总会执行，而不管无异常发生。 使用finally可以维护对象的内部状态，并可以清理非内存资源。特别是在关闭数据库连接这方面，如 果程序员把数据库连接的close()方法放到finally中，就会大大降低程序出错的几率。

finalize：Java中的一个方法名。

​ Java技术使用finalize()方法在垃圾收集器将对象从内存中清除出去前，做必要的清理工作。这个方 法是由垃圾收集器在确定这个对象没被引用时对这个对象调用的。它是在Object类中定义的，因此所的 类都继承了它。子类覆盖finalize()方法以整理系统资源或者执行其他清理工作。finalize()方法是 在垃圾收集器删除对象之前对这个对象调用的。

3.详细区别：

​ 这是一道再经典不过的面试题了，我们在各个公司的面试题中几乎都能看到它的身影。final、 finally和finalize虽然长得像孪生兄弟一样，但是它们的含义和用法却是大相径庭。

final关键字我们首先来说说final。它可以用于以下四个地方:

1).定义变量，包括静态的和非静态的。

2).定义方法的参数。

3).定义方法。

4).定义类。

定义变量，包括静态的和非静态的。定义方法的参数

第一种情况：

​ 如果final修饰的是一个基本类型，就表示这个变量被赋予的值是不可变的，即它是个常量；

​ 如果final修饰的是一个对象，就表示这个变量被赋予的引用是不可变的

这里需要提醒大家注意的是，不可改变的只是这个变量所保存的引用，并不是这个引用所指向的对象。

第二种情况：final的含义与第一种情况相同。

实际上对于前两种情况，一种更贴切的表述final的含义的描述，那就是，如果一个变量或方法参数被 final修饰，就表示它只能被赋值一次，但是JAVA虚拟机为变量设定的默认值不记作一次赋值。被 final修饰的变量必须被初始化。初始化的方式以下几种：

1.在定义的时候初始化。

2.final变量可以在初始化块中初始化，不可以在静态初始化块中初始化。

3.静态final变量可以在定义时初始化，也可以在静态初始化块中初始化，不可以在初始化块中初始化。

4.final变量还可以在类的构造器中初始化，但是静态final变量不可以。

public class Ex5 {
   @Override
   protected void finalize() throws Throwable {
       super.finalize();
       System.out.println("垃圾回收中");
   }

   public static void main(String[] args) {
       Ex5 ee= new Ex5();
       ee = null;
       System.gc();
   }
}