看题，看题

我能继续混技术分么？

来看看，抢楼抢分抢美女，如果有的话。

1. /* 要求：输入某年某月，判断这一年与这一月分别距离1898年1月1日多少天
   
2. */
   
3. import java.util.Scanner;
   
4. class Test{
   
5. //判断输入的年份是否是闰年，是返回真，不是则返回假
   
6. public static boolean isLeepYear(int year){
   
7.        return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
   
8. }
   
9. //获取这一年的天数
   
10. public static int getDaysByYear(int year) {
    
11.   if (isLeepYear(year))
    
12.         return 366;
    
13.   else
    
14.         return 365;
    
15. }
    
16. public static void main(String[] args){
    
17.     Scanner s = new Scanner(System.in);
    
18.     System.out.print("请选择年份：");
    
19.     int year = s.nextInt(); // 输入年
    
20.    System.out.print("请选择月份：");
    
21.    int month = s.nextInt(); // 输入月
    
22.    int days=0; //统计天数
    
23.    //定义一个整数数组，用来存储每个月的天数
    
24.    int[] monthly={ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    
25.   //判断这一年是否是闰年，是则将数组中的序标为1的数值改为29；
    
26.   if(isLeepYear(year)){
    
27.       monthly[1]=29;
    
28.   }
    
29.    //计算输入的年数距离1898年的天数
    
30.   for(int i=1898;i<year;i++){
    
31.        days+=getDaysByYear(year);
    
32.   }
    
33.    //计算输入的月份到1月的天数
    
34.   for(int j=0;j<=month-1;j++){
    
35.      days+=monthly[j];
    
36.   }
    
37.     System.out.println(year+"年"+month+"月距离1898年1月1日天数为："+days);
    
38. }
    
39. }
    

复制代码

file:///C:/Users/Administrator/Desktop/%E8%AE%A1%E7%AE%97%E5%A4%A9%E6%95%B0.PNG

hmYing 发表于 2013-8-1 00:05

import java.util.Scanner;
/**
* 输入某年某月，判断这一年与这一月分别距离1898年1月1日多少天？
* 程序分析：以2013年7月为例，使用循环计算1898年1月1日距离2013年1月1日的总天数（考虑润年与平年的情况）
*                  再计算2013年1月1日距离7月的总天数
*/
public class CountDays {

        public static void main(String[] args) {
                Scanner in = new Scanner(System.in);
                System.out.printf("请输入一个年份：");
                int year = in.nextInt();               
                System.out.printf("请输入一个月份：");
                int month = in.nextInt();
                               
                int daysToYear = 0;
                for(int i=1898;i<year;i++){
                        daysToYear +=365;
                        if(i%400 == 0){
                                daysToYear += 1;
                        }else if(i%4==0 && i%100!=0){
                                daysToYear += 1;
                        }else{
                                ;
                        }
                }               
                int daysToMonth = 0;
                int []months = new int[]{31,28,31,30,31,30,31,31,30,31,30,31};
                for(int j=0;j<month;j++){
                        daysToMonth += months[j];
                }
                if((year%400==0)||(year%4==0 && year%100!=0)){
                        if(month>=2){
                                daysToMonth += 1;
                        }
                }
               
                System.out.println("距离"+year+"年有"+daysToYear+"天");
                System.out.println("距离"+year+"年"+month+"月有"+(daysToYear+daysToMonth)+"天");
        }
}

eclipse中编写代码计算天数

看看是怎么样的

鼎力支持~！壮哉我大黑马

好的，来瞧一瞧

1. 
   
2. 
   
3. import java.util.Scanner;
   
4. 
   
5. /**
   
6. * @ClassName: DayOfYear_Month
   
7. * @Description: TODO(这里用一句话描述这个类的作用)
   
8. * @author Sergio Han
   
9. * @date 2013-8-1 上午10:07:38
   
10. *
    
11. */
    
12. 
    
13. public class DayOfYear_Month {
    
14. 
    
15.         public static void main(String[] args) {
    
16.                
    
17.                 //创建输入对象
    
18.                 Scanner in = new Scanner(System.in);
    
19.                
    
20.                 System.out.println("请输入年份： ");
    
21.                 int year = in.nextInt();
    
22.                 System.out.println("请输入月份");
    
23.                 int month = in.nextInt();
    
24.                
    
25.                 in.close(); //关闭输入
    
26.                
    
27.                 int days = 0; //统计天数变量
    
28.                
    
29.                 //循环获取距离的天数
    
30.                 for(int i = 1898; i < year; i++)
    
31.                 {
    
32.                         days += getDaysByYear(i);
    
33.                 }
    
34.                
    
35.                 //给定每年的月份天数
    
36.                 int[] daysOfmonth = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    
37.                 //判断是否为闰年，如果是把2月份设置为29天，也就是daysOfmonth数组下标为1的值为29
    
38.                 if(isLeepYear(year))
    
39.                 {
    
40.                         daysOfmonth[1] = 29;
    
41.                 }
    
42.                
    
43.                 //计算结果年份距离天数
    
44.                 System.out.println("输入年份距离1898年1月1日的天数： " + days);
    
45.                
    
46.                 //循环获取月份的天数
    
47.                 for(int i = 1; i < month; i++)
    
48.                 {
    
49.                         days += daysOfmonth[i];
    
50.                 }
    
51.                
    
52.                 //计算结果月份距离天数
    
53.                 System.out.println("输入月份距离1898年一月一日的天数 ：" + days);
    
54.                 System.out.println("当前月份的天数：" + daysOfmonth[month]);
    
55.                
    
56.         }
    
57.        
    
58.         //获取某年的天数
    
59.         public static int getDaysByYear(int year)
    
60.         {
    
61.                 //判断是否为闰年
    
62.                 if(isLeepYear(year))  
    
63.                 {
    
64.                         return 366;
    
65.                 }else {
    
66.                         return 365;
    
67.                 }
    
68.         }
    
69.        
    
70.         //判断是否闰年
    
71.         public static boolean isLeepYear(int year)
    
72.         {
    
73.                 return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
    
74.         }
    
75. }
    
76. 
    

复制代码

看一下 做题了

1. import java.util.*;
   
2. /**
   
3. 输入某年某月，判断这一年与这一月分别距离1898年1月1日多少天？
   
4.   程序分析：以2013年7月为例，使用循环计算1898年1月1日距离2013年1月1日的总天数（考虑闰年与平年的情况）
   
5.                   再计算2013年1月1日距离7月的总天数
   
6. */
   
7. 
   
8. class Demo
   
9. {
   
10.         public static final int baseYear = 1898;
    
11. 
    
12.         public static void main(String[] args)
    
13.         {
    
14.                 Scanner scan = new Scanner(System.in);
    
15.                 System.out.print("请输入年份：");
    
16.                 int year = scan.nextInt();
    
17.                 System.out.print("请输入月份：");
    
18.                 int month = scan.nextInt();
    
19.                
    
20.                 //如果输入年份大于1898年
    
21.                 if(year >= baseYear)
    
22.                 {
    
23.                         System.out.println(getDays1(year, month));
    
24.                 }
    
25.                 else
    
26.                 {
    
27.                         System.out.println(getDays2(year, month));
    
28.                 }
    
29.         }
    
30. 
    
31.         public static long getDays1(int year, int month)
    
32.         {
    
33.                 long sum = 0l;
    
34.                
    
35.                 //遍历年，瑞年366，平年365
    
36.                 for(int i = baseYear; i < year; i++)
    
37.                 {
    
38.                         if(isLeapYear(i))
    
39.                         {
    
40.                                 sum += 366;
    
41.                         }
    
42.                         else
    
43.                         {
    
44.                                 sum += 365;
    
45.                         }
    
46.                 }
    
47.                
    
48.                 //遍历月份
    
49.                 for(int i = 1; i < month; i++)
    
50.                 {
    
51.                         switch(i)
    
52.                         {
    
53.                                 case 1:
    
54.                                 case 3:
    
55.                                 case 5:
    
56.                                 case 7:
    
57.                                 case 8:
    
58.                                 case 10:
    
59.                                 case 12:
    
60.                                         sum += 31;
    
61.                                         break;
    
62.                                 case 2:
    
63.                                         if(isLeapYear(year))
    
64.                                         {
    
65.                                                 sum += 29;
    
66.                                         }
    
67.                                         else
    
68.                                         {
    
69.                                                 sum += 28;
    
70.                                         }
    
71.                                         break;
    
72.                                 case 4:
    
73.                                 case 6:
    
74.                                 case 9:
    
75.                                 case 11:
    
76.                                         sum += 30;
    
77.                                         break;
    
78.                         }
    
79.                 }
    
80. 
    
81.                 return sum;
    
82.         }
    
83.        
    
84.         //如果year小于1898，计算方法就变了
    
85.         public static long getDays2(int year, int month)
    
86.         {
    
87.                 long sum = 0;
    
88. 
    
89.                 for(int i = year; i < baseYear; i++)
    
90.                 {
    
91.                         if(isLeapYear(i))
    
92.                         {
    
93.                                 sum += 366;
    
94.                         }
    
95.                         else
    
96.                         {
    
97.                                 sum += 365;
    
98.                         }
    
99.                 }
    
100. 
     
101.                 for(int i = 1; i < month; i++)
     
102.                 {
     
103.                         switch(i)
     
104.                         {
     
105.                                 case 1:
     
106.                                 case 3:
     
107.                                 case 5:
     
108.                                 case 7:
     
109.                                 case 8:
     
110.                                 case 10:
     
111.                                 case 12:
     
112.                                         sum -= 31;
     
113.                                         break;
     
114.                                 case 2:
     
115.                                         if(isLeapYear(year))
     
116.                                         {
     
117.                                                 sum -= 29;
     
118.                                         }
     
119.                                         else
     
120.                                         {
     
121.                                                 sum -= 28;
     
122.                                         }
     
123.                                         break;
     
124.                                 case 4:
     
125.                                 case 6:
     
126.                                 case 9:
     
127.                                 case 11:
     
128.                                         sum -= 30;
     
129.                                         break;
     
130.                         }
     
131.                 }
     
132. 
     
133.                 return sum;
     
134.         }
     
135.        
     
136.         //判断是否是瑞年
     
137.         public static boolean isLeapYear(int year)
     
138.         {
     
139.                 //1. 能被4整除，但不能被100整除。2.能被400整除
     
140.                 if(year%4 == 0 && year%100 != 0 || year%400 == 0)
     
141.                 {
     
142.                         return true;
     
143.                 }
     
144.                 return false;
     
145.         }
     
146. }

复制代码

虽然我分够了，不过还是来看看吧

虽然我分够了，不过还是来看看吧

看看会不会

支持一下，看看

好难的题目

试试吧，检验一下自己。

飘过来瞄一眼看看能回答不