A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 小黑子 中级黑马   /  2014-8-20 16:20  /  2321 人查看  /  13 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

/*
需求:老师调用电脑上课,电脑可能出现蓝屏或冒烟异常
当电脑蓝屏时,需重启电脑
当电脑冒烟时,需运用课时无法进行异常解决
*/
现在想要让电脑重启后,继续调用run() , 可是调用run()又需对异常进行抛出或声
这样问题就来了:
1、 如果蓝屏这个问题,需要在函数内部解决,不希望被抛出,代码应该怎么写?
2、如果蓝屏主个问题,可以抛出,由调用者解决,那应该怎么写?
==================程序代码=========================
class Teacher6
{
        String name;
        Computer6 cmpt;
        Teacher6(String name)
        {
                this.name = name;
        }
        //讲课
        public void prelect() throws NoPlanException,
        {
                try
                {
                        cmpt = new Computer6();
                        cmpt.run();
                }
                catch (LanPingException6 e)
                {
                        cmpt.reset();
                        cmpt.run();//异常需被抛出或声明
                }
                catch(MaoYanException6 e)
                {
                        throw new NoPlanException("换电脑");
                }
                System.out.println("老师讲课");
        }
}

class Computer6
{
        private int status = 2;
        //电脑运行
        public void run() throws LanPingException6,MaoYanException6
        {
                if (status==2)
                        throw new LanPingException6("电脑蓝屏了!");
                if(status==3)
                        throw new MaoYanException6("电脑冒烟了!");
                System.out.println("电脑运行");
        }
        //电脑重启
        public void reset()
        {
                System.out.println("电脑重启");
                status = 1;
        }
}
//蓝屏异常
class LanPingException6 extends Exception
{
        LanPingException6(String msg)
        {
                super(msg);
        }
}
//冒烟异常
class MaoYanException6 extends Exception
{
        MaoYanException6(String msg)
        {
                super(msg);
        }
}
//课时无法进行异常
class NoPlanException6 extends Exception
{
        NoPlanException6(String msg)
        {
                super(msg);
        }
}

class ExceptionDemo6
{
        public static void main(String[] args)
        {
                Teacher6 t = new Teacher6("qu");
                try
                {
                        t.prelect();
                }
                catch (NoPlanException e)
                {
                        System.out.println(e.toString());
                }
                System.out.println("Hello World!");
        }
}

==========================运行截图=========================



更多图片 小图 大图
组图打开中,请稍候......

13 个回复

倒序浏览
为啥浏览量是0???顶起来&&求大神
回复 使用道具 举报
函数内部解决就是try
由调用者解决就是抛
回复 使用道具 举报
第一种情况,对run()方法进行try
  1. try
  2.                 {
  3.                         cmpt = new Computer();
  4.                         cmpt.run();
  5.                 }
  6.                 catch (LanPingException e)
  7.                 {
  8.                         cmpt.reset();
  9.                         try {
  10.                                                         cmpt.run();
  11.                                                 } catch (LanPingException e1) {
  12.                                                         e1.printStackTrace();
  13.                                                 } catch (MaoYanException e1) {
  14.                                                         e1.printStackTrace();
  15.                                                 }//异常需被抛出或声明
  16.                 }
  17.                 catch(MaoYanException e)
  18.                 {
  19.                         throw new NoPlanException("换电脑");
  20.                 }
  21.                 System.out.println("老师讲课");
复制代码

第二种,直接在函数声明上抛出
  1. public void prelect() throws NoPlanException, LanPingException, MaoYanException
复制代码

其实你的问题在eclipse中按下ctrl+1快速修复提示,是几秒钟的事情。你去尝试用eclipse这样的IDE吧
回复 使用道具 举报
a6511631 发表于 2014-8-21 10:14
第一种情况,对run()方法进行try

第二种,直接在函数声明上抛出

第一种情况:
      你提出的这种做法,我也想到了。但现在才是我真正要问的问题:
       1、运行cmpt.reset()之后,再运行cmpt.run(),如果再次出现 蓝屏问题,你的做法是将问题打印,而不是重启电脑,但这就违背了蓝屏可以通过重启电脑解决的原则,
      2、可是,如果捕捉到蓝屏问题后,不打印,而是通过重启电脑,然后再调用run()来解决。这样调用run()还是可能出现蓝屏,又得重启电脑,调用run()………………这样就会陷入一个无限循环的状态,代码就会限长。
     有没有什么办法,即可以通过内容调用reset()解决蓝屏,再调用run(),而又不会陷入死循环呢?
