对于想了解Java异常处理的读者，本文将是一篇不可错过的文章，我们将详细介绍java异常处理的三种方法，并且为您提供关于20180805-Java异常处理、Java-异常处理、JavaExceptio

对于想了解Java 异常处理的读者，本文将是一篇不可错过的文章，我们将详细介绍java异常处理的三种方法，并且为您提供关于20180805-Java 异常处理、Java - 异常处理、Java Exception 异常处理、Java 中的 try-catch-finally 异常处理的有价值信息。

• Java 异常处理（java异常处理的三种方法）
• 20180805-Java 异常处理
• Java - 异常处理
• Java Exception 异常处理
• Java 中的 try-catch-finally 异常处理

Java 异常处理（java异常处理的三种方法）

1.异常处理（exception handing）:

　　一种捕获错误的机制。

2.异常的分类：

　　检查性异常（CheckedException）：程序本身没有问题，由于用户的错误操作或其他外部环境而引起的异常。是程序员无法预见的。

　　　　　　　　　　　　　　　　　　　　比如，试图打开一个不存在的文件，根据给定字符串，找不到所对应的类。

　　　　　　　　　　　　　　　　　　　　对于检查性异常，java编译器强制程序员必须捕获处理或抛出声明。否则编译不通过。

　　运行时异常(RuntimeException)：由于程序错误而导致的异常。比如，错误的类型转换、访问空指针、访问越界数组。

　　　　　　　　　　　　　　　　　 　 大部分运行时异常是可以避免的，“如果出现RuntimeException异常，那么就一定是你的问题”。

　　　　　　　　　　　　　　　　　　  对于非检查性异常（包括Error 和 RuntimeException）,java编译器不要求必须做出捕获处理或抛出声明。

　　错误(Error)：是无法处理的异常，如OutOfMemoryError,一般说来，JVM会终止程序。

3.Exception类的层次：

　　Throwable 是Error 和Exception的父类。

　　所有的异常类都是 java.lang.Exception的子类。

　　Exception类有两个主要的子类，IOException 和 RuntimeException。

　　Error 在 java 程序的处理范畴之外。

4.捕获异常：

　　1) try/catch/finally

　　　　catch不能独立于try而存在。可以进行多重catch。

　　　　无论是否发生异常，finally块都会被执行。fianlly块不是强制要求的。

　　　　try后面不能既没有catch或又没有finally。

　　　　try{

　　　　　　// 程序代码

　　　　}catch(异常类型1 异常的变量名1){

　　　　　　// 程序代码

　　　　}

　　　　}catch(异常类型2 异常的变量名2){

　　　　　　// 程序代码

　　　　}finally{

　　　　　　// 程序代码

　　　　}

　　2.throws 和throw

　　　　可以使用关键字 throws 或throw来抛出异常。

5. 声明自定义异常　　　

　　自定义一个检查性异常，需要继承 Exception类。

　　自定义一个运行是异常，需继承RuntimeException类。

　　一个异常类和普通类一样，包含变量和方法。

20180805-Java 异常处理

try{
//程序代码
}catch(ExceptionName e1){
//Catch 块
}

下面的例子中声明有两个元素的一个数组，当代码试图访问数组的第三个元素的时候就会抛出一个异常。

//文件名： ExcepTest.java
import java.io.*;

public class ExcepTest{
public static void main(String[] args){
try{
int a[] = new int[2];
System.out.println("Access element three :" + a[3]);
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("Exception thrown :" + e);
}
System.out.println("Out of the block");
}
}

try{
//程序代码
}catch(异常类型1 异常的变量名1){
//程序代码
}catch(异常类型2 异常的变量名2){
//程序代码
}catch(异常类型3 异常的变量名3){
//程序代码
}

实例

该实例展示了怎么使用多重try/catch。

try{
file = new FileInputStream(fileName);
x = (byte)file.read();
}catch(IOException i){
i.printStackTrace();
return -1;
}catch(FileNotFoundException f) //Not valid!{
f.printStackTrace();
return -1;
}

下面方法的声明抛出一个RemoteException异常：

import java.io.*;

