1. 
   
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.*;
    
15. 
    
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();
    
28. 
    
29.                 //最常见的标准的键盘录入
    
30.                 BufferedReader bufr =
    
31.                         new BufferedReader(new InputStreamReader(System.in));
    
32.                 String line = null;
    
33.                 double sum = 0;
    
34. 
    
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();
    
41. 
    
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();//关闭流
    
60. 
    
61. 
    
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.          }
    
84. 
    
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.          }
     
103. 
     
104. 
     
105. }
     
106. 
     
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.          }
     
122. 
     
123. }

复制代码

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

逻辑错误在51行，关于if（）else的，帮忙看看，其实小至语句，到方法，到结构，无一不得掌握牢固才行

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

拜读，不错。

按照我的理解，不应该用遍历来对比，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. */
    
11. import java.io.*;
    
12. import java.util.*;
    
13. 
    
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. 
    
25. //最常见的标准的键盘录入
    
26. BufferedReader bufr = new BufferedReader(new InputStreamReader(
    
27. System.in));
    
28. String line = null;
    
29. double sum = 0;
    
30. 
    
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. }
    
43. 
    
44. }
    
45. </FONT>System.out.println("购买的商品总价为：" + sum);//console打印出结果
    
46. bufr.close();//关闭流
    
47. 
    
48. }
    
49. 
    
50. }
    
51. 
    
52. class Goods {
    
53. private int id;
    
54. private double price;
    
55. 
    
56. public Goods(int id, double price) {
    
57. this.id = id;
    
58. this.price = price;
    
59. }
    
60. 
    
61. public int getId() {
    
62. return id;
    
63. }
    
64. 
    
65. public double getPrice() {
    
66. 
    
67. return price;
    
68. }
    
69. 
    
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 15:58
按照我的理解，不应该用遍历来对比，map中有1001和2001，你输入了1001，能获得1001商品信息，但是与2001比 ...

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