异常 Throwable
所有异常类的根类
error
错误，不能被处理，因为是系统内部的错误，运行报错，系统问题
- 内存溢出
- 系统崩溃
Exception
编译期异常，编码中出现的，根据问题描述可以处理的
- RuntimeException运行期异常，运行过程出现的问题
//例如
package java15;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Exception {
public static void main(String[] args) /*throws ParseException*/ {
// SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
// Date date = null;
// try {
// date = sdf.parse("2000-1103");
// } catch (ParseException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// System.out.println(date);
// System.out.println("后续方法");
// /*
// * 解决异常方法
// * throws ParseException 抛出异常，有错误直接输出异常 后续代码不实现
// * 第二种，后续方法可实现
// */
//运行期异常 //也可以用Try catch处理 快捷键 shift+alt+z
// int[] arr= {1,2,3};
// System.out.println(arr[0]);
// try {
// System.out.println(arr[3]);
// } catch (java.lang.Exception e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
//
// System.out.println("后续代码");
}
}
异常的处理
try ， catch , finally , throw , throws
throw关键字
package java15;
public class ThrowMain {
/*
在指定方法抛出指定异常
格式
throw new xxxException（“产生原因”）；
注
必须写在方法内部
方法对象必须是Exception或他的子类
throw抛出异常，必须处理这个异常
throw关键字后面创建的是运行异常，可以不处理
创建的是编译异常，必须处理，try，throw
*/
public static void main(String[] args) {
//method(null, 0);
int[] arr= {1,2,3};
method(arr, 3);
}
private static int method(int[] arr,int index) {
//对传递的参数合法性校验
//空指针异常
if(arr==null) {
throw new NullPointerException("传递的是空");
}
//数组越界异常
if(index < 0 || index >arr.length-1 ) {
throw new ArrayIndexOutOfBoundsException("数组索引越界");
}
int x=arr[index];
return x;
}
}
Objects静态方法
requireNonNull方法
import java.util.Objects;
public class ObjectMain {
public static void main(String[] args) {
method(null);
}
private static void method(Object obj) {
//自己书写代码合理性判断
// if(obj==null) {
// throw new NullPointerException("空指针异常");
// }
//使用方法自行判断
// Objects.requireNonNull(obj);
Objects.requireNonNull(obj, "空指针异常");
}
}
异常处理1----throws
package java15;
import java.io.FileNotFoundException;
import java.io.IOException;
public class ThrowsMain {
/*
* 异常处理的第一种方法
* 会把异常对象声明抛出给方法调用者处理，自己不处理，给别人处理，JVM处理
* 格式
* 修饰符 返回值类型 方法名（参数列表） throws{
* throw new AAAException(“产生原因”);
* ...
* }
*
* 注意：
* throws关键字必须写在方法声明处
* throws关键字后面声明的异常必须是Exception，或者是Exception的子类
* 方法内部如果抛出了多个异常对象，那么throws垢面必须声明多个异常
* 如果抛出的多个异常对象有字父类关系，那么直接声明父类异常
* 调用一个声明抛出异常的方法，必须处理声明的异常
* throws/try catch
*
*/
public static void main(String[] args) throws FileNotFoundException,IOException { //调用一个声明抛出异常的方法，必须处理声明的异常
method1("c:\\a.tx");
System.out.println("后续代码"); //后续代码不执行
}
private static void method1(String FileName) throws FileNotFoundException,IOException {
if(!FileName.equals("c:\\a.txt")) {
throw new FileNotFoundException("传递路径错误");
}
/*
* 如果后缀名不对
*
*/
if(!FileName.endsWith(".txt")) {
throw new IOException("后缀命错误");
}
System.out.println("路径正确，读取文件中.......");
}
}
异常处理2----try catch
package java15;
import java.io.FileNotFoundException;
import java.io.IOException;
public class TryCatchMain {
/*
* 自己处理异常
* try{
* 可能产生的异常代码
* }catch（定义一个异常变量，接受try抛出异常对象）{
* 异常的处理逻辑，，异常对象之后，怎么处理异常对象
* 一般把异常的信息记录到日志中
* }
* ...
* catch(异常类名 变量名){
* }
*
* 注意：
* 1.try种抛出多个异常，可以使用多个catch来处理这些异常对象
* 2.如果try种产生了异常，那么会执行catch中的异常处理逻辑，处理完后继续执行后续代码
如果没产生异常，就不会执行catch
*/
public static void main(String[] args) {
try {
method1("abc");
System.out.println("后续代码");//不执行
} catch (IOException e) {
// try抛出异常的接受
System.out.println("后缀命错误");
}
System.out.println("后续代码");//执行
}
private static void method1(String FileName) throws FileNotFoundException,IOException {
if(!FileName.equals("c:\\a.txt")) {
throw new FileNotFoundException("传递路径错误");
}
/*
* 如果后缀名不对
*
*/
if(!FileName.endsWith(".txt")) {
throw new IOException("后缀命错误");
}
System.out.println("路径正确，读取文件中.......");
}
}
Finally代码块----try catch中
- try catch 的 try 中后续代码不实现，需要实现的话，放在finally代码块里面
- 必须和try catch一起使用
- 一般用于资源回收（释放）
- 如果finally中有return语句，返回的是finally中的结果 因为finally语句必须执行
package java15;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FinallyMain {
public static void main(String[] args) {
try {
method1("c:\\a.tx");
} catch (IOException e) {
System.out.println("后缀名错误1");
}finally {
//无论是否出现异常，都执行
System.out.println("资源释放");
}
}
private static void method1(String FileName) throws FileNotFoundException,IOException {
if(!FileName.endsWith(".txt")) {
throw new IOException();
}
System.out.println("路径正确，读取文件中.......");
}
}
Throwable的3个异常处理方法
代码借用上方
public static void main(String[] args) {
try {
method1("c:\\a.tx");
} catch (IOException e) {
// try抛出异常的接受
System.out.println("传递路径错误");
System.out.println(e.getMessage()); // 壹：传递路径错误---简短的描述
System.out.println(e.toString()); //贰：java.io.FileNotFoundException: 传递路径错误
e.printStackTrace();
/*叁：最全面的信息
* java.io.FileNotFoundException: 传递路径错误
at java15.TryCatchMain.method1(TryCatchMain.java:40)
at java15.TryCatchMain.main(TryCatchMain.java:26)
*/
}
异常处理注意事项
多异常捕获处理
- 异常依次捕获，依次处理，一个try 对应一个catch
- 异常一次捕获，依次处理，一个try 对应多个catch
注意：catch里定义的异常变量，如果有字符类关系，子类写在父类上方 - 一次捕获一次处理
子父类异常
父类异常什么样子，子类异常也是什么样子
父类抛出多个异常，子类抛出和父类一样的异常，或者父类抛出的子类或不抛出
父类不抛出异常，子类也不，若此时子类有异常，只能捕获，不能声明抛出
自定义异常
格式：
public class XxxException extends Exception 、RunTimeException{ 添加一个空参构造， 添加一个带异常信息的构造}
注意：
命名一般以Exception结尾
自定义异常类，必须继承Exception（编译期异常）和RunTimeException（运行期异常 ）
//自定义异常类
package java15;
/*
* 自定义异常类
*/
public class RegisterException extends Exception{
public RegisterException() {
// 空参构造方法
super();
}
public RegisterException(String s) {
//带异常信息
super(s);
}
}
主方法
package java15;
import java.util.Scanner;
public class Case {
/*
* 自定义异常的练习
*/
static String[] arr= {"张三","李四","王五","赵六"}; //得到初始数据
public static void main(String[] args) throws RegisterException {
//Scanner得到数据
Scanner sc=new Scanner(System.in);
System.out.println("请输入用户名");
String next = sc.next();
checkarr(next);
}
/*
* 判断用户名
*/
private static void checkarr(String str) throws RegisterException {
for(String s : arr) {
if(s.equals(str)) {
throw new RegisterException("该用户被注册");
}
}
System.out.println("注册成功");
}
}
扫一扫
80
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
