java程序设计13-内部类与异常类

枚举enum
java中的枚举类型定义包括枚举声明和枚举体

package course9;

public class MyEnum {
	enum Season{
		spring,summer,autumn,winter
	}
	
	public static void main(String[] args){
	//定义一个枚举变量
	Season x;
	x = Season.spring;
	
	//创建一个枚举Season数组，
	Season a[] = Season.values();
	
	//遍历a[]中所有的元素
	for(Season s:Season.values()){
		System.out.println(s);
	}
	}

}

输出结果：

spring
summer
autumn
winter

内部类

package course9;

//红牛农场类,把RedCow类叫做内部类，也可以叫做RedCowForm的内部类，
//RedcowForm类叫做RedCow的外嵌类
public class RedCowForm {
	private String formName;
	
	RedCow cow;
	
	RedCowForm(){
	}
	
	RedCowForm(String s){
		formName = s;
		cow = new RedCow(150,112,5000);
	}
	
	//定义一个红牛内部类，仅供RedCowForm使用
	class RedCow{
		String cowName = "红牛";
		int height, weight, price;
		RedCow(int h,int w,int p){
			height = h;
			weight = w;
			price = p;
		}
		void speak(){
			System.out.println("我的名字是：" + cowName);
			System.out.println("身高：" + height);
			System.out.println("体重：" + weight);
			//内部类可以方便的使用它的外嵌类的属性和方法
			System.out.println("我生活在：" + formName);
			
		}
		
	}

}

异常

指程序在运行时，由于程序使用者没有按照程序的设计规格进行操作或输入所带来的运行问题。

package course9;

public class Test1 {
	//异常：程序在运行时，由于程序使用者（用户）没有按照程序设计规格进行操作或输入所带来的程序的问题。
	public static void main(String[] args){
		
		int r = devide(3,0);
		
	}
	
	//除法操作
	public static int devide(int x,int y){
		int result = x/y;
		return result;
	}
}

Exception in thread "main" java.lang.ArithmeticException: / by zero
	at course9.Test1.devide(Test1.java:15)
	at course9.Test1.main(Test1.java:7)

说明此程序是不健壮的

异常处理机制

异常抛出------>异常捕获------>异常处理

异常处理机制中的模块
1.try模块：捕获异常
2.catch模块：异常处理
3.finally模块

异常出现时，Java运行环境会生成一个该种异常的一个对象(该对象含有异常信息)，这个过程称为异常的抛出(throw)。

Java虚拟机接收到异常对象时，会寻找能处理这种异常的代码：
若有，则将上述异常对象交给该代码处理；
若无，则由Java虚拟机做默认处理。
这一过程称为异常的捕获(catch)。

catch和try模块必须成对出现。
try模块
在异常处理中，当主函数需要调用一个可能导致异常的方法或者语句时，可以将其放入try模块中。
若异常发生，整个try模块停止运行，并抛出异常。

catch模块
catch模块与try模块成对出现，发生异常后，try模块停止运行，一场对象交给catch模块进行处理，这个过程也叫做捕获。catch可以有多个。

package course9;

public class Test1 {
	//异常：程序在运行时，由于程序使用者（用户）没有按照程序设计规格进行操作或输入所带来的程序的问题。
	public static void main(String[] args){
		
		int r = devide(3,0);
		
		System.out.println("程序继续运行");
	}
	//除法操作
	public static int devide(int x,int y){
		int result = 0;
		
		try{
			result = x/y;
		}catch(Exception e){//e为异常对象
			System.out.println(e);
		}
		return result;
}
}

输出结果：

java.lang.ArithmeticException: / by zero
程序继续运行

运行时异常：编译可以通过，可以处理也可以不处理
非运行时异常：编译通不过，必须使用trycatch处理

finally语句为异常提供一个统一的出口，无论是否发生异常，finally模块中的语句都会被执行。

package course9;

