详述throw与throws

封装：被调用代码

package com.jd.vo;
import com.jd.exception.AgeException;
public class Student {
//public int age;如果该变量为public级别的变量，则定义Student类的人无法对该变量的范围进行有效的约束  ，公共方法操作私有属性
private int age;
public void setAge( int age) {
	if (age>1 && age<20) {
		this.age = age;
	}else {
	System.out.println("年龄无效");//思考：这种提示错误的方式对于调用该方法的程序员没有什么过多的直接的帮助，解决方案：**throw 异常对象**
	}
}
}		

调用代码：

package com.jd.vo;
public static void main(String[] args) throws AgeException {
	Student student=new Student();
	student.setAge(100);//超过范围，为异常
	System.out.println(student.getAge());
}	

抛出异常

throw关键字
throw用于抛出具体异常类的对象，一般用于方法体中。
什么时候使用：当所写的代码因不满足某些条件致使程序无法运行时可以借助throw抛出一个异常对象提醒程序员。

package com.jd.vo;
import com.jd.exception.AgeException;
public class Student {
private int age;
public void setAge( int age) {
	if (age>1 && age<20) {
		this.age = age;
	}else {
		//throw new NullPointerException("年龄无效");//思考：词不达意 String str=null;str.length()
		throw new AgeException("年龄无效");/*如何自定义异常：创建继承Exception 或其子类的自		定义类；自定义异常类调用父类构造函数(通常是含有一个String类型参数的构造函数)；	*/

package exception;
public class AgeException extends Exception{
/**
*
*/
private static final long serialVersionUID = 1774000285487138362L;
public AgeException(String arg0) {
	super(arg0);
	}
}	

问题为什么那里不使用普通的System.out.println（）进行提示？
普通的输出仅仅是输出一句话，无法像抛出异常那样能准确定位到代码出错的位置，执行下面备注代码，进行比较即可知道

public class Test {
	public static void div(int a, int b){
		if(b==0){
			System.out.println("操作失败：分母不能为0");
			return;
			}
			System.out.println(a/b);
		}
		public static void main(String[] args) {
			div(1, 0);
		}
}		

1、如果异常对象为运行时，则方法参数列表后面可以不使用throws，也可以将异常抛给方法调用者；try-catch

package com.jd.vo;
import exception.AgeException;
public class Student {
private int age;
public void setAge(int age) throws AgeException  {//可以没有throws AgeException
	if(age>0&&age<20) {
		this.age=age;
	}
	else{
	throw new AgeException ("年龄无效");	//该异常为运行异常
	}
}	

try -catch

package com.jd.vo;
import exception.AgeException;
public class Student {
private int age;
public void setAge(int age) throws AgeException  {
	if(age>0&&age<20) {
		this.age=age;
	}
	else{
		try {
			throw new AgeException ("年龄无效");
		     }catch(AgeException e){
			e.printStackTrace();
}

throw将异常对象抛给谁
1、抛给自己

public class Test {
	int a = 9;
	int b = 0;
	{
		if (b == 0) {
				throw new UnsupportedOperationException("操作失败：分母不能为0");
		}
		System.out.println(a / b);
	}
	public static void main(String[] args) {
			new Test();
	}
}

2、抛给方法调用者

方法调用者继续上抛该异常，由于方法抛出的是运行时异常类创建的对象，所以可以如下这样做；如果抛出由检查时异常类创建的对象，则这种处理方式必须使用throws关键字抛出创建该对象的异常类或其父类

import javax.print.PrintException;
public class PrintUtil {
	public  static void printAge(int age) throws PrintException {/*此处由于该方法使用throw抛出的是			*由检查时异常创建的对象并且throw后没有自行处理，所以这里必须要使用throws抛				出创建该异常的异常类；此处也可以throws */
		if (age >= 150 || age <= 0) {
			throw new PrintException("打印失败，请输入0~150之间的数");
		} else {
			System.out.println("年龄为：" + age);
		}
	}
}		

如果异常对象为检查异常时，则方法参数列表后面必须使用throws抛出创建该对象的类；如果没有throws 必须try-catch

package com.jd.vo;
import exception.AgeException;
public class Student {
private int age;
public void setAge(int age) throws AgeException  {
	if(age>0&&age<20) {
		this.age=age;
	}
	else {
		try {
			throw new AgeException ("年龄无效");
		}catch(AgeException e){
			e.printStackTrace();
		}	
	}
}		

使用throw抛出异常对象如果没有try-catch捕获该异常对象，则该抛出异常对象语句执行后其所在方法结束执行。

public class Test {
	public static void main(String[] args) {
			div(1, 0);
			System.out.println("代码2");
	}
	static void div(int a, int b){
		if(b==0){
			throw new UnsupportedOperationException("第二个参数不能为0");
		}
		System.out.println("代码1");
	}
}	

throws关键字

throws用于声明方法可能抛出的异常，其后为异常类，可以有多个，异常类之间用英文逗号间隔。
什么时候使用：
当方法体中的throw关键字抛出由检查时异常创建的对象时，如果该异常对象在抛出的同时已经通过try-catch进行了处理，则可以不使用throws，否则必须使用throws抛出创建该对象的异常类或其父类。
所调用的方法抛出了检查时异常时，如果该方法在调用的同时已经通过try-catch进行了处理，则可以不使用throws继续上抛该异常，否则必须使用throws才能上抛该异常，此时上抛的异常类可以是调用方法时方法抛出的异常类也可以是其父类。

如果方法中的异常已经通过try-catch进行了捕获则无需再使用throws上抛该异常了，否则即使上抛也无效，只会做无用功。

public class Test{
	public static void show(int age) throws PrinterException{
		if(age<0||age>150){
				try {
				throw new PrinterException(“操作失败：年龄取值范围为0~150”);/*此处异常已
				*经通过try-catch语句进行了处理，所以show方法无需再使用throws抛出异常
				*了，否则即使上抛也无效：执行代码会发现，即使这里异常被触发了，在main
				方法中catch依然没有执行，所以此时在通过throws抛出异常类纯属无用功*/
				} catch (PrinterException e) {
					System.out.println("show方法");
					e.printStackTrace();
				}
				return;
		}		
		System.out.println(age);
}
public static void main(String[] args) {
	try {
		show(1000);
	} catch (PrinterException e) {
		System.out.println("main方法");
		e.printStackTrace();
		}
	}
}	

** throw与throws的区别**
throw与throws的区别：
1、抛出的东西不同：throw抛出的是具体的异常对象，而throws抛出的是抽象的异常类；
2、使用位置不同：throw一般用在方法体中，也可用在代码块中，但是如果抛出的是检查时异常类创建的对象，则必须使用try-catch自行处理；throws只能用在方法声明括号后面；
自定义异常类
1、为什么？
Java API提供的已有异常类无法准确表述当前发生的异常问题，这时就需要创建自定义的异常。
2、怎么做？
创建继承Exception 或其子类的自定义类；
自定义异常类调用父类构造函数(通常是含有一个String类型参数的构造函数)；

举例：如上面年龄问题引出的AgeException异常

package exception;
public class AgeException extends Exception{
/**
*
*/
private static final long serialVersionUID = 1774000285487138362L;
public AgeException(String arg0) {
	super(arg0);
}
}