黑马程序员技术交流社区

标题: debug之后可以运行，但是有个逻辑错的地方，求解释 [打印本页]
作者: 曹睿翔    时间: 2013-1-10 10:06
标题: debug之后可以运行，但是有个逻辑错的地方，求解释
本帖最后由 曹睿翔 于 2013-1-10 15:46 编辑

  2. //需求：模拟超市收银员的工作，收银员（从键盘录入商品ID时获得商品价格）为顾客购买的商品计算总价
  3. /*思路：1,商品有自己的共同属性（价格、ID等），抽取出来作为父类，
  4. *       子类则定义自己特殊的属性（食品有保质期、衣服有颜色尺码等），当超市添加待售商品时，只要继承父类、并加上独有属性即可。
  5. *       2.每个商品都是ID对应价格，由此想到用Map集合来存放，id作为Key，商品类作为Value
  6.                 3.从键盘录入则用到标准输入流，BufferedReader bufr =
  7.                         new BufferedReader(new InputStreamReader(System.in));
  8.                 4.遍历Map用 Set<Map.Entry<String,Goods>> entrySet = map.entrySet();将Map转换为Set集合，
  9.                   用迭代的方法，与输入流中的line对比，获得其Goods对象的Value
  10.         测试：输入商品的id 1001 按下enter，接着输入2001，按下enter，最后按下over结束程序
  11.                         
  12. */
  13. import java.io.*;
  14. import java.util.*;

  16. public class GetGoodsInfo{
  17.         public static void main(String[] args) throws Exception // 抛出异常，不错try处理
  18.         {        //定义两个Goods的子类。Milk和Clothes
  19.                 Milk m = new Milk(1001,2.5);
  20.                 Clothes clo = new Clothes(2001,100.0);
  21.                 //定义一个Map<String,Goods>集合
  22.                 Map<String,Goods> map = new HashMap<String,Goods>();
  23.                 //加入两个元素
  24.                 map.put("1001",m);
  25.                 map.put("2001",clo);
  26.                 //用Map集合Entry的方法返回Set，目的是用到迭代器
  27.         Set<Map.Entry<String,Goods>> entrySet = map.entrySet();

  29.                 //最常见的标准的键盘录入
  30.                 BufferedReader bufr =
  31.                         new BufferedReader(new InputStreamReader(System.in));
  32.                 String line = null;
  33.                 double sum = 0;

  35.                 while((line=bufr.readLine())!=null)
  36.                 {
  37.                         if("over".equals(line))//当从console输入over的时候程序停止
  38.                                 break;
  39.                         else
  40.                         { Iterator<Map.Entry<String,Goods>> it = entrySet.iterator();

  42.                                 while(it.hasNext())
  43.                                 {
  44.                                         Map.Entry<String,Goods> me = it.next();
  45.                                         if (me.getKey().equals(line))//通过迭代遍历Map，找出Key对应的Goods对象
  46.                                         {        double d = me.getValue().getPrice();
  47.                                                 sum +=d;
  48.                                                 System.out.println("商品单价为："+d);
  49.                                         }
  50.                                         else
  51.                                                 System.out.println("未找到对应商品，请核查");//<font color="#ff0000">目的是错误输入ID时才打印，为毛输入一次打印一次？</font>
  52.      
  53.            }
  54.                         }
  55.                         
  56.                         
  57.                 }
  58.                 System.out.println("购买的商品总价为："+sum);//console打印出结果
  59.                 bufr.close();//关闭流


  62.         }
  63.         
  64.         
  65. }
  66. class Goods
  67. {
  68.          private int id;
  69.          private double  price;
  70.          public Goods(){
  71.                  
  72.          }
  73.          public  Goods(int id, double price){
  74.                  this.id= id;
  75.                  this.price = price;
  76.          }
  77.          public int getId(){
  78.                  return id;
  79.          }
  80.          public double getPrice() {
  81.                  
  82.                 return price;
  83.          }

  85. }
  86. class Milk extends Goods
  87. {
  88.          
  89.          private int id;
  90.          private double  price;
  91.          
  92.          public Milk(int id, double price){
  93.                  this.id= id;
  94.                  this.price = price;
  95.          }
  96.          public int getId(){
  97.                  return id;
  98.          }
  99.          public double getPrice() {
  100.                  
  101.                  return  price;
  102.          }


  105. }

  107. class Clothes extends Goods
  108. {
  109.          private int id;
  110.          private double  price;
  111.          public Clothes(int id, double price){
  112.                  this.id= id;
  113.                  this.price = price;
  114.          }
  115.          public int getId(){
  116.                  return id;
  117.          }
  118.          public double  getPrice() {
  119.                  
  120.                  return  price;
  121.          }

  123. }
