异常

最新推荐文章于 2023-06-02 19:28:17 发布
最新推荐文章于 2023-06-02 19:28:17 发布
阅读量135 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51621893/article/details/110882153
版权

今日内容

  • 异常

  • 线程

学习目标

  • 能够分辨程序中异常和错误的区别

  • 说出异常的分类

  • 说出虚拟机处理异常的方式

  • 列举出常见的四个运行期异常

  • 能够使用try--catch关键字处理异常

  • 能够使用throws关键字处理异常

  • 能够自定义异常类

  • 能够处理自定义异常类

  • 说出进程的概念

  • 说出线程的概念

  • 能够理解并发与并行的区别

  • 能够开启新线程

异常

异常，就是不正常的意思。在生活中，医生说，你的身体某个部位出现异常了，该部位和正常情况不一样，该部位的功能将会受到影响，在程序中的意思是：

  • 异常：指的是在程序的运行过程中，出现的非正常情况，最终会导致JVM的非正常停止。

    在Java等面向对象的编程语言中，异常本身就是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

    备注：异常指的并不是语法错误，语法错了，编译无法通过的，不会产生字节码文件，根本不会运行。

异常体系

异常机制其实是帮助我们找到程序中出现的问题，异常的根类是java.lang.Throwable,它的下面有两个子类：java.lang.Error 和java.lang.Exception，平常说的异常指的是java.lang.Exception

体系图：

  • Error：严重错误Error，无法通过异常处理的错误，好比绝症，只能是事先预防。

  • Exception：异常，异常产生后程序员可以通过代码的方式进行纠正处理，使程序能够继续进行下去，好比感冒，阑尾炎。

异常产生的过程解析：

public static void main(String[] args) {
		// 创建int类型的数组
		int[] arr = {1,2,3};
		int e = getElement(arr, 3);
		System.out.println(e);	
	}
	/*
	 *   参数：
	 * 		int[]  arr
	 *       int   index
	 */
	public static int getElement(int[] arr,int index) {
		int e = arr[index];
		return e;
	}

异常的处理

Java异常处理的五个关键字：try catch finally throw throws

抛出异常throw

当我们在编写程序的时候，我们必须要考虑程序可能会出现问题的情况。比如说：在定义方法的时候，方法需要接受参数，那么对于调用者来说，当调用方法的时候需要接受参数，首先需要对参数数据进行合法的判断，若数据不合法，就应该告诉调用者，传递合法的数据进来。这时候就需要使用抛出异常的方式来告诉调用者。

在Java当中，提供了一个关键字throw，他用来抛出一个指定的异常对象。步骤：

  1. 创建一个异常对象，封装一些提示信息(信息可以自己编写)。

  2. 需要将这个异常对象告知给调用者，通过关键字throw就可以完成。throw抛出一个异常对象

    throw一般我们用在方法内，用来抛出一个具体的异常对象，将这个异常对象抛出给调用者处，并结束当前方法的执行。

使用格式：

throw new 异常类名(参数)

示例：

// 给调用者抛出一个空指针异常
throw new NullPointerException("要访问的arr数组不存在，值为null");
// 给调用者抛出一个索引越界异常
throw new IndexOutOfBoundsException("该索引超出了引用的范围");

Objects非空判断

在该类中，提供一些静态的实用方法，这是方法是null-safe（空指针安全）或者null-tolerant(容忍空指针的)，那么在他的源码中，对对象的null值进行了抛出异常的操作。

  • public static <T> T requireNonNull(T obj)：查看指定的引用对象不是null值

public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
}

声明异常处理----throws

声明异常：将问题标识出来，报告给调用者，如果方法内通过throw抛出了一个编译期异常，又没有通过捕获处理(try..catch),那么必须通过throws进行声明，让调用者去处理。

关键字throws运用在方法的声明上，用于表示不处理异常，提醒调用者该方法的调用携带的是有异常信息，谁调用谁处理。

声明异常处理的格式：

修饰符  返回值类型  方法名(参数列表) throws 异常类名1,异常类名2,....{}

示例代码

public class DemoThrows {
    
    public static void main(String[] args) {
        read("C:/a.txt");
    }
    public static void read(String path) throws FileNotFoundException{
        // 校验 如果你传递的路径不是以.txt的结尾的，抛出调用者文件找不到异常
        if (!path.endsWith(".txt")) {
            // 抛出一个文件找不到异常
            throw new FileNotFoundException("文件找不到");
        }
    }
}