public class className{
public void deposit(double amount) throws RemoteException{
// Method implementation
throw new RemoteException();
}
// Remainder of class definition
}

例如，下面的方法声明抛出RemoteException和InsufficientFundsException：

import java.io.*;

public class ClassName{
public void withdraw(double amount) throws RemoteException,InsufficientFundsException{
//Method implementation
}
// Remainder of class definition
}

try{
//程序代码
}catch(异常类型1 异常的变量名1){
//程序代码
}catch(异常类型2 异常的变量名2){
//程序代码
}finally{
//程序代码
}

实例

public class ExcepTest{
public static void main(String[] args){
int a[] = new int[2];
try{
System.out.println("Access element three :"+a[3]);
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("Exception thrown :" + e);
}
finally{
a[0] =6;
System.out.println("First element value:" +a[0]);
System.out.println("The finally statement is executed");
}
}
}

实例

//文件名 InsufficientFundsException.java

import java.io.*

public class InsufficientFundsException extends Exception{
private double amount;
public InsufficientFundsException(double amount){
this.amount = amount;
}
public double getAmount(){
return amount;
}
}

为了展示如何使用我们自定义的异常类，

在下面的CheckingAccount 类中包含一个withdraw()方法抛出一个InsufficientFundsException异常。

//文件名称 CheckingAccount.java

import java.io.*;

public class CheckingAccount{
private double balance;
private int number;

public CheckingAccount(int number){
this.number = number;
}
public void deposit(double amount){
balance += amount;
}
public void withdraw(double amount) throws InsufficientFundsException{
if(amount<=balance){
balance -= amount;
}else{
double needs = amount - balance;
throw new InsufficientFundsException(needs);
}
}
public double getBalance(){
return balance;
}
public int getNumber(){
return number;
}
}

下面的BankDemo程序示范了如何调用CheckingAccount类的deposit() 和withdraw()方法。

// 文件名称 BankDemo.java

public class BankDemo{
public static void main(String[] args){
CheckingAccount c = new CheckingAccount(101);
System.out.println("Depositing $500...");
c.deposit(500.00);
try{
System.out.println("\nWithdrawing $100...");
c.withdraw(100.00);
System.out.println("\nWithdrawing $600...");
c.withdraw(600.00);
}catch(InsufficientFundsException e){
System.out.println("......" + e.getAmount());
e.printStackTrace();
}
}
}

Java 异常处理

异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。
比如说，你的代码少了一个分号，那么运行出来结果是提示是错误java.lang.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出java.lang.ArithmeticException的异常。

异常发生的原因有很多，通常包含以下几大类：

用户输入了非法数据。
要打开的文件不存在。
网络通信时连接中断，或者JVM内存溢出。

这些异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的。-

要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常：

检查性异常：
最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。

运行时异常：
运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。

错误：
错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

Exception类的层次
所有的异常类是从java.lang.Exception类继承的子类。
Exception类是Throwable类的子类。除了Exception类外，Throwable还有一个子类Error 。
Java程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外。

Error用来指示运行时环境发生的错误。
例如，JVM内存溢出。一般地，程序不会从错误中恢复。
异常类有两个主要的子类：IOException类和RuntimeException类。


Throwable

Error Exception

IOException RuntimeException

在Java 内置类中(接下来会说明)，有大部分常用检查性和非检查性异常。


Java 内置异常类

Java 语言定义了一些异常类在java.lang标准包中。
标准运行时异常类的子类是最常见的异常类。由于java.lang包是默认加载到所有的Java程序的，所以大部分从运行时异常类继承而来的异常都可以直接使用。

Java根据各个类库也定义了一些其他的异常，下面的表中列出了Java的非检查性异常。


