源代码见附件！

看到自己的技术分才那么点，这样的活动还得多参与，云7加油

quan23355 发表于 2013-12-4 01:25

有bug，输入01时,会输出数据，而不是提示异常、当输入1时，提示异常。bug-1
正则额外+1
共+5技术分！

答案提交
TestDemo.zip (656 Bytes, 下载次数: 1)

2013-12-4 10:30 上传

点击文件名下载附件
阅读权限: 100

杨丽静 发表于 2013-12-4 10:10
import java.io.*;
import java.util.*;
/*

当输入字符时(比较FFF)，会抛出异常没有处理。而且。自然数x的范围是2到10000而不是0到10000呢~如果有疑问可以联系我！群里能找到我的QQ等联系方式。

杨丽静 发表于 2013-12-4 10:10
import java.io.*;
import java.util.*;
/*

异常这块学的不太好,运用的不熟练能不能让我看一看,您点评比较好的,异常处理得比较好的帖子

杨丽静 发表于 2013-12-4 10:44
异常这块学的不太好,运用的不熟练能不能让我看一看,您点评比较好的,异常处理得比较好的帖子 ...

有的，到时你再回来看看好了！我会公布所有的答案的。到时你可以看看我加分高的。都是实现得比较好的！
异常处理，不一定要用try与throw。只有你充分考虑到“异常”这种情况，就算是对异常进行了处理！

提交答案，哈哈

邢栋 安卓28

Θ动@咚Θ 发表于 2013-12-5 07:35
邢栋 安卓28

下次要再细心一点哦~

版主辛苦了！！！

秋晨 发表于 2013-12-4 11:08
提交答案，哈哈

我的技术分够啦，哈哈，谢谢版主

import java.util.Scanner;
//自定义一个异常类，用于显示输入的数字不在2～10000范围类的异常。
class YiChang extends Exception{
        //自定义异常了构造函数
        public YiChang(String msg) {
                super(msg);
        }       
}

public class PrintData{
        //主函数
        public static void main(String[] args) {
                //调用shuRu从键盘接收一个数字，并赋值给data。
                int data = 0;
                try {
                        //从键盘接收一个整型数字并复制给data，
                        //如果输入的不是整型nextInt会自动抛出异常。
                        data = new Scanner(System.in).nextInt();
                        //输出1～x的奇数。
                        jiShu(data);
                        //输出0～x的偶数。
                        ouShu(data);
                } catch (Exception e) {
                        //捕获输入的不是整数的这个异常并进行处理。
                        System.out.println("输入的不是整数！");
                }
        }

        public static void jiShu(int data){
                try {
                        //判断输入的整型数字是否在2～10000范围内。
                        if ((data>=2)&&(data<=10000)) {
                                System.out.println("1到"+ data +"范围的奇数有:");
                                //如果整型数组在范围了则打印出1～data范围内的奇数。
                                for (int i = 1; i <= data; i += 2)
                                        System.out.print(i + " ");
                                System.out.println();
                        }
                        else {
                                //如果不在2～10000范围内则抛出自定义的异常。
                                throw new YiChang("输入的数字格式不正确！");
                        }
                } catch (Exception e) {
                        System.out.println("请仔细输入。");
                }
        }
        public static void ouShu(int data){
                try {
                        //判断输入的整型数字是否在2～10000范围内。
                        if ((data>=2)&&(data<=10000)){
                                System.out.println("0到"+ data +"范围的偶数有:");
                                //如果整型数组在范围了则打印出0～data范围内的偶数。
                                for (int i = 0; i <= data; i += 2)
                                        System.out.print(i + " ");
                                System.out.println();
                        }
                        else {
                                //如果不在2～10000范围内则抛出自定义的异常。
                                throw new YiChang("输入的数字格式不正确！");
                        }
                } catch (Exception e) {
                        System.out.println("请仔细输入。");
                }
        }
}

1. /*
   
2. 要求：输入整型自然数x,且,要求先把1到x中的所有奇数从小到大输出，再把所有的偶数从小到大输出。
   
3. 
   
4. 思路：
   
5.         获取字符;
   
6. 1，判断输入是否为整数；
   
7. 2，判断输入是否符合要求的整数；
   
8. 3，遍历整数中的奇数偶数存入各自的StringBuilder；
   
9. 4，打印StringBuilder；
   
10. */
    
11. 
    
12. import java.io.*;
    
13. import java.lang.*;
    
14. import java.util.*;
    
15. 
    
16. class TestDemo
    