捕获异常 try...catch

如果异常出现的话，会立刻终止程序。

  1. 如果使用throws关键字来声明式处理，由该方法的调用者来处理(很危险)

  2. 在方法中使用try...catch的语句块来处理异常

     

try...catch的方式就是捕获异常

  • 捕获异常：java中对异常有针对性的语句块来进行捕获，可以对出现的异常进行指定的方式处理。

捕获异常的格式：

try {
    // 编写的可能会出现的异常代码
    //.....
} catch (异常类型 e) {
    // 处理异常的逻辑代码
    // 记录日志 // 打印异常信息 // 继续往上抛
}

try：该语句块中可能出现异常的代码

catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。

备注：try和catch都不能单独使用，一般建议连用。

代码演示：

public class TryCatchDemo {
    public static void main(String[] args) {
        try {
             readFile("D:\\a.txt");
        } catch (FileNotFoundException e) {//括号中需要定义什么异常类型？
            // try中抛出的是什么类型，在括号中就定义成什么样的异常类型
            // 打印异常信息
            System.out.println(e);
        }
       System.out.println("程序往下加载了。。。");
    }
    
    public static void readFile(String path) throws FileNotFoundException {
        if (!path.startsWith("C:")) {
            throw new FileNotFoundException("传递的文件不是在C盘中，文件找不到异常");
        }
    }
    
}

如何获取异常的信息

Throwable类中定义了一些常用的api方法

  • public String getMessage()：获取异常的描述信息、原因(提示给用户看的，提示错误原因)

  • public String toString()：获取异常的类型、异常的描述信息

  • public void printStackTrace()：打印异常的跟踪栈信息并且输出到控制台中

包含了异常的类型，异常的原因，还包括异常出现的位置，在开发和调试阶段一般都是使用printStackTrace()方法

finally语句块

finally：有一些特定的代码无论异常是否发生，都需要执行。当程序发生异常时，会引发程序的跳跃性，导致有一些代码加载不到，而finally语句块就是用来解决这样的问题的，在finally语句块中存放的代码一般都是一定会被执行到的

什么样的代码最终一定要被执行到的？

比如说，在try中打开了一些物理资源(磁盘文件/网络连接/数据据的连接)，我们一般在使用完毕后必须关闭掉，可以使用finally语句块来实现。

finally语句块的语法格式;

try {
    // 
} catch (异常类型 e) {
    // ....
}
.....
finally {
    //....
}

备注：中间的catch语句块可以省略，finally不能单独使用，建议连用。

代码演示：

public class FinallyDemo06 {
    public static void main(String[] args) {
        try {
            System.out.println("开启IO流");
            readFile("b.txt");
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            System.out.println("不管程序如何运行，此处代码块一定会被加载到");
            System.out.println("关闭IO流");
        }
		System.out.println("over");
    }
    public static void readFile(String path) throws IOException{
        if (!path.endsWith(".txt")) {
            throw new IOException("文件的后缀名不对。。。");
        }
    }
}

备注：

 1. 如果finally语句块中有return语句，永远返回的是finally语句块中的结果值
 2. 当只有在try或者catch中调用退出JVM的相关方法，此时finally才不会被执行到，否则finally永远会执行。

异常的注意事项

当程序中出现了多个异常那么该如何捕获又该如何处理？

1. 多个异常分别处理

多个异常一次捕获，多次处理

多个异常一次捕获，一次处理

一般我们都是使用一次捕获，多次处理方式，格式如下：

try {
    // 可能出现异常的代码 多个异常
} catch (异常类型A e) { // 当try中出现A异常的时候，就用该catch来捕获
    // 处理异常的逻辑
} catch (异常类型B e) {// 当try中出现B异常的时候，就用该catch来捕获
    // 处理异常的逻辑
}
....
....

注意：这种异常处理方式，要求多个catch的异常不能相同，并且若catch中的多个异常之间存在子父类关系，那么子类异常的处理在父类异常处理的上面，父类异常的处理在下面。

  • 运行时异常被抛出可以不处理，即不捕获也不声明抛出

  • 如果finally中有return语句，那么永远返回finally语句块中结果值

  • 如果父类抛出了多个异常，子类重写父类方法时，抛出和父类相同的异常或者是父类异常的子类或者不抛出异常

  • 父类方法如果没有抛出异常，子类重写该方法时也不可能抛出异常。此时子类方法内产生了异常，只能捕获处理，不能声明抛出。

