外围概述：本篇咱们还是将持续学习罕用的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("亲，该用户名曾经注册");      }    }  }