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);
    }
}

使用匿名内部类当参数

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

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. 编译异常：

异常处理

1. try-catch-finally

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

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

如果出现异常，则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);
       }
   }
   

   例题

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 {
   
       }
   }

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