示例代码

自定义异常

概述

Java中根据不同的情况，提供了不同的异常类，JDK官方提供的异常类始终是有限的，大多数情况下我们需要根据自己的业务需要自定义异常类。例如：年龄负数异常。成绩负数异常，登录异常，注册异常等等。

什么是自定义异常类？

在开发中根据自己的业务的异常情况来定义的异常类。

例如：我想自定义一个业务逻辑异常类：注册异常 RegisterException。

异常类如何定义？

  1. 自定义一个编译期异常，自定义类继承于java.lang.Exception。

  2. 自定义一个运行期异常类，自定义类 继承于java.lang.RuntimeException。

自定义异常的练习：

模拟注册操作，如果用户存在，则抛出异常并提示：亲,您的名字已经被注册了，再换个名字吧！

// 首先 定义一个注册异常类  RegisterException  --->业务逻辑异常类
public class RegisterException extends RuntimeException {
    
    // 空参构造
    public RegisterException(){}
    
    // 有参构造
    public RegisterException(String message) {
        super(message);
    }
}

public class Demo {
    // 使用数组模拟数据库 已存在多个账户名称
    public static String[] names = {"小孙","小王","小赵"};
    
    public static void main(String[] args) {
        // Scanner
        Scanner scan = new Scanner(System.in);
        String name = scan.next();   
        // 校验账户是否已被注册过
       try {
           // 可能会引发异常的代码
           checkName(name);// 如果没有发生异常，就代表注册成功
           System.out.println("注册成功！")
           names = Arrays.copyOf(names,names.length+1);
           names[names.length-1] = name;
       } catch (RegisterException e) {
          // 异常的处理逻辑
           e.printStackTrace();
       }           
    }
     
    // 校验账户是否已被注册
    public static boolean checkName(String usernmae) throws RegisterException {
        for (String name : names) {
            if (name.equals(username)) {
                // 表明 名字已经注册过了，就抛出注册异常
                throw new RegisterException("亲,您的名字已经被注册了，再换个名字吧！");
            }
        }
        return true;
    }
}

代码：

/*
 * java.lang.Throwable类是java语言中所有错误和异常
 *  Exception:编译期异常,进行代码编译的时候(写代码)java程序出现的问题
 *  RunyiomeException:运行期异常，java程序运行过程中出现的问题
 *  异常就相当于程序的了一个小感冒把异常处理掉，程序可以进行执行(吃点药)
 *  Error:错误
 *  错误就相当于程序得了一个无法治愈的毛病(非典,艾滋病)，必须修改源代码,程序才能继续运行
 * */
public class DemoException {
  //Exception 构建编译期异常 进行写代码的时候，程序出现了问题
	public static void main(String[] args) {
	SimpleDateFormat sdf=	new SimpleDateFormat("yyy-MM-dd");
		//把字符串解析成日期
	Date date=null;
	try {
		 date=sdf.parse("19990-09-03");
	} catch (ParseException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	System.out.println(date);
	
    //RuntimeException:运行期异常，程序运行过程中出现的问题
	int[] arr=new int[1024*1504*480];
	System.out.println(arr);
	}
}

/*
 * 异常的产生过程的解析(分析异常是怎么产生的，如何处理异常)
 * */
public class DemoException2 {
	public static void main(String[] args) {
		// 创建int类型的数组
		int[] arr = { 1, 2, 3 };
		int e = getElement(arr, 3);
		System.out.println(e);

	}

	public static int getElement(int[] arr, int index) {
		int e = arr[index];
		return e;
	}

}
/*
 * throw 关键字
 * 作用：
 *   可以使用throw关键字在指定的方法中抛出指定的异常
 *   使用格式：
 *   throw new XxxException("异常产生的原因")
 *   注意：
 *   1.throw关键字写在方法的内部
 *   2.throw关键字后面new的对象必须是Exception或者Exception的子类对象
 *   3.throw关键字抛出指定的异常对象，我们就必须去处理这个异常对象
 *   throw关键字后面创建的是RuntimeException或者RuntimeException的子类对象，我们可以选择不处理，交个JVM(打印异常对象，中断程序)
 *   
 * */
public class DemoException3 {
	public static void main(String[] args) {
		// 构建一个数组
		int[] arr = null;
		int e = getElement(arr, 3);
		System.out.println(e);
	}

