【黑马程序员】面向对象（五） 第九天

public class InnerClassDemo {
	public static void main(String[] args) {
		//直接访问内部类中的成员。
		Outer.Inner in = new Outer().new Inner();
		in.function();
		System.out.println("------------");
		Outer o = new Outer();
		o.method();
	}
}
class Outer{
	private int x = 3;
	void method(){
		Inner in = new Inner();//创建内部类Inner对象。
		in.function();
	}
	
	class Inner{//内部类
		void function(){
			System.out.println("Innner: " + x);
		}
	}
}

public class InnerClassDemo_2 {
	public static void main(String[] args) {
		new Outer_1.Inner().function_1();//直接访问static内部类中的非静态成员。
		System.out.println("-------------");
		Outer_1.Inner_2.function_2();//直接访问static内部类中的静态成员。
	}
}
class Outer_1{
	private static int x = 3;
	static class Inner{//静态内部类
		void function_1() {
			System.out.println("Inner: " + x);
		}
	}
	static class Inner_2{//静态内部类
		static void function_2() {
			System.out.println("Inner: " + x);
		}
	}
}

/*
 * 异常：就是程序在运行时出现不正常情况。
 * 异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。
 * 			其实就是java对不正常情况进行描述后的对象体现。
 * 对于问题的划分：两种：一种是严重的问题，一种是非严重的问题。
 * 对于严重的，java通过Error类进行描述。对于非严重的，java通过Exception类进行描述。
 */
public class ExceptionDemo {
	public static void main(String[] args) {
		Demo d = new Demo();
		int a = d.div(10, 3);
		System.out.println("A: " + a);
//		int b = d.div(10, 0);//除数不能为0。
//		System.out.println("B: " + b);//异常：ArithmeticException
	}
}
class Demo{
	int div(int a, int b){
		return a / b;
	}
}

06）try-catch

public class ExceptionDemo_2 {
	public static void main(String[] args) {
		Demo_2 d = new Demo_2();
		try{
			int a = d.div(10, 3);
			System.out.println("A: " + a);
			int b = d.div(a, 0);//异常：ArithmeticException
			System.out.println("B: " + b);
		}catch(Exception e){//Exception e = new ArithmeticException();//多态。
			System.out.println("除数不能为O");
			System.out.println(e.getMessage());//打印异常信息
			System.out.println(e.toString());//打印异常名称+异常信息。
			e.printStackTrace();//打印异常名称+异常信息+异常出现的位置。
								//这是JVM默认的异常处理机制。
		}
	}
}
class Demo_2{
	int div(int a, int b){
		return a / b;
	}
}

public class ExceptionDemo_3 {
	public static void main(String[] args){
		Demo_3 d = new Demo_3();
		try{
			int a = d.div(100, 10);
			System.out.println("A: " + a);
			int b = d.div(a, 0);//出现异常后，下面一行语句将不执行。
			System.out.println("B: " + b);
		}catch (Exception e){
			System.out.println(e.toString());
		}
		
	}
}
class Demo_3{
	int div(int a, int b) throws Exception{//在功能上通过throws的关键字声明了该功能有可能会出现问题。
		return a / b;
	}
}

public class ExceptionDemo_4 {
	public static void main(String[] args) {
		Demo_4 d = new Demo_4();
		try{
			int a = d.div(5, 2);
			System.out.println("A: " + a);
		}catch (ArithmeticException e){
			System.out.println("除数不能为0： " + e.toString());
		}catch (ArrayIndexOutOfBoundsException e){//被捕获
			System.out.println("下标越界异常： " + e.toString());
		}catch (Exception e){
			System.out.println("发现异常： " + e.toString());
		}
	}
}
class Demo_4{
	int div(int a, int b) throws ArithmeticException, ArrayIndexOutOfBoundsException{
		int[] arr = new int[a];
		System.out.println(arr[5]);//发生异常，结束语句。
		return a / b;
	}
}

