throws和throw区别
throws关键字
throws定义一个方法的时候可以使用throws关键字声明,表示此方法不处理异常,而交给方法调用处进行处理。
- 任何方法都可以使用throws关键字声明异常类型,包括抽象方法。
- 子类重写父类中的方法,子类方法不能声明抛出比父类类型更大的异常。
- 使用了throws的方法,调用时必须处理声明的异常,要么使用try-catch,要么继续使用throws声明。
package ThrowsAndThrow;
import java.text.ParseException;
import java.text.SimpleDateFormat;
public class ThrowsDemo {
public static void main(String[] args) {
// 在调用方法处进行异常处理,亦可以抛出
try {
ThrowsDemo.testThrows();
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// 定义方法是使用throws抛出异常,谁调用谁处理
public static void testThrows() throws ParseException {
String string = "1999-09-15";
// SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
System.out.println(simpleDateFormat.parse(string)); // 解析为日期
}
}
结果1:
java.text.ParseException: Unparseable date: "1999-09-15"
at java.text.DateFormat.parse(DateFormat.java:366)
at ThrowsAndThrow.ThrowsDemo.testThrows(ThrowsDemo.java:25)
at ThrowsAndThrow.ThrowsDemo.main(ThrowsDemo.java:11)
结果2:
Wed Sep 15 00:00:00 CST 1999
throw关键字
- throw关键字用于显式抛出异常,抛出的时候是抛出的是一个异常类的实例化对象。
- throw用于方法体中,使用后要么使用try/catch捕获异常,要么throws异常。
- 在throw所new的异常方法中一般需要在方法声明处throws异常类型。
- void方法没有返回值,所以一般把可能有异常的代码.主动抛出,让调用方法处理。
package ThrowsAndThrow;
public class ThrowDemo {
public static void main(String[] args) {
ThrowDemo.testThrow(120);
}
public static void testThrow(int num) {
if (num < 0 || num > 100) {
// return ; 直接结束方法,但是没有给用户提示
throw new RuntimeException("非法成绩");
}
if (num >= 90 && num <= 100) {
System.out.println("A");
}
}
}
结果:
Exception in thread "main" java.lang.RuntimeException: 非法成绩
at ThrowsAndThrow.ThrowDemo.testThrow(ThrowDemo.java:13)
at ThrowsAndThrow.ThrowDemo.main(ThrowDemo.java:6)
throws抛出抽象方法异常
在抽象类中方法声明时可以throws异常,但是需要注意Exception属于编译期异常。
当实现抽象类时,子类中重写抽象类Exception异常的方法声明时可以throws编译期的其他(具体的)异常,但是当抽象类中是具体的异常时,子类中重写时就不能使用Exception异常;
当实现抽象类时,子类中重写抽象类RuntimeException中具体的异常的方法声明时可以throws运行期的RuntimeException异常。
- 声明抽象类
import java.text.ParseException;
/**
* 抽象类中的异常
*/
public abstract class ThrowsDemo {
// 运行期异常中的算数异常
abstract void arithetic() throws ArithmeticException;
// 编译期异常中解析异常
abstract void parse() throws ParseException;
// 编译期异常
abstract void excep() throws Exception;
}
- 通过子类实现抽象类
import java.text.ParseException;
/**
* 实现抽象类中的方法
*/
public class ExtendsThrows extends ThrowsDemo {
@Override
void arithetic() throws RuntimeException {
System.out.println("抽象类中使用具体的运行期异常,实现类中可以通过RuntimeException或者原本的异常来抛出异常的。");
}
@Override
void parse() throws ParseException {
System.out.println("抽象类中使用具体的编译期异常,实现类中是不能通过Exception来抛出异常的。");
}
@Override
void excep() throws ParseException {
System.out.println("抽象类中使用Exception异常,实现类中可以通过Exception或者具体的编译期异常来抛出异常的。");
}
}
自定义异常
- 自定义异常类继承编译期(Exception),在方法中使用throw抛出后,必须在方法中try-catch或throws抛出.
- 自定义异常类继承运行期(RuntimeException),在方法中使用throw抛出后,必须在方法中try-catch或throws抛出.
/**
* 运行时异常类,通过throw创建异常对象,但是不会通过throws在方法声明处抛出
*/
public class RunExecption extends RuntimeException {
/**
* 注意运行时异常通过throw创建异常对象,不会在方法上通过throws声明
*/
public void Runtest(){
throw new RuntimeException();
}
}
自定义异常类:
- 往往不写其他方法,只重载需要使用的构造方法
/**
* 当成绩不在正常范围内时,抛出此异常类
* @author wenhua
*/
public class ExceptionClass extends Exception {
/**
* 序列化ID号
*/
private static final long serialVersionUID = 1L;
// 构造方法
public ExceptionClass() {
}
public ExceptionClass(String message) {
super(message);
}
}
测试类:
public class ThrowDemo {
public static void main(String[] args) {
try {
ThrowDemo.testThrow(120);
} catch (ExceptionClass e) {
e.printStackTrace();
System.out.println(e.getMessage());
}
System.out.println("后面代码");
}
/**
* 打印成绩
* @param num 成绩
* @throws ExceptionClass 当成绩非法时抛出异常对象
*/
public static void testThrow(int num) throws ExceptionClass {
if (num < 0 || num > 100) {
throw new ExceptionClass("非法成绩"); // 当不满足条件是,主动抛出一个异常对象
}
if (num >= 90 && num <= 100) {
System.out.println("A");
}
}
}
结果:(当catch中的System在前时会有变化哟)
UserDefinedException.ExceptionClass: 非法成绩
at UserDefinedException.ThrowDemo.testThrow(ThrowDemo.java:23)
at UserDefinedException.ThrowDemo.main(ThrowDemo.java:6)
非法成绩
后面代码
throws和throw的区别
- 不同点:
- 位置:throws抛出异常在方法声明处且可以有多个异常类型,而throw抛出异常在方法体中
- 修饰对象:throws修饰的是方法名,而throw修饰的对象
- 用到throw一般就会用到throws抛出异常或者try - catch处理。
- 用到thrwos时需要在顶方法中通过try - catch处理。
当throw在方法体中抛出编译期异常时,需要通过throws在方法声明处显示抛出异常。