JavaSE第14篇：常用API、异常

核心概述：本篇我们还是将继续学习常用的API，其中有用于一些基本数学运算的工具类Math、任意精度的整数BigInteger类、超大浮点数据BigDecimal；此外，在程序开发的过程中，我们常常会遇到各种各样的异常现象，所以在本篇我们也将会学习认识并处理java中的异常。

第一章：Math类

1.1-概述（了解）

java.lang.Math 类包含用于执行基本数学运算的方法，如初等绝对值、四舍五入等。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

1.2-常用方法（记忆）

方法

image

代码

  public static void main(String[] args) {
    System.out.println(Math.abs(-100));   // 100
    System.out.println(Math.ceil(10.1));  // 11.0
    System.out.println(Math.floor(10.1));  // 10.0
  }

第二章：BigInteger类

2.1-概述（了解）

java.math.BigInteger类，不可变的任意精度的整数。如果运算中，数据的范围超过了long类型后，可以使用BigInteger类实现，该类的计算整数是不限制长度的。

2.2-构造方法（记忆）

BigInteger(String value) 将 BigInteger 的十进制字符串表示形式转换为 BigInteger。超过long类型的范围，已经不能称为数字了，因此构造方法中采用字符串的形式来表示超大整数，将超大整数封装成BigInteger对象。

2.3-常用方法（记忆）

方法

image

代码

public static void main(String[] args){
    BigInteger big1 = new BigInteger("987654321123456789000");
    BigInteger big2 = new BigInteger("123456789987654321");
    //加法运算
    BigInteger add = big1.add(big2);
    System.out.println("求和:"+add);
    //减法运算
    BigInteger sub = big1.subtract(big2);
    System.out.println("求差:"+sub);
    //乘法运算
    BigInteger mul = big1.multiply(big2);
    System.out.println("乘积:"+mul);
    //除法运算
    BigInteger div = big1.divide(big2);
    System.out.println("除法:"+div);
}

第三章：BigDecimal类

3.1-概述（了解）

java.math.BigDecimal类，不可变的、任意精度的有符号十进制数。该类可以实现超大浮点数据的精确运算。

3.2-构造方法（记忆）

BigDecimal(String value)将 BigDecimal的十进制字符串表示形式转换为 BigDecimal。

3.3-常用方法（记忆）

方法

image

divide方法

BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)
- divesor：此 BigDecimal 要除以的值。
- scale：保留的位数
- roundingMode：舍入方式
舍入方式：BigDecimal类提供静态的成员变量来表示舍入的方式
- BigDecimal.ROUND_UP 向上加1。
- BigDecimal.ROUND_DOWN 直接舍去。
- BigDecimal.ROUND_HALF_UP 四舍五入。

代码

public static void main(String[] args){
      BigDecimal big1 = new BigDecimal("5.25");
      BigDecimal big2 = new BigDecimal("3.25");
      //加法计算
      BigDecimal add = big1.add(big2);
      System.out.println("求和:"+add);
      //减法计算
      BigDecimal sub = big1.subtract(big2);
      System.out.println("求差:"+sub);
      //乘法计算
      BigDecimal mul = big1.multiply(big2);
      System.out.println("乘法:"+mul);
      //除法计算
      BigDecimal div = big1.divide(big2,2,BigDecimal.ROUND_HALF_UP);
      System.out.println(div);
}

第四章：基本类型包装类

4.1-概述（了解）

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

image

4.2-Integer类（了解）

概述

包装一个对象中的原始类型 int 的值。其构造方法和静态方法如下：

image

代码

public static void main(String[] args) {
    //public Integer(int value)：根据 int 值创建 Integer 对象(过时)
    Integer i1 = new Integer(100);
    System.out.println(i1);

    //public Integer(String s)：根据 String 值创建 Integer 对象(过时)
    Integer i2 = new Integer("100");
    //Integer i2 = new Integer("abc"); //NumberFormatException
    System.out.println(i2);
    System.out.println("--------");

    //public static Integer valueOf(int i)：返回表示指定的 int 值的 Integer 实例
    Integer i3 = Integer.valueOf(100);
    System.out.println(i3);

    //public static Integer valueOf(String s)：返回一个保存指定值的Integer对象 String
    Integer i4 = Integer.valueOf("100");
    System.out.println(i4);
}

4.3-装箱与拆箱（理解）

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

装箱：从基本类型转换为对应的包装类对象。
拆箱：从包装类对象转换为对应的基本类型。

用Integer与 int为例：（看懂代码即可）

基本数值---->包装对象

Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法

包装对象---->基本数值

int num = i.intValue();

4.4-自动装箱与拆箱（理解）

由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：

Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。

4.5-基本类型与字符串互相转换（记忆）

基本类型转String

转换方式：

方式一：直接在数字后加一个空字符串
方式二：通过String类静态方法valueOf()

示例代码：

public static void main(String[] args) {
    //int --- String
    int number = 100;
    //方式1
    String s1 = number + "";
    System.out.println(s1);
    //方式2
    //public static String valueOf(int i)
    String s2 = String.valueOf(number);
    System.out.println(s2);
}

