本文详细解析了Java中error和Exception的区别，涵盖运行期异常与编译期异常实例，并演示了try-catch、throws和finally的使用。自定义异常和异常处理策略也逐一探讨，助您提升异常处理能力。
异常
异常：程序在运行时出现的不正常的情况，经过异常处理机制后，程序可以继续运行
分类：error和Exception
error：Java虚拟机无法解决的严重问题，一般不编写针对性的代码进行处理。
程序运行是出现错误，例如内存不够大等，程序自身无法解决。
Exception：可以分为运行期异常和编译期异常
运行期异常特点：1.直接或间接继承RuntimeException类
2.在编译期间不强制要求处理
编译期异常特点：1.直接或间接继承Exception类，与RuntimeException无关
2.在编译期间强制要求处理，否则不可以编译
实例1：
实现代码：
*/
public class Demo1 {
public static void main(String[] args) {
/* 常见的运行期异常
1.数组越界异常
2.空指针异常
3.类型转换异常
4.数字格式化异常
5.算术异常*/
//1.数组越界异常,java.lang.ArrayIndexOutOfBoundsException
/*int [] a= new int[5];
a[5] = 10;
System.out.println(a[5]);*/
//2.空指针异常,java.lang.NullPointerException
/* String s = null;
System.out.println(s.length());*/
//3.类型转换异常 ,java.lang.ClassCastException java.lang.String cannot be cast to java.lang.Integer
/*Object object = "abc";
Integer i = (Integer)object;*/
//4.数字转换格式异常,java.lang.NumberFormatException For input string: "abc"
// new Integer("abc");
//5.算术异常,java.lang.ArithmeticException: / by zero
int a = 10;
int b = 0;
int c = a / b;
System.out.println(c);
}
}
解决异常的方法：
1.使用try -catch
2.用throws将异常抛向父类
实例2：
public class Demo2 {
public static void main(String[] args) {
int a = 10;
int b = 0;
try {
int c = a / b;
int[] a1 = new int[5];
a1[5] = 10;
System.out.println(a1[5]);
} catch (ArithmeticException e) {
System.out.println("算术异常");
} catch (NullPointerException d) {
System.out.println("空指针异常");
} catch (Exception f) {
System.out.println("其他异常");
}
}
}
运行结果：
实例3：
代码实现：
import java.io.FileNotFoundException;
import java.io.PrintWriter;
/*
异常处理方式 1：try...catch
格式： try{
可能出现异常的代码块
}catch (异常类型 引用名){
处理异常的代码
}
*/
public class Demo3 {
public static void main(String[] args) throws FileNotFoundException {
int a = 12;
int b = 0;
System.out.println("try前的代码");
try{
int c = a/b;
System.out.println("try中的代码");
}catch (Exception e){
System.out.println(e.getMessage());//获取异常信息，返回字符串。如在本例中运行后为：/ by zero
e.printStackTrace();//将异常信息打印输出到控制台，这是最常用的一种方法
/*
将异常打印到指定文件夹中，如在E盘新建一个名为Exception.txt 文件，将异常存放在其中。
用这种方法时需要写出更新和关闭才可以在创建的对应文件中打印输出，否则程序一直被编译器占用，无法打印出异常报告。
p.flush();
p.close();
*/
PrintWriter p = new PrintWriter("E:\\Exception.txt");
e.printStackTrace(p);
p.flush();
p.close();
System.out.println("出现异常，暂时不能处理");
}
}
}
运行结果：
异常处理
try-catch-finally
try-finally
实例4：
代码实现：
package day1;
public class Demo41 {
/*
异常处理：
try-catch-finally
在没有return的情况下：
若出现异常，先执行catch中的代码块，再执行finally中的代码块，finally代码块后面的代码也可以继续执行
若未出现异常，先执行try中的代码块，在执行finally中的代码块，finally代码块后面的代码也可以继续执行
try{
可能会出现异常的代码
}catch(异常类型 引用名){
处理异常的代码
}finally{
无论是否出现异常,finally块中的代码都会执行
}
try-finally：
在没有return的情况下：
若出现异常，直接执行finally中的代码块,程序终止。
若不出现异常，先执行try中的代码块，在执行finally中的代码块，且finally代码块后面的代码也可以继续执行。
try{
可能会出现异常的代码
}finally{
此处没有异常处理,try中一旦出现问题,执行finally,程序终止，后面的程序都不在执行。
}
*/
public static void main(String[] args) {
try{
System.out.println(10/0);
System.out.println("try中的代码");
}catch (Exception e){
System.out.println("无法执行，未知错误");
}finally {
System.out.println("finally中的代码");
}
System.out.println("finally后面的代码");
System.out.println("-------------------------------------------------------");
try{
System.out.println(10/2);
System.out.println("try中的代码");
}finally {
System.out.println("finally中的代码");
}
System.out.println("后面的代码");
}
}
运行结果：
带有return的try-catch-finally
先执行finally中的代码块，在执行return
实例5：
代码实现：
package day1;
import java.io.FileNotFoundException;
public class Demo4 {
public static void main(String[] args) {
Demo4 demo4 = new Demo4();
System.out.println(demo4.getNum(12,0));
}
public int getNum(int a,int b){
try {
return a/b;
}catch (Exception s){
return -1;
}finally {
System.out.println("不论有没有错误都会执行的代码");
}
}
}
运行结果：
throws
实例6：
代码实现：
import java.io.FileNotFoundException;
import java.io.UnsupportedEncodingException;
/*
throws 作为方法的声明，声明此方法是可能会出行某种异常，调用时就需要注意
在main方法中一般不会使用throws，main方法中的异常处理一般使用try-catch实现
声明方法中出现的异常，可以声明一个，也可以声明多个。一般为编译期异常，因为运行期异常在编译时不会强制要求处理
*/
public class Demo6 {
public static void main(String[] args) {
day1.Demo5 d5 = new day1.Demo5();
try {
d5.test1();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
public void test1() throws UnsupportedEncodingException, FileNotFoundException {
test2();
}
public void test2() throws UnsupportedEncodingException, FileNotFoundException,NullPointerException {
"a".getBytes("utf-8");
}
}
用throws处理异常时，对于编译期的异常子类中的异常类型必须小于或等于父类中的异常类型。
用throws处理异常时，对于执行期的异常子类中的异常类型与父类中的异常类型没有要求。
实例7：
代码实现：
新建一个父类Demo7
public abstract class Demo7 {
abstract void test() throws Exception;
abstract void test1() throws RuntimeException;
}
新建一个子类Demo7Child，继承父类Demo7
package day1;
import java.io.UnsupportedEncodingException;
/*
用throws处理异常时，对于编译期的异常子类中的异常类型必须小于或等于父类中的异常类型
用throws处理异常时，对于执行期的异常子类中的异常类型与父类中的异常类型没有要求
在方法重写时，子类的访问权限必须大于或等于父类的访问权限
*/
public class Demo7Child extends Demo7 {
@Override
void test() throws UnsupportedEncodingException {
}
@Override
void test1() throws NullPointerException{
}
}
自定义类
实例8.1：
代码实现：
/*
自定义异常类：
成绩不合法是抛出此异常对象，例如百分制中的分数小于0或者大于100。
根据实际业务逻辑的需要来指定一种场景下的异常类
若在现实情况中出现了jdk中没有定义过的异常类，我们可自定义一个异常类
*/
public class Demo8 {
public static void main(String[] args) {
Demo8 demo8 = new Demo8();
try {
demo8.getScore(120);
} catch (ScoreException e) {
e.printStackTrace();
}
}
public String getScore(int score) throws ScoreException {
if (score < 0 || score > 100) {
throw new ScoreException("成绩不合法");
} else if (score > 90) {
return "优秀";
} else {
return "不优秀";
}
//return null;
}
}
自定义的异常类，可让它继承于Exception成为编译期异常，也可以让它继承于RuntimeException成为运行期异常。在自己根据实际要求重写方法。
public class ScoreException extends Exception {
public ScoreException() {
}
public ScoreException(String message) {
super(message);
}
}
运行结果：
扫一扫
1万+
到【灌水乐园】发言