异常 描述
ArithmeticException 当出现异常的运算条件时，抛出此异常。例如，一个整数"除以零"时，抛出此类的一个实例。
ArrayIndexOutOfBoundsException 用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引。
ArrayStoreException 试图将错误类型的对象存储到一个对象数组时抛出的异常。
ClassCastException 当试图将对象强制转换为不是实例的子类时，抛出该异常。
IllegalArgumentException 抛出的异常表明向方法传递了一个不合法或不正确的参数。
IllegalMonitorStateException 抛出的异常表明某一线程已经试图等待对象的监视器，或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。
IllegalStateException 在非法或不适当的时间调用方法时产生的信号。换句话说，即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。
IllegalThreadStateException 线程没有处于请求操作所要求的适当状态时抛出的异常。
IndexOutOfBoundsException 指示某排序索引（例如对数组、字符串或向量的排序）超出范围时抛出。
NegativeArraySizeException 如果应用程序试图创建大小为负的数组，则抛出该异常。
NullPointerException 当应用程序试图在需要对象的地方使用 null 时，抛出该异常
NumberFormatException 当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。
SecurityException 由安全管理器抛出的异常，指示存在安全侵犯。
StringIndexOutOfBoundsException 此异常由 String 方法抛出，指示索引或者为负，或者超出字符串的大小。
UnsupportedOperationException 当不支持请求的操作时，抛出该异常。

下面的表中列出了Java定义在java.lang包中的检查性异常类。

异常 描述
ClassNotFoundException 应用程序试图加载类时，找不到相应的类，抛出该异常。
CloneNotSupportedException 当调用 Object 类中的 clone 方法克隆对象，但该对象的类无法实现 Cloneable 接口时，抛出该异常。
IllegalAccessException "拒绝访问一个类的时候，抛出该异常。
"
InstantiationException 当试图使用 Class 类中的 newInstance 方法创建一个类的实例，而指定的类对象因为是一个接口或是一个抽象类而无法实例化时，抛出该异常。
InterruptedException 一个线程被另一个线程中断，抛出该异常。
NoSuchFieldException 请求的变量不存在
NoSuchMethodException 请求的方法不存在

异常方法

下面的列表是Throwable 类的主要方法:

方法 说明
public String getMessage() 返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。

public Throwable getCause() 返回一个Throwable 对象代表异常原因。

public String toString() 使用getMessage()的结果返回类的串级名字。

public void printStackTrace() 打印toString()结果和栈层次到System.err，即错误输出流。

public StackTraceElement [] getStackTrace() 返回一个包含堆栈层次的数组。下标为0的元素代表栈顶，最后一个元素代表方法调用堆栈的栈底。

public Throwable fillInStackTrace() 用当前的调用栈层次填充Throwable 对象栈层次，添加到栈层次任何先前信息中。


捕获异常

使用try和catch关键字可以捕获异常。try/catch代码块放在异常可能发生的地方。

try/catch代码块中的代码称为保护代码，使用 try/catch的语法如下：


Catch语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try后面的catch块就会被检查。
如果发生的异常包含在catch块中，异常会被传递到该catch块，这和传递一个参数到方法是一样。

多重捕获块
一个try代码块后面跟随多个catch代码块的情况就叫多重捕获。

多重捕获块的语法如下所示：
"try{
//程序代码
}catch(异常类型1 异常的变量名1){
//程序代码
}catch(异常类型2 异常的变量名2){
//程序代码
}catch(异常类型3 异常的变量名3){
//程序代码
}"
上面的代码段包含了3个catch块。
可以在ry语句后面添加任意数量的catch块。

如果保护代码中发生异常，异常被抛给第一个catch块。
如果抛出异常的数据类型与ExceptionType1匹配，它在这里就会被捕获。
如果不匹配，它会被传递给第二个catch块。
如此，直到异常被捕获或者通过所有的catch块。

throws/throw关键字：
如果一个方法没有捕获一个检查性异常，那么该方法必须使用throws 关键字来声明。throws关键字放在方法签名的尾部。
也可以使用throw关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。

一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。


finally关键字
finally关键字用来创建在try代码块后面执行的代码块。
无论是否发生异常，finally代码块中的代码总会被执行。
在finally代码块中，可以运行清理类型等收尾善后性质的语句。
inally代码块出现在catch代码块最后，语法如下：

"try{
//程序代码
}catch(异常类型1 异常的变量名1){
//程序代码
}catch(异常类型2 异常的变量名2){
//程序代码
}finally{
//程序代码
}"