public class Test1 {
	//异常：程序在运行时，由于程序使用者（用户）没有按照程序设计规格进行操作或输入所带来的程序的问题。
	public static void main(String[] args){
		
		try{
		int r = devide(3,1);
		}catch(Exception e){
			System.out.println(e);
		}
		System.out.println("程序继续运行");
	}
	//除法操作
	public static int devide(int x,int y){
		int result = 0;
		
		try{
			result = x/y;
		}catch(Exception e){//e为异常对象
			System.out.println(e);
		}finally{
			System.out.println("执行finally模块代码");
		}
		
		return result;
}
}

输出结果：

执行finally模块代码
程序继续运行

package course9;

public class Test1 {
	//异常：程序在运行时，由于程序使用者（用户）没有按照程序设计规格进行操作或输入所带来的程序的问题。
	public static void main(String[] args){
		
		try{
		int r = devide(3,1);
		}catch(Exception e){
			System.out.println(e);
		}
		System.out.println("程序继续运行");
	}
	//除法操作
	public static int devide(int x,int y){
		int result = 0;
		
		try{
			result = x/y;
		}catch(ArithmeticException e){//e为异常对象
			System.out.println(e);
		}catch(NullPointerException e){
		}finally{
			System.out.println("执行finally模块代码");
		}
		
		return result;
}
}

package course9;

public class Test1 {
	//异常：程序在运行时，由于程序使用者（用户）没有按照程序设计规格进行操作或输入所带来的程序的问题。
	public static void main(String[] args){
		//如果方法定义时定义了throws Exception,那么在使用时必须要进行异常处理
		try{
			int r = devide(3,1);
		}catch(Exception e){
			System.out.println(e);
		}
		
		System.out.println("程序继续运行");
	}
	//除法操作
	public static int devide(int x,int y)throws Exception{//抛出异常
		int result = 0;
		
		try{
			result = x/y;
		}catch(ArithmeticException e){//e为异常对象
			System.out.println(e);
		}catch(NullPointerException e){
		}finally{
			System.out.println("执行finally模块代码");
		}
		
		return result;
}
}

自定义异常

package course9;

public class Test1 {
	//异常：程序在运行时，由于程序使用者（用户）没有按照程序设计规格进行操作或输入所带来的程序的问题。
	public static void main(String[] args){
		//如果方法定义时定义了throws Exception,那么在使用时必须要进行异常处理
		try{
			int r = devide(3,0);
		}catch(Exception e){
			System.out.println(e);
		}
		
		System.out.println("程序继续运行");
	}
	//除法操作
	public static int devide(int x,int y)throws Exception{//抛出异常
		int result = 0;
		
		if(y == 0){
			MyException me = new MyException("自定义异常：除数为0");
			//throw关键字抛出异常
			throw me;
		}
		result = x/y;
		
		return result;
}
}

package course9;

public class MyException extends Exception{
	public MyException(String s){
		super(s);
		
	}

}

输出结果：

course9.MyException: 自定义异常：除数为0
程序继续运行

异常处理中的关键字

try：可能导致异常的语句放在try模块中，如果异常停止运行整个try模块中，进入catch模块，如果没有异常则正常执行try中语句。
catch：捕捉异常，接受一个异常种类对象作为参数。try模块中语句出现异常时，运行第一个与异常种类匹配的catch模块，若没有异常则不执行catch中语句。
finally：无论是否发生异常，都执行该模块中代码。
throws：若写于方法声明后，则使用该方法时必须进行异常处理。
throw：用于抛出异常，触发try模块进入工作状态。

package course9;

public class Circle {
	private double r;
	
	public void setRadius(double r) throws Exception{
		if(r>0)
		   this.r = r;
		else 
			throw new CircleException(r);
	}
	public void calculatrArea(){
		System.out.println("面积是：" +(3.14*r*r));
	}

	public static void main(String[] args){
		Circle c = new Circle();
		try{
			c.setRadius(-10);
		}catch(Exception e){
			System.out.println(e);
		}	
		c.calculatrArea();
	}
}