	/*
	 * 定义一个方法:获取数组指定索引出的元素 参数： int[] arr int index 如果在工作中，我们首先要考虑是对方传递过来的数据进行合法的校验
	 * 如果参数不合法，那么我们可以选择使用抛出异常的方式，告知方法的调用者，传递的参数有问题
	 * 
	 */
	public static int getElement(int[] arr, int index) {

		if (arr == null) {
			throw new IndexOutOfBoundsException("该索引超过为空");
		}
		return 0;

	}

}

/*
 * throws关键字:异常处理的第一种方式：声明异常处理，交给方法的调用者来处理
 * 作用：
 *  当方法内部抛出了异常对象的时候，那么我们就必须处理这个异常
 *  可以使用throws关键字处理异常对象，会把异常对象的声明抛出给方法的调用者(自己不处理，让别人处理),最终交个虚拟机处理-->中端处理
 *  格式：
 *  修饰符 返回值类型 方法名(参数列表) throws AaaException,BbbException...{
 *  throw new AaaException("产生的原因);
 *  
 *  }
 * */
public class DemoException4 {

}
/*
 * try..catch 异常处理的第二种方式：自己处理异常
 * 格式：
 *  try{
 *  //可能产生的异常代码
 *  }catch(异常的类型   变量名){//用来接收try中抛出的异常对象
 *  异常的处理逻辑
 *  一般在工作中会把异常的信息记录到日志中
 *  }
 *  
 *  catch(异常类型 变量名){
 *  ...
 *  }
 *  注意事项：
 *  1.try中可能会抛出多个异常的对象，那么就需要使用多个catch语句块来处理异常对象
 *  2.如果try产生了异常，那么就会执行catch语句块中的异常处理逻辑，执行完毕catch中的逻辑，继续执行try...catch后面的代码内容
 *  如果try没有产生异常，那么就不会执行catch语句块中的异常处理逻辑，执行try中的代码后，继续执行try...catch后面的代码内容
 * */
public class DemoException5 {
	public static void main(String[] args) {
		
	}
	
   /*
    * 如果你传递的不是以。trt结尾的,那么我们就跑出一个IO异常，告知调用者，文件的后缀名不对
    * */
	public static void readFile(String path) throws IOException {
		if(!path.equals(".txt")) {
			throw new IOException("文件的后缀名不对");
		}
	}
	System.out.println()
}

/*
 * java.lang.Throwable类是Java语言中所有错误和异常的根类
 * 
 * 		Exception：编译期异常，进行代码编译的时候(写代码)Java程序出现的问题。
 *      	RuntimeException：运行期异常，java程序运行过程中出现的问题。
 *           异常就相当于程序得了一个小感冒，把异常处理掉，程序可以进行执行(吃点药)	
 *      Error：错误
 *      	错误就相当于程序得了一个无法治愈的毛病(非典，艾滋病)，必须修改源代码，程序才能继续运行
 */
public class Demo01Exception {

	public static void main(String[] args) {
		// Exception 构建编译期异常 进行写代码的时候，程序出现的问题
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		// 把字符串解析成日期
		Date date = null;
		try {
			date = sdf.parse("1990-09-03");
		} catch (ParseException e) {
			e.printStackTrace();
		}
		System.out.println(date);
		// RuntimeException：运行期异常，程序运行过程中出现的问题
		int[] arr = { 1, 2, 3, 4 };
		// System.out.println(arr[0]);
		try {
			// try 可能会出现异常的代码
			System.out.println(arr[4]);// ArrayIndexOutOfBoundsException
		} catch (ArrayIndexOutOfBoundsException e) {
			// 异常的处理逻辑
			System.out.println(e);
		}
		/*
		 * Error: 错误
		 * 
		 * OutOfMemoryError 内存溢出错误 java.lang.OutOfMemoryError: Java heap space
		 * 创建的数组太大了，超出了JVM分配的内存
		 */
		// 必须修改源代码，创建的数组小一点
		// int[] arr2 = new int[1024*1024*1024];
		int[] arr2 = new int[1024 * 1024];
		System.out.println(arr2);

	}

}

/*
 * 异常的产生过程解析(分析异常是怎么产生的，如何处理异常)
 * 
 */
public class Demo02Exception {

	public static void main(String[] args) {
		// 创建int类型的数组
		int[] arr = { 1, 2, 3 };
		int e = getElement(arr, 3);
		System.out.println(e);

	}

