关于java:JavaSE第14篇常用API异常

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

第一章：Math 类

1.1- 概述（理解）

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

1.2- 罕用办法（记忆）

办法

代码

  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- 罕用办法（记忆）

办法

代码

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- 罕用办法（记忆）

办法

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 提供了两个类型零碎，根本类型与援用类型，应用根本类型在于效率，然而很多状况，会创建对象应用，因为对象能够做更多的性能，如果想要咱们的根本类型像对象一样操作，就能够应用根本类型对应的包装类，如下：

4.2-Integer 类（理解）

概述

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

代码

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- 异样体系（了解）

在 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 办法后，会做两件事：

  • 在控制台打印异样信息（内容、起因、地位）
  • 终止程序的执行

图解

第六章：解决异样

6.1- 异样关键字（记忆）

• try
• catch
• finally
• throw
• throws

6.2- 抛出异样 throw（了解）

概述

在编写程序时，咱们必须要思考程序呈现问题的状况。比方，在定义方法时，办法须要承受参数。那么，当调用办法应用承受到的参数时，首先须要先对参数数据进行非法的判断，数据若不非法，就应该通知调用者，传递非法的数据进来。这时须要应用抛出异样的形式来通知调用者。

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

1. 创立一个异样对象。封装一些提示信息(信息能够本人编写)。

2. 须要将这个异样对象告知给调用者。怎么告知呢？怎么将这个异样对象传递到调用者处呢？通过关键字 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 如何定义异样类（记忆）

1. 自定义一个编译期异样: 自定义类 并继承于 java.lang.Exception。
2. 自定义一个运行期间的异样类: 自定义类 并继承于 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("亲，该用户名曾经注册");
      }
    }
  }