1.动手动脑
import javax.swing.*;
class AboutException {
public static void main(String[] a)
{
int i=1, j=0, k;
k=i/j;
try
{
k = i/j; // Causes division-by-zero exception
//throw new Exception("Hello.Exception!");
}
catch ( ArithmeticException e)
{
System.out.println("被0除. "+ e.getMessage());
}
catch (Exception e)
{
if (e instanceof ArithmeticException)
System.out.println("被0除");
else
{
System.out.println(e.getMessage());
}
}
finally
{
JOptionPane.showConfirmDialog(null,"OK");
}
}
}
结果：
异常处理：Try{ //可能发生运行错误的代码；}
catch（异常类型 异常对象引用）{ //用于处理异常的代码；}
finally{ //用于“善后” 的代码；}
（1）把可能会发生错误的代码放进try语句块中。
（2）当程序检测到出现了一个错误时会抛出一个异常对象。异常处理代码会捕获并处理这个错误。
（3）catch语句块中的代码用于处理错误。
（4）当异常发生时，程序控制流程由try语句块跳转到catch语句块。
（5）不管是否有异常发生，finally语句块中的语句始终保证被执行。
如果没有提供合适的异常处理代码，JVM将会结束掉整个应用程序。
Java中的异常分类：
Throwable类有两个直接子类： Exception：出现的问题是可以被捕获的； Error：系统错误，通常由JVM处理。 可捕获的异常又可以分为两类： （1）Check异常:直接派生自Exception的异常类，必须被捕获或再次声明抛出 （2）Runtime异常：派生自RuntimeException的异常类。使用throw语句可以随时抛出这种异常对象： throw new ArithmeticException(…);
2.动手动脑
阅读以下代码（CatchWho.java），写出程序运行结果：
public class CatchWho {
public static void main(String[] args) {
try {
try {
throw new ArrayIndexOutOfBoundsException();
}
catch(ArrayIndexOutOfBoundsException e) {
System.out.println( "ArrayIndexOutOfBoundsException" + "/内层try-catch");
}
throw new ArithmeticException();
}
catch(ArithmeticException e) {
System.out.println("发生ArithmeticException");
}
catch(ArrayIndexOutOfBoundsException e) {
System.out.println( "ArrayIndexOutOfBoundsException" + "/外层try-catch");
}
}
}
输出结果：
3.动手动脑
写出CatchWho2.java程序运行的结果
public class CatchWho2 {
public static void main(String[] args) {
try {
try {
throw new ArrayIndexOutOfBoundsException();
}
catch(ArithmeticException e) {
System.out.println( "ArrayIndexOutOfBoundsException" + "/内层try-catch");
}
throw new ArithmeticException();
}
catch(ArithmeticException e) {
System.out.println("发生ArithmeticException");
}
catch(ArrayIndexOutOfBoundsException e) {
System.out.println( "ArrayIndexOutOfBoundsException" + "/外层try-catch");
}
}
}
运行结果：
4.动手动脑
请先阅读 EmbedFinally.java示例，再运行它，观察其输出并进行总结。
public class EmbededFinally {
public static void main(String args[]) {
int result;
try {
System.out.println("in Level 1");
try {
System.out.println("in Level 2");
// result=100/0; //Level 2
try {
System.out.println("in Level 3");
result=100/0; //Level 3
}
catch (Exception e) {
System.out.println("Level 3:" + e.getClass().toString());
}
finally {
System.out.println("In Level 3 finally");
}
// result=100/0; //Level 2
}
catch (Exception e) {
System.out.println("Level 2:" + e.getClass().toString());
}
finally {
System.out.println("In Level 2 finally");
}
// result = 100 / 0; //level 1
}
catch (Exception e) {
System.out.println("Level 1:" + e.getClass().toString());
}
finally {
. System.out.println("In Level 1 finally");
}
}
}
输出结果：
当有多个嵌套的try…catch…finally时，要特别注意finally的执行时机。
当有多层嵌套的finally时，异常在不同的层次抛出 ，在不同的位置抛出，可能会导致不同的finally语句块执行顺序。
5.动手动脑
辨析：finally语句块一定会执行吗？
请通过 SystemExitAndFinally.java示例程序回答上述问题
public class SystemExitAndFinally {
public static void main(String[] args)
{
try{
System.out.println("in main");
throw new Exception("Exception is thrown in main");
//System.exit(0);
}
catch(Exception e)
{
System.out.println(e.getMessage());
System.exit(0);
}
finally
{
System.out.println("in finally");
}
}
}
输出结果：
finally不一定执行，当catch()从句中有System.exit()语句即程序退出时，finally()就不会被执行。
6.
当程序中出现异常时，JVM会依据方法调用顺序依次查找有关的错误处理程序。
可使用printStackTrace 和 getMessage方法了解异常发生的情况：
printStackTrace：打印方法调用堆栈。
每个Throwable类的对象都有一个getMessage方法，它返回一个字串，这个字串是在Exception构造函数中传入的，通常让这一字串包含特定异常的相关信息。
请通过 PrintExpressionStack.java示例掌握上述内容。
// UsingExceptions.java
// Demonstrating the getMessage and printStackTrace
// methods inherited into all exception classes.
public class PrintExceptionStack {
public static void main( String args[] )
{
try {
method1();
}
catch ( Exception e ) {
System.err.println( e.getMessage() + "\n" );
e.printStackTrace();
}
}
public static void method1() throws Exception
{
method2();
}
public static void method2() throws Exception
{
method3();
}
public static void method3() throws Exception
{
throw new Exception( "Exception thrown in method3" );
}
}
输出结果：
异常处理：
try
{
需要检测的代码；
}
catch（异常类 变量）
{
异常处理代码；
}
finally
{
一定会执行的代码；
}
异常处理的嵌套。
异常处理流程代码可以放在任何能放可执行性代码的地方，因此完整的异常处理流程既可放在try块里，也可放在catch块里，也可放在finally块里。
异常处理嵌套的深度没有明确的限制，但通常没有必要使用超过两层的嵌套异常处理，层次太深的嵌套异常处理没有太大必要，而且导致程序可读性降低。
checked异常与Runtime异常：
Java的异常被分为两大类：Checked异常和Runtime异常（运行时异常）。所有RuntimeException类及其子类的实例被称为Runtime异常；不是RuntimeException类及其子类的异常实例则被称为Checked异常。
Checked异常的处理：
当前方法明确知道如何处理该异常，程序应该使用try...catch块来捕获该异常，然后在对应的catch块中修改该异常。当前方法不知道如何处理这种异常，应该在定义该方法时声明抛出该异常。
Runtime异常的处理：
Runtime异常则更加灵活，Runtime异常无需显示声明抛出。如果程序捕捉Runtime异常，也可以使用try...catch块来捕捉Runtime异常。
使用throws声明抛出异常：
throws声明抛出异常的思路是：当前方法不知道应该如何这种类型的异常，该异常应该由上一级调用者处理，如果main方法也不知道应该如何处理这种类型的异常，也可以使用throws声明抛出异常，该异常交给JVM处理。JVM对异常的处理方法是：打印异常跟踪栈信息，并中止程序的运行，这就是程序在遇到异常后自动结束的原因。
throws声明抛出只能在方法签名中使用，throws可以声明抛出多个异常类，多个异常类之间以逗号隔开。
如果需要在程序中自行抛出异常，应使用throw语句，throw语句可以单独使用，throw语句抛出的不是异常类，而是一个异常实例，而且每次只能抛出一个异常实例。throw语句的语法格式如下：throw ExceptionInstance;
如果throw语句抛出的异常是Checked异常，则该throw语句要么处于try块里，显示捕获该异常，要么放在一个带throws声明抛出的方法中，即把该异常交给方法的调用者处理。
异常处理原则：
不要过度使用异常；
不要使用过于庞大的try块；
避免使用Catch AII 语句；
不要忽略捕获到异常。
标签：动脑,System,try,动手,catch,println,异常,out From： https://www.cnblogs.com/JJTyyds/p/16804315.html