	/*
	 * 参数： int[] arr int index
	 */
	public static int getElement(int[] arr, int index) {
		int e = arr[index];
		return e;
	}

}

/*
 * throw 关键字
 * 	作用：
 * 		可以使用throw关键字在指定的方法中抛出指定的异常
 *  使用格式：
 *  	throw new XxxException("异常产生的原因");
 *  注意：
 *  	1.throw关键字写在方法的内部
 *      2.throw关键字后面 new的对象必须是Exception或者Exception的子类对象
 *      3.throw关键字抛出指定的异常对象，我们就必须去处理这个异常对象
 *      	throw关键字后面创建的是RuntimeException或者RuntimeException的子类对象，我们可以选择不处理，交给JVM(打印异常对象，中断程序)
 *          throw关键字后面创建的是编译异常(写代码的时候就会出现的问题),我们就必须处理这个异常，要么是throws，要么使用try...catch	
 */
public class Demo03Throw {

	public static void main(String[] args) {
		// 构建一个数组
		// int[] arr = null;
		int[] arr = { 1, 2, 3 };
		// 从数组当中获取某一个元素
		int e = getElement(arr, 2);
		System.out.println(e);
	}

	/*
	 * 定义一个方法：获取数组指定索引出的元素 参数： int[] arr int index 以后在工作中，我们首先需要考虑是对方法传递过来的数据进行合法性校验
	 * 如果参数不合法，那么我们可以选择使用抛出异常的方式，告知方法的调用者，传递的参数有问题。
	 * 
	 * NullPointerException ArrayIndexOutOfBoundsException
	 * 以上两个异常都是运行期异常，可以选择不处理，默认交给JVM处理，打印异常对象，中断程序。
	 */
	public static int getElement(int[] arr, int index) {
		/*
		 * 我们可以对传递过来的数据，进行合法性校验 如果数组arr为null 那么我们给调用者抛出一个空指针异常，告知方法的调用者“传递的数组的值为null”
		 * java.lang.NullPointerException
		 */
		if (arr == null) {
			// 抛出一个空指针异常
			throw new NullPointerException("传递的数组的值为null");// 传递的数组的值为null
		}

		/*
		 * 我们可以对传递的参数index进行合法性校验 如果index的值不在数组的索引范围内
		 * 那么我们抛出一个数组索引越界异常，告知方法的调用者"传递的索引超出了数组的索引范围"
		 */
		if (index < 0 || index > arr.length - 1) {
			// 抛出一个数组索引越界异常
			throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的索引范围");
			// java.lang.ArrayIndexOutOfBoundsException: 传递的索引超出了数组的索引范围
		}

		int element = arr[index];
		return element;
	}

}

/*
 * java.util.Objecs类中定义的基本是静态的方法
 * 
 * public static <T> T requireNonNull(T obj,String message)：查看指定的对象不是null，返回的还是对象本身
 */
public class Demo04Objects {

	public static void main(String[] args) {
		isNull(null);

	}

	/*
	 * 定义一个方法用来校验对象是否为null
	 */
	public static void isNull(Object obj) {
		// 对参数进行合法性校验 判断obj是否为null
		/*
		 * if (obj == null) { throw new NullPointerException("传递的对象的值为null"); }
		 */
		// Objects.requireNonNull(obj);
		Objects.requireNonNull(obj, "传递的对象的值为null");
	}

}

/*
 * throws关键字：异常处理的第一种方式：声明异常处理，交给方法的的调用者来处理
 * 作用：
 * 		当方法内部抛出了异常对象的时候，那么我们就必须处理这个异常对象
 *      可以使用throws关键字处理异常对象，会把异常对象声明抛出给方法的调用者(自己不处理，让别人处理)，最终交给虚拟机处理--->中断处理
 * 格式：
 * 		修饰符  返回值类型 方法名(参数列表) throws AaaException,BbbException.... {
 *      	
 *      	throw new AaaException("产生的原因");
 *      	throw new BbbException("产生的原因");
 *      	....
 *          ....
 *      }     
 * 注意事项：
 * 		1. throws 关键字必须写在方法声明处
 *      2. throws 关键字后面声明的异常必须是Exception或者是Exception类的子类
 *      3. 方法内部如果抛出了多个异常对象，那么throws后面也必须声明对应的多个异常
 *       	如果抛出的多个异常对象有子父类关系，那么直接声明父类类型即可
 *      4. 调用了一个声明抛出异常的方法，我们就必须处理这个声明异常
 *         要么继续使用throws声明抛出，	交给方法的调用者处理，最终交给了JVM处理
 *         要么try...catch自己处理异常 
 * 
 */

public class Demo04Throws {

