异常，针对性处理方式

/*
 *异常：java程序在运行时期发生的不正常情况。
 *     java就按照面向对象的思想对不正常情况进行描述和对象的封装。
 *问题分两种：
 *Throwable:定义了对于问题的共性的功能。 java中所有异常的超类
 *   Error:由系统底层发生，通常出现重大问题，运行的类不存在或者内存溢出。
 *     告诉jvm，jvm告诉使用者，不做针对性处理，直接修改代码。
 *   Exception:jvm发生，告诉使用者，可以进行针对性处理
 */
public class ExceptionDemo1 {

 public static void main(String[] args) {
//  int[] arr = new int[1];//ArrayIndexOutOfBoundsException  数组脚标越界异常
  int[] arr = new int[1024*1024*100];//OutOfMemoryError  内存溢出                
                                      //Memory---内存       heap---堆 
  System.out.println(arr[1]);
  
 }

}

 * 异常的处理：
 * 两种：
 *    1.遇到问题不进行具体的处理，而是继续抛给调用者。
 *     其实就是在函数上通过throws关键字声明异常。告诉调用者处理。
 *    2.针对性的处理方式：捕获！
 *   try
 *      {
 *       //有可能发生异常的代码
 *   }
 *   catch(异常类   变量)
 *   {
 *    //这是真正的捕获，处理异常的代码。
 *   }
 *   finally
 *   {
 *    //一定会被执行的代码
 *   }

 在编写功能时，编写者知道该功能有可能发生问题，而这个问题很容易来自于调用者传递的参数。
  而导致功能无法运行。这时发生的问题就应该让调用者知道，并最好让调用有预先的处理方式。
  所以在定义功能时，需要在功能上对其有可能发生的问题进行声明。
  声明问题需要关键字。throws 异常类，声明的目的：就是让调用者可以进行处理
  */

 * 2.针对性的处理方式：捕获！
 *   try
 *      {
 *       //有可能发生异常的代码
 *   }
 *   catch(异常类   变量)
 *   {
 *    //这是真正的捕获，处理异常的代码。
 *   }
 *   finally
 *   {
 *    //一定会被执行的代码
 *   }
 */
class Demo3{
 public int show(int a,int b)throws Exception  //该功能可能发生问题，声明异常
 {
  return a/b;//new ArithmeticExceptin("/ by zero")抛给调用者。
 }
}

public class ExceptionDemo3 {

 public static void main(String[] args) {
  Demo3 d = new Demo3();
  try                             //有可能发生异常的代码
  {
   int num = d.show(5, 0);
   System.out.println(num);
  }
  catch(Exception e) //Exception e = new ArithmeticExceptin("/ by zero");
  {
   System.out.println("出错了！");
  }
  System.out.println("over");
 }

}

/*
throw和throws有什么区别呢？

1.位置不同。
throws用在函数上，后面跟的是异常类，可以跟多个。
throw用在函数内，后面跟的是异常对象。
2.功能不同
throws用来声明异常，让调用者只知道该功能有可能出现的问题，并有调用者可以给出预先的处理方式。
throw抛出具体问题对象，执行到throw功能就已经结束了，跳转到调用者，并将具体的问题对象也抛给调用者。

也就是说throw语句独立存在时，下面不要定义其他语句，因为执行不到。

异常体系最大的特点就是体系中的类以及类产生的对象，都具备可抛性，可抛性的意思是可以被throws和throw所操作。

 */

/*
 * 异常的原则
 * 1.功能内部有异常throw抛出，功能上一定要有throws声明。
 *   内部抛什么，功能上就声明什么。(throws XXX 与 throw XXX 一致)
 *   声明的目的就是为了让调用者处理，如果调用者不处理，编译失败。
 * 2.特殊情况
 *   当函数内通过throw抛出RuntimeException及其子类的异常对象时，函数上可以不用throws声明。
 *   不声明的目的就是不让调用者处理，让调用者的程序停止，要对代码进行修改。
 *  

*小节：
 *异常：  其实就将问题封装成对象，并抛给调用者。
 *         如果声明了，就需要调用者处理（继续声明or捕获）
 *          什么时候声明，什么时候捕获？
 *         功能内部可以解决，就捕获，不能解决，或者解决了还必须告诉调用者问题这时就应该声明。

/*
 异常的针对性处理方式：
 try,catch,fianlly的几种组合方式
 1.有资源需要释放，仅仅是处理异常
 try
 {
 
 }
 catch()
 {
 
 }
 2.一个try多个catch，一般对应的是被调用的函数，抛出多个异常的情况，分别处理。
  try
 {
 
 }
 catch()
 {
 }
  catch()
 {
 }
  catch()
 {
 }
 注意：在多catch语法上特殊的地方，如果catch中的异常类存在子类。
 父类的catch一定要放子类的下面，否则编译失败。
 3.不一定要处理异常，但是有资源需要释放。
 try
 {
 }
 finally
 {
 }
 
 */
class Demo9{
 int a,b;
 int  show(int a,int b)throws ArithmeticException
 {
  if(b==0)
  {
   throw new ArithmeticException("错了123");//声明的异常和抛出的异常要相同：throws 的和 throw 的异常要相同
  }
  return a/b;
 }
}
public class ExceptionDemo9 {
 public static void main(String[] agrs)
 {
  Demo9 d = new Demo9();
  try
  {
   int num=d.show(4,0);
   System.out.println(num);
  }
  catch(ArithmeticException e)   //Exception e = new ArithmeticException("错了123");
                       //throw new 什么，catch参数里就是什么，当然也可以写它的父类（Exception）
  {
   System.out.println(e.toString());
   System.out.println(e.getMessage());
  }
 }
}