String转基本类型

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。

代码：（以Integer为例）

public class Demo18WrapperParse {
    public static void main(String[] args) {
        int num = Integer.parseInt("100");
    }
}

第五章：认识异常

5.1-什么是异常（了解）

异常，就是不正常的意思。在生活中:医生说,你的身体某个部位有异常,该部位和正常相比有点不同,该部位的功能将受影响.在程序中的意思就是：

异常：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。（因程序问题而中断程序执行的现象。）

在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

需要注意的是：异常指的并不是语法错误，语法错了，编译不通过，不会产生字节码文件，根本不能运行。

5.2-异常体系（理解）

image

在Java中，为了维护程序正常执行，Java提供了处理异常的异常机制（异常类）。

在Java提供的异常机制中，其中java.lang.Throwable是根类，而根类的派生类有java.lang.Error和java.lang.Excepiton两个子类。

Error，错误（绝症，比如：“癌症”），该类型异常在程序中无法处理，只能尽量避免。

Excepiton，编译期异常（写源代码时）（小毛病，比如：类似感冒），该类型异常在程序中是可处理的。Excepiton类型还有一个子类RunTimeException，表示运行期异常（程序运行的过程中），该类型异常在程序中也是可处理的。

为了更好的区分以上描述的异常分类，我们看以下程序。

// 【Error异常】
// Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
// 内存溢出。超出了分配给JVM内存大小。
// 该程序只能修改源代码解决问题。
int[]nums = new int[1024*1024*1024];

// 【Exception异常】
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
// Unhandled exception: java.text.ParseException
// 此处在编写源代码时就发生异常，该异常后续可以通过相关的处理机制处理和避免
Date date = format.parse("2083-10-10"); 

// 【RunTimeException异常】
int[] nums = {1,2,3};
// Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException
// 在程序运行时出现的异常，数组下标超出。该异常可以通过相关异常机制处理
System.out.println(nums[4]);

5.3-异常产生的过程（理解）

在编程中，为了更好的处理异常，我们首先要了解异常产生的过程。下面通过一段异常代码来分析。

需求和代码

  // 需求：定义一个方法，用来获取指定数组的指定位置的元素
  public static void main(String[] args) {
    int[]nums = {1,2,3};
    System.out.println(getElement(nums,4));
  }
  public static int getElement(int[]arr,int index){
    return arr[index];
  }

分析

在执行getElement方法的过程中，JVM检测出数组索引越界异常，此时JVM会做两件事：
- 创建一个ArrayIndexOutOfBoundsException异常对象，该对象中包含了异常的信息（内容、原因、位置）
- 因为getElment方法中没有异常处理，JVM会把异常对象抛给getElment方法的调用处-main方法。
main方法接收到了ArrayIndexOutOfBoundsException异常对象，也没有处理异常，则会把异常对象抛给JVM
JVM接收到了main方法后，会做两件事：
- 在控制台打印异常信息（内容、原因、位置）
- 终止程序的执行

图解

image

第六章：处理异常

6.1-异常关键字（记忆）

try
catch
finally
throw
throws

6.2-抛出异常throw（理解）

概述

在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。

在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？

创建一个异常对象。封装一些提示信息(信息可以自己编写)。
需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字throw就可以完成。
- throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

使用格式

throw new 异常类名(参数);

代码演示

public static void main(String[] args) {
    //创建一个数组 
    int[] arr = {2,4,52,2};
    //根据索引找对应的元素 
    int index = 4;
    int element = getElement(arr, index);

    System.out.println(element);
    System.out.println("over");
}
  /*
   * 根据 索引找到数组中对应的元素
   */
public static int getElement(int[] arr,int index){ 
    //判断  索引是否越界
    if(index<0 || index>arr.length-1){
        /*
             判断条件如果满足，当执行完throw抛出异常对象后，方法已经无法继续运算。
             这时就会结束当前方法的执行，并将异常告知给调用者。这时就需要通过异常来解决。 
        */
        throw new ArrayIndexOutOfBoundsException("哥们，角标越界了~~~");
    }
    int element = arr[index];
    return element;
}

注意：如果产生了问题，我们就会throw将问题描述类即异常进行抛出，也就是将问题返回给该方法的调用者。

那么对于调用者来说，该怎么处理呢？一种是进行捕获处理，另一种就是继续讲问题声明出去，使用throws声明处理。

6.3-声明异常throws（理解）

什么是声明异常

将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理。

关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).

声明异常格式

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{   }

声明异常的代码演示：

public static void main(String[] args) throws FileNotFoundException {
    read("a.txt");
}

// 如果定义功能时有问题发生需要报告给调用者。可以通过在方法上使用throws关键字进行声明
public static void read(String path) throws FileNotFoundException {
    if (!path.equals("a.txt")) {//如果不是 a.txt这个文件 
        // 我假设  如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常  throw
        throw new FileNotFoundException("文件不存在");
    }
}

throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。

public static void main(String[] args) throws IOException {
    read("a.txt");
}