17. {
    
18.         public static void main(String[] args)
    
19.         {
    
20.                         System.out.println("请输入整数大于2小于10000:");
    
21.                         while(true)                                                                                //循环输入
    
22.                         {       
    
23.                                 try
    
24.                                 {
    
25.                                         Scanner input = new Scanner(System.in);   //定义一个Scanner对象获取输入字符
    
26.                                         int num=input.nextInt();                                //将获取的字符转换为int型；
    
27.                                         if(num<=10000 && num>=2)                                //判断是否符合题目要求的数据；
    
28.                                         {
    
29.                                                 myOutput(num);                                                //调用自己的myOutput输出方法；
    
30.                                                 break;
    
31.                                         }
    
32.                                         else
    
33.                                                 System.out.println("请输入大于2小于10000整数！");
    
34.                                 }
    
35.                                 catch(Exception e)                                                        //捕捉异常，input.nextInt()如果不是整数转换抛出异常；
    
36.                                 {
    
37.                                         System.out.println("输入不是整数，请重新输入！");
    
38.                                 }
    
39.                                
    
40.                         }
    
41. 
    
42.         }
    
43.                  
    
44. 
    
45.         public static void myOutput(int  num)
    
46.         {
    
47.                  StringBuilder sb1 = new StringBuilder();                //新建StringBuilder对象 存放偶数
    
48.                  StringBuilder sb2 = new StringBuilder();                //新建StringBuilder对象 存放奇数
    
49. 
    
50.                  for (int x=0;x<=num ;x++ )                                         //循环判断
    
51.                  {
    
52.                          if (x%2 == 0)                                                                 //是否为偶数
    
53.                          {
    
54.                                  sb1.append(x);                                                        //将偶数存入Stringbuilder
    
55.                                  sb1.append(" ");               
    
56.                          }       
    
57.                                 
    
58.                          else
    
59.                          {       
    
60.                                  sb2.append(x);                                                        //将奇数存入StringBuilder
    
61.                                  sb2.append(" ");                       
    
62.                          }
    
63.                  }
    
64. 
    
65.                  System.out.println(sb1.toString());                        //打印偶数
    
66.                  System.out.println(sb2.toString());                        //打印奇数
    
67.         }
    
68.        
    
69. }

复制代码

看到的晚了，希望还来得及吧，马上就要面试，就要开班了，分数还差那么一大截。恳请版主开恩，多加点儿分吧{:soso_e154:}

1. import java.io.BufferedReader;
   
2. import java.io.InputStreamReader;
   
3. import java.util.ArrayList;
   
4. import java.util.Arrays;
   
5. import java.util.List;
   
6. 
   
7. /*
   
8.   需求：1.输入整型自然数x,且2<= x<=10000,要求先把1到x中的所有奇数从小到大输出，再把所有的偶数从小到大输出。
   
9. *            2.要考虑当用户输入非整形字符时或超出范围的的异常处理。
   
10. *            3.代码必须有完整的注释。否则0分处理。
    
11. *            4.代码尽可能的简单，用高的效率实现最快的速度。(完成时，有加分。未完成、对成绩没有影响)
    
12. *            5.完成基本功能，加3分。完成基本功能，有注释，效率高，有5分。(江湖传闻：听说~如果完成得特别优秀者，加10分~~~)
    
13. */
    
