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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

本帖最后由 曹睿翔 于 2013-1-10 15:46 编辑

  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.遍历Map用 Set<Map.Entry<String,Goods>> entrySet = map.entrySet();将Map转换为Set集合,
  8.                   用迭代的方法,与输入流中的line对比,获得其Goods对象的Value
  9.         测试:输入商品的id 1001 按下enter,接着输入2001,按下enter,最后按下over结束程序
  10.                         
  11. */
  12. import java.io.*;
  13. 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);
  24.                 //用Map集合Entry的方法返回Set,目的是用到迭代器
  25.         Set<Map.Entry<String,Goods>> entrySet = map.entrySet();

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

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

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


  55.         }
  56.         
  57.         
  58. }
  59. class Goods
  60. {
  61.          private int id;
  62.          private double  price;
  63.          public Goods(){
  64.                  
  65.          }
  66.          public  Goods(int id, double price){
  67.                  this.id= id;
  68.                  this.price = price;
  69.          }
  70.          public int getId(){
  71.                  return id;
  72.          }
  73.          public double getPrice() {
  74.                  
  75.                 return price;
  76.          }

  77. }
  78. class Milk extends Goods
  79. {
  80.          
  81.          private int id;
  82.          private double  price;
  83.          
  84.          public Milk(int id, double price){
  85.                  this.id= id;
  86.                  this.price = price;
  87.          }
  88.          public int getId(){
  89.                  return id;
  90.          }
  91.          public double getPrice() {
  92.                  
  93.                  return  price;
  94.          }


  95. }

  96. class Clothes extends Goods
  97. {
  98.          private int id;
  99.          private double  price;
  100.          public Clothes(int id, double price){
  101.                  this.id= id;
  102.                  this.price = price;
  103.          }
  104.          public int getId(){
  105.                  return id;
  106.          }
  107.          public double  getPrice() {
  108.                  
  109.                  return  price;
  110.          }

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

评分

参与人数 1技术分 +1 收起 理由
郑传庆 + 1 赞一个!

查看全部评分

10 个回复

倒序浏览
逻辑错误在51行,关于if()else的,帮忙看看,其实小至语句,到方法,到结构,无一不得掌握牢固才行
回复 使用道具 举报
本帖最后由 郑传庆 于 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();// 关闭流

        }

回复 使用道具 举报
楼上正确{:soso_e179:}
回复 使用道具 举报
其实我感觉用不着迭代器的。
只是想看一下你输入的值是不是在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 13:31
其实我感觉用不着迭代器的。
只是想看一下你输入的值是不是在map里面
然后得到该ID对应的Value

多谢,这个方法不错,前天晚上只顾找方法的返回值了,没考虑到在if里边判断
回复 使用道具 举报
郑传庆 发表于 2013-1-10 10:30
public static void main(String[] args) throws Exception // 抛出异常,不错try处理
        { // 定义两 ...

恩恩,把这个方法给忘了,多谢指点
回复 使用道具 举报
曹佳佳 发表于 2013-1-10 10:55
楼上正确

妹子,多谢跟帖:lol
回复 使用道具 举报
拜读,不错。
回复 使用道具 举报
本帖最后由 黄锦成 于 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结束程序

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

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

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

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

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

  42. }

  43. }

  44. class Goods {
  45. private int id;
  46. private double price;

  47. public Goods(int id, double price) {
  48. this.id = id;
  49. this.price = price;
  50. }

  51. public int getId() {
  52. return id;
  53. }

  54. public double getPrice() {

  55. return price;
  56. }

  57. }
  58. /**
  59. * 牛奶,id,price
  60. * @author Administrator
  61. *
  62. */
  63. class Milk extends Goods {
  64. public Milk(int id, double price) {
  65. super(id,price);
  66. }
  67. }
  68. /**
  69. * 衣服,id,price
  70. * @author Administrator
  71. *
  72. */
  73. class Clothes extends Goods {
  74. public Clothes(int id, double price) {
  75. super(id,price);
  76. }
  77. }
复制代码
回复 使用道具 举报
黄锦成 发表于 2013-1-10 15:58
按照我的理解,不应该用遍历来对比,map中有1001和2001,你输入了1001,能获得1001商品信息,但是与2001比 ...

多谢,商品那调用父类的构造函数那你让我明白了,楼上也说用containsKey方法了
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马