java 异常基础知识以及一些面试题讲解

标签：java   android   

java是面向对象设计语言,所以异常在java中也封装了成类,而我们只要知道如何处理异常就可以,

异常概述

异常：异常就是Java程序在运行过程中出现的错误。

异常由来：问题也是现实生活中一个具体事务，也可以通过java 的类的形式进行描述，并封装成对象。其实就是Java对不正常情况进行描述后的对象体现

异常分类

程序的异常：Throwable
严重问题：Error 我们不处理。这种问题一般都是很严重的，比如说内存溢出。
问题：Exception
编译期问题:不是RuntimeException的异常 必须进行处理的，因为你不处理，编译就不能通过。
运行期问题:RuntimeException 这种问题我们也不处理，因为是你的问题，而且这个问题出现肯定是我们的代码不够严谨，需要修正代码的。

举例

除数为0

public class ExceptionDemo {
	public static void main(String[] args) {
		//第一阶段
		int a = 10;
		int b = 0;
		System.out.println(a / b);
		//第二阶段
		System.out.println("over");
	}
}

我们发现异常报错了,而且后面一句System.out.println("over");没有输出,也就是jvm遇到错误就直接退出了,

JVM的默认处理方案

把异常的名称，错误原因及异常出现的位置等信息输出在了控制台,程序停止执行

异常处理方案

1:try…catch…finally处理异常
2:throws向调用者抛出异常

先讲下try...catch的处理方式

语法格式

 try {
         可能出现问题的代码;
   }catch(异常名 变量) {
  针对问题的处理;
  }
 注意：
  A:try里面的代码越少越好
  B:catch里面必须有内容，哪怕是给出一个简单的提示

现在使用try catch对上述代码进行处理

public class ExceptionDemo {
	public static void main(String[] args) {
		int a = 10;
		int b = 0;
		try{
			System.out.println(a / b);
		}catch(Exception e){
			System.out.println("代码出错了");
		}
		System.out.println("over");
	}
}

代码出错了
over

我们发现程序报错被我们捕获了,而且后面的代码也执行了,现在是程序出现一个异常,如果出现多个异常呢?怎么做

解决方案

写一个try，多个catch

语法格式

 try{
  可能出现异常的代码 ...
     }catch(异常类名 变量名) {
   捕获异常
     }
 catch(异常类名 变量名) {
捕获异常
   }
在catch语句中不要把父类异常写在最前面,否则后面的异常处理就会出错?

正确的写法：

public class ExceptionDemo2 {
	public static void main(String[] args) {
		method4();
	}
	public static void method4() {
		int a = 10;
		int b = 0;
		int[] arr = { 1, 2, 3 };
		try {
			System.out.println(a / b);
			System.out.println(arr[3]);
			System.out.println("这里出现了一个异常，你不太清楚是谁，该怎么办呢?");
		} catch (ArithmeticException e) {
			System.out.println("除数不能为0");
		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.println("你访问了不该的访问的索引");
		} catch (Exception e) {
			System.out.println("出问题了");
		}

		System.out.println("over");
	}
}

错误写法

总结：

1:能明确的尽量明确，不要用大的来处理。
2:平级关系的异常谁前谁后无所谓，如果出现了子父关系，父必须在后面。

一旦try里面出了问题，就会在这里把问题给抛出去，然后和catch里面的问题进行匹配，
一旦有匹配的，就执行catch里面的处理，然后结束了try...catch
继续执行后面的语句

编译时异常和运行时异常的区别

Java中的异常被分为两大类：编译时异常和运行时异常。所有的RuntimeException类及其子类的实例被称为运行时异常，其他的异常就是编译时异常
编译时异常
Java程序必须显示处理，否则程序就会发生错误，无法通过编译
运行时异常
无需显示处理，也可以和编译时异常一样处理

现在讲下Throwable中的方法中常用的方法

getMessage()
获取异常信息，返回字符串。
toString()
获取异常类名和异常信息，返回字符串。
printStackTrace()
获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。
printStackTrace(PrintStream s)
通常用该方法将异常内容保存在日志文件中，以便查阅。 

刚开始说异常处理的2中方式,但是就讲了一种,还有一种处理方式没讲,现在就讲下异常的另一种处理方式

throws 抛出的意思,也就是说在此不处理,直接抛出,谁调用谁处理

throws功能描述

定义功能方法时，需要把出现的问题暴露出来让调用者去处理。那么就通过throws在方法上标识

代码