复制代码
昨天写了个小程序试试，没敢往大了写，没加GUI，一试就知道自己的不足了，看来寒假还是需要自己多敲代码，必须自己能不参考视频，API写出框架结构，不全代码。
写这个小东西遇到了多态、构造函数，IO，集合、方法返回值等问题，没能好好考虑代码扩展性等等，也建议大家自己在生活中遇到事情可以简化成代码体现，多练手
   上边的那个错误求解释，另外麻烦给点建议，怎么优化代码，我都觉得自己有点拼凑之嫌了

作者: 曹睿翔    时间: 2013-1-10 10:08
逻辑错误在51行，关于if（）else的，帮忙看看，其实小至语句，到方法，到结构，无一不得掌握牢固才行
作者: 郑传庆    时间: 2013-1-10 10:30
本帖最后由 郑传庆 于 2013-1-10 10:38 编辑

public static void main(String[] args) throws Exception // 抛出异常，不错try处理
        { // 定义两个Goods的子类。Milk和Clothes
                Milk m = new Milk(1001, 2.5);
                Clothes clo = new Clothes(2001, 100.0);
                // 定义一个Map<String,Goods>集合
                Map<String, Goods> map = new HashMap<String, Goods>();
                // 加入两个元素
                map.put("1001", m);
                map.put("2001", clo);
                // 用Map集合Entry的方法返回Set，目的是用到迭代器
                Set<Map.Entry<String, Goods>> entrySet = map.entrySet();

                // 最常见的标准的键盘录入
                BufferedReader bufr = new BufferedReader(new InputStreamReader(
                                System.in));
                String line = null;
                double sum = 0;
                //做个标记，记录如果没找到相应的值时
                boolean falg = true;
                while ((line = bufr.readLine()) != null) {
                        if ("over".equals(line))// 当从console输入over的时候程序停止
                                break;
                        else {
                                Iterator<Map.Entry<String, Goods>> it = entrySet.iterator();

                                while (it.hasNext()) {
                                        Map.Entry<String, Goods> me = it.next();
                                        if (me.getKey().equals(line))// 通过迭代遍历Map，找出Key对应的Goods对象
                                        {
                                                double d = me.getValue().getPrice();
                                                sum += d;
                                                falg = false;
                                                System.out.println("商品单价为：" + d);
                                                /* 这里可以加个break，当查找到符合的结果时，就跳出循环 */
                                                break;
                                        }
                                        /*else
                                                
                                                 // 当不满足if条件时，有多少条数据就打印多少次
                                                
                                                System.out.println("未找到对应商品，请核查");*/

                                }
                               /*
                                 * 把这个打印语句放到迭代的循环外面，就可以做到输入一次就打印一次的效果了
                                 */
                                if(falg){
                                         
                                        System.out.println("未找到对应商品，请核查");
                                }
                        }

                }
                System.out.println("购买的商品总价为：" + sum);// console打印出结果
                bufr.close();// 关闭流

        }

作者: 曹佳佳    时间: 2013-1-10 10:55
楼上正确{:soso_e179:}
作者: 肖亚光    时间: 2013-1-10 13:31
其实我感觉用不着迭代器的。
只是想看一下你输入的值是不是在map里面
然后得到该ID对应的Value
map自己就可以操作的

else
           {
                        if(map.containsKey(line))
                                {        double d = map.get(line).getPrice();
                                         sum +=d;
                                          System.out.println("商品单价为："+d);
                                   }
                        else
                                System.out.println("未找到对应商品，请核查");
                                                       
    /*Iterator<Map.Entry<String,Goods>> it = entrySet.iterator();

                                while(it.hasNext())
                                {
                                        Map.Entry<String,Goods> me = it.next();
                                        if (me.getKey().equals(line))//通过迭代遍历Map，找出Key对应的Goods对象
                                        {        double d = me.getValue().getPrice();
                                                sum +=d;
                                                System.out.println("商品单价为："+d);
                                        }
                                        else
                                                System.out.println("未找到对应商品，请核查");//<font color="#ff0000">目的是错误输入ID时才打印，为毛输入一次打印一次？</font>
     
                                                                 }*/
                     
  }

我把你的那段代码注掉了
作者: 曹睿翔    时间: 2013-1-10 15:35
可乐咖啡厅 发表于 2013-1-10 13:31
其实我感觉用不着迭代器的。
只是想看一下你输入的值是不是在map里面
然后得到该ID对应的Value