14. public class Distinguish {
    
15.        
    
16.         //主函数入口
    
17.         public static void main(String[] args) {
    
18.                 try {
    
19.                         firstInput();
    
20.                 } catch (Exception e) {
    
21.                         e.printStackTrace();
    
22.                 }
    
23.         }
    
24.        
    
25.         //接收输入字符转换的数值
    
26.         static int num;
    
27.        
    
28.         //定义第一次输入自然数的方法
    
29.         public static void firstInput() throws Exception{
    
30.                 System.out.println("请输入要区分奇偶的整数。。。");
    
31.                 BufferedReader inputFir = new BufferedReader(new InputStreamReader(System.in));
    
32.                
    
33.                 String firstGet = inputFir.readLine();
    
34.                
    
35.                 if(isNumber(firstGet)){                //判断是否是整数
    
36.                         if(isLegal(firstGet)){        //判断是否是非法的
    
37.                                 sortAndDist(num);
    
38.                         }
    
39.                         else{
    
40.                                 System.out.println("输入值超出设定范围，请重新输入");
    
41.                                 firstInput();
    
42.                         }
    
43.                 }
    
44.                 else{
    
45.                         secondInput();
    
46.                 }
    
47.                
    
48.         }
    
49.        
    
50.         //判断输入值是不是整数的方法
    
51.         public static boolean isNumber(String get) throws Exception{
    
52.                 char[] charArr = get.toCharArray();
    
53.                
    
54.                 boolean flag = false;
    
55.                 for(int i=0; i<charArr.length; i++){
    
56.                        
    
57.                         flag = !Character.isLetter(charArr[i]);//false
    
58.                 }
    
59. 
    
60.                 return flag;
    
61.         }
    
62.        
    
63.         //第二次输入方法
    
64.         public static void secondInput() throws Exception{
    
65.                
    
66.                         System.out.println("请输入0-10000的正整数。。。");
    
67.                         BufferedReader inputSec = new BufferedReader(new InputStreamReader(System.in));
    
68.                         String secondGet = inputSec.readLine();
    
69.                        
    
70.                                 if(isLegal(secondGet)){        //判断是否是非法的
    
71.                                         sortAndDist(num);
    
72.                                 }
    
73.                                 else{
    
74.                                         System.out.println("输入值超出设定范围，请重新输入");
    
75.                                         firstInput();
    
76.                                 }
    
77.         }
    
78.        
    
79.         //判断输入值是否位于指定区间的方法
    
80.         public static boolean isLegal(String get){
    
81.                 char[] charArr = get.toCharArray();
    
82.                
    
83.                
    
84.                 for(int i=0; i<charArr.length; i++){
    
85.                         if(Character.isDigit(charArr[i]))
    
86.                                 num = Integer.parseInt(get);
    
87.                 }
    
88.                 boolean flag = (num>0 && num<10000);
    
89. 
    
90.                 return flag;
    
91.         }
    
92. 
    
93.        
    
94.         //打印结果
    
95.         public static void sortAndDist(int num){
    
96.                
    
97.                 System.out.println(getOdd(num));
    
98.                 System.out.println(getEven(num));
    
99.                
    
100.         }
     
101.        
     
102.         //取奇数
     
103.         public static List<Integer> getOdd(int num){
     
104.                 List<Integer> odd = new ArrayList<Integer>();
     
105.                
     
106.                 for(int i=0; i<=num; i++){
     
107.                         int tmp = i;
     
108.                         if(tmp%2 != 0){
     
109.                                 odd.add(tmp);
     
110.                         }
     
111.                 }
     
112.                 Arrays.sort(odd.toArray());
     
113.                 return odd;
     
114.         }
     
115.        
     
116.         //取偶数
     
117.         public static List<Integer> getEven(int num){
     
118.                 List<Integer> even = new ArrayList<Integer>();
     
119.                
     
120.                 for(int i=0; i<=num; i++){
     
121.                         int tmp = i;
     
122.                                 if(tmp%2 == 0){
     
123.                                         even.add(tmp);
     
124.                                 }
     
125.                 }
     
126.                 Arrays.sort(even.toArray());
     
127.                 return even;
     
128.         }
     
129.        
     
130.        
     
131. }

复制代码

1. <IMG border=0 alt="" src="http://bbs.itheima.com/forum.php?mod=image&aid=31666&size=300x300&key=16925f1c28ac04de&nocache=yes&type=fixnone" aid="attachimg_31666">/*
   
2. 需求：1.输入整型自然数x,且2<=x<=10000,要求先把1到x中的所有奇数
   
3. 从小到大输出，再把所有的偶数从小到大输出。
   
4. 2.要考虑当用户输入非整型字符时或超出范围的异常处理。
   
5. 思考；1.首先要完成输入功能。
   
6. 2.要判断是否是整型，是否超出范围
   
7. 3.把从0到X的数字进行奇数偶数判断，分别输出
   
8. */
   
9. import java.util.Scanner;
   
10. class Activity
    
11. {
    
12. public static void main(String[] args)
    
13. {
    
14. Scanner input=new Scanner(System.in);   System.out.println("please input one mach:");
    
15. try
    
16. {
    
17. // 判断是否为整型，不是就catch
    
18. int num=input.nextInt();   //完成输入功能
    
19. //完成超出范围，以及输入其他类型的判断与处理
    
20. if(num<=2||num>=10000) //判断是否在范围里
    
21. {
    
22. System.out.println("You input is too big or small");
    
23. }
    
24. else
    
25. {
    
26. for (int x=0;x<=num ;x++ ) // 判断奇数偶数分别输出
    
27. {
    
28. if(x%2==0)
    
29. {
    
30. System.out.print(" "+x);
    
31. }
    
32. }
    
33. System.out.println();
    
34. for (int x=0;x<=num ;x++ )
    
35. {
    
36. if(x%2!=0)
    
37. System.out.print(" "+x);
    
38. }
    
39. }
    
40. }
    
41. catch (Exception e) // 如果不是整型 ，输出重新输入
    
42. {
    
43. System.out.println("please input new ");
    
44. }
    
45. 
    
46. 
    
47. 
    
48. 
    
49. 
    
50. }
    
51. }
    
52. 
    
53. PS:第一次参加活动啊  ，毕老师的视频都还没看完就来了，本来是想把功能进行封装，但是担心时间来不及，先发了。
    

复制代码

版主改作业了

乔_博_文 发表于 2013-12-6 13:50
看到的晚了，希望还来得及吧，马上就要面试，就要开班了，分数还差那么一大截。恳请版主开恩，多加点儿分吧 ...

实现基本的功能+5、输入1时，有输出，而不是异常-1、注释太少-1、使用正则+1额外+1
最后得分+4.

依旧 发表于 2013-12-6 17:45
版主改作业了

完成了基本功能。但因技术已经达到>=25，所以没有任何额外技术++。哈哈哈~~~

感谢大家的参与。