public class ExceptionDemo{
	public static void main(String[] args) throws Exception  {
		int a = 10;
		int b = 0;
		System.out.println(a / b);
		System.out.println("over");
	}
}

语法格式

throws 异常类名

注意：这个格式必须跟在方法的括号后面

还有一种解决异常的方式,但是很少使用,就是throw,下面对throw进行简单的概述

在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出

代码

public class ExceptionDemo {
	public static void main(String[] args) {
		try {
			method2();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void method2() throws Exception {
		int a = 10;
		int b = 0;
		if (b == 0) {
			throw new ArithmeticException();
		} else {
			System.out.println(a / b);
		}
	}
}

1：throws和throw的区别

throws
用在方法声明后面，跟的是异常类名
可以跟多个异常类名，用逗号隔开
表示抛出异常，由该方法的调用者来处理
throws表示出现异常的一种可能性，并不一定会发生这些异常
throw
用在方法体内，跟的是异常对象名
只能抛出一个异常对象名
表示抛出异常，由方法体内的语句处理
throw则是抛出了异常，执行throw则一定抛出了某种异常

我们还有一个重要的知识点没讲,就是finally语句,

finally语句的特点

被finally控制的语句体一定会执行
特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))

finally的作用

用于释放资源，在IO流操作和数据库操作中会见到

finally语句是集合try一起使用的,常用的搭配使用方法有如下几种

try…catch…finally可以使用
try…catch也可以使用
try…finally也可以使用
但是，catch，finally不能单独使用

finally相关的面试题

final,finally和finalize的区别
final：最终的意思，可以修饰类，成员变量，成员方法
修饰类，类不能被继承
修饰变量，变量是常量
修饰方法，方法不能被重写
finally：是异常处理的一部分，用于释放资源。
一般来说，代码肯定会执行，特殊情况：在执行到finally之前jvm退出了
finalize：是Object类的一个方法，用于垃圾回收

如果catch里面有return语句，请问finally的代码还会执行吗?如果会，请问是在return前还是return后？

<span style="font-size:18px;">public class ExceptionDemo{
	public static void main(String[] args) throws Exception  {
		System.out.println(getInt());
	}
	@SuppressWarnings("finally")
	public static int getInt() {
		int a = 10;
		try {
			System.out.println(a / 0);
			a = 20;
		} catch (ArithmeticException e) {
			a = 30;
			return a;
			/*
			 * return a在程序执行到这一步的时候，这里不是return a而是return 30;这个返回路径就形成了。
			 * 但是呢，它发现后面还有finally，所以继续执行finally的内容，a=40
			 * 再次回到以前的返回路径，继续走return 30;
			 */
		} finally {
			a = 40;
		}
		return a;
	}
}</span>

理由：上面已经注释讲了,如果在finally语句中也有return语句呢?会返回多少呢?

<span style="font-size:18px;">public class ExceptionDemo{
	public static void main(String[] args) throws Exception  {
		System.out.println(getInt());
	}
	@SuppressWarnings("finally")
	public static int getInt() {
		int a = 10;
		try {
			System.out.println(a / 0);
			a = 20;
		} catch (ArithmeticException e) {
			a = 30;
			return a;
		} finally {
			a = 40;
			return a;//如果这样结果就是40了。
		}
	}
}</span>

现在讲最后一个技术点了就是自定义异常

自定义异常

java不可能对所有的情况都考虑到，所以，在实际的开发中，我们可能需要自己定义异常。
而我们自己随意的写一个类，是不能作为异常类来看的，要想你的类是一个异常类，就必须继承自Exception或者RuntimeException

两种方式：
A:继承Exception
B:继承RuntimeException

写一个例子就明白了：需求;考试成绩必须在0-100之间

MyException.java自定义异常类

public class MyException extends Exception {
public MyException() {
}


public MyException(String message) {
super(message);
}
}

Teacher.java业务类 

public class Teacher {
public void check(int score) throws MyException {
if (score > 100 || score < 0) {
throw new MyException("分数必须在0-100之间");
} else {
System.out.println("分数没有问题");
}
}
}
StudentDemo.java业务的测试类

public class StudentDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入学生成绩：");
int score = sc.nextInt();


Teacher t = new Teacher();
try {
t.check(score);
} catch (MyException e) {
e.printStackTrace();
}
}
}

ok自定义异常就是这么简单！

异常注意事项

子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类
如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws

java 异常基础知识以及一些面试题讲解

标签：java   android   

原文地址：http://blog.csdn.net/coderinchina/article/details/43924727