JAVA自学教程之异常的应用和注意事项（三））



JAVA自学教程之异常的应用和注意事项（三））

十、异常的应用

  1. import java.util.Random;
  3. import javax.rmi.CORBA.Stub;
  5. /*
  6. *老师用电脑上课
  7. *用面向对象思考问题
  8. *问题设计两个对象
  9. *老师，电脑
  10. *
  11. *可能发生的问题：
  12. *电脑蓝屏、电脑冒烟
  13. */
  14. class Lan extends Exception//蓝屏
  15. {
  16.     Lan(String problem)
  17.     {
  18.         super(problem);
  19.     }
  20. }
  21. class Fir extends Exception//冒烟
  22. {
  23.     Fir(String problem)
  24.     {
  25.         super(problem);
  26.     }
  27. }
  28. class No extends Exception
  29. {
  30.     No(String problem)
  31.     {
  32.         super(problem);
  33.     }
  34. }
  35. class Computer
  36. {//定义一个电脑运行的状态
  37.     private int stu = 3; //stu为1正常，2是蓝屏，3是冒烟
  38.     //stu = Random()%2+1;
  39.     public void run()throws Lan,Fir
  40.     {
  41.         switch (stu)
  42.         {
  43.         case 2:
  44.             throw new Lan(“Computer is Lan!!!”);
  45.             //此处就不用break了，因为已经抛出了
  46.         case 3:
  47.             throw new Fir(“Computer is Fir!!!”);
  48.         case 1:
  49.             System.out.println(“Computer is running”);
  50.             break;
  51.         }
  53.     }
  54.     public void rest()//电脑重启
  55.     {
  56.         stu = 0;
  57.         System.out.println(“Computer is rest”);
  58.     }
  59. }
  60. class Teacher
  61. {
  62.     private String name = null;
  63.     private Computer C;
  64.     Teacher(String name)
  65.     {
  66.         this.name = name;
  67.         C = new Computer();
  68.     }
  69.     public void lesson()throws Fir,No
  70.     {
  71.         try
  72.         {
  73.             C.run();
  74.             System.out.println(name+” teacher is teaching”);
  75.         }
  76.         catch(Lan a)
  77.         {
  78.             System.out.println(a.toString());//打印信息
  79.             C.rest();
  80.             lesson();
  81.         }
  82.         catch(Fir b)
  83.         {
  84.             System.out.println(b.toString());//打印信息
  85.             test();
  86.             //能处理的已经处理了，处理不了的继续向外抛
  87.             //找人，对电脑进行维修,并告知学校并带原因，不告知，就是异常异常
  88.             throw new No(“课时无法进行,”+b.getMessage());
  90.         }
  92.     }
  93.     public void test()//做练习
  94.     {
  95.         System.out.println(“student is exciesing”);
  96.     }
  97. }
  98. public class Main
  99. {
  100.     public static void main(String[] args)
  101.     {
  102.         Teacher B = new Teacher(“BLF2″);
  103.         try
  104.         {
  105.             B.lesson();
  106.         }
  107.         catch (Fir e)
  108.         {
  109.             System.out.println(“…..”);
  110.         }
  111.         catch (No e)
  112.         {
  113.             System.out.println(e.toString());
  115.         }
  116.         finally
  117.         {//无论课上发生什么，但是还是会下课
  118.             System.out.println(“到点下课”);
  119.         }
  121.     }
  122. }
import java.util.Random;

import javax.rmi.CORBA.Stub;

/*
 *老师用电脑上课
 *用面向对象思考问题
 *问题设计两个对象
 *老师，电脑
 *
 *可能发生的问题：
 *电脑蓝屏、电脑冒烟
 */
