练习，异常，异常处理，try-catch,throws

1. package com.jshedu.homework_;
   
   /**
    * @author Mr.jia
    * @version 1.0
    */
   //匿名内部类
   public class Homework04 {
       public static void main(String[] args) {
           Cellphone cellphone = new Cellphone();
           //1.匿名内部类，同时也是一个对象
           /*
           new computer() {
               @Override
               public double work(double n1, double n2) {
                   return n1+n2;
               }
           }//它的编译类型computer，它的运行类型就是匿名内部类。
            */
           cellphone.testWork(new computer() {
               @Override
               public double work(double n1, double n2) {
                   return n1+n2;
               }//匿名内部类
           },10,20);
       }
   
   }
   interface computer{//计算器接口
       public double work(double n1,double n2);
   }
   
   class Cellphone{
       //当我们调用testWork方法时，直接传入一个实现computer接口的匿名内部类即可
       //该匿名内部类，可以灵活的实现work，完成不同的计算任务
       public void testWork(computer com,double n1,double n2){
           double result = com.work(n1,n2);//动态绑定，
           System.out.println("计算后的结果是="+result);
       }
   }
   

   使用匿名内部类当参数

2. 异常：将程序执行中发生的不正确情况称为"异常"，（开发过程中的语法错误和逻辑错误不是异常）

   package com.jshedu.exception;
   
   /**
    * @author Mr.jia
    * @version 1.0
    */
   
   public class Exception01 {
       public static void main(String[] args) {
           int num1 = 10;
           int num2=0;
           //将该代码块->选中->快捷键ctrl+alt+t选中try-catch
           try{
               int res=num1/num2;
           }catch (Exception e){
               System.out.println(e.getMessage());
               //e.printStackTrace();
           }
           System.out.println("程序继续执行...");
   
       }
   }
   

   1. 执行过程中所发生的异常事件可分为两大类

      1. Error（错误）：java虚拟机无法解决的严重问题。如：JVM系统内部错误，资源耗尽等严重情况。比如：Stack OverflowError【栈溢出】和OOM（out of memory），Error是严重错误，程序会崩溃

      2. Exception：其他因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如空指针访问，试图读取不存在的文件，网络连接中断等等，Exception分为两大类：运行时异常（程序运行时，发生的异常）和编译时异常（编程时，编译器检查出的异常）

      3. 运行时异常，编译器不要求强制处置的异常。一般是指编程时的逻辑错误，是程序员应该避免其出现的异常。对于运行时异常，可以不做处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响。

      4. 编译时异常，是编译器要求必须处置的异常。

      5. java源程序-->字节码文件（发生的是编译异常）

      6. 字节码文件-->在内存中加载，运行类（运行异常）

      7. 

      8. package com.jshedu.exception;
         
         /**
          * @author Mr.jia
          * @version 1.0
          */
         
         public class NullPointer01 {
             public static void main(String[] args) {
                 String name=null;
                 //当应用程序试图在需要对象的地方使用null时，抛出该异常
                 //System.out.println(name.length());//NullPointerException空指针异常
                 //ArithmeticException,除数为0时异常，数学运算异常
                 int[] arr = {1,2,3,4};
                 //ArrayIndexOutOfBoundsException数组下标越界,数组的下标只能到3
                 for (int i = 0; i <= arr.length; i++) {
                     System.out.println(arr[i]);
                 }
         
         
         
             }
         }
         

         空指针，下标越界，数字运算

      9. package com.jshedu.exception;
         
         /**
          * @author Mr.jia
          * @version 1.0
          */
         
         public class ClassCast_ {
             public static void main(String[] args) {
                 A b = new B();//向上转型
                 B b2 = (B)b;//向下转型ok，这个b本身就指向这个B
                 //这里不能把b转成C类型，原先b就没有指向C类型。
                 C c2 = (C)b;//ClassCastException,类型转换异常
         
                 String name = "1234";
                 //将String转成int，ok这是正确的
                 int num = Integer.parseInt(name);
                 String name1 = "zhangsan";
                 //这里就不能转换成int了,NumberFormatException数字格式不正确异常
                 int num1 = Integer.parseInt(name1);
         
             }
         }
         class A{}
         class B extends A{
         
         }
         class C extends A{}
         

         类型转换，数字格式

   2. 编译异常：

