java异常踩坑心得

我们使用如下代码来故意产生一个异常，下面的代码由于被除数是0，因此将会产生算术异常

int s=10/0;

下面我们来进行我们的实验。

1.

public static String a()
	{
		try {
			int s=10/0;
			return "aaaa";
		} catch (Exception e) {
			System.out.println("bbbb");
			return "cccc";
		}
	}
	
	public static void main(String[] args) {
		System.out.println(a());
	}

执行结果：

执行到int s = 10/0;就会被捕获到异常，直接跳到catch块中，根本不会去执行打印aaaaa，因此只执行打印bbbbb和ccccc

2.

public static String a()
	{
		try {
			int s=10/0;
			return "aaaa";
		} catch (Exception e) {
			System.out.println("bbbb");
			return "cccc";
		} finally {
			System.out.println("lllll");
			return "finally";
		}
	}
	
	public static void main(String[] args) {
		System.out.println(a());
	}

执行结果：

虽然在catch块中写了return语句，但是由于要执行finally块中的代码，因此方法暂时还不能return，而是去执行了finally中的语句和finally中的return,本来应该去将catch块中的return语句置于finally之后执行的，但是由于finally中有return语句，因此还没来得及执行catch块中的return，方法就已经返回了

3.

public static String a()
	{
		try {
			int s=10/0;
			return "aaaa";
		} catch (Exception e) {
			System.out.println("bbbb");
			return "cccc";
		} finally {
			System.out.println("lllll");
		}
	}
	
	public static void main(String[] args) {
		System.out.println(a());
	}

执行结果：

为了验证上一条所说的，我们将finally块中的return语句去掉，发现这次果然执行了catch块中的return语句，证明了catch块中的return语句确实被置于finally块之后执行了

4.

public static String a()
	{
		try {
			int s=10/0;
			return "aaaa";
		} catch (Exception e) {
			System.out.println("bbbb");
		} finally {
			System.out.println("lllll");
			return "finally";
		}
	}

	public static void main(String[] args) {
		System.out.println(a());
	}

执行结果：

这个没什么好说的，先执行了catch块再执行了finally块

5.

public static String a()
	{
		try {
			int s=10/0;
		} catch (Exception e) {
			System.out.println("bbbb");
			return b();
		} finally {
			System.out.println("lllll");
			return "finally";
		}
	}
	public static String b()
	{
		System.out.println("ooooooo");
		return "mmmmm";
	}
	
	public static void main(String[] args) {
		System.out.println(a());
	}

执行结果：

这里我们将刚才直接返回一个字符串改成了返回一个方法的运行结果，和之前一样，catch块中的return依然因为被置于在finally的return后而没能执行

6.

public static void a()
	{
		try {
			b();
		} catch (Exception e) {
			System.out.println("aaaaa");
		}
	}
	public static void b()
	{
		try {
			throw new Exception("bbbbb");
		} catch (Exception e) {
			System.out.println("ccccc");
		}
	}
	
	public static void main(String[] args) {
		a();
	}

执行结果：

这里在try块中捕获到了产生的异常，并且已经在b()方法的catch块中对异常进行了处理，那么在a()方法中就不会再次捕获到异常了，注意，throw是显示一个异常，而throws是向上级抛出一个异常让上级去进行try catch处理，两者不要混淆

7.

public static void a()
	{
		try {
			try {
				int b = 10/0;
			} catch (Exception e) {
				System.out.println("aaaaa");
			}
		} catch (Exception e) {
			System.out.println("bbbbb");
		}
	}
	
	public static void main(String[] args) {
		a();
	}

执行结果：

和上一条类似，已经在第一个try catch块中对异常处理完毕了，就不会再在外部的try块中捕获到异常了

8.

public static void a() throws Exception
	{
		try {
			int a = 10/0;
		} catch (Exception e) {
			System.out.println("bbbbb");
		}
	}
	
	public static void main(String[] args) {
		try {
			a();
		} catch (Exception e) {
			System.out.println("ccccc");
			e.printStackTrace();
		}
	}

执行结果：

依然和上面两条类似，已经在内部的try catch块中对异常处理完毕，即使向上级抛出了异常，上级再try，也不会捕获到异常，因此不会执行上级的catch块