Java知识点05——泛型、异常处理
声明:
- 该资料来自自己整理。
- 参考书籍
疯狂 Java讲义(第五版) 李刚©著
一、泛型(Generic)
1.1 泛型概述
泛型:可以在类或方法中预知地使用未知的类型。
泛型机制将类型转换时的类型检查从运行时提前到了编译时,在强制类型转换的机制具有更好的可读性和安全性。
tips:一般在创建对象时,将未知的类型确定具体的类型。当没有指定泛型时,默认类型为Object类型。
1.2 泛型的定义与使用
1.2.1 定义
定义格式:
修饰符 class 类名<代表泛型的变量> { }
例如,API中的ArrayList集合:
class ArrayList<E>{
public boolean add(E e){ }
public E get(int index){ }
....
}
使用泛型: 即什么时候确定泛型。
在创建对象的时候确定泛型
例如,ArrayList<String> list = new ArrayList<String>();
此时,变量E的值就是String类型,那么我们的类型就可以理解为:
class ArrayList<String>{
public boolean add(String e){ }
public String get(int index){ }
...
}
再例如,ArrayList<Integer> list = new ArrayList<Integer>();
此时,变量E的值就是Integer类型,那么我们的类型就可以理解为:
class ArrayList<Integer> {
public boolean add(Integer e) { }
public Integer get(int index) { }
...
}
举例自定义泛型类
public class MyGenericClass<MVP> {
//没有MVP类型,在这里代表 未知的一种数据类型 未来传递什么就是什么类型
private MVP mvp;
public void setMVP(MVP mvp) {
this.mvp = mvp;
}
public MVP getMVP() {
return mvp;
}
}
使用:
public class GenericClassDemo {
public static void main(String[] args) {
// 创建一个泛型为String的类
MyGenericClass<String> my = new MyGenericClass<String>();
// 调用setMVP
my.setMVP("大胡子登登");
// 调用getMVP
String mvp = my.getMVP();
System.out.println(mvp);
//创建一个泛型为Integer的类
MyGenericClass<Integer> my2 = new MyGenericClass<Integer>();
my2.setMVP(123);
Integer mvp2 = my2.getMVP();
}
}
1.2.2 含泛型的类
定义格式:修饰符 class 类名< 代表泛型的变量 > { }
例如,API中的ArrayList集合:
class ArrayList< E >{
public boolean add(E e){ }
public E get(int index){ }
....
}
使用泛型: 即什么时候确定泛型。
在创建对象的时候确定泛型
例如,ArrayList<String> list = new ArrayList<String>();
此时,变量E的值就是String类型,那么我们的类型就可以理解为:
class ArrayList<String>{
public boolean add(String e){ }
public String get(int index){ }
...
}
1.2.3 含泛型的接口
定义格式:修饰符 interface 接口名<代表泛型的变量> { }
public interface MyGenericInterface<E>{
public abstract void add(E e);
public abstract E getE();
}
使用格式:
1、定义类时确定泛型的类型
public class MyImp1 implements MyGenericInterface<String> {
@Override
public void add(String e) {
// 省略...
}
@Override
public String getE() {
return null;
}
}
此时,泛型E的值就是String类型。
2、始终不确定泛型的类型,直到创建对象时,确定泛型的类型
public class MyImp2<E> implements MyGenericInterface<E> {
@Override
public void add(E e) {
// 省略...
}
@Override
public E getE() {
return null;
}
}
确定泛型:
public class GenericInterface {
public static void main(String[] args) {
MyImp2<String> my = new MyImp2<String>();
my.add("aa");
}
}
1.2.4 含泛型的方法
定义格式:修饰符 < 代表泛型的变量 > 返回值类型 方法名(参数){ }
例如
public class MyGenericMethod {
public <MVP> void show(MVP mvp) {
System.out.println(mvp.getClass());
}
public <MVP> MVP show2(MVP mvp) {
return mvp;
}
}
使用格式:调用方法时,确定泛型的类型
public class GenericMethodDemo {
public static void main(String[] args) {
// 创建对象
MyGenericMethod mm = new MyGenericMethod();
// 演示看方法提示
mm.show("aaa");
mm.show(123);
mm.show(12.45);
}
}
1.3 泛型通配符
当使用泛型类或者接口时,传递的数据中,泛型类型不确定,可以通过通配符<?>
表示。但是一旦使用泛型的通配符后,只能使用Object类中的共性方法,集合中元素自身方法无法使用。
1.3.1 通配符基本使用
泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?
,?表示未知通配符。
此时只能接受数据,不能往该集合中存储数据。
举个例子大家理解使用即可:
public static void main(String[] args) {
Collection<Intger> list1 = new ArrayList<Integer>();
getElement(list1);
Collection<String> list2 = new ArrayList<String>();
getElement(list2);
}
public static void getElement(Collection<?> coll){}
//?代表可以接收任意类型
tips:泛型不存在继承关系 Collection list = new ArrayList();这种是错误的。
1.3.2 通配符高级使用----受限泛型
之前设置泛型的时候,实际上是可以任意设置的,只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。
泛型的上限:
- 格式:
类型名称 <? extends 类 > 对象名称
- 意义:
只能接收该类型及其子类
泛型的下限:
- 格式:
类型名称 <? super 类 > 对象名称
- 意义:
只能接收该类型及其父类型
比如:现已知Object类,String 类,Number类,Integer类,其中Number是Integer的父类
public static void main(String[] args) {
Collection<Integer> list1 = new ArrayList<Integer>();
Collection<String> list2 = new ArrayList<String>();
Collection<Number> list3 = new ArrayList<Number>();
Collection<Object> list4 = new ArrayList<Object>();
getElement1(list1);
getElement1(list2);//报错
getElement1(list3);
getElement1(list4);//报错
getElement2(list1);//报错
getElement2(list2);//报错
getElement2(list3);
getElement2(list4);
}
// 泛型的上限:此时的泛型?,必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限:此时的泛型?,必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}
1.4 使用泛型的好处
- 将运行时期的ClassCastException,转移到了编译时期变成了编译失败。
- 避免了类型强转的麻烦。
通过我们如下代码体验一下:
public class GenericDemo2 {
public static void main(String[] args) {
Collection<String> list = new ArrayList<String>();
list.add("abc");
list.add("hjm");
// list.add(5);//当集合明确类型后,存放类型不一致就会编译报错
// 集合已经明确具体存放的元素类型,那么在使用迭代器的时候,迭代器也同样会知道具体遍历元素类型
Iterator<String> it = list.iterator();
while(it.hasNext()){
String str = it.next();
//当使用Iterator<String>控制元素类型后,就不需要强转了。获取到的元素直接就是String类型
System.out.println(str.length());
}
}
}
tips:泛型是数据类型的一部分,我们将类名与泛型合并一起看做数据类型。
二、异常处理
2.1 异常
2.1.1 异常概念
Java提出了一种假设:如果程序可以顺利完成,那就“一切正常”,把系统的业务实现代码放在try块中定义,所有的异常处理逻辑放在catch块中进行处理。
- 异常 :指的是程序在执行过程中,出现的非正常的情况,最终会导致JVM的非正常停止。
在Java等面向对象的编程语言中,异常本身是一个类,产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。
异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行.
2.1.2 异常体系
异常机制其实是帮助我们找到程序中的问题,异常的根类是java.lang.Throwable
,其下有两个子类:java.lang.Error
与java.lang.Exception
,平常所说的异常指java.lang.Exception
。
Throwable体系:
- Error:Error错误,一般是指与虚拟机相关的问题,如系统崩溃、虚拟机错误、动态链接失败等,这种错误无法恢复和捕获,将导致应用程序中断。无法通过处理的错误,只能事先避免。
- Exception:表示异常,异常产生后程序员可以通过代码的方式纠正,使程序继续运行,是必须要处理的。
Throwable中的常用方法:
-
public void printStackTrace()
:打印异常的详细信息。包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。
-
public String getMessage()
:获取发生异常的原因。提示给用户的时候,就提示错误原因。
-
public String toString()
:获取异常的类型和异常描述信息(不用)。
【异常案例】
2.2 异常分类
我们平常说的异常就是指Exception,因为这类异常一旦出现,我们就要对代码进行更正,修复程序。
异常(Exception)的分类:根据在编译时期还是运行时期去检查异常?
编译时期异常
:checked异常。在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常)运行时期异常
:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。(如数学异常)
2.2.1 异常的产生过程解析
先运行下面的程序,程序会产生一个数组索引越界异常ArrayIndexOfBoundsException。我们通过图解来解析下异常产生的过程。
工具类
public class ArrayTools {
// 对给定的数组通过给定的角标获取元素。
public static int getElement(int[] arr, int index) {
int element = arr[index];
return element;
}
}
测试类
public class ExceptionDemo {
public static void main(String[] args) {
int[] arr = { 34, 12, 67 };
intnum = ArrayTools.getElement(arr, 4)
System.out.println("num=" + num);
System.out.println("over");
}
}
上述程序执行过程图解:
2.3 异常的处理
Java异常处理的五个关键字:try、catch、finally、throw、throws
2.3.1 抛出异常 throw
如果执行try块里的业务逻辑代码块时出现异常,系统自动生成一个异常对象,该异常对象被提交给Java运行时环境,这个过程被称为抛出(throw)异常
。
在编写程序时,我们必须要考虑程序出现问题的情况。比如,在定义方法时,方法需要接受参数。那么,当调用方法使用接受到的参数时,首先需要先对参数数据进行合法的判断,数据若不合法,就应该告诉调用者,传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。
在java中,提供了一个throw关键字,它用来抛出一个指定的异常对象。那么,抛出一个异常具体如何操作呢?
- 创建一个异常对象。封装一些提示信息(信息可以自己编写)。
- 需要将这个异常对象告知给调用者。怎么告知呢?怎么将这个异常对象传递到调用者处呢?通过关键字throw就可以完成。throw 异常对象。
throw用在方法内,用来抛出一个异常对象,将这个异常对象传递到调用者处,并结束当前方法的执行。
使用格式:throw new 异常类名(参数);
例如:
throw new NullPointerException("要访问的arr数组不存在");
throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在,已超出范围");
学习完抛出异常的格式后,我们通过下面程序演示下throw的使用。
public class ThrowExceptionTest {
public static void main(String[] args) {
int[] arr = {1,2,3,4};
int index = 4;
int element = getElement(arr,index);
}
private static int getElement(int[] arr, int index) {
//判断 索引是否越界
if(index<0 || index>=arr.length){
/*
判断条件如果满足,当执行完throw抛出异常对象后,方法已经无法继续运算。
这时就会结束当前方法的执行,并将异常告知给调用者。这时就需要通过异常来解决。
*/
throw new ArrayIndexOutOfBoundsException("数组越界异常。。。");
}
return arr[index];
}
}
注意:如果产生了问题,我们就会throw将问题描述类即异常进行抛出,也就是将问题返回给该方法的调用者。那么对于调用者来说,该怎么处理呢?一种是进行
捕获处理
,另一种就是继续讲问题声明出去,使用throws声明处理
。
2.3.2 Objects非空判断
类Objects 在它的源码中,对对象为 null 的值进行了抛出异常操作。
public static <T> T requireNonNull(T obj)
:查看指定引用对象不是null。
查看源码发现这里对为null的进行了抛出异常操作:
public static <T> T requireNonNull(T obj) {
if (obj == null)
throw new NullPointerException();
return obj;
}
import java.util.Objects;
public class ObjectsNullTest {
public static void main(String[] args) {
method(null);
}
public static void method(Object obj){
//对传递过来的参数进行合法性校验
//Objects.requireNonNull(obj);//NullPointerException
//NullPointerException: 传递过来的对象为null
Objects.requireNonNull(obj,"传递过来的对象为null");
}
}
2.3.3 声明异常 throws(方法一)
声明异常:将问题标识出来,报告给调用者。如果方法内通过throw抛出了编译时异常,而没有捕获处理(稍后讲解该方式),那么必须通过throws进行声明,让调用者去处理。
关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).
声明异常格式:修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{ }
【声明异常的代码演示】:
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* 注意:1.throws关键字必须写在方法声明处
* 2.throws关键字后面声明的异常必须是Exception或者是Exception的子类
* 3.方法内部如果抛出了多个异常对象,那么throws后边必须也声明多个异常,
* 如果抛出的多个异常对象有父子关系,那么直接声明父类异常即可。
* 4.调用了一个声明抛出异常的方法,我们就必须得处理声明的异常,要么继续使用throws声明抛出,
* 交给方法的调用者处理,最终交给JVM;要么try...catch自己处理异常
*/
public class ThrowsException {
//作为redFile方法的调用者main方法也必须对redFile方法抛出的异常进行处理
public static void main(String[] args) throws IOException {
redFile("d:\\a.doc");
System.out.println("如果redFile方法抛出异常,则该行语句不会执行!!");
}
//FileNotFoundException extends IOException extends Exception
//public static void redFile(String fileName) throws FileNotFoundException, IOException
//所以这里使用声明一个父类异常对象即可即IOException
public static void redFile(String fileName) throws IOException {
if (!fileName.equals("c:\\a.txt")){
throw new FileNotFoundException("文件路径不是规定的路径!");
}
if (fileName.endsWith(".txt")) {
throw new IOException("文件后缀名不正确");
}
System.out.println("路径正确读取文件");
}
}
注意:如果上述代码中main方法中的redFile()方法出现异常,则其后面的代码不会执行!!!!
throws用于进行异常类的声明,若该方法可能有多种异常情况产生,那么在throws后面可以写多个异常类,用逗号隔开。
public class ThrowsDemo2 {
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();
}
}
}
2.3.4 捕获异常 try…catch(方法二)
Java提出了一种假设:如果程序可以顺利完成,那就“一切正常”,把系统的业务实现代码放在try块中定义,所有的异常处理逻辑放在catch块中进行处理。
如果异常出现的话,会立刻终止程序,所以我们得处理异常:
- 该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)。
- 在方法中使用try-catch的语句块来处理异常。
try-catch的方式就是捕获异常。
- 捕获异常:Java中对异常有针对性的语句进行捕获,可以对出现的异常进行指定方式的处理。
捕获异常语法如下:
try{
编写可能会出现异常的代码
}catch(异常类型 e){
处理异常的代码
//记录日志/打印异常信息/继续抛出异常
}
try: 该代码块中编写可能产生异常的代码。
catch: 用来进行某种异常的捕获,实现对捕获到的异常进行处理。
注意:try和catch都不能单独使用,必须连用。
捕获异常时,一定要注意先捕获小异常,再捕获大异常。
演示如下:
import java.io.IOException;
/**
*注意:1.try中可能会抛出多个异常对象,那么就可以使用多个catch来处理这些异常对象
* 2.如果try中产生了异常,那么就会执行catch中的异常处理逻辑,执行完毕catch中的处理逻辑,继续执行try...catch之后的代码【try中没有执行完的代码就不会执行】
* 如果try中没有产生异常,那么就不会执行catch中异常的处理逻辑,执行完try中的代码,继续执行try...catch之后的代码
*/
public class TryCatchTest {
public static void main(String[] args) {
try{
//将可能抛出异常的语句放在try块中
redFile("d:\\hello.tx");
}catch (IOException e){
System.out.println("catch 中的处理逻辑代码");
}
System.out.println("try...catch 后面的代码可以继续执行");
}
private static void redFile(String fileName) throws IOException {
if (!fileName.endsWith(".txt")){
throw new IOException("文件后缀名不是.txt");
}
System.out.println("开始读取文件");
}
}
2.4 访问异常信息
如何获取异常信息:
Throwable类中定义了一些查看方法:
-
public String getMessage()
:返回此throwable的简短描述;获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。 -
public String toString()
:返回此throwable的详细消息字符串;获取异常的类型和异常描述信息(不用)。 -
public void printStackTrace()
:JVM打印异常对象(默认此方法),打印的异常信息最全面;打印异常的跟踪栈信息并输出到控制台。
包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。
import java.io.IOException;
/**
*注意:1.try中可能会抛出多个异常对象,那么就可以使用多个catch来处理这些异常对象
* 2.如果try中产生了异常,那么就会执行catch中的异常处理逻辑,执行完毕catch中的处理逻辑,继续执行try...catch之后的代码【try中没有执行完的代码就不会执行】
* 如果try中没有产生异常,那么就不会执行catch中异常的处理逻辑,执行完try中的代码,继续执行try...catch之后的代码
*/
public class TryCatchTest {
public static void main(String[] args) {
try{
//将可能抛出异常的语句放在try块中
redFile("d:\\hello.tx");
}catch (IOException e){
System.out.println("catch 中的处理逻辑代码");
System.out.println("e:"+e);
System.out.println("String getMessage():"+e.getMessage());
System.out.println("String toString():"+e.toString());
e.printStackTrace();
}
System.out.println("try...catch 后面的代码可以继续执行");
}
private static void redFile(String fileName) throws IOException {
if (!fileName.endsWith(".txt")){
throw new IOException("文件后缀名不是.txt");
}
System.out.println("开始读取文件");
}
}
2.5 finally 代码块
finally:有一些特定的代码无论异常是否发生,都需要执行。另外,因为异常会引发程序跳转,导致有些语句执行不到。而finally就是解决这个问题的,在finally代码块中存放的代码都是一定会被执行的。
什么时候的代码必须最终执行?
当我们在try语句块中打开了一些物理资源(磁盘文件/网络连接/数据库连接等),我们都得在使用完之后,最终关闭打开的资源。
finally的语法: try...catch....finally
:自身需要处理异常,最终还得关闭资源。
注意:finally不能单独使用。
比如在我们之后学习的IO流中,当打开了一个关联文件的资源,最后程序不管结果如何,都需要把这个资源关闭掉。
finally代码参考如下【案例】:
public class TryCatchDemo4 {
public static void main(String[] args) {
try {
//可能产生异常的代码
read("a.txt");
} catch (FileNotFoundException e) {
//异常的处理逻辑
throw new RuntimeException(e);
} finally {
//无论是否出现异常,都会执行
System.out.println("不管程序怎样,这里都将会被执行。");
System.out.println("一般用于资源释放!!");
}
System.out.println("over");
}
//产生异常的red()方法
public static void read(String path) throws FileNotFoundException {
if (!path.equals("a.txt")) {
throw new FileNotFoundException("文件不存在");
}
}
}
当只有在try或者catch中调用退出JVM的相关方法,此时finally才不会执行,否则finally永远会执行。
2.6 异常注意事项
2.6.1 多异常捕获
public class MultiExceptionTest {
public static void main(String[] args) {
try {
int a = Integer.parseInt(args[0]);
int b = Integer.parseInt(args[1]);
int c = a / b;
System.out.println("您输入的两个数相除的结果是:"+c);
}catch (IndexOutOfBoundsException | NumberFormatException | ArithmeticException ie){
System.out.println("程序发生了数组越界异常、数字格式异常、算数异常之一");
//捕获多异常时,异常变量默认有final修饰,重新赋值会报错
//ie = new ArithmeticException("test");
}catch (Exception e){
System.out.println("未知异常");
//捕获一种异常时,异常变量没有final修饰
e = new RuntimeException("test");
}
}
}
多个异常使用捕获又该如何处理呢?
- 多个异常分别处理。
- 多个异常一次捕获,多次处理。
- 多个异常一次捕获一次处理。
一般我们是使用一次捕获多次处理方式,格式如下:
try{
编写可能会出现异常的代码
}catch(异常类型A e){ 当try中出现A类型异常,就用该catch来捕获.
处理异常的代码
//记录日志/打印异常信息/继续抛出异常
}catch(异常类型B e){ 当try中出现B类型异常,就用该catch来捕获.
处理异常的代码
//记录日志/打印异常信息/继续抛出异常
}
注意:这种异常处理方式,要求多个catch中的异常不能相同,并且若catch中的多个异常之间有子父类异常的关系,那么子类异常要求在上面的catch处理,父类异常在下面的catch处理。
public class TryCatchTest02 {
public static void main(String[] args) {
//1.多个异常分别处理
System.out.println("//1.多个异常分别处理");
try{
int[] arr = {1,2,3};
System.out.println(arr[3]);
}catch (ArrayIndexOutOfBoundsException e){
System.out.println(e);
}
try{
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
System.out.println(list.get(3));
}catch (IndexOutOfBoundsException e){
System.out.println(e);
}
//2.多个异常一次捕获,多次处理
/**
* ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException
* 注意:1.catch里面定义的异常变量,如果有子父类关系,那么子类异常变量必须写在上边,否则会报错
*/
try{
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
System.out.println(list.get(3));
}catch (ArrayIndexOutOfBoundsException e){
System.out.println(e);
}catch (IndexOutOfBoundsException e){
System.out.println(e);
}
//3.多个异常一次捕获一次处理 即抛出的异常是所有出现异常的 公共父类!!
try{
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
System.out.println(list.get(3));
}catch (IndexOutOfBoundsException e){
System.out.println(e);
}
System.out.println("后续代码...");
}
}
-
运行时异常被抛出可以不处理。即不捕获也不声明抛出。
-
如果finally有return语句,永远返回finally中的结果,避免该情况.
-
如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
-
父类方法没有抛出异常,子类重写父类该方法时也不可抛出异常。此时子类产生该异常,只能捕获处理,不能声明抛出
-
通常情况下,不要再 finally块 中使用如 return 或 throw 等导致方法终止的语句,一旦在finally块中使用了return或throw语句,将会使try块、catch块中的return、throw语句失效!
2.6.2 子父类异常
public class ZiFuClassException {
public void show01() throws NullPointerException,ClassCastException{}
public void show02() throws IndexOutOfBoundsException{}
public void show03() throws IndexOutOfBoundsException{}
public void show04() {}
}
class Zi extends ZiFuClassException{
//1.子类重写父类方法时,抛出和父类相同的异常
public void show01() throws NullPointerException,ClassCastException{}
//2.子类重写父类方法时,抛出父类异常的子类
public void show02() throws ArrayIndexOutOfBoundsException{}
//3.子类重写父类方法时,不抛出异常
public void show03() {}
//4.父类方法没有抛出异常,子类重写父类方法时也不能抛出异常,
// 此时此类产生该异常,只能捕获处理,不能声明处理
//public void show04() thorws Exception{} //错误
public void show04(){
try {
throw new Exception("编译期异常");
}catch (Exception e){
System.out.println(e);
}
}
}
2.7 自定义异常
2.7.1 概述、定义
什么是自定义异常类:
在开发中根据自己业务的异常情况来定义异常类.
自定义一个业务逻辑异常: RegisterException。一个注册异常类。
异常类如何定义:
- 自定义一个编译期异常: 自定义类 并继承于
java.lang.Exception
。 - 自定义一个运行时期的异常类:自定义类 并继承于
java.lang.RuntimeException
。
2.7.2 自定义异常的练习
要求:我们模拟注册操作,如果用户名已存在,则抛出异常并提示:亲,该用户名已经被注册。
首先定义一个登陆异常类RegisterException:
// 业务逻辑异常
public class RegisterException extends Exception {
/**
* 空参构造
*/
public RegisterException() {
}
/**
*
* @param message 表示异常提示
*/
public RegisterException(String message) {
super(message);
}
}
/**
* 自定义异常类:
* java提供的异常类,不够我们使用,需要子集定义一些异常类
* 格式:
* public class XXXException extends Excetpion | RuntimeException{
* 添加一个空参数的构造方法
* 添加一个带异常信息的构造方法
* }
* 注意:
* 1.自定义异常类一般都是以Exception结尾,说明该类是一个异常类
* 2.自定义异常类,必须得继承Exception或者RuntimeException
* 继承Exception:那么自定义的异常类就是一个编译期异常,
* 如果方法内部抛出了编译期异常,就必须处理这个异常,要么throws,要么try...catch。
* 继承RuntimeException:那么自定义的异常类就是一个运行期异常,
* 无需处理,交给虚拟机处理(中断处理)
*/
public class CustomException extends Exception{
//添加一个空参数的方法
public CustomException(){
super();
}
//添加一个带异常信息的构造方法
//方法内部会调用父类带异常信息的构造方法,让父类来处理这个异常信息
public CustomException(String message){
super(message);
}
}
模拟登陆操作,使用数组模拟数据库中存储的数据,并提供当前注册账号是否存在方法用于判断。
public class Demo {
// 模拟数据库中已存在账号
private static String[] names = {"bill","hill","jill"};
public static void main(String[] args) {
//调用方法
try{
// 可能出现异常的代码
checkUsername("nill");
System.out.println("注册成功");//如果没有异常就是注册成功
}catch(RegisterException e){
//处理异常
e.printStackTrace();
}
}
//判断当前注册账号是否存在
//因为是编译期异常,又想调用者去处理 所以声明该异常
public static boolean checkUsername(String uname) throws RegisterException{
for (String name : names) {
if(name.equals(uname)){//如果名字在这里面 就抛出登陆异常
throw new RegisterException("亲"+name+"已经被注册了!");
}
}
return true;
}
}
2.8 JDK7 和 JDK9 对try…catch的优化
JDK7前处理
之前的入门练习,我们一直把异常抛出,而实际开发中并不能这样处理,建议使用try...catch...finally
代码块,处理异常部分,代码使用演示:
public class HandleException1 {
public static void main(String[] args) {
// 声明变量
FileWriter fw = null;
try {
//创建流对象
fw = new FileWriter("fw.txt");
// 写出数据
fw.write("我是程序员"); //我是程序员
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fw != null) {
fw.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
JDK7的处理(扩展知识点了解内容)
还可以使用JDK7优化后的try-with-resource
语句,该语句确保了每个资源在语句结束时关闭(该资源类需要实现 AutoCloseable 接口
并重写 close 方法
,才可以自动关闭)。所谓的资源(resource)是指在程序完成后,必须关闭的对象。
格式:
try (创建流对象语句,如果多个,使用';'隔开) {
// 读写数据
} catch (IOException e) {
e.printStackTrace();
}
代码使用演示:
public class HandleException2 {
public static void main(String[] args) {
// 创建流对象
try ( FileWriter fw = new FileWriter("fw.txt"); ) {
// 写出数据
fw.write("我是程序员"); //我是程序员
} catch (IOException e) {
e.printStackTrace();
}
}
}
JDK9的改进(扩展知识点了解内容)
JDK9中try-with-resource
的改进,对于引入对象的方式,支持的更加简洁。被引入的对象,同样可以自动关闭,无需手动close,我们来了解一下格式。
改进前格式:
// 被final修饰的对象
final Resource resource1 = new Resource("resource1");
// 普通对象
Resource resource2 = new Resource("resource2");
// 引入方式:创建新的变量保存
try (Resource r1 = resource1;
Resource r2 = resource2) {
// 使用对象
}
改进后格式:
// 被final修饰的对象
final Resource resource1 = new Resource("resource1");
// 普通对象
Resource resource2 = new Resource("resource2");
// 引入方式:直接引入
try (resource1; resource2) {
// 使用对象
}
改进后,代码使用演示:
public class TryDemo {
public static void main(String[] args) throws IOException {
// 创建流对象
final FileReader fr = new FileReader("in.txt");
FileWriter fw = new FileWriter("out.txt");
// 引入到try中
try (fr; fw) {
// 定义变量
int b;
// 读取数据
while ((b = fr.read())!=-1) {
// 写出数据
fw.write(b);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}