3. 异常处理

   1. try-catch-finally

   2. throws：将发生的异常抛出，交给调用者（方法）来处理，最顶级的处理者就是JVM，try和throws二选一，如果程序员没有显示处理异常，默认throws

4. 练习，finally里的一定执行，catch里的变量是保存在临时变量里。如果catch里有return，finally里也有return，catch里的return是返回到栈里，继续执行finally里return会把catch返回在栈里的值覆盖。

5. 如果出现异常，则try块中异常发生后，try块剩下的语句不在执行。将执行catch块中的语句，如果有finally，最后还需要执行finally里面的语句。

   1. package com.jshedu.try_;
      
      import java.util.Scanner;
      
      /**
       * @author Mr.jia
       * @version 1.0
       */
      
      public class TryCatch01 {
          public static void main(String[] args) {
              //如果用户输入的不是一个整数，就提示反复输入，直到输入为止
              Scanner scanner = new Scanner(System.in);
              int num = 0;
              String inputStr = "";
              while (true){
                  System.out.println("请输入一个整数：");
                  inputStr = scanner.next();
                  try {
                      num = Integer.parseInt(inputStr);//这里可能抛出异常
                      break;
                  } catch (NumberFormatException e) {
                      System.out.println("你输入的不是一个整数");
                  }
      
              }
              System.out.println("你输入的数是："+num);
          }
      }
      

      例题

6. throws异常处理

   1. 如果一个方法（中的语句执行时）可能发生某种异常，但是并不能确定如何处理这种异常，则此方法应显示的声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。

   2. 在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。

   3. 编译异常和运行异常的处理机制，父类和子类的异常处理

   4. package com.jshedu.exception;
      
      import java.io.FileInputStream;
      import java.io.FileNotFoundException;
      
      /**
       * @author Mr.jia
       * @version 1.0
       */
      
      public class ThrowsDetails_ {
          public static void main(String[] args) {
      
          }
      
          public static void f1() throws FileNotFoundException {
              //1.因为f2()方法抛出的是一个编译异常
              //2.即这时，就要f1()必须处理这个编译异常
              //3.在f1()中要门try-catch，或者继续throws这个编译异常
              //   throws FileNotFoundException
              f2();//这里直接调用f2方法会显示编译错误
      
      
          }
      
          public static void f2() throws FileNotFoundException {
              //这里FileInputStream会报编译异常，所以我们使用throws处理
              FileInputStream fileInputStream = new FileInputStream("d://aa.txt");
          }
      
          //运行异常
          public static void f3() {
              //1.这里是不报错的，ok的
              //2.因为f4()抛出的是运行异常
              //3.而java中并不要求程序员显示处理，因为有默认处理机制
              f4();
          }
      
          public static void f4() throws ArithmeticException {
      
          }
      }
      
      class Father {
          public void method() throws RuntimeException {
      
          }
      }
      
      //1.对于编译异常，程序中必须处理，try-catch或throws
      //2.对于运行时异常，程序中如果没有处理，默认就是throws的方式处理。
      //3.子类重写父类的方法时，对抛出异常的规定：子类重写的方法，所抛出的异常类型要么
      //  和父类抛出的异常一致，要么为父类抛出的异常类型的子类型。
      //  RuntimeException,NullPointerException子类。
      //4.在throws过程中，如果有方法try-catch，就相当于处理异常，就可以不必throws
      class Son extends Father {
          @Override
          public void method() throws NullPointerException {
      
          }
      }

7. throws和throw的区别

   1. 	意义	位置	后面跟的东西
      throws	异常处理的一种方式	方法声明处	异常类型
      throw	手动生成异常对象的关键字	方法体中	异常对象