	public static void main(String[] args) throws IOException {
		String path = "C:\\abc.txt";
		readFile(path);// java.io.FileNotFoundException: 传递的文件路径不是以.txt结尾的!，此时文件找不到！

		System.out.println("程序加载到此行代码.....");
	}

	/*
	 * 定义一个方法：对传递的文件路径进行合法性校验 如果路径不是".txt"
	 * 或者"C:","C:\\a.txt",那么我们就抛出文件找不到异常对象，告知方法的调用者
	 * 
	 * FileNotFoundException 是一个编译期异常
	 */
	public static void readFile(String path) throws IOException {
		// 参数的合法性校验
		if (!path.endsWith(".txt")) {

			throw new FileNotFoundException("传递的文件路径不是以.txt结尾的!，此时文件找不到！");
		}

		// java.io.FileNotFoundException: 传递的文件路径不是在C盘中!，此时文件找不到！
		if (!path.startsWith("C:")) {
			throw new IOException("传递的文件路径不是在C盘中!，此时文件找不到！");
		}

		System.out.println("路径没有问题，读取到了文件！");
	}

}

/*
 * 
 * 注意事项：
 * 		1. finally不能单独使用，必须和try一起使用
 *      2. finally语句块一般用于资源的释放，(资源的回收)，无论程序是否出现了异常，最后都要加载finally语句块中的内容，都要释放资源 
 */
public class FinallyDemo06 {

	public static void main(String[] args) {
		try {
			System.out.println("开启IO流");
			readFile("b.doc");
		} catch (IOException e) {
			e.printStackTrace();
			// System.exit(0);
		} finally {
			System.out.println("不管程序如何运行，此处代码块一定会被加载到");
			System.out.println("关闭IO流");
		}
		System.out.println("over");
	}

	public static void readFile(String path) throws IOException {
		if (!path.endsWith(".txt")) {
			throw new IOException("文件的后缀名不对。。。");
		}
		System.out.println("文件的后缀名正确，读取到了该文件");
	}

}

// 如果finally语句块中有return语句，永远返回finally语句块中的结果值，避免出现此情况
public class FinallyDemo07 {

	public static void main(String[] args) {
		int element = getElement();
		System.out.println(element);
	}

	public static int getElement() {
		int num = 10;
		try {
			// System.exit(0);
			return num;
		} catch (Exception e) {
			System.out.println(e);
		} finally {
			num = 200;
			return num;
		}
		// return num;
	}

}

/*
 * try...catch 异常处理的第二种方式：自己处理异常
 *   格式：
 *   	  try {
 *        
 *           // 可能产生的异常代码
 *        }	catch(异常的类型  变量名) { // 用来接收try中抛出的异常对象
 *        	   异常的处理逻辑	
 *           一般在工作中，会把异常的信息记录到日志中。
 *        }
 *        ....
 *        ....
 *        catch(异常类型  变量名) {
 *        		....
 *        }
 *  注意事项：
 *  	1. try中可能会抛出多个异常对象，那么就需要使用多个catch语句块来处理异常对象
 *      2. 如果try产生了异常，那么就会执行catch语句块中的异常处理逻辑，执行完毕catch中的逻辑，继续执行try...catch后面的代码内容
 *         如果try没有产生异常，那么就不会执行catch语句块中的异常处理逻辑，执行try中的代码后，继续执行try...catch后面的代码内容
 */
public class TryCatchDemo05 {

	public static void main(String[] args) {
		try {

			readFile("d:\\a.doc");
			System.out.println("文件读取完毕，需要加载文件中的内容。。。。");
			System.out.println("资源释放！！");
		} catch (IOException e) {// try中抛出的是什么样的异常对象，catch中就定义成什么样的异常类型，用来接收异常对象
			// 异常的处理逻辑
			// System.out.println("catch--->传递的文件的后缀名不对，不是以txt结尾的");
			/*
			 * Throwable类中定义了一些常用的api方法
			 * 
			 * - public String getMessage()：获取异常的描述信息、原因(提示给用户看的，提示错误原因) - public String
			 * toString()：获取异常的类型、异常的描述信息 - public void
			 * printStackTrace()：打印异常的跟踪栈信息并且输出到控制台中
			 */
			// System.out.println(e.getMessage());// 文件的后缀名不对！
			// System.out.println(e.toString());// java.io.IOException: 文件的后缀名不对！'
			System.out.println(e);
			// e.printStackTrace();
			/*
			 * java.io.IOException: 文件的后缀名不对！ at
			 * com.zhiyou100.exception.demo01.TryCatchDemo05.readFile(TryCatchDemo05.java:
			 * 56) at
			 * com.zhiyou100.exception.demo01.TryCatchDemo05.main(TryCatchDemo05.java:30)
			 */
		}

		System.out.println("后续代码加载到了。。。");
	}