注意下面事项：
catch不能独立于try存在。
在try/catch后面添加finally块并非强制性要求的。
try代码后不能既没catch块也没finally块。
try, catch, finally块之间不能添加任何代码。


声明自定义异常
在Java中你可以自定义异常。编写自己的异常类时需要记住下面的几点。

所有异常都必须是Throwable的子类。
如果希望写一个检查性异常类，则需要继承Exception类。
如果你想写一个运行时异常类，那么需要继承RuntimeException 类。

可以像下面这样定义自己的异常类：
"class MyException extends Exception{
}"

只继承Exception 类来创建的异常类是检查性异常类。
下面的InsufficientFundsException类是用户定义的异常类，它继承自Exception。
一个异常类和其它任何类一样，包含有变量和方法。


通用异常

在Java中定义了两种类型的异常和错误。

JVM(Java虚拟机)异常：由JVM抛出的异常或错误。例如：NullPointerException类，ArrayIndexOutOfBoundsException类，ClassCastException类。
程序级异常：由程序或者API程序抛出的异常。例如IllegalArgumentException类，IllegalStateException类。

备注：随笔中内容来源于网上资料整理,仅供参考。

Java - 异常处理

异常处理

异常分类与体系结构:

Error 相关类型的异常是程序无法处理(大多都是修改代码无法解决的)的异常,这类异常通常需要我们调整JVM的运行环境

Exception 相关类型的异常是程序可以处理的异常,其包含两大子类型

• 编译异常(CheckedException)

  通常是语法错误,或是方法明确指明可能抛出异常则必须捕获处理

• 运行时异常(RuntimeException)

  指的是检查阶段没有发现任何问题,满足所有语法规范,只有在运行时才能发现的异常

异常处理

关键字 try catch finally throws throw

基本语法:

注意:

• try 无法单独使用,必须与catch 或finally 组合使用

• finally 表示最终,即无论异常是否真的发生了,最终都会执行finally

• 当异常类型为Exception时 表示通用异常处理(万能异常处理),可以捕获所有异常但是无法针对性的处理

• 一个try可以有多个catch

• 通常将Exception添加到最后一个catch中作为完全保证,让程序可以继续运行

• 一个try中的所有catch下每个异常类型只能出现一次

• catch中异常类型必须从小到大(先子类在父类)

• 无论有多个catch最终只有一个会被执行(类似 if else.....)

• 如要打断finally的执行可以直接退出虚拟机,System.exit();

finally 对return的影响

在方法中,如果有finally,即使在 try 或catch中遇到了return 语句,方法也不会立即结束,而是必须执行完finally后才会执行结束,

案例:

class Test{
  public static void main(String[] args){
		System.out.println(func(0));
    //此处得到的结果为10000;
    //如果没有finally 则是10;
  }
  public static int func(int arg){
    try{
      int a = 1/arg;
      return a;
    }catch(Exception e){
      return 10;
    }finally{
      return 10000;
    }
  }
}

强调:方法中无论是否出现异常,返回值都以finally中的返回值为准,这是不符合实际的,所以通常不这么写

抛出异常

throws

用于方法定义,在定义方法时可以使用throws来声明,方法可能会抛出某种类型的异常

什么时候使用throws

当方法中可能会有异常,但是方法本身无法处理,或是不想处理....就可以使用throws来抛出

需要强调的是:如果一个异常抛出后没最终没有得到处理,将导致程序运行中断,所以通常我们不能放任不管

使用

注意:

• 简单的说,只要声明了,则表明方法内部不会处理该异常,谁调用就由谁处理;

• 相应的调用者则需要捕获异常并处理,若调用方也无法处理,则可以继续向上抛出

• 一个方法也可以声明抛出多种不同类型异常,响应的调用方应增加对应的catch

案例:

package com.yh.test;

public class Test {
    public static void main(String[] args){
       //一直抛向程序入口都没有得到处理则程序被终止
        func3();
    }
    static public void func2() throws ArithmeticException{
        int a = 1/0;
    }

    static public void func3() throws ArithmeticException{
        try{
            func2();//func2抛出异常
        }catch (Exception e){
           //无法处理则继续向上抛出
            throw e;
        }
    }
}

