2021.10.20
异常:
异常是Java中提供的一种识别及响应错误情况的一致性机制。有效地异常处理能使程序更加健壮、易于调试。
异常发生的原因有很多，比如：
- 用户输入了非法数据
- 要打开的文件不存在
- 网络通信时连接中断
- JVM内存溢出
- 这些异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的。
常见异常:
空指针
下标越界
栈内存溢出
类型转换异常
继承体系:
Error:
系统内部错误，这类错误由系统进行处理，程序本身无需捕获处理。
比如：OOM(内存溢出错误)、VirtualMachineError(虚拟机错误)、StackOverflowError(堆栈溢出错误)等，一般发生这种情况，JVM会选择终止程序。
Exception:
Exception是所有异常类的父类。分为非RuntimeException和RuntimeException 。
- 非RuntimeException
指程序编译时需要捕获或处理的异常，如IOException、自定义异常等。属于checked异常。- RuntimeException
指程序编译时不需要捕获或处理的异常，如：NullPointerException等。属于unchecked异常。一般是由程序员粗心导致的。如空指针异常、数组越界、类型转换异常等。常用方法:
public String getMessage() 返回关于发生的异常的详细信息,这个消息在Throwable类的构造函数中初始化了
public void printStackTrace() 打印错误的追踪栈帧
package study.exception;
public class Part01 {
public static void main(String[] args) {
System.out.println(1);
System.out.println(3);
//运行时出错
String s=null;
s.equals("");
System.out.println(4);
System.out.println(6);
}
}
package study.exception;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class Part02 {
// public static void main(String[] args) throws FileNotFoundException {
public static void main(String[] args) {
// 打开资源文件
try {
FileInputStream fis = new FileInputStream("D:/xxx");
System.out.println(123);
} catch (FileNotFoundException e) {
// 打印错误的追踪栈帧,比较常用,适合程序员排错
// e.printStackTrace();
// 获取错误信息,适合响应给用户
String msg = e.getMessage();
System.out.println(msg);
}
System.out.println(456);
}
}
package study.exception;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Part03 {
}
class A{
public void m1() throws IOException{
}
}
class B extends A{
@Override
// 方法覆写,不能比原方法拥有更宽泛的异常
// 抛出的异常类,可以是父类方法中抛出的类,也可以是对应的子类 , 但是不能是它的父类
// 父类抛出一个异常A , 那么子类 要么还抛出A , 要么抛出A的子类, 要么不抛异常 , 但是不能是A的父类
public void m1() throws FileNotFoundException{
}
}
package study.exception;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class Part04 {
public static void main(String[] args) throws FileNotFoundException {
m1();
}
public static void m1() throws FileNotFoundException {
m2();
}
public static void m2() throws FileNotFoundException {
m3();
}
public static void m3() throws FileNotFoundException {
FileInputStream fis = new FileInputStream("xxx");
}
}
package study.exception;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class Part05 {
public static void main(String[] args) {
try {
FileInputStream fis = new FileInputStream("");
} catch (FileNotFoundException e) {
System.out.println("找不到文件");
} catch (NullPointerException e) {
System.out.println("不能为null");
} catch (Exception e) {
System.out.println("其他异常");
}
}
}
package study.exception;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Part06 {
// 抛异常 可以同时抛出多个,逗号隔开,没有先后顺序
public static void main(String[] args) throws Exception,
FileNotFoundException, IOException {
}
}
package study.exception;
public class Part07 {
public static void main(String[] args) {
try {
int a = 0;
int b = 3;
// 除数不能为0,会出错
int c = b / a;
System.out.println(c);
} catch (Exception e) {
e.printStackTrace();
// 终止方法执行
return;
// System.exit(0);
} finally {
// 但是finally会执行
System.out.println("2222");
}
// 执行不到,因为上面有return
System.out.println("1111");
}
}
package study.exception;
public class Part08 {
public static void main(String[] args) {
int result = m1();
// 11
System.out.println(result);
}
public static int m1() {
int i = 10;
try {
// 因为finally中有return,并且优先级是比较高的
// 所以在编译的时候 就把这里的return去掉了,只有i++
System.out.println("assass");
return i++;
// i++;
} catch (Exception e) {
e.printStackTrace();
} finally {
// 11
System.out.println(i+"------------");
return i;
}
}
}
package study.exception;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Part09 {
public static void main(String[] args) {
FileInputStream fis = null;
try {
// 打开资源
fis = new FileInputStream("xxx");
// xx 操作
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
// 关闭资源
try {
// 判断是否打开资源,如果打开 就关闭
if (fis != null) {
fis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
package study.exception;
import java.io.FileInputStream;
public class Part10 {
public static void main(String[] args) {
// 自动关闭资源
try(FileInputStream fis = new FileInputStream("xxx");){
// 操作
}catch (Exception e) {
e.printStackTrace();
}
}
}
自定义异常类:
怎么自定义
1 继承一个已有的异常类
判断你应该是运行是异常还是编译时异常,如果是运行时异常需要继承 RuntimeException 否则就继承Exception即可,一般情况下 我们写的 一定是 编译时异常
2 公共的无参构造3 公共的有参构造
,传入字符串,并在构造方法中把该字符串传递给父类
package study.throw_;
public class UserException extends Exception{
public UserException() {
}
public UserException(String msg) {
super(msg);
}
}
package study.throw_;
public class UserService {
public static void login(String username,String password) throws UserException{
if (username.equals("admin")) {
if (password.equals("root")) {
// TODO 登陆成功
// return "登陆成功";
}else {
// TODO 密码不正确
// return "密码不正确" ;
throw new UserException("密码不正确");
}
}else{
// TODO 用户名不正确
// return "用户名不正确";
throw new UserException("用户名不正确");
}
}
}
package study.throw_;
import java.util.Scanner;
public class Client {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入用户名和密码 : ");
String username = scanner.next();
String password = scanner.next();
// System.out.println(username+" : "+password);
// String result = UserService.login(username, password);
// if (result.equals("登陆成功")) {
// System.out.println("欢迎回来");
// }else{
// System.out.println(result);
// }
try {
UserService.login(username, password);
System.out.println("登陆成功");
} catch (UserException e) {
// e.printStackTrace();
System.out.println(e.getMessage());
}
}
}
