Java异常

import java.util.Scanner;

/*
 * 异常：
 * 	不正常
 *  在某些情况下，因为用户的一些原因，例如：配置问题、错误输入的问题、用户磁盘空间满了等因素，导致程序无法正常运行。
 *  
 *  不是异常：（1）语法错误（2）逻辑错误
 * 
 * Java的程序如果出现异常，并且在代码中，没有做相应的处理，那么程序会“崩溃”，“挂了”
 * 
 * Java如何处理异常？或Java异常处理的过程？
 * （1）当程序运行到某一句时，发生了异常，那么程序会先停下来
 * （2）程序会在这句代码处，查看原因，生成一个合理“异常对象”，然后“抛”出
 * （3）JVM会检测在这句代码的外围，是否有try..catch结构，可以“捕获”它，
 * 如果可以捕获，那么程序再处理完异常后，继续下面的运行，不会崩溃；
 * 如果不能捕获，那么会把这个异常继续抛给“上级”，如果“上级”能处理，那么程序从“上级"处理完的代码后面继续运行；
 * 如果上级也不能处理，那么继续往上抛，一直到达JVM，那么就“崩溃”
 * 
 * 
 */
public class TestException {
	public static void main(String[] args) {
//		System.out.println(a);//语法错误
		
		int sum = getSum(1,2);
		System.out.println("sum = " + sum);
		
			try {
				testInput();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		
		System.out.println("main的其他代码");
	}
	
	public static void testInput(){
		Scanner input = new Scanner(System.in);
		try {
			System.out.print("请输入一个整数：");
			int num = input.nextInt();
		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.println("输入有误");//这里 只是提醒，没有让他 重新输入
		}
		
		System.out.println("其他的代码");
	}
	
	
	//求两个整数的和
	public static int getSum(int a ,int b){
		return a - b;
	}
}

/*
 * 所有类的根父类是Object。
 * 枚举的公共父类是Enum，根父类仍然是Object
 * 异常的公共父类是Throwable，根父类仍然是Object
 * 
 * 1、异常的公共父类：java.lang.Throwable
 * (1)只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句“抛”出。
 * (2)只有此类或其子类之一才可以是 catch 子句中的参数类型。 
 * 
 * 2、Throwable又分为两大派别：
 * （1）Error：错误
 * 		一般指严重错误，一般合理的应用程序不应该试图去捕获它。
 *		如果出现这个问题，要么需要升级程序，要么需要升级架构，要么需要升级硬件。
 *		例如：报了一个OutOfMemoryError
 *
 *		经典代表：VirtualMachineError（堆内存溢出OutOfMemoryError，栈内存溢出StackOverflowError）
 * （2）Exception：异常
 * 		一般异常，合理的应用程序应该试图去捕获它。
 * 
 * 3、Exception还可以分为两大类：
 * （1）运行时异常(RuntimeException或它子类)：又称为非受检异常
 * 		编译时，编译器是不会提醒你做处理的，只有运行期间，才会发生。
 * 		运行时异常是不建议用try...catch，因为它发生频率太高，而且一般都是很不应该发生的问题。
 * 		例如：空指针异常，数组下标越界异常，类型转换异常等，这些异常完全可以避免掉。
 * 		但是如果实在没有考虑到，也可以通过try...catch处理。
 * 
 * （2）编译时异常，除了RuntimeException系列以外的，都是编译时异常。又称为受检异常。
 * 		编译时，编译器会强制要求程序员编写处理的代码，如果你不编写，那么就编译不通过。
 * 		例如：FileNotFoundException，IOException等
 */
public class TestExceptionType {
	public static void main(String[] args) {
		
	}
}

/*
 * 一、异常的处理方式：try...catch
 * 1、语法格式：
 * try{
 * 		可能发生异常的代码
 * }catch(异常类型1  异常对象名){//异常对象名绝大多数都是写e
 * 		处理这个异常的代码
 * }catch(异常类型2  异常对象名){//异常对象名绝大多数都是写e
 * 		处理这个异常的代码
 * }catch(异常类型3  异常对象名){//异常对象名绝大多数都是写e
 * 		处理这个异常的代码
 * }
 * 。。。。
 * 
 * 2、异常对象的常用方法
 * （1）e.printStackTrace();
 * 打印异常的详细信息，包括追踪跟踪信息，即这个异常对象一路经过了哪些方法
 * （2）e.getMessage()；
 * 返回异常对象中简单的错误信息提示
 * 
 * 3、打印异常/错误信息
 * System.err.println(xx);打印错误信息
 * 
 * System.out.println(xx);打印正常信息
 * 
 * 4、多个catch分支，如何匹配和执行的？
 * 从上到下依次判断，一旦有一个满足，后面就不看了。
 * 
 * 建议：如果多个catch中的异常类型有大小包含关系，那么小的在上，大的在下，如果没有大小包含关系，顺序随意。
 * 
 * 5、如果catch，可以捕获try中发生的异常，那么程序，会从try...catch下面的代码继续运行 ，不会崩溃。
 * 	如果catch无法捕获try中发生的异常，那么就会导致当前方法结束，并把异常对象抛出调用者，
 * 如果调用者可以处理，那么从调用者处理代码的后面继续运行，否则继续往上抛，最终到达JVM，程序就崩溃了。
 */
public class TestTryCatch {
	//从命令行接收2个整数，求商
	public static void main(String[] args) {
		try {
			int a = Integer.parseInt(args[0]);//第一个参数赋值给a变量
			int b = Integer.parseInt(args[1]);//第二个参数赋值给b变量
			int shang = a/b;
			System.out.println(a +"/" + b + "=" + shang);
		} catch (NumberFormatException e) {
			e.printStackTrace();//标准的
//			System.err.println(e.getMessage());
//			System.out.println(e.getMessage());
		} catch (ArrayIndexOutOfBoundsException e){
			e.printStackTrace();
		} catch (ArithmeticException e){
			e.printStackTrace();
		} catch (Exception e){
			e.printStackTrace();
		} 
		
		
		System.out.println("其他的代码....");
	}
}

/

