3.19 ApI 异常

基本类型包装类概述

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据常用的操作之一:用于基本数据类型与字符串之间的转换

装箱: 把一个基本数据类型 变量对应的包装类

自动: java底层会帮我们自动的调用valueof方法

自动装箱和自动拆箱

装箱:把基本数据类型转换为对应的包装类类型

拆箱:把包装类类型转换为对应的基本数据类型

在使用包装类类型的时候，如果做操作，最好先判断是否为 null

我们推荐的是，只要是对象，在使用前就必须进行不为 null 的判断

int 和 String的相互转换

基本类型包装类的最常见操作就是:用于基本类型和字符串之间的相互转换

1.int 转换为 String

方式一:加双引号即可

方式二:publicstatic String valueofinti):返回int 参数的字符串表示形式。该方法是String类中的方法

2.String 转换为int

public static int parselnt(String s):将字符串解析为int类型。该方法是Integer类中的方法

public class Test01 {
    public static void main(String[] args) {
        String s="91 27 46 38 50";
        String[] stuArr = s.split(" ");
        int[] numberArr = new int[stuArr.length];
        for (int i = 0; i < stuArr.length; i++) {
            int number = Integer.parseInt(stuArr[i]);
            numberArr[i]=number;
        }
        for (int i = 0; i < numberArr.length; i++) {
            System.out.println(numberArr[i]);
        }
    }
}

数组的二分查找步骤

1，定义两个变量，表示要查找的范围。默认min=0，max = 最大索引

2，循环查找，但是min<=max

3，计算出mid的值

4，判断mid位置的元素是否为要查找的元素，如果是直接返回对应索引

5，如果要查找的值在mid的左半边，那么min值不变，max= mid-1.继续下次循环查找

6，如果要查找的值在mid的右半边，那么max值不变，min = mid +1.继续下次循环查找

7，当min>max时，表示要查找的元素在数组中不存在，返回-1.

public class Test02 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6,7,8,9,10};
        int number=3;

        int index =binaryIndex(arr,number);
        System.out.println(index);
    }

    private static int binaryIndex(int[] arr, int number) {
        int min=0;
        int max=arr.length-1;
        while (min<=max){
            int mid=(min+max)>>1;
            if (arr[mid]>number){
                max=mid-1;
            }else if (arr[mid]<number){
                min=mid+1;
            }else {
                return mid;
            }
        }
       return -1;
    }
}

public class Test03 {
    public static void main(String[] args) {
        int[] arr={3,5,2,1,4};
        bubbleSort(arr);
    }
    private static void bubbleSort(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        printArr(arr);
    }
    private static void printArr(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]+" ");
        }
        System.out.println();
    }
}

递归

递归概述:以编程的角度来看，递归指的是方法定义中调用方法本身的现象

递归解决问题的思路把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算

递归解决问题要找到两个内容

递归出口:否则会出现内存溢出

递归规则:与原问题相似的规模较小的问题

异常:就是程序出现了不正常的情况。程序在执行过程中，出现的非正常的情况，最终会导致JVM 的非正常停止注意:语法错误不算在异常体系中。

Exception:称为异常类，它表示程序本身可以处理的问题

RuntimeException及其子类:运行时异常。(空指针异常，数组索引越界异常)

除RuntimeException之外所有的异常:编译期必须处理的，否则程序不能通过编译.(日期格式化异常)。

public class Test05 {
    public static void main(String[] args) {
        try {
            int result = new Test().devide(3,0);
            System.out.println("the result is"+result);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        System.out.println("program is running here,that is normal!");
    }
}
class Test
{
    public int devide(int x,int y){
        int result=x/y;
        return x/y;
    }
}

catch 关键字后跟有一个用括号括起来的Exception类型的参数e,这跟我们经常用到的如何定义一个函数接收的参数格式是一样的。括号中的 Exception 就是 ty 代码块传递给catch 代码块的变量类型，e就是变量名，所以我们也可以将 e 改用成别的名称(如ex 等)

如果一个方法中的语句执行时可能生成某种异常，但是并不能确定如何处理，则此方法应声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理也就是，程序中异常没有用 try...catch 捕捉异常、处理异常的代码，我们可以在程序代码所在的函数(方法)声明后用throws 声明该函数要抛出异常，将该异常抛出到该函数的调用函数中，一直到 main 方法，JVM 肯定要处理的，这样，编译就能通过了。用作者的话讲，就是将麻烦传递给了上级，村长传给乡长，乡长不处理就传给县长，县长不处理又传给市长，最后一直传到国务院就截止了，因为国务院没有上级了。在 Java 程序中， 异常传递到main 方法后，就截止了，因为没有哪个方法会调用 main 方法的。

public class Test06 {
    public static void main(String[] args) {
        try {
            int result = new Test1().devide(3, 1);
            System.out.println("the result is"+result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class Test1
{
    public int devide(int x,int y)throws Exception{
        int result=x/y;
        return x/y;
    }
}

ArithmeticException在算术运算中发生的异常，如除以零。

NullPointerException 变量还没有指向一个对象，就引用这个对象的成员ArrayIndexOutOfBoundsException访问数组对象中不存在的元素

除了系统提供的异常，我们也可以定义自己的异常类，自定义的异常类必须继承Exception类。假设我们在上面程序的 devide 函数中，不允许有负的被除数，当 devide 函数接收到一个负的被除数时，程序返回一个自定义的异常(这里就叫负数异常吧!)通知调用者。我们可以这样定义这个负数异常类。

在一个方法内使用 throw 关键字抛出了异常对象，如果该方法内部没有用 try...catch 语句对这个抛出的异常进行处理，则此方法应声明抛出异常，而由该方法的调用者负责处理。

publicclassTestException
{
    public static void main(String [l args)
    {
        try
        {
            int reslut = new Test().devide( 3， 0 );
            System.out.println("the result is" + result );
        }
        catch(DevideByMinusException e)
        {
            System.out.println("program is running into"+DevideByMinusException");
            System.out.printIn(e.getMessage());
            System.out.println("the devisor is " + e.getDevisor());
            System.exit(0);
        }
        catch(ArithMeticException e)
        {
            System.out.println("program is running into"+DevideByMinusException");
            Systen.out.printIn(e.getMessage());
            return ;
        }
        catch(Exception e)
        {
            System.out.println("program is running into"+"other unknowned Exception");
            System.out .printlnle.getMessage();
        }
        finally
        {
            System.out.println("program is running into finally");
        }
        System,out.printin("program is running here ,that is normal!");
    }
}

finally 还是有其特殊之处的，即使 try 代码块和catch代码块中使用了return 语句退出当前方法或 break 跳出某个循环，相关的 finally 代码块都要执行，读者可以逐一去掉程序中被注释的 devide 语句的注释符，注释掉其他的 devide 语句，对比观察运行结果。finally中的代码块不能被执行的惟一情况是:在被保护代码块中执行了Systemexit(0)。每个ty语句必须有一个或多个catch 语句对应，try 代码块与 catch 代码块及 finally 代码块之间不能有其他语句。

1.一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类

2.如果父类抛出多个异常，那么重写(覆盖)方法必须抛出那些异常的一个子集，也就是说，不能抛出新的异常。