java之异常处理

    Hashmap与Hashtable的区别

      HashMap可以保存null值

      Hashtable不能保存null值

 异常处理

     main函数处理中出现异常

     1.由自己main函数来处理异常

     2.由main的上级来处理

     main函数由JVM来调用

     (谁调用方法，谁就来处理这异常)

     这里最终异常是由JVM来处理

   JVM默认的处理异常方式

     1.打印错误所在位置    

     2.打印错误信息

     3.停止你的程序

   如何处理异常?

     try...catch...finally

   try指的要被测试的代码(有可能发生异常的代码)

   catch指的要捕获的异常

    finally指的异常出后要执行的代码

   多catch的处理异常

     由上至下进行匹配，匹配上一个剩下的catch都不走了

     捕获时使用的类，要由小到大书写

public class Demo03 {
	public static void main(String[] args) {
		//测试异常的发生
		TestException test=new TestException();
		try {
			//放要可能发生异常的代码
			//返回ArithmeticException对象
			int num = test.fun(10, 0);
			System.out.println(num);
		} catch(ArithmeticException e) {
			//ArithmeticException e=new ArithmeticException();
			//捕获异常对象(匹配这个异常对象)
			//捕获成功 会执行catch中的代码
			//程序不会被终止
			System.out.println("你除了零");
		}catch(IndexOutOfBoundsException e) {
			System.out.println("越界异常");
		}catch (Exception e) {
			System.out.println("Exception异常");
		}
		System.out.println("你猜我执行了吗");
		//发生异常时
		//会创建一个异常对象
		//new ArithmeticException("异常信息/by zero")
		//这时会把创建出来异常对象返回
		//返回给他的上级去除处理
		//(谁调用这个方法 就给谁处理)
		//这个异常对象返回给main函数
		//main函数接到异常没处理交给上级
		//JVM处理(打印错误信息)
		
	}
}//最终 你除了零 你猜我执行了吗 这两句话都执行了

   finally

    finally中的代码，一定会被执行

    finally一般关闭资源，关闭数据库，关闭流

public class Demo04 {
	public static void main(String[] args) {
		try {
			int num=10/1;
			return;
		} catch (ArithmeticException e) {
			System.out.println("你除了0");
		}finally {
			System.out.println("我是finally中的语句");
		}
	}
}//最终 我是finally中的语句执行了

   final finally finalize之间的区别?

   三者之间没有关系

   修饰类 修饰方法 修饰变量

   finally 异常处理中关键字，可以关闭资源，一定会被执行的

   finalize是Object类的方法，用垃圾回收

   可以将内存中没有任何引用的垃圾空间回收，系统调用

 使用throw关键词抛出异常，把异常抛给上级处理，使用throws来标识方法，是个带异常的方法，在方法的声明上标识

public class Demo05 {
	public static void main(String[] args) throws Exception {
		Person person=new Person();
		person.setName("张三");
		//调用该方法可能接收到异常对象
		//需要你来处理异常
		//try {
			//person.setAge(150);
			//System.out.println(person);
		//} catch (Exception e) {
			//打印错误信息
			//System.out.println(e.getMessage());
		//}
		//把异常抛给上级处理
		//直接在main函数的声明上标识一下该方法有异常
		person.setAge(150);
		System.out.println(person);
	}
}
class Person{
	private String name;
	private int age;
	
	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;	
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) throws Exception {
		//判断年龄
		if (age>0&&age<120) {
			this.age = age;
		}else {
			//抛出一个异常
			//创建一个异常出来
			Exception exception=new Exception("你超龄了");
			//使用throw关键词 抛出异常
			//报错原因 现在这个方法不支持抛出异常
			//需要在方法中标识一下
			//标识本方法可以抛出一个异常对象
			//使用throws来标识方法是个带异常的方法
			//在方法的声明上标识
			throw exception;
		}	
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
}

   throw和throws的关系?

     throw 抛出异常对象 书写位置 方法中

     throws 标识这个方法是个带异常的方法  书写位置 方法声明上

   异常处理的方式

     1.某个方法出现了异常

     2.产生一个异常对象

     3.这个异常对象要返回给方法的调用者

     4调用者接到这个异常进行处理

     方式一:抛出去 抛给上级去处理

     抛给JVM处理,调用JVM的默认处理机制 程序被停止

     方式二:自己处理 try---catch处理

     接到异常时 使用catch进行匹配

     匹配成功后 执行catch中的语句    

     并且没有终止程序 程序继续进行