 * 。。。。
 * finally{
 * 		不管try中是否发生异常，也不管catch是否可以捕获异常，这里代码都必须执行
 * }
 * 
 * 一般用于编写释放资源，断开连接等代码
 * 
 * 特殊情况：可以没有catch部分
 * try{
 * 		
 * }finally{
 * 		
 * }
 */
public class TestTryCatchFinally {
	public static void main(String[] args) {
		try {
			int a = 1;
			int b = 0;
			System.out.println(a/b);
		} catch (ArrayIndexOutOfBoundsException e) {
			e.printStackTrace();
		} finally{
			System.out.println("最终块");
		}
	}
}

/*
 * finally与return混用：
 * 
 * （1）不管try中是否发生异常，也不管catch是否可以捕获异常，也无论try或catch中是否有return。
 * 	finally中的代码都必须执行
 * （2）如果finally中有return，就从finally块的的return回去。
 * （3）如果finally中没有return，那么先把try或catch中该执行的执行完，
 * 在return结束当前方法之前，先走一下finally，然后回去结束当前方法
 */
public class TestFinallyNoReturn {
	public static void main(String[] args) {
		String str = getNum(1);
		System.out.println(str);
	}
	
	public static String getNum(int a){
		try{
			System.out.println(a/0);
			if(a > 0){
				return "正数";
			}else if(a < 0){
				return "负数";
			}else{
				return "零";
			}
		}catch(Exception e){
			System.out.println("exception");
			return "异常";
		}finally{
			System.out.println("finally");
		}
	}
}

/*
 * finally与return混用：
 * 
 * （1）不管try中是否发生异常，也不管catch是否可以捕获异常，也无论try或catch中是否有return。
 * 	finally中的代码都必须执行
 * （2）如果finally中有return，就从finally块的的return回去。
 * （3）如果finally中没有return，那么先把try或catch中该执行的执行完（包括把返回值的结果放到要带回调用处的操作数栈的位置）
 * 在return结束当前方法之前，先走一下finally，然后回去结束当前方法.
 * 结论，如果finally中没有return，finally中的代码不影响返回值。
 */
public class TestFinallyNoReturn2 {
	public static void main(String[] args) {
		int num = getNum(4);
		System.out.println(num);//0
	}
	
	public static int getNum(int a){
		int result = 10;
		try{
			System.out.println(a/0);
			if(a > 0){
				result = 20;
				return result;
			}else if(a < 0){
				result = -20;
				return result;
			}else{
				return result;
			}
		}catch(Exception e){
			System.out.println("exception");
			result = 0;
			return result;
		}finally{
			result = 30;
			System.out.println("finally");
//			return result;//如果有这句，结果就变成30
		}
	}
}