第二种:
    不知道你运行了没有,如果直接在函数是声明LanPingException6,而函数体内的代码不做改动的话,编译是无法参通过的。那函数体内代码应该怎么改呢?
回复 使用道具 举报
付江涛 发表于 2014-8-21 09:59
函数内部解决就是try
由调用者解决就是抛

伟大滴版主!现在只是抛砖引玉。
你看看我楼下的回答,和我给楼下的回复,那才是我真正的问题
看看这问题到底该如何解决:'(
回复 使用道具 举报
icris 中级黑马 2014-8-22 11:37:55
7#
小黑子 发表于 2014-8-22 11:09
第一种情况:
      你提出的这种做法,我也想到了。但现在才是我真正要问的问题:
       1、运行cmpt.r ...

外层套上 while(true) 或 for(;;) ,运行结束加上 break;
有异常就会循环回去,没异常就 break 了
回复 使用道具 举报
小黑子 发表于 2014-8-22 11:09
第一种情况:
      你提出的这种做法,我也想到了。但现在才是我真正要问的问题:
       1、运行cmpt.r ...

那就用递归吧,在catch中打印异常信息后继续调用自身方法。
你看看我的涂鸦之作
  1. class Teacher6
  2. {
  3.         String name;
  4.         Computer cmpt;
  5.         Teacher6(String name)
  6.         {
  7.                 this.name = name;
  8.         }
  9.         //讲课
  10.         public void prelect(Computer cmpt) throws NoPlanException
  11.         {
  12.                 try
  13.                 {
  14.                         cmpt.run();
  15.                 }
  16.                 catch (LanPingException e)
  17.                 {
  18.                         cmpt.reset();
  19.                         try {
  20.                                                         cmpt.run();
  21.                                                 } catch (LanPingException e1) {
  22.                                                         e1.printStackTrace();
  23.                                                         prelect(cmpt);
  24.                                                 } catch (MaoYanException e1) {
  25.                                                         e1.printStackTrace();
  26.                                                 }//异常需被抛出或声明
  27.                 }
  28.                 catch(MaoYanException e)
  29.                 {
  30.                         throw new NoPlanException("换电脑");
  31.                 }
  32.                 System.out.println("老师讲课");
  33.         }
  34. }

  35. class Computer
  36. {
  37.         private int status = 2;
  38.         //电脑运行
  39.         public void run() throws LanPingException,MaoYanException
  40.         {
  41.                 if (status==2)
  42.                         throw new LanPingException("电脑蓝屏了!");
  43.                 if(status==3)
  44.                         throw new MaoYanException("电脑冒烟了!");
  45.                 System.out.println("电脑运行");
  46.         }
  47.         //电脑重启
  48.         public void reset()
  49.         {
  50.                 System.out.println("电脑重启");
  51.                 status = 1;
  52.         }
  53. }
  54. //蓝屏异常
  55. class LanPingException extends Exception
  56. {
  57.         LanPingException(String msg)
  58.         {
  59.                 super(msg);
  60.         }
  61. }
  62. //冒烟异常
  63. class MaoYanException extends Exception
  64. {
  65.         MaoYanException(String msg)
  66.         {
  67.                 super(msg);
  68.         }
  69. }
  70. //课时无法进行异常
  71. class NoPlanException extends Exception
  72. {
  73.         NoPlanException(String msg)
  74.         {
  75.                 super(msg);
  76.         }
  77. }

  78. class ExceptionDemo6
  79. {
  80.         public static void main(String[] args)
  81.         {
  82.                 Teacher6 t = new Teacher6("qu");
  83.                 Computer cmpt = new Computer();
  84.                 try
  85.                 {
  86.                         t.prelect(cmpt);
  87.                 }
  88.                 catch (NoPlanException e)
  89.                 {
  90.                         System.out.println(e.toString());
  91.                 }
  92.                 System.out.println("Hello World!");
  93.         }
  94. }
复制代码
回复 使用道具 举报
小黑子 发表于 2014-8-22 11:09
第一种情况:
      你提出的这种做法,我也想到了。但现在才是我真正要问的问题:
       1、运行cmpt.r ...

对于第一种情况,按照LZ的思路无限重启是可能的,但是这是设计代码不合理导致的,其实重启是一个动作包括关闭和启动,应该全部由reset()函数完成。这样才符合面向对象的思想。
对于第二种情况,对于不想处理的异常应该抛出并声明,由调用者解决
回复 使用道具 举报
icris 发表于 2014-8-22 11:37
外层套上 while(true) 或 for(;;) ,运行结束加上 break;
有异常就会循环回去,没异常就 break 了 ...

