乐趣区

关于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.Errorjava.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("亲,该用户名曾经注册");
      }
    }
  }
 

退出移动版