黑马程序员_Java异常

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

异常笔记：
所谓异常就是指：程序出现了不正常的情况。
Throwable是java语言中所有错误或异常的超类。
Error：
      这是一个严重的错误，比如说：内存溢出，这是我们没有办法改变的问题和异常，
      对此，我们无能为力，只能说我们尽量的避免。Error是Throwable的子类，用于指示合理的应用程序不应该试图
      捕获的严重问题。大多数这样的错误都是异常的条件，虽然ThreadDeath错误是一个“正规”的条件，但它也是
      Error的子类，因为大多数应用程序都不应该试图捕获它。
      换句话说：如果出现这种问题是不需要我们进行捕获处理的。
这个异常是我们尽量去避免的。 
Exception：
      这个异常又分为两种：
1.就是编译的时候出现了问题：如果这个问题你不解决，那
   程序是不可能运行了。所以说你必须要解决问题才可以。
这个异常才是我们要做处理的。
2.就是程序运行时候出现了问题，就是说，程序已经运行时出现了
 问题，这个时候肯定是程序员的事。是需要程序员改代码来修正的。
 在API中的Exception中，除了RuntimeException，及其子类以外，
 其它的都是编译时的异常，其它的都是需要我们自己要进行处理的。

 RuntimeException及其子类，这个是不需要做异常处理的，是靠程序员来自己进行改正自己的代码的
 简单说：就是如果说RuntimeException，那肯定是程序员的事情，是靠程序员来处理的。
接下来通过如下代码：

package heima.com;
public class yi {
	public static void main(String[] args) {
		int a=100;
		int b=24;
		int c=0;
		System.out.println(a/b);
		//System.out.println(a/c);
		System.out.println("over");
	}
}

但运行到 System.out.println(a/c);这一行的时候，程序会报错：ArithmeticException。
这是一个Runtime中的一个子类，也就是说这是需要程序员自己解决的异常。
是运行的时候出现了问题。

同时知道：
jvm的工作原理：
当一旦出现了问题，会在这一行的代码中停下来，然后会在控制台告诉我们是哪一行出现了问题，
比如说：是在System.out.println(a/c);这一行出现了问题，那就会在这一样停下来。程序不再继续执行。

同时告诉我们是属于Exception中的哪一类，是需要抛出异常还是需要进行修正代码？
错误原因，还有就是位置统统告诉我们，在控制台输出，告诉程序员。

package heima.com;
public class two {
	public static void main(String[] args) {
		int a=100;
		int b=24;
		int c=0;
		System.out.println(a/b);
		try {
			System.out.println(a/c);
		} catch (ArithmeticException e) {
		 //这里就是学习了怎么抛出了异常，同时告诉我们这个地方必须要
		 //写点东西，否则这被看做是隐藏了异常，
           	 //同时，我们在对软件进行上线的时候，就是这样将这个异常隐藏，
		 //也是无所谓的。	
		}		
		System.out.println("over");
	}	
}

异常中几个常见的方法：
 * public String toString():现实异常的一些基本信息
 * public String getMessage():获取异常信息
 * public void printStackTrace():把信息输出在控制台
实现如下：

package heima.com;
public class two {	
	public static void main(String[] args) {
		int a=100;
		int b=24;
		int c=0;
		System.out.println(a/b);
		try {
			System.out.println(a/c);
		} catch (ArithmeticException e) {
		 System.out.println("这个地方有一个异常");
			e.toString();
			e.getMessage();
			e.printStackTrace();	
		}			
		System.out.println("over");
	}	
}		   	  		  

运行如下：
4
这个地方有一个异常
java.lang.ArithmeticException: / by zero
over
at heima.com.two.main(two.java:11)

at heima.com.two.main(two.java:11)这一行之前有over的出现。
其实over是在at heima.com.two.main(two.java:11)之后的。
只是运行问题。会出现不同的情况。

时而在前，时而在后。
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
如果说程序中多处异常，怎么办？
1.针对每一个出现问题的地方，都写一个try...catch进行处理。
下面的程序就有两个异常，解决方法就是将两个异常都抛出便可。

