折纸的不规律(19)

一.异常

一.异常的分类

受检查异常

如:ClassNotFoundException
NoSuchMethodException
IOException

运行时异常

如:NullPointerException
ClassCastException
ArrayIndexOutofBoundsException

二.异常的体系

Throwable
–Exception
–Error
Exception类
所有的异常类都是Exception类的子类

三.异常处理的机制

由发生异常的位置不断向上抛出,经由方法的调用者一层一层判断处理,
如果异常被处理.则停止抛出,如果异常未被处理,则继续向上(方法的调用者)
抛出,直到抛出main方法,如果main方法也未处理,则抛给JVM.由JVM生成对应的异常类
抛给程序员

四.如何处理异常

try…catch

直接在当前方法内处理异常
语法:

try{//可能会发生异常的代码
			}catch(异常类1 e1){//发生异常情况1的处理
			}catch(异常类2 e2){//发生异常情况2的处理
			}catch(异常类3 e3){//发生异常情况3的处理
			}

catch捕捉的异常必须从小到大,从上到下依次写
try…catch的相关测试

package com.briup.day17;

public class TryTest {
	public static void main(String[] args) {
		//new TryTest().show();
		try {
			new TryTest().info();			
		}catch (ArithmeticException e) {
			System.out.println("main方法中处理异常");
		}catch (ClassNotFoundException e) {
			throw new CustomException("在TryTest里找不到类进行反射");
		}
		System.out.println("main结束");
	}
	
	public void info() throws ArithmeticException, ClassNotFoundException{
		Class.forName("");
		System.out.println("开始");
		System.out.println(10/0);
		System.out.println("结束");
	}
	
	public void show() {
		System.out.println("开始");
		try {
			//如果下一行代码出现异常则进入catch代码块
			//System.out.println(10/0);
			int[] a = new int[10];
			System.out.println(a[20]);
		}catch (ArithmeticException e) {
			System.out.println("出错了");
		}catch (Exception e) {
			System.out.println("这是一个大异常");
		}
		System.out.println("结束");
	}
}

throws

代表当前方法无法处理异常,向方法调用者抛出,由方法调用者进行处理
如果方法调用者也不处理,直接再向上抛出,直到main方法抛给JVM

一般用于受检查异常的处理

throw

一般存在方法体每部,用来抛出一个异常的实例

package com.briup.day17;

public class ThrowTest {
	public static void main(String[] args){
		
//		int i = 20;
//		if(i<5) {
//			System.out.println("正常");
//		}else{
//			throw new Exception("没事干");
//		}
		
		try {
			System.out.println(10/1);
			//new ThrowTest().showMyException();
		}catch (CustomException e) {
			//e.printStackTrace();//用来打印异常栈
			System.out.println(e.getMessage());
			System.out.println(e.getStackTrace()[0]);
			System.out.println(e.getStackTrace()[1]);
//			e.show();
//			System.out.println("抓起来");
		}finally {
			//不管trycatch是异常还是正常，都会最后执行finally代码块
			//一般用作处理后来的事，比如必须关闭的连接，必须释放的资源
			System.out.println("结束。。。");
		}
	}
	public void showMyException() throws CustomException {
		throw new CustomException();
	}
	
	public void showException() throws Exception{
		throw new ClassNotFoundException("还是没事");
	}
}

五.自定义异常

如何让一个类具有特殊的功能
实现一个接口
继承一个父类
如何让两个类具有相同的功能
实现同一个接口
继承同一个父类

继承Exception或者继承RuntimeException
写一个自定义的CustomerException
异常对象可以拥有自己的自定义方法,也可以调用Throwable里的一些方法
示例:
e.getMessage();
e.getStackTrace();
finally:
必须完成的代码
关闭资源,释放资源,物理资源
语法:

finally{
代码块
}

相关测试

package com.briup.day17;

public class FinallyTest {
	public static void main(String[] args) {
		System.out.println(new FinallyTest().test());
	}
	public int test(){
		try{
			//int k = 10/0;
			int k = 10/1;
			System.out.println("bbb");
			//
			return 1;
		}catch(Exception e){
			return -1;
		}finally{
			try {
				return 2;
			}catch (Exception e) {
				return -2;
			}finally {
				return 0;
			}
			
		}
	}
}

六.异常处理的原则

1.不要频繁使用异常处理
2.遇到异常之后不能忽略,再适当的位置进行捕捉处理
3.不要在try中写大段可能会发生异常的代码

二.枚举

JDK1.5之后推出了枚举,可以理解为一种特殊的类,
用来抽象实例个数是固定的类,
不通过new的方式在外界随意创建对象
Enum:
1.方法,变量,构造器
2.创建固定个数的实例
3.所有的实例用public static final 修饰,并提供了默认构造器的初始化

枚举相关:

package com.briup.day17;

public enum SeasonEnum implements EnumInterface{
	SPRING("春天"){
		@Override
		public void info() {
			System.out.println("春天的方法");
		}
		
		public void test() {
			System.out.println("spring");
		}
	},
	SUMMER("夏天","吃冰的"){
		@Override
		public void info() {
			System.out.println("夏天的方法");
		}
	},
	FALL(){
		@Override
		public void info() {
			System.out.println("秋天的方法");
		}
	},
	WINTER{
		@Override
		public void info() {
			System.out.println("冬天的方法");
		}
	};
	//添加属性、方法、构造器
	private String name;
	private String desc;
	//构造器默认的修饰符是private 
	//如果强行要给显性添加修饰符，只能添加private
	SeasonEnum() {
		System.out.println("空参构造器");
	}
	private SeasonEnum(String name) {
		this.name = name;
	}
	SeasonEnum(String name,String desc) {
		this.name = name;
		this.desc = desc;
	}
	//方法
	public void show() {
		System.out.println(name+desc);
	}
	public String getName() {
		return name;
	}
	public String getDesc() {
		return desc;
	}
//	@Override
//	public void info() {
//		System.out.println("Enum里的方法");
//	}
	//抽象方法
	//public abstract void test();
	
//	@Override
//	public String toString() {
//		
//		return "aaa";
//	}
}

测试:

public class EnumTest {
	public static void main(String[] args) {
		Season s = Season.SPRING;
		s.show();
		Season s1 = Season.getSeason(3);
		s1.show();
		SeasonEnum s2 = SeasonEnum.SPRING;
		//s2.spring();
		SeasonEnum.SUMMER.info();
		
		//遍历获得Enum下面的所有实例 values
		for(SeasonEnum se :SeasonEnum.values()) {
			System.out.println(se);
		}
	}
}

三.心得

这周学的东西都不是特别难,都相对来说比较好接受,这个周末也没有前几个周末那么紧张,下周就即将开启地狱的一周了,继续加油!