public static void read(String path)throws FileNotFoundException, IOException {
    if (!path.equals("a.txt")) {//如果不是 a.txt这个文件 
        // 我假设  如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常  throw
        throw new FileNotFoundException("文件不存在");
    }
    if (!path.equals("b.txt")) {
        throw new IOException();
    }
}

6.4-捕获异常try…catch （记忆）

throws声明异常的弊端是：异常后续代码无法执行（因为交给了JVM，JVM会终止程序）。

try-catch可以让调用者处理异常，并会继续执行后续程序。

try...catch格式

try{
     编写可能会出现异常的代码
}catch(异常类型  e){
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}

如何获取异常信息

Throwable类中定义了一些查看方法:

public String getMessage():获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。
public String toString():获取异常的类型和异常描述信息(不用)。
public void printStackTrace():打印异常的跟踪栈信息并输出到控制台。

包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。

代码演示

  // 需求：定义一个读取文件的方法，检测文件的路径和后缀名
  public static void main(String[] args)  {
    try{
      retFile("d.txt");
    }catch (Exception e) {
      e.printStackTrace();
    }
    System.out.println("后续代码");
    /*
     执行结果：
        java.io.IOException: 文件路径错误
            at it.leilei.cn.demo01.Main01.retFile(Main01.java:27)
            at it.leilei.cn.demo01.Main01.main(Main01.java:12)
        后续代码
    */


  }
  // 读取文件的方法
  private static void retFile(String path) throws IOException {
    // 如果后缀名不是.txt则抛出
    if(!path.contains(".txt")){
      throw  new FileNotFoundException("文件后缀名不是.txt");
    }
    if(!path.contains("c:")) {
      throw  new IOException("文件路径错误");
    }
  }

6.5-finally代码块（记忆）

为什么要使用finally代码块

finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。

什么时候的代码必须最终执行

当我们在try语句块中打开了一些物理资源(磁盘文件/网络连接/数据库连接等),我们都得在使用完之后,最终关闭打开的资源。

语法格式

try{
     编写可能会出现异常的代码
}catch(异常类型  e){
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}
...
finally{
    // 代码块
}

代码演示

// 需求：定义一个读取文件的方法，检测文件的路径和后缀名
  public static void main(String[] args)  {
    try{
      retFile("d.txt");
    }catch (Exception e) {
      e.printStackTrace();
    }finally {
      System.out.println("释放资源");
    }
    System.out.println("后续代码");


  }
  // 读取文件的方法
  private static void retFile(String path) throws IOException {
    // 如果后缀名不是.txt则抛出
    if(!path.contains(".txt")){
      throw  new FileNotFoundException("文件后缀名不是.txt");
    }
    if(!path.contains("c:")) {
      throw  new IOException("文件路径错误");
    }
  }

6.6-异常注意事项（了解）

注意事项

运行时异常被抛出可以不处理。即不捕获也不声明抛出。
如果父类抛出了多个异常,子类覆盖父类方法时,只能抛出相同的异常或者是他的子集。
父类方法没有抛出异常，子类覆盖父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
当多异常处理时，捕获处理，前边的类不能是后边类的父类
在try/catch后可以追加finally代码块，其中的代码一定会被执行，通常用于资源回收。
多个异常使用捕获又该如何处理呢？
1. 多个异常分别处理。
2. 多个异常一次捕获，多次处理。
3. 多个异常一次捕获一次处理。

多个异常常用方式

try{
     编写可能会出现异常的代码
}catch(异常类型A  e){  当try中出现A类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}catch(异常类型B  e){  当try中出现B类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}

第七章：自定义异常类

3.1 为什么要自定义异常类（了解）

我们说了Java中不同的异常类,分别表示着某一种具体的异常情况,那么在开发中总是有些异常情况是SUN没有定义好的,此时我们根据自己业务的异常情况来定义异常类。例如年龄负数问题,考试成绩负数问题等等。

3.2 什么是自定义异常类（了解）

在开发中根据自己业务的异常情况来定义异常类.

自定义一个业务逻辑异常: RegisterException。一个注册异常类。

3.3 如何定义异常类（记忆）

自定义一个编译期异常: 自定义类并继承于 java.lang.Exception 。
自定义一个运行时期的异常类:自定义类并继承于 java.lang.RuntimeException 。

3.4 代码演示（练习）

要求：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。

自定义异常类：

public class RegisterException extends Exception{
  public RegisterException(){
      super();
  }
  public RegisterException(String message){
      super(message);
  }

}

测试：

  public static void main(String[] args)  {
    // 接收用户注册的用户名
    String name = new Scanner(System.in).next();
    try{
      check(name);
    }catch (RegisterException e){
      e.printStackTrace();
      return;
    }
    System.out.println("注册成功");
  }

  public static void check(String n) throws RegisterException{
    String[]users={"张三","李四","王五"};
    for (int i = 0; i < users.length; i++) {
      if (n.equals( users[i])) {
        throw new RegisterException("亲，该用户名已经注册");
      }
    }
  }

image