Java新手：异常和递归

最新推荐文章于 2025-07-15 08:19:11 发布

原创最新推荐文章于 2025-07-15 08:19:11 发布 · 606 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#运行时异常 #编译时异常 #捕获异常 #斐波那契数列 #自定义异常

java基础专栏收录该内容

22 篇文章

订阅专栏

异常

异常是指我们在写代码时出现的编译或者运行时的错误。

异常的体系结构：
1、Throwable是Java语言中所有错误或异常的超类，Throwable有两个子类，Error和Exception，Error是指出现的不能够处理的严重问题，Exception是乐意处理的异常问题。
2、在Exception的子类有一个RuntimeException，是那些可能在java虚拟机正常运行期间抛出的异常的超类，RuntimeException和他所有的子类异常，都属于运行时的异常，在编译时期可以自由选择处理或者不处理。
3、运行时期异常的特点:
方法中抛出运行时期异常,方法定义中无需throws声明,调用者也无需处理此异常
运行时期异常一旦发生,需要程序人员修改源代码.
4、编译时期异常:是Exception的子类，非RuntimeExcpetion的子类，在编译时期必须处理。
异常的处理方式
jvm处理异常的方式：如果我们没有自己处理异常，jvm或帮助我们处理，会把异常的类型，原因还有位置显示在命令行；还会终止程序，异常后面的代码不在执行。例如除以0.
1、捕获处理
捕获是指对可能出现的异常进行指定方法的处理捕获。
try {
有可能出现问题的代码;
} catch(ArithmeticException e) {
处理异常;
}finally{
释放资源；
清理垃圾；
}
注意：finally:组合try…catch使用，用于释放资源等收尾工作，无论try…catch语句如何执行，finally的代码一定会执行。

public static void main(String[] args) {
		try{
			System.out.println(1);
			System.out.println(2/0);
			System.out.println(2);
		}catch(ArithmeticException e){
			System.out.println("除数不能为零");
		}
		System.out.println(3);
	}

输出结果：

1
除数不能为零
3

注意：try…catch的执行顺序：
首先执行try语句，如果发现异常，异常下面的代码不在执行，直接跳入catch语句中，catch语句结束后，整个try…catch结束；如果没有发现异常，try语句执行结束后，try…catch直接结束，不在执行catch语句

public static void main(String[] args) {
		FileWriter fw = null;
		try {
			//System.out.println(2 / 0);
			fw = new FileWriter("a.txt");
			fw.write("hello");
			fw.write("world");
			//System.out.println(2 / 0);
			fw.write("java");
			//fw.close();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//释放资源
			try {
				if(fw != null) {
					fw.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

2、抛出去
当我们不想处理异常，或者没有能力处理的时候，我们可以选择抛出异常，谁调用方法谁处理异常，使用关键字throws在方法的声明出抛出异常

public static void main(String[] args) throws Exception {
		function();
}
public static void function() throws Exception{
	FileWriter fw = new FileWriter("a.txt");
}

注意：
throws使用:
权限修饰符返回值类型方法名(形参列表)throws 异常类型1,异常类型2….{ }

多异常处理
对异常进行异常检测，对每种异常信息进行不同的捕获异常。
try{
throw new Exception();//产生异常，直接捕获处理
}catch(XxxException e){
//处理方式
}catch(YyyException e){
//处理方式
}catch(ZzzException e){
//处理方式
}

public static void main(String[] args) {
		try{
			String s = null;
			System.out.println(s.length());
			int[] arr = new int[5];
			System.out.println(arr[6]);
			System.out.println(2 / 0);
		} catch(ArrayIndexOutOfBoundsException e) {
			System.out.println("出现数组越界了");
		} catch(NullPointerException e) {
			System.out.println("出现空指针了");
		}catch(Exception e) {
			System.out.println("出现异常了");
		} 
	}

结果：出现空指针了，因为出现空指针异常后，try就不再往下走了，直接跳到catch中。
注意:这种异常处理方式，要求多个catch中的异常不能相同，多个catch之间可以有子父类，平级之间没有顺序关系，如果有子父类，父类异常必须放在后面。

Throwable的常用方法：
1、String getMessage() 返回此 throwable 的详细消息字符串
2、 String toString() 返回此 throwable 的简短描述
3、 void printStackTrace() 打印异常的堆栈的跟踪信息

public static void main(String[] args) {
		try{
			System.out.println(2/0);
		}catch(ArithmeticException e){
			System.out.println("e.getMessage()="+e.getMessage());
			System.out.println("e.toString()="+e.toString());
			e.printStackTrace();
		}
	}

结果：

e.getMessage()=/ by zero
e.toString()=java.lang.ArithmeticException: / by zero
java.lang.ArithmeticException: / by zero
	at com.ArrayListTest.RecurrenceDemo.main(RecurrenceDemo.java:8)

自定义异常
1、throws:处理异常的一种方式，把异常抛出，由调用者来处理
throw:制造异常的方式,并且结束方法
2、自定义一个运行时异常：写一个类去继承Exception或者RuntimeException，然后实现多个构造即可。

public class myException extends RuntimeException{
	public myException() {
		super();
		// TODO Auto-generated constructor stub
	}
	public myException(String message) {
		super(message);
		// TODO Auto-generated constructor stub
	}
}

使用该异常类

public static void main(String[] args) {
		try{
			checkScore(110);
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	public static void checkScore(int score)throws Exception{
		if(score<0||score>100)
			throw new myException("考试成绩不符合要求");
		System.out.println("考试成绩符合要求");
	}

结果：

com.ArrayListTest.myException: 考试成绩不符合要求
	at com.ArrayListTest.RecurrenceDemo.checkScore(RecurrenceDemo.java:16)
	at com.ArrayListTest.RecurrenceDemo.main(RecurrenceDemo.java:9)

注意：如果抛出（throw）的是编译时期异常，必须在方法声明处抛出（throws）

递归

递归就是指在当前方法内调用自己的这种现象，把大问题拆成小问题，再把小问题拆成更多的小问题，然后随着把更多小问题的解决，大问题也随之解决了。
递归的注意事项：
1、递归一定要有出口，避免内存溢出。
2、递归次数不宜过多，避免内存溢出。
斐波那契数列
有一对小兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数。
规律：除了第一个月和第二个月以外，其余每个月都是前两个月之和。

月份	对数
第1个月	1
第二个月	1
第三个月	2
第四个月	3
第五个月	5
第六个月	8
第七个月	13

public class RecurrenceDemo {
	public static void main(String[] args) {
	int result = method(20);
	System.out.println("结果是"+result);
	}
	public static int method(int n){
		if(n==1||n==2){
			return 1;
		}else{
			return method(n-1)+method(n-2);
		}
	}
}

结果是：结果是6765