class Lan extends Exception//蓝屏
{
	Lan(String problem)
	{
		super(problem);
	}
}
class Fir extends Exception//冒烟
{
	Fir(String problem)
	{
		super(problem);
	}
}
class No extends Exception
{
	No(String problem)
	{
		super(problem);
	}
}
class Computer
{//定义一个电脑运行的状态
	private int stu = 3; //stu为1正常，2是蓝屏，3是冒烟
	//stu = Random()%2+1;
	public void run()throws Lan,Fir 
	{
		switch (stu) 
		{
		case 2:
			throw new Lan("Computer is Lan!!!");
			//此处就不用break了，因为已经抛出了
		case 3:
			throw new Fir("Computer is Fir!!!");
		case 1:
			System.out.println("Computer is running");
			break;
		}

	}
	public void rest()//电脑重启
	{
		stu = 0;
		System.out.println("Computer is rest");
	}
}
class Teacher
{
	private String name = null;
	private Computer C;
	Teacher(String name) 
	{
		this.name = name;
		C = new Computer();
	}
	public void lesson()throws Fir,No
	{
		try 
		{
			C.run();
			System.out.println(name+" teacher is teaching");
		} 
		catch(Lan a)
		{
			System.out.println(a.toString());//打印信息
			C.rest();
			lesson();
		}
		catch(Fir b)
		{
			System.out.println(b.toString());//打印信息
			test();
			//能处理的已经处理了，处理不了的继续向外抛
			//找人，对电脑进行维修,并告知学校并带原因，不告知，就是异常异常
			throw new No("课时无法进行,"+b.getMessage());

		}

	}
	public void test()//做练习
	{
		System.out.println("student is exciesing");
	}
}
public class Main
{
	public static void main(String[] args)
	{
		Teacher B = new Teacher("BLF2");
		try 
		{
			B.lesson();
		} 
		catch (Fir e)
		{
			System.out.println(".....");
		}
		catch (No e)
		{
			System.out.println(e.toString());

		}
		finally 
		{//无论课上发生什么，但是还是会下课
			System.out.println("到点下课");
		}

	}	
}

/* * 异常的转换，也就叫异常的封装 * 数据库 * class Nosuess extends Exception * { * …..//将异常转换，只需要告知出现异常 * } * void adddata（）throws Nosuess * { * 1.连接数据库 * try * { * 添加数据，出现异常  SQLException，但是添加数据的人不知道SQLException是什么 * } * catch * { * 内部处理 * throw new Nosuess(); * } * finally * { * 关闭数据库 * } * } * */

 

 

十一、异常的注意事项

(1).子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出子类的异常或者该异常的子类（见下述代码）

(2).如果父类抛出多个异常，那么子类只能抛出父类异常的子集


简单说：子类覆盖父类只能抛出父类的异常或者父类异常的子类或者子集

注意：如果父类的方法没有抛出异常，那么子类的覆盖时绝对不能抛

 

下述代码解释注意事项(1)

  1. class A extends Exception
  2. {}
  3. class B extends A
  4. {}
  5. class C extends Exception
  6. {}
  7. class FU
  8. {
  9.     void show()throws A
  10.     {
  11.     }
  12. }
  13. class Test
  14. {
  15.     void method(FU f)
  16.     {
  17.         try
  18.         {
  19.             f.show();
  20.         }
  21.         catch (A a)
  22.         {
  24.         }
  25.     }
  26. }
  27. class ZI extends FU
  28. {
  29.     void show()throws A,B //也可以不抛,但是不可以抛出其他异常
  30.     {}
  31. }
  32. public class Main
  33. {
  34.     public static void main(String[] args)
  35.     {
  36.         Test t = new Test();
  37.         t.method(new ZI());//用多态就可以解释为什么不能抛其他的异常
  38.     }
  39. }
 class A extends Exception
{}
class B extends A
{}
class C extends Exception
{}
class FU
{
	void show()throws A
	{
	}
}
class Test
{
	void method(FU f)
	{
		try
		{
			f.show();
		}
		catch (A a)
		{

		}
	}
}
class ZI extends FU
{
	void show()throws A,B //也可以不抛,但是不可以抛出其他异常
	{}
}
public class Main
{
	public static void main(String[] args)
	{
		Test t = new Test();
		t.method(new ZI());//用多态就可以解释为什么不能抛其他的异常
	}	
}

下述代码解释注意事项(2)

 

  1. interface in
  2. {
  3.     abstract void show();
  4. }
  5. class BB implements in
  6. {
  7.     public void show()//throws Exception,因为父类没有出现异常，子类就不能抛
  8.     {
  9.             //如果真的出现异常，那么只能try，不能抛
  10.     }
  11. }
interface in
{
	abstract void show();
}
class BB implements in
{
	public void show()//throws Exception,因为父类没有出现异常，子类就不能抛
	{
			//如果真的出现异常，那么只能try，不能抛
	}
}

异常到此就结束了，内容很多，自己需要多复习，消化才是。。。