Java基础之throws和throw关键字

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在方法声明处显示抛出异常。