抛出多种类型异常:

import java.util.InputMismatchException;
import java.util.Scanner;

public class Test {
    public static void main(String[] args){
        try {
            func3();
        } catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
        } catch (InputMismatchException e) {
            e.printStackTrace();
        }
    }
    static public int func3() throws ArrayIndexOutOfBoundsException,InputMismatchException{//        try{
            int a = new Scanner(System.in).nextInt();
            return 10/a;
    }
}

throw

主动抛出异常

使用场景:

当方法的提供者需要调用者提供一些数据,但是这些数据不合法,导致功能无法正常处理时,就应该主动抛出异常

调用方可以在捕获到异常后进行处理

抛出还是处理?

方法内部导致的异常自己处理,调用者导致的异常则抛出(或者能处理则处理)

疑惑:为什么throws Exception时编译器要求必须提供解决方案?

因为Exception 既包含了运行时异常 又包含了 编译时异常,所以要求必须处理,由此可知,当throws声明的异常为编译时异常时则要求必须提供处理代码;

案例:

package com.yh.test;

public class Test {
    public static void main(String[] args){
        try {
            func(1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    static void func(int a) throws  Exception{
        if (a < 1){
            throw new Exception("参数不能小于1");
        }
    }
}

自定义异常

当内置异常无法满足特点业务场景时,可以自定义异常类,只需要继承Exception即可

案例:

class MyException extends Exception{
    public MyException() {
        super("固定的异常提示!");
    }
}

当异常提示信息固定的时候可以像上面一样定义构造器

异常链

当一个方法抛出的异常被调用方法捕获,但是调用方法又抛出了新的异常时,则形成了异常链,

如果我们在调用方法中直接抛出新的异常不做任何额外的操作时,原始异常信息则被丢失;

我们有两个方法可以保留原始异常信息

1.实例化时使用原始异常作为参数

2.实例化后调用initCause传入原始异常对象

案例:

package com.yh.test;

public class ExceptionLinkeTest {
    public static void main(String[] args) {
        try {
            func2();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    static public void fun1() throws ArithmeticException{
        int a = 1 / 0;
    }

    static public void func2() throws Exception{
        try{
            fun1();
        }catch (ArithmeticException e){
          	//不保留原始异常信息
            //throw  new Exception("新的异常信息!");
          
            //保留异常信息方法1
          	throw  new Exception("新的异常信息!",e);
          
            //保留异常信息方法2
	          Exception newex = new Exception("新的异常信息!");
          	newex.initCause(e);
          	throw newex;          
        }
    }
}

当我们不做处理时,得到的异常信息如下:

使用 方法1或方法2 来保留异常信息结果如下:

Java Exception 异常处理

一、定义

异常（Exception) : 是指程序运行时出现的非正常情况，是特殊的运行错误对象，对应着Java语言特定的运行错误处理机制。

二、两大常见的异常类型

• RuntimeException(运行时异常）：主要包括“错误的类型转换”、“数组下标越界”、“数组越界”和“空指针”等，这种RuntimeException往往是由于程序的不正确导致的；

•Non-RuntimeException(非运行时异常）：主要包括“从一个不存在的文件中读取数据”、“越过文件结尾继续读取”、“连接一个不存在的URL”等，这种Non-RuntimeException一般是在编译器编译时产生的，通常由环境因素造成，而不是程序本身的作用导致的,例如：IOException。

三、异常处理的两种方式

①用 try......catch......（finally） 捕获异常

try{
           可能遇到的异常
         }

   catch{
             处理异常的方法
           }

    finally{ 程序输出的内容 }

 （注意：①try 在程序中不能单独使用，每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象；②finally语句为异常处理提供了一个统一的出口，无论在try代码块中是否发生了异常，finally块中的语句都会被执行，即finally语句无论遇到什么异常都会输出。）

②用 throws 抛出异常

public void readFile (Srting file) throws FileNotFoundException{ }

  //格式：返回类型 + 方法名（参数列表）+ throws + 异常类型列表

四、举例说明

eg: 定义一个整型的数字69，判断它是否与ASCII码表中的字符‘T’是否相等，若不等于‘T’就继续执行代码，输出69所对应的字符。在这个判断的过程可能会出现IOException,我们就通过这个例子来比较一下异常处理的这两种方式。

①用 try......catch......（finally） 捕获异常

import java.io.IOException;

   public class ExceptionTest {
   public static void read( ) {
     int a = 69;
     try {  
         while((char)a != ''T'') {          //判断69对应的字符是否等于‘T’，若不等则继续执行代码
            System.out.println((char) a);
            a = System.in.read( );        //从a中读取字符
         }
         }
     catch(IOException e){
            System.out.println("ExceptionTest");
   }
}
    
   public static void main(String[] args) {
            ExceptionTest.read( );
   }
}

②用 throws 抛出异常

import java.io.IOException;

   public class ExceptionTest  {
   public static void read( ) throws IOException {
     int a = 69;
    
         while((char)a != ''T'') {          //判断69对应的字符是否等于‘T’，若不等则继续执行代码
            System.out.println((char) a);
            a = System.in.read( );        //从a中读取字符
            throw new IOException();      //在方法体中，抛出异常的throw不需要加s（该异常对象可省略不写
         }
         
            System.out.println("ExceptionTest");
   }

    
   public static void main(String[] args) throws IOException {
            ExceptionTest.read( );
   }
}

Java 中的 try-catch-finally 异常处理

Java 中的 try-catch-finally 异常处理

一、异常处理

异常 (Exception): 是在运行发生的不正常情况。

原始异常处理：

if(条件)
{
　　处理办法1
　　处理办法2
　　处理办法3
}
if(条件)
{
　　处理办法4
　　处理办法5
　　处理办法6
}

　　代码阅读性差，臃肿不堪，与正常流程代码结合的很紧密，所以，在 JAVA 中进行一系列的改良，将一系列常见的问题，用面向对象的思考方式，对其进行了描述、封装。

class 处理办法
{
    处理办法1()
    {
    举例1
    }
    处理办法2()
    {
    举例2
    }
}
if(出错了)
{
　　抛出 new 处理办法1();此方法可能包含问题的名称，信息，时间，地点等。
}

在 JAVA 中，用类的形式对不正常情况进行了描述和封装对象。当程序出现问题时，调用相应的处理办法。

描述不正常情况的类，就称为异常类。将流程代码和异常代码进行分离。

异常就是 JAVA 通过面向对象的思想，将问题封装成了对象。用异常类对其进行描述。不同的问题，用不同的类进行描述。那么意味着，问题有多少，类就有多少。

二、异常体系

问题很多，意味着描述的类也很多，将其共性进行向上抽取，就形成了异常体系。最终异常分为两大类：

Throwable（父类）：问题发生，就应该抛出，让调用者处理。该体系的特点就在于 Throwable 及其子类都具有可抛性。

　　两个关键字实现可抛性：throws、throw

1. 一般不可处理的。Error（错误）

　　特点：是由 JVM（java 虚拟机）抛出的严重性的问题。这种问题发生，一般不针对性处理，直接修改程序。

2. 可以处理的。Exception（异常）

　　特点：子类的后缀名都是用其父类名作为后缀，阅读性很强。

三异常 - 原理 & 异常对象的抛出 throw

public static void main(String [] args)
{
    代码块　　throw new 异常方法();
}
throw为关键字，专门用于抛出异常动作。
 
定义中文异常信息（举个例子）：
throw new 异常方法(异常的方法一般里面可以放入String类型的字符串的，在这里写上中文提示就OK了);

可以看出，异常时，底层 throw 直接调用异常方法，抛出异常，只不过这些都在底层完成，我们看不到而已。

JAVA 虚拟机它有一套异常处理机制，就是会把异常的各种信息，位置等报出来，以供解决异常。

真正开发的时候，这些异常信息是不会直接报出来的，会存成日志，我们定期查看。而且这个异常信息给用户也没用，只有给我们才有用。

四、异常 - 自定义异常 & 异常类的抛出 throws

自定义异常：JAVA 给出的一堆现有的异常没有我们需要的，这时候可以自定义了。但是这个类一定要继承 Exception 类。

这是自定义的异常，需要继承Exception类
class Demo extends Exception
{
    异常的构造方法嘛
    Demo()
    {
    }
    Demo(int a)
    {
    super(a);这是Throwable父类写好的方法，Exception继承的是Throwable父类
    }
     Demo(String b)
    {
    super(b);
    }
}
 
class Demo1
{
    public static void main(String [] args) throws Demo   注意这里是throws抛出，要在方法上声明异常，直接后边写就行
    {
    throw new Demo(这里写上你的中文异常提示);
    }
}

五、异常 - 编译时检测异常和运行时异常的区别 & throw 和 throws 的区别

Exception 体系分两种：1. 一种是编译时被检测异常（throws）。除 runtimeException 子类的所有子类。这样的问题可以针对性的处理。

2. 运行时异常（throw）。Exception 的子类中 runtimeException 和其子类。这种问题一般不处理，直接编译通过，在运行时让调用时的程序强制停止。

六、异常 - 异常捕捉 try-catch

异常处理的捕捉形式：具体格式：

try尝试
{
　　需要被检测异常的代码
　　不要啥玩意都往try里放，不需要检测的不用放
}
catch（异常类 变量）-这个变量专门接收当前发生异常的对象
{
　　处理异常的代码，问题解决了，程序继续运行
}
finally最终化
{
　　一定会被执行的代码
}

七、异常 - 多 catch 情况

try尝试
{
　　需要被检测异常的代码
}
catch（异常类 变量）
{
　　处理异常的代码
}
catch（异常类 变量）
{
　　处理异常的代码
}
finally最终化
{
　　一定会被执行的代码
}

一个 try 对应多个 catch 的时候，小细节：

当多 catch 需要存在 catch (Exception e) 的时候，需要放到最后，不然会挂，因为 Exception 为父类，能接收所有的异常，放它之后，其他的就多余了，所以，它要放在最后的 catch。

八、异常 - 异常处理原则

异常就是问题，JAVA 对一些常见的问题已经弄好了，拿来用就好了。

如果，个别问题只在你自己的项目里出现，并且 JAVA 里没有这类问题，那就需要自己描述该问题。

1. 方法内如果抛出需要检测的异常，那么方法上必须要声明，否则必须在方法内用 try-catch 捕捉，否则编译失败。

2. 如果调用了声明异常的函数，要么 try-catch 要么 throws，否则编译失败。

3. 什么时候 catch，什么时候 throws？功能内容可以解决，用 catch，解决不了，用 throws 告诉调用者，有调用者解决。

4. 如果一个功能抛出了多个异常，那么调用时必须有对应多个 catch 进行针对性的处理。

九、异常 - finally 代码块

finally 为一定会执行的代码，只有一种情况，finally 不会执行。

try
{
检测代码
}
catch
{
　　return; 退出整个方法，但finally依旧执行。
　　System.exit(0);退出java虚拟机，只有这种情况finally不会执行。
}
finally  通常用于关闭（释放）资源
{
　　除退出虚拟机一种情况外，不管咋地，都会执行。
}
System.out.println("catch中写有return，finally外的代码将不会执行，确切的说，就是直接退出了整个方法");

try-catch-finally 代码块组合特点：

1.try-catch-finally 常见组合体

2.try-catch (可以多个 catch) 没有 finally，没有资源需要释放（关闭），可以不用 finally。

3.try-finally，没有 catch 时，方法旁边需要 throws 声明，因为没 catch 没处理。异常无法直接 catch 处理，但是资源需要关闭，这时用此组合。

十、异常的注意事项

1. 子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。

2. 如果父类抛出多个异常，那么子类只能抛出父类异常的子集。---- 子类覆盖父类只能抛出父类异常或者子类或者子集。如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，只能 try。

常用异常方法：

Error 类的常见子类：

 Exception 类的常见子类：

RuntimeException 类的常见的子类：

关于Java 异常处理和java异常处理的三种方法的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于20180805-Java 异常处理、Java - 异常处理、Java Exception 异常处理、Java 中的 try-catch-finally 异常处理等相关知识的信息别忘了在本站进行查找喔。