Java try-catch方式处理异常与throws和throw的区别

1.异常

1.1 异常的概述

• 异常的概述：程序出现了不正常的情况
• 异常的体系结构
  
• Error和RuntimeException及其子类成为未检查异常(unchecked),其它异常成为已检查异常(checked).

1.2 JVM默认处理异常的方式

当程序出现问题，我们没有做任何处理，最终JVM会做默认处理，处理方式有如下两个步骤：

• 把异常的名称，错误原因及异常出现的位置等信息输出在了控制台
• 程序停止执行

1.3 try-catch方式处理异常

• 定义格式

try {
	可能出现异常的代码;
} catch(异常类名 变量名) {
	异常的处理代码;
}

//示例
try {
     method();
}catch (ParseException e) {
     e.printStackTrace(); 
}

• 执行流程
  • 程序从 try 里面的代码开始执行
  • 出现异常，就会跳转到对应的 catch 里面去执行
  • 执行完毕之后，程序还可以继续往下执行

1.4 Throwable成员方法

• 常用方法

方法名	说明
public String getMessage()	返回此 throwable 的详细消息字符串
public String toString()	返回此可抛出的简短描述
public void printStackTrace()	把异常的错误信息输出在控制台

• 示例

//public String getMessage():返回此 throwable 的详细消息字符串
try {
     method();
}catch (ParseException e) {
     System.out.println(e.getMessage());
}

//public String toString():返回此可抛出的简短描述
try {
     method();
}catch (ParseException e) {
     System.out.println(e.toString());
}

//public void printStackTrace():把异常的错误信息输出在控制台
try {
     method();
}catch (ParseException e) {
     e.printStackTrace(); 
}

1.5 编译时异常和运行时异常的区别

• 编译时异常

  • 都是Exception类及其子类
  • 必须显示处理，否则程序就会发生错误，无法通过编译

• 运行时异常

  • 都是RuntimeException类及其子类
  • 无需显示处理，也可以和编译时异常一样处理

1.6 throws方式处理异常

定义格式

public void 方法() throws 异常类名 {
    
}
//示例
public static void method() throws ParseException {
        String s = "2048-08-09";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date d = sdf.parse(s);
        System.out.println(d);
    }
}

注意事项

• 这个throws格式是跟在方法的括号后面的
• 编译时异常必须要进行处理，两种处理方案：try…catch …或者 throws，如果采用 throws 这种方案，将来谁调用谁处理
• 运行时异常可以不处理，出现问题后，需要我们回来修改代码

1.7 throws和throw的区别

1.8 自定义异常

格式：

public class 异常类名 extends Exception {
		无参构造
		带参构造
}

//示例
public class ScoreException extends Exception {

    public ScoreException() {}

    public ScoreException(String message) {
        super(message);
    }
}

练习示例：编写一个计算N个整数平均值的程序。程序应该提示用户输入N的值，如何必须输入所有N个数。如果用户输入的值是一个负数，则应该抛出一个异常并捕获，提示“N必须是正数或者0”。并提示用户再次输入该数(自定义异常)

自定义异常类

public class FistExcption extends Exception{
    public FistExcption(){}
    public FistExcption(String message){
        super(message);
    }
}

public class CodeRunning {
    public static void main(String[] args) {
         Scanner sc = new Scanner(System.in);

        System.out.println("----------------------");
        System.out.println("要计算几个整数的平均值呢：");
        int numder = sc.nextInt();

        int count = 0;//个数
        int sum = 0;//和

        for (int i = 0; i < numder; i++) {
            count++;
            try {
                sum += amount(count);

            } catch (FistExcption e) {
                e.printStackTrace();
            }
        }
        System.out.println("一共" + numder + "个数，" + "和为:" + sum + "，平均值为:" + (double) sum / numder);

    }


    public static int amount(int count) throws FistExcption {
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入第" + count + "个数");
        int N = sc.nextInt();

        while (true) {
            if (N < 0) {
                System.out.println("N必须是正数或者0");
                System.out.println("请输入第" + count + "个数");
                N = sc.nextInt();
            } else {
                return  N;
            }

        }
    }
}

1.9 JAVA语言如何进行异常处理，关键：throws,throw,try,catch,finally分别代表什么意义？

Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。
一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throw）一个异常，
这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理

try：用来指定一块预防所有“异常”的程序；

catch： 紧跟在try块后面，用来指定你想要捕捉的“异常”的类型；

throw：用来明确地抛出一个“异常”；

throws：用来标明一个成员函数可能抛出的各种“异常”；

finally：为确保一段代码不管发生什么“异常”都被执行一段代码；

1.10 try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?

public class ReturnExceptionDemo {
	static void methodA() {
		try {
			System.out.println("进入方法A");
			throw new RuntimeException("制造异常");
		} finally {
			System.out.println("用A方法的finally");
		}
	}
	static int methodB() {
		try {
			System.out.println("进入方法B");
			// throw new Exception();
			return 1;
		} catch (Exception e) {
			return 3;
		} finally {
			System.out.println("调用B方法的finally");
			 return 2;
		}
	}

	public static void main(String[] args) {
		try {
			methodA();
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
		int i = methodB();
		System.out.println(i);
	}
}

结果

进入方法A
用A方法的finally  
制造异常
进入方法B
调用B方法的finally
1

当程序执行try{}遇到return时，程序会先执行return语句，但并不会立即返回，程序把执行流程转去执行finally块，当finally块执行完成后就直接返回刚才return语句已经准备好的结果。所以说finally{}在return中间执行。
即使finally中对返回值进行了改变，但是不会影响返回结果。