package heima.com;
/**
 * 
 * @author yulongchao
 *
 */
public class san {
	public static void main(String[] args) {
		int a=100;
		int b=0;
		//System.out.println(a/b);
		try {
			System.out.println(a/b);
		} catch (ArithmeticException e) {
//			catch后面绝对不可以写为Exception e，因为这是属于多态，就好像导包一样，
//			尽量用到哪个包中的类就导入哪个包中类，
		System.out.println("除数后面不可以为零");		
		}
		
		int[] arr={1,2,3};
		try {
			System.out.println(arr[3]);
		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.println("数组下标越界");
		}	
	}
}

2、针对多个异常写一个try，但是有多个catch
 注意点：1.  注意一旦程序发现一个异常的话，会立马运行到catch{}里面去；
             而一旦有一个catch被执行，其它的catch就不会再执行。
             然后直接运行到catch后面程序运行。
        但是如果是程序员的需要，一个单元的重点异常，必须是逐个抛出。
       而不是简单的多行抛出。
    2.catch的顺序问题
  如果是平级关系，谁前谁后没有关系。
  如果有子父关系，那么，父亲必须在最后。
3.C:JDK7的新特性
  catch(异常1 | 异常2 | 异常3 ... 变量) {
  }
  要求这多个异常间必须是平级关系。
  比如说：像这种问题的 catch (ArrayIndexOutOfBoundsException |ArithmeticException |Exception e)系统就会报错。
  因为这是一种或者的符号|，里面不可有父类Exception

package package1;
public class er {
		public static void main(String[] args) {
			int a=100;
			int b=0;
			int[] arr={1,2,3};
			try {
				System.out.println(a/b);
				System.out.println(arr[5]);
			} catch (ArithmeticException e) {
				
				System.out.println("这个地方是除数不能为零");
			}catch (ArrayIndexOutOfBoundsException e) {
				
				System.out.println("数组越界"); //在这个地方是在控制台是不会输出的，因为
								//程序运行完System.out.println(a/b);这一行以后，
								//直接运行的System.out.println("over");
			}
			
			
			System.out.println("over");
		}
}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
Finally：是异常处理的一部分。用于释放资源。
它的特征就是：Finally里面的代码可以永远的执行。
         但是如果是在Finally之前，写上：System.exit(0);
此时Finally里面的代码就不会再继续执行了！

package heima.com;
public class san {
	public static void main(String[] args) {
		 int a=100;
		 int b=0;	
		try {
			System.out.println(a/b);
		} catch (ArithmeticException e) {
			e.printStackTrace();
			System.exit(0);
		}finally{
			System.out.println("程序执行了！");
		}		
	}
}

问：1：finaly，finally，finalize的区别：
    final：最终的意思，可以修饰类，方法，变量。
  它修饰的类不能被继承
  它修饰的方法不能被重写
  它修饰的变量是常量
  finally：是异常处理的一部分，里面的代码永远会执行。
  特殊情况：在执行到finally之前jvm退出了。
  finalize：Object类的一个方法，用于垃圾回收。

问：假设说catch语句里面有return语句，那么finally里面的语句会执行吗？
    那finally的语句是在return语句之前执行，还是在return语句之后执行？
能执行，finally语句是在return之前执行的。
其实是在return执行间进行的。
3:请输出下列程序的结果
30。  

public class FinallyTest {
	public static void main(String[] args) {
		// method1();
		System.out.println(method2());
	}
	private static int method2() {
		int x = 10;
		try {
			System.out.println(x / 0);
			x = 20;
		} catch (ArithmeticException e) {
			x = 30;
			return x;
		} finally {
			x = 40;
		}
		return x;
	}
	private static void method1() {
		try {
			System.out.println(10 / 0);
		} catch (ArithmeticException e) {
			e.printStackTrace();
			return;
		} finally {
			System.out.println("finally");
		}
	}
}

第一次执行到return x;的时候，在内存中已经形成了一个返回路径，这次记录的值：return 30;
接着，finally执行，x=40。

最后，第二次执行return的时候，就直接返回了return 30;

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------