	/*
	 * 如果你传递的不是以.txt结尾的，那么我们就抛出一个IO异常，告知调用者，文件的后缀名不对
	 */
	public static void readFile(String path) throws IOException {
		if (!path.endsWith(".txt")) {
			throw new IOException("文件的后缀名不对！");
		}
		// System.out.println("文件的后缀名正确，读取到了txt文件！");
	}

}

public class Fu {

	public void show01() throws RuntimeException, IOException {
	}

	public void show02() throws IndexOutOfBoundsException {
	}

	public void show03() throws IndexOutOfBoundsException {
	}

	public void show04() {
	}
}

class Zi extends Fu {
	// 子类在重写父类时，抛出和父类相同的异常，也可以不抛出异常
	@Override
	public void show01() throws RuntimeException, IOException {
	}

	// 也可以抛出父类异常的子类
	@Override
	public void show02() throws ArrayIndexOutOfBoundsException {
	}

	// 也可以不抛出异常
	@Override
	public void show03() {
	}

	// 父类方法没有抛出异常，子类重写方法时也不可以抛出异常
	/*
	 * @Override public void show04() {}
	 */

	// 子类产生了异常，只能捕获处理，不能声明抛出
	@Override
	public void show04() {
		try {
			throw new Exception("编译期异常");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}
public class Fu {

	public void show01() throws RuntimeException, IOException {
	}

	public void show02() throws IndexOutOfBoundsException {
	}

	public void show03() throws IndexOutOfBoundsException {
	}

	public void show04() {
	}
}

class Zi extends Fu {
	// 子类在重写父类时，抛出和父类相同的异常，也可以不抛出异常
	@Override
	public void show01() throws RuntimeException, IOException {
	}

	// 也可以抛出父类异常的子类
	@Override
	public void show02() throws ArrayIndexOutOfBoundsException {
	}

	// 也可以不抛出异常
	@Override
	public void show03() {
	}

	// 父类方法没有抛出异常，子类重写方法时也不可以抛出异常
	/*
	 * @Override public void show04() {}
	 */

	// 子类产生了异常，只能捕获处理，不能声明抛出
	@Override
	public void show04() {
		try {
			throw new Exception("编译期异常");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

 

学java的狗蛋
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java异常处理总结
不吃香蕉的猴子
07-30 320
找到一个关于异常总结的很详细的文章,分享下.异常在我们编程中很重，在适当的位置，合理的处理或者抛出异常，对程序来说至关重要。 转：异常处理是程序设计中一个非常重要的方面，也是程序设计的一大难点，从C开始，你也许已经知道如何用if...else...来控制异常了，也许是自发的，然而这种控制异常痛苦，同一个异常或者错误如果多个地方出现，那么你每个地方都要做相同处理，感觉相当的麻烦！ ...
android开发，异常处理，捕获异常上传到bugly，捕获异常库module
12-20
在Android应用开发中，异常处理是一项至关重要的任务，它确保了程序在遇到错误时能够以适当的方式响应，而不是突然崩溃。本项目聚焦于如何在Android应用程序中有效地捕获异常，并将其上传到Bugly这一第三方错误追踪...
java(3)-深入理解java异常处理机制
热门推荐
黄规速博客:学如逆水行舟，不进则退
01-20 37万+
1. 引子 try…catch…finally恐怕是大家再熟悉不过的语句了，而且感觉用起来也是很简单，逻辑上似乎也是很容易理解。不过，我亲自体验的“教训”告诉我，这个东西可不是想象中的那么简单、听话。不信？那你看看下面的代码，“猜猜”它执行后的结果会是什么？不要往后看答案、也不许执行代码看真正答案哦。如果你的答案是正确，那么这篇文章你就不用浪费时间看啦。 pa
Java 处理异常
风中的劲草
06-08 2858
Java 中使用 try-catch 或 try-catch-finally 来捕获并处理异常。一、关于try - catch基本语法try{ //一些会抛出异常的方法 }catch(Exception e){ //处理该异常的代码块 }如果try块中的代码抛出异常会发生什么呢？抛出异常的方法终止执行，程序的控制权将被移交给catch块中的异常处理程序，那么catch块中的代码如何写呢？可以发出一些
java异常处理
qq_44801321的博客
08-25 443
什么是异常 异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。 比如说，你的代码少了一个分号，那么运行出来结果是提示是错误 java.lang.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出 java.lang.ArithmeticException 的异常。 异常发生的原因有很多，通常包含以下几大类： 用户输入了非法数据。 要打开的文件不存在。 网络通信时连接中断，或者JVM内存溢出。 这些异常有的是因为用户错误引
Java自定义异常
12-22
Java异常机制可以保证程序更安全和更健壮。虽说Java类库已经提供很多可以直接处理异常的类，但是有时候为了更加地捕获和处理异常以呈现更好的用户体验，需要开发者自定义异常。本文是探讨如何自定义异常以及使用...
Java 异常详解
08-31
Java异常详解异常是编程过程中不可避免的问题，它们是程序运行时发生的错误或不正常情况。Java提供了完善的异常处理机制，帮助开发者有效地管理和恢复程序状态。本文将深入探讨异常与错误的区别、异常的分类以及异常...
JSP 异常处理
01-08
JSP 异常处理 当编写JSP程序的时候，程序员可能会遗漏一些BUG，这些BUG可能会出现在程序的任何地方。JSP代码中通常有以下几类异常: 检查型异常:检查型异常就是一个典型的用户错误或者一个程序员无法预见的错误。举例...
java异常捕捉
12-17
在Java编程语言中，异常处理是一项至关重要的机制，它允许程序员优雅地处理程序运行时可能出现的问题，从而确保程序的稳定性和可靠性。Java异常捕捉通过使用try、catch、finally和throw关键字来实现，这些关键字帮助...
Java异常处理
U_DADA的博客
06-03 589
1、异常概述 开发过程中的语法错误和逻辑错误不是异常 1、异常是程序执行过程中发生的不正常状况 分为两类：Error和Exception Error：Java虚拟机无法解决的严重问题 Exception：其他因编程错误或偶然外在因素导致的一般性问题，可以使用针对性的代码进行处理。 2、异常分类 1、可控式异常 ...
Java中处理异常的9个最佳实践
博客
08-24 1085
原文：9 Best Practices to Handle Exceptions in Java 作者：Thorben Janssen 译者：Teixeira10 【译者注】在本文中，作者介绍了9个处理异常的最佳方法与实践，以举例与代码展示结合的方式，让开发者更好的理解这9种方式，并指导读者在不同情况下选择不同的异常处理方式。 以下为译文：Java中的异常处理不是一个简单的...
java中的异常处理
weixin_45581692的博客
07-17 1万+
异常的作用增强程序的健壮性。java中异常以什么形式存在？异常在java中以类的形式存在，每一个异常类都可以创建异常对象。JVM执行到某一处觉得有异常，会new异常对象，并且将new的异常对象抛出，打印输出信息到控制台了。如异常对应的现实生活火灾（异常类）2008年8月8日，小明家着火了（异常对象）2008年8月9日，小红家着火了（异常对象）异常体系结构注意所有异常都是在运行阶段发生的，因为只有程序运行阶段才可以new对象，因为异常的发生就是new异常对象。第一种方式。......
Java中的异常处理
最新发布
weixin_64189867的博客
06-02 452
在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的，比如：客户输入数据的格式，读取文件是否存在，网络是否始终保持通畅等等。自定义异常就是自己定义的异常类，也就是API中的标准异常类的直接或间接的子类。作用：用自定义异常标记业务逻辑的异常，避免与标准异常混淆。自定义异常类基本语法public class 异常类名 extends Exception/RuntimeException{
JAVA中的异常处理
weixin_73986007的博客
05-20 1404
异常和异常处理
Java 异常的基本概念
qinuna's home
09-13 720
什么是异常 异常是在程序的执行过程中，发生的不正常情况。异常分为两种：错误 Error 和 异常 Exception 问题：Error 与 Exception 的区别 1、Error 表示错误，是一种致命的异常，是 Java 运行环境内部或硬件问题发生的错误。无法通过程序处理，只能退出运行，是虚拟机抛出的。常见的如 OutOfMemoryError、StackOverflowError 2、Exception 是由于程序设计的不完善而导致的一般性问题，可以利用代码解决 3、两种异常都继承自 Throwab

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值