小生愚钝,想不出具体代码怎么实现,求大神指教
回复 使用道具 举报
a6511631 发表于 2014-8-22 14:52
那就用递归吧,在catch中打印异常信息后继续调用自身方法。
你看看我的涂鸦之作
...

大神,我觉得把你的19到26行换成我这样,是不是会更好一些?
  1. class Teacher6
  2. {
  3.         String name;
  4.         Computer cmpt;
  5.         Teacher6(String name)
  6.         {
  7.                 this.name = name;
  8.         }
  9.         //讲课
  10.         public void prelect(Computer cmpt) throws NoPlanException
  11.         {
  12.                 try
  13.                 {
  14.                         cmpt.run();
  15.                 }
  16.                 catch (LanPingException e)
  17.                 {
  18.                                         cmpt.reset();
  19.                                                 try
  20.                                                 {
  21.                                                         prelect(cumpt);
  22.                                                 }
  23.                                                 catch (NoPlanException e)
  24.                                                 {
  25.                                                          System.out.println(e.toString());
  26.                                                 }
  27.                                              
  28.                 }
  29.                 catch(MaoYanException e)
  30.                 {
  31.                         throw new NoPlanException("换电脑");
  32.                 }
  33.                 System.out.println("老师讲课");
  34.         }
  35. }

  36. class Computer
  37. {
  38.         private int status = 2;
  39.         //电脑运行
  40.         public void run() throws LanPingException,MaoYanException
  41.         {
  42.                 if (status==2)
  43.                         throw new LanPingException("电脑蓝屏了!");
  44.                 if(status==3)
  45.                         throw new MaoYanException("电脑冒烟了!");
  46.                 System.out.println("电脑运行");
  47.         }
  48.         //电脑重启
  49.         public void reset()
  50.         {
  51.                 System.out.println("电脑重启");
  52.                 status = 1;
  53.         }
  54. }
  55. //蓝屏异常
  56. class LanPingException extends Exception
  57. {
  58.         LanPingException(String msg)
  59.         {
  60.                 super(msg);
  61.         }
  62. }
  63. //冒烟异常
  64. class MaoYanException extends Exception
  65. {
  66.         MaoYanException(String msg)
  67.         {
  68.                 super(msg);
  69.         }
  70. }
  71. //课时无法进行异常
  72. class NoPlanException extends Exception
  73. {
  74.         NoPlanException(String msg)
  75.         {
  76.                 super(msg);
  77.         }
  78. }

  79. class ExceptionDemo6
  80. {
  81.         public static void main(String[] args)
  82.         {
  83.                 Teacher6 t = new Teacher6("qu");
  84.                 Computer cmpt = new Computer();
  85.                 try
  86.                 {
  87.                         t.prelect(cmpt);
  88.                 }
  89.                 catch (NoPlanException e)
  90.                 {
  91.                         System.out.println(e.toString());
  92.                 }
  93.                 System.out.println("Hello World!");
  94.         }
  95. }
复制代码
回复 使用道具 举报
看着挺难得啊!真心不会啊
回复 使用道具 举报
我是来学习的
回复 使用道具 举报
icris 中级黑马 2014-8-23 12:26:52
14#
小黑子 发表于 2014-8-23 09:09
小生愚钝,想不出具体代码怎么实现,求大神指教
  1.         // 讲课
  2.         public void prelect() throws NoPlanException6 {
  3.                 cmpt = new Computer6();
  4.                 while (true) {
  5.                         try {
  6.                                 cmpt.run();
  7.                                 break;
  8.                         } catch (LanPingException6 e) {
  9.                                 cmpt.reset();
  10.                         } catch (MaoYanException6 e) {
  11.                                 throw new NoPlanException6("换电脑");
  12.                         }
  13.                 }
  14.                 System.out.println("老师讲课");
  15.         }
  16. }
复制代码

这样蓝屏就循环回去,不蓝屏就走完 break ,冒烟就抛异常停了。在 main 里也这样循环就能换电脑了。
递归的话需要把 while 里面的提出来写一个方法,包含前面一句就会自动换电脑,包含后面一句就会重启正常以后讲两次课。应该是吧。
还有要抛出去的异常就不要 catch 了,弄多了以后就不知道是谁处理了。
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马