/*
 * 自定义异常：
 * 需求：在本程序中，对于除数是负数，也视为错误的是无法进行运算的。那么就需要对这个问题进行自定义的描述。
 * 当函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。
 * 要么在catch内部try catch处理。
 * 要么在函数上声明让调用者处理。
 * 
 * 一般情况下，函数内部出现异常，函数上需要声明。
 * 定义异常信息：因为父类中已经把异常信息的操作都完成了。
 * 				所以子类在构造时，只要将异常信息传递给父类，通过super语句。就可以直接通过getMessage()方法获取自定义的异常信息。
 * 
 */
public class ExceptionDemo_5 {
	public static void main(String[] args) {
		Demo_5 d = new Demo_5();
		try{
			int a = d.div(10, -6);
			System.out.println("A: " + a);
		}catch (FuShuException e){
			System.out.println(e.toString());
			System.out.println("错误的负数是： " + e.getValue());
		}
		
	}
}
class Demo_5{
	int div(int a, int b) throws FuShuException {//抛出异常
		if (b < 0)
			throw new FuShuException("出现了除数为负数的情况", b);
		return a / b;
	}
}
class FuShuException extends Exception{
	private int value;
	FuShuException(){
		super();
	}
	FuShuException(String mag, int value){
		super(mag);
		this.value = value;
	}
	public int getValue(){
		return value;
	}
}

/*
 * 练习：汤姆在看电视。
 * 思考汤姆在看电视时会遇到的问题。
 * 
 * 比如问题是：电视卡屏、电视冒烟、杰瑞来捣乱。
 * 对问题进行描述，封装成对象。
 * 当出现第一种情况：电视机卡屏。重启电视机。
 * 当出现第二种情况：电视机冒烟。汤姆找斯派克修理电脑。
 * 当出现第三种情况：杰瑞来捣乱。汤姆抓杰瑞。
 */
public class ExceptionDemoTest {
	public static void main(String[] args) {
		Tom tom = new Tom("汤姆");
		try{
			tom.userTV();
		}catch (SPKException e){
			System.out.println(e.getMessage());
		}
	}
}
class TV{//电视机
	private int state = 2;//其它的都代表正常状态。这里初始化state为第二种状况：电视机冒烟。
	public void run() throws KaPException, MaoYException, JieRException{
		if (state == 1)
			throw new KaPException("第一种情况：电视机卡屏");
		if (state == 2)
			throw new MaoYException("第二种情况：电视机冒烟");
		if (state == 3)
			throw new JieRException("第三种情况：杰瑞来捣乱");
		else
			System.out.println("电视机正常运行");
	}
	public void reset(){//电视机出现问题后重启.
		System.out.println("重启电视机");//为了方便把关机再开机并为重启。
	}
}

class Tom{//汤姆使用电视机
	private String name;
	private TV tv;
	Tom(String name){
		this.name = name;
		tv = new TV();
	}
	public void userTV() throws SPKException{//抛给调用者
		try{
			tv.run();
			System.out.println("看电视");
		}catch (KaPException e){
			System.out.println(e.getMessage());
			tv.reset();
		}catch (MaoYException e){
			System.out.println(e.getMessage());
			System.out.println("不看电视啦");
			throw new SPKException("汤姆找斯派克修理电视机");//汤姆处理不了异常，只能抛出异常。
		}catch (JieRException e){
			System.out.println(e.getMessage());
			System.out.println("汤姆抓杰瑞");
		}
	}
}

class KaPException extends Exception{//卡屏异常
	KaPException(String mag){
		super(mag);
	}
}
class MaoYException extends Exception{//冒烟异常
	MaoYException(String mag){
		super(mag);
	}
}
class JieRException extends Exception{//杰瑞捣乱异常
	JieRException(String mag){
		super(mag);
	}
}
class SPKException extends MaoYException{//异常抛给斯派克
	SPKException(String mag){
		super(mag);
	}
}

private int state = 2;//其它的都代表正常状态。这里初始化state为第二种状况：电视机冒烟。

附言：我是Java新人，如有错误的地方请指出。

                         每天学习一点点，纠错一点点，进步很大点。

-------  android培训、java培训、java学习型技术博客、期待与您交流！ ----------