多谢，这个方法不错，前天晚上只顾找方法的返回值了，没考虑到在if里边判断
作者: 曹睿翔    时间: 2013-1-10 15:42
郑传庆 发表于 2013-1-10 10:30
public static void main(String[] args) throws Exception // 抛出异常，不错try处理
        { // 定义两 ...

恩恩，把这个方法给忘了，多谢指点
作者: 曹睿翔    时间: 2013-1-10 15:43
曹佳佳 发表于 2013-1-10 10:55
楼上正确

妹子，多谢跟帖:lol
作者: 黄嵘才    时间: 2013-1-10 15:53
拜读，不错。
作者: 黄锦成    时间: 2013-1-10 15:58
本帖最后由 黄锦成 于 2013-1-10 15:59 编辑

按照我的理解，不应该用遍历来对比，map中有1001和2001，你输入了1001，能获得1001商品信息，但是与2001比较时，会输出没有商品的信息，即使不管你有没有找到商品，都会提示没有找到，我建议使用containsKey方法

我把商品那里优化了一下
  1. //需求：模拟超市收银员的工作，收银员（从键盘录入商品ID时获得商品价格）为顾客购买的商品计算总价
  2. /*思路：1,商品有自己的共同属性（价格、ID等），抽取出来作为父类，
  3. * 子类则定义自己特殊的属性（食品有保质期、衣服有颜色尺码等），当超市添加待售商品时，只要继承父类、并加上独有属性即可。
  4. * 2.每个商品都是ID对应价格，由此想到用Map集合来存放，id作为Key，商品类作为Value
  5. 3.从键盘录入则用到标准输入流，BufferedReader bufr =
  6. new BufferedReader(new InputStreamReader(System.in));
  7. 4.使用containsKey来取得是否有商品
  8. 测试：输入商品的id 1001 按下enter，接着输入2001，按下enter，最后按下over结束程序

  10. */
  11. import java.io.*;
  12. import java.util.*;

  14. public class GetGoodsInfo {
  15. public static void main(String[] args) throws Exception // 抛出异常，不错try处理
  16. { //定义两个Goods的子类。Milk和Clothes
  17. Milk m = new Milk(1001, 2.5);
  18. Clothes clo = new Clothes(2001, 100.0);
  19. //定义一个Map<String,Goods>集合
  20. Map<String, Goods> map = new HashMap<String, Goods>();
  21. //加入两个元素
  22. map.put("1001", m);
  23. map.put("2001", clo);

  25. //最常见的标准的键盘录入
  26. BufferedReader bufr = new BufferedReader(new InputStreamReader(
  27. System.in));
  28. String line = null;
  29. double sum = 0;

  31. <FONT color=red>while (true) {
  32. line = bufr.readLine();
  33. if ("over".equals(line))//当从console输入over的时候程序停止
  34. break;
  35. else {
  36. if(map.containsKey(line)){
  37. double d = map.get(line).getPrice();
  38. sum += d;
  39. System.out.println("商品单价为：" + d);
  40. }else
  41. System.out.println("未找到对应商品，请核查");//<font color="#ff0000">目的是错误输入ID时才打印，为毛输入一次打印一次？</font>
  42. }

  44. }
  45. </FONT>System.out.println("购买的商品总价为：" + sum);//console打印出结果
  46. bufr.close();//关闭流

  48. }

  50. }

  52. class Goods {
  53. private int id;
  54. private double price;

  56. public Goods(int id, double price) {
  57. this.id = id;
  58. this.price = price;
  59. }

  61. public int getId() {
  62. return id;
  63. }

  65. public double getPrice() {

  67. return price;
  68. }

  70. }
  71. /**
  72. * 牛奶，id，price
  73. * @author Administrator
  74. *
  75. */
  76. class Milk extends Goods {
  77. public Milk(int id, double price) {
  78. super(id,price);
  79. }
  80. }
  81. /**
  82. * 衣服，id，price
  83. * @author Administrator
  84. *
  85. */
  86. class Clothes extends Goods {
  87. public Clothes(int id, double price) {
  88. super(id,price);
  89. }
  90. }
复制代码
作者: 曹睿翔    时间: 2013-1-10 16:05
黄锦成 发表于 2013-1-10 15:58
按照我的理解，不应该用遍历来对比，map中有1001和2001，你输入了1001，能获得1001商品信息，但是与2001比 ...

多谢，商品那调用父类的构造函数那你让我明白了，楼上也说用containsKey方法了




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2