/*
java.lang.Throwable:类是 Java 语言中所有错误或异常的超类。
Exception:编译期异常,进行编译(写代码)java程序出现的问题
RuntimeException:运行期异常,java程序运行过程中出现的问题
异常就相当于程序得了一个小毛病(感冒,发烧),把异常处理掉,程序可以继续执行(吃点药,继续革命工作)
Error:错误
错误就相当于程序得了一个无法治愈的毛病(非典,艾滋).必须修改源代码,程序才能继续执行
*/
package day5;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Objects;
public class ExceptionTes {
public static void main(String[] args) throws IOException {
demo01();
int[] arr1 = {1,2,3};
demo02(arr1 , 2);
Object obj = "str";
demo03(obj);
demo04("c://java.txt");
demo05("c:123");
}
/*
try...catch:异常处理的第二种方式,自己处理异常
注意:
1.try中可能会抛出多个异常对象,那么就可以使用多个catch来处理这些异常对象
2.如果try中产生了异常,那么就会执行catch中的异常处理逻辑,执行完毕catch中的处理逻辑,继续执行try...catch之后的代码
如果try中没有产生异常,那么就不会执行catch中异常的处理逻辑,执行完try中的代码,继续执行try...catch之后的代码
3.finally不能单独使用,必须和try一起使用
4.finally一般用于资源释放(资源回收),无论程序是否出现异常,最后都要资源释放(IO)
5.如果finally有return语句,永远返回finally中的结果,避免该情况.
*/
private static void demo05(String filename) throws IOException {
System.out.println("----------------in demo05---------------");
try{
if (!filename.equals("c://java.txt")){
throw new FileNotFoundException("文件路径不正确");
}
if (!filename.endsWith(".txt")){
throw new IOException("文件后缀名不正确");
}
}
catch (FileNotFoundException e1){
System.out.println(e1);
}
catch (IOException e2){
System.out.println(e2);
}
finally {
System.out.println("demo05执行完毕，释放资源");
}
}
/*
throws关键字:异常处理的第一种方式,交给别人处理
作用:
当方法内部抛出异常对象的时候,那么我们就必须处理这个异常对象
可以使用throws关键字处理异常对象,会把异常对象声明抛出给方法的调用者处理(自己不处理,给别人处理),最终交给JVM处理-->中断处理
注意:
1.throws关键字必须写在方法声明处
2.throws关键字后边声明的异常必须是Exception或者是Exception的子类
3.方法内部如果抛出了多个异常对象,那么throws后边必须也声明多个异常
如果抛出的多个异常对象有子父类关系,那么直接声明父类异常即可
4.调用了一个声明抛出异常的方法,我们就必须的处理声明的异常
要么继续使用throws声明抛出,交给方法的调用者处理,最终交给JVM
要么try...catch自己处理异常
*/
private static void demo04(String file) throws IOException {
System.out.println("------------in demo04-----------");
if (!file.equals("c://java.txt")){
throw new FileNotFoundException("文件路径不正确");
}
if (!file.endsWith(".txt")){
throw new IOException();
}
}
/*
Obects类中的静态方法
public static <T> T requireNonNull(T obj):查看指定引用对象不是null。
*/
private static void demo03(Object obj) {
System.out.println("---------------in demo03-------------");
Objects.requireNonNull(obj);
}
/*
throw关键字
作用:
可以使用throw关键字在指定的方法中抛出指定的异常
注意:
1.throw关键字必须写在方法的内部
2.throw关键字后边new的对象必须是Exception或者Exception的子类对象
3.throw关键字抛出指定的异常对象,我们就必须处理这个异常对象
throw关键字后边创建的是RuntimeException或者是 RuntimeException的子类对象,我们可以不处理,默认交给JVM处理(打印异常对象,中断程序)
throw关键字后边创建的是编译异常(写代码的时候报错),我们就必须处理这个异常,要么throws,要么try...catch
*/
private static void demo02 (int[] arr1 , int index) {
System.out.println("-----------------in demo02-----------------");
if (index <0 || index > arr1.length - 1){
throw new ArrayIndexOutOfBoundsException("索引越界异常");
}
if (arr1 == null){
throw new NullPointerException("传递的数组不能为空");
}
System.out.println(arr1[index]);
}
/*
异常的种类及举例
*/
private static void demo01() {
System.out.println("-----------------in demo01-----------------");
//Exception:编译期异常,进行编译(写代码)java程序出现的问题
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//用来格式化日期
Date date = null;
try {
date = sdf.parse("1999-0909");//把字符串格式的日期,解析为Date格式的日期
} catch (ParseException e) {
System.out.println("输入格式有误");
}
System.out.println(date);
//RuntimeException:运行期异常,java程序运行过程中出现的问题
int[] arr = {1,2,3};
try {
System.out.println(arr[3]);
}catch(Exception e){
System.out.println("索引越界异常");
}
// Error:错误
// 内存溢出的错误,创建的数组太大了,超出了给JVM分配的内存
int[] arr1 = new int[1024*1024];//只能修改代码，否则无法运行
}
}子类继承父类抛出的异常：
/*
子父类的异常:
- 如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
- 父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
注意:
父类异常时什么样,子类异常就什么样
*/
package day5;
import java.io.IOException;
public class FuTes {
public void method01() throws NullPointerException,ClassCastException{};
public void method02() throws IOException{};
public void method03(){};
public void method04() throws IndexOutOfBoundsException{};
}
//重写父类方法
class Zi extends FuTes{
public void method01() throws NullPointerException{};//子类抛出的异常可以比父类的少
public void method02() throws IOException{};//子类抛出的异常可以和父类一样
//public void method03() throws IOException{};父类没有抛出异常时，子类也不能抛出异常
public void method4() throws ArrayIndexOutOfBoundsException{}//子类抛出的异常可以是父类抛出的异常的子类
}自定义异常类：
自定义异常类1：
/*
自定义异常类:
java提供的异常类,不够我们使用,需要自己定义一些异常类
格式:
public class XXXExcepiton extends Exception | RuntimeException{
添加一个空参数的构造方法
添加一个带异常信息的构造方法
}
注意:
1.自定义异常类一般都是以Exception结尾,说明该类是一个异常类
2.自定义异常类,必须的继承Exception或者RuntimeException
继承Exception:那么自定义的异常类就是一个编译期异常,如果方法内部抛出了编译期异常,就必须处理这个异常,要么throws,要么try...catch
继承RuntimeException:那么自定义的异常类就是一个运行期异常,无需处理,交给虚拟机处理(中断处理)
*/
package day5;
public class MyException1 extends Exception{
public MyException1(){
super();
};
public MyException1(String message){
super(message);
};
}
自定义异常类2：
package day5;
public class MyException2 extends RuntimeException {
public MyException2(){
super();
};
public MyException2(String message){
super(message);
};
}
另起一个测试类：
package day5;
import java.util.Scanner;
public class MyExceptionTes {
static String[] arr = {"vergil","danti"};
public static void main() {
demo01();
demo02();
}
/*
继承RuntimeException:那么自定义的异常类就是一个运行期异常,无需处理,交给虚拟机处理(中断处理)
*/
private static void demo02() {
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名");
String name = sc.next();
for (String s : arr) {
if (s.equals(name)) {
throw new MyException2("用户名重复");
}
}
}
/*
继承Exception:那么自定义的异常类就是一个编译期异常,如果方法内部抛出了编译期异常,就必须处理这个异常,要么throws,要么try...catch
*/
private static void demo01() {
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名");
String name = sc.next();
for (String s : arr) {
if (s.equals(name)){
try{
throw new MyException1();
}catch (MyException1 e1){
System.out.println(e1 + "用户名重复");
}
}
}
System.out.println("注册成功");
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
