用面向对象和面向过程思想解决两个日期间隔的天数和两个时间之间间隔秒数以及两个时间的间隔

蔚落 2022-11-19 09:43 255阅读 0赞

目录

  • 两个日期间隔的天数
    • 类的实现
    • 类的源码：
    • 具体调用：
    • 具体结果：
  • 两个时间之间间隔秒数
    • 类的定义：
    • 类的调用
    • 具体结果
  • 两个日期和时间之间间隔时间
    • 类的定义：

两个日期间隔的天数

类的实现

求解两个日期间，间隔的天数，我们可以利用面向对象的思想，将日期抽象出3个属性：year，month，day。

  1. public class MyDate { 
  2.     public int year;
  3.     public int month;
  4.     public int day;
  5. }

在类中，建立MyDate的构造函数，

  1. public MyDate(int year, int month, int day) { 
  2.         this.year = year;
  3.         this.month = month;
  4.         this.day = day;
  5.     }

通过在主函数内部建两个对象，将两个日期定义出来。同时直接传参

  1. MyDate from = new MyDate(2020, 1, 1);
  2.         MyDate to = new MyDate(2020, 1, 3);

对于传入的参数，我们要进行合法性判断：

  1. if (year < 1900 || year > 3000) { 
  2.             throw new RuntimeException("year参数有问题！");
  3.         }
  4.         if (month < 1 || month > 12) { 
  5.             throw new RuntimeException("month参数有问题！");
  6.         }
  7.         if (day < 1 || day > getMonthDay(year, month)) { 
  8.             throw new RuntimeException("day参数有问题！");
  9.         }

同时还要判断是否闰年，以及月份的日期是多少天：

  1. private int getMonthDay(int year, int month) { 
  2.         switch (month) { 
  3.             case 1:
  4.             case 3:
  5.             case 5:
  6.             case 7:
  7.             case 8:
  8.             case 10:
  9.             case 12:
  10.                 // 利用不加 break，代码会继续向下的规则
  11.                 return 31;
  12.             case 4:
  13.             case 6:
  14.             case 9:
  15.             case 11:
  16.                 return 30;
  17.             case 2:
  18.                 return isLeapYear(year) ? 29 : 28;
  19.             default:
  20.                 return -1;
  21.         }
  22.     }
  24.     //是否是闰年
  25.     private boolean isLeapYear(int year) { 
  26.         return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
  27.     }

将起始日期传递进来：

  1. //将from的参数传进来
  2.     public MyDate(MyDate from) { 
  3.         this.year = from.year;
  4.         this.month = from.month;
  5.         this.day = from.day;
  6.     }

创建方法，计算相差的天数：
利用循环，只要传进来的日期和现在日期不相等，count++；

  1. //计算相差天数：
  2.     public int method(MyDate from) { 
  3.         if (this.compareTo(from) <= 0) { 
  4.             throw new RuntimeException("from 的日期必须当前日期之前");
  5.         }
  6.         MyDate fromCopy = new MyDate(from);
  7.         int count = 0;
  8.         while (fromCopy.compareTo(this) < 0) { 
  9.             System.out.println(fromCopy);
  10.             fromCopy.increment();
  11.             count++;
  12.         }
  13.         return count;
  14.         //return count = between(this) - between(fromCopy);
  15.     }

同时我们也要考虑，进位的问题：

  1. //考虑进位
  2.     private void increment() { 
  3.         day++;
  4.         if (day <= getMonthDay(year, month)) { 
  5.             // day 不需要考虑进位
  6.             return;
  7.         }
  8.         // day 需要考虑日期进位
  9.         month++;
  10.         day = 1;
  11.         if (month <= 12) { 
  12.             // month 不需要考虑进位
  13.             return;
  14.         }
  15.         year++;
  16.         month = 1;
  17.     }
  18.         }

比较两个日期问题

  1. private int compareTo(MyDate from) { 
  2.         if (year != from.year) { 
  3.             return year - from.year;
  4.         }
  5.         if (month != from.month) { 
  6.             return month - from.month;
  7.         }
  8.         return day - from.day;
  9.     }

类的源码：

  1. /** * 相差多少天的计算 */
  2. public class MyDate { 
  3.     public int year;
  4.     public int month;
  5.     public int day;
  7.     //判断合法性
  8.     public MyDate(int year, int month, int day) { 
  9.         if (year < 1900 || year > 3000) { 
  10.             throw new RuntimeException("year参数有问题！");
  11.         }
  12.         if (month < 1 || month > 12) { 
  13.             throw new RuntimeException("month参数有问题！");
  14.         }
  15.         if (day < 1 || day > getMonthDay(year, month)) { 
  16.             throw new RuntimeException("day参数有问题！");
  17.         }
  18.         this.year = year;
  19.         this.month = month;
  20.         this.day = day;
  21.     }
  23.     private int getMonthDay(int year, int month) { 
  24.         switch (month) { 
  25.             case 1:
  26.             case 3:
  27.             case 5:
  28.             case 7:
  29.             case 8:
  30.             case 10:
  31.             case 12:
  32.                 // 利用不加 break，代码会继续向下的规则
  33.                 return 31;
  34.             case 4:
  35.             case 6:
  36.             case 9:
  37.             case 11:
  38.                 return 30;
  39.             case 2:
  40.                 return isLeapYear(year) ? 29 : 28;
  41.             default:
  42.                 return -1;
  43.         }
  44.     }
  45.     //是否是闰年
  46.     private boolean isLeapYear(int year) { 
  47.         return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
  48.     }
  50.     //将from的参数传进来
  51.     public MyDate(MyDate from) { 
  52.         this.year = from.year;
  53.         this.month = from.month;
  54.         this.day = from.day;
  55.     }
  57.     @Override
  58.     public String toString() { 
  59.         return "MyDate{" + "year=" + year + ", month=" + month + ", day=" + day + '}';
  60.     }
  62.     //计算相差天数：
  63.     public int method(MyDate from) { 
  64.         if (this.compareTo(from) <= 0) { 
  65.             throw new RuntimeException("from 的日期必须当前日期之前");
  66.         }
  67.         MyDate fromCopy = new MyDate(from);
  68.         int count = 0;
  69.         while (fromCopy.compareTo(this) < 0) { 
  70.             System.out.println(fromCopy);
  71.             fromCopy.increment();
  72.             count++;
  73.         }
  74.         return count;
  75.         //return count = between(this) - between(fromCopy);
  76.     }
  77.     //考虑进位
  78.     private void increment() { 
  79.         day++;
  80.         if (day <= getMonthDay(year, month)) { 
  81.             // day 不需要考虑进位
  82.             return;
  83.         }
  84.         // day 需要考虑日期进位
  85.         month++;
  86.         day = 1;
  87.         if (month <= 12) { 
  88.             // month 不需要考虑进位
  89.             return;
  90.         }
  91.         year++;
  92.         month = 1;
  93.     }
  95.     private int compareTo(MyDate from) { 
  96.         if (year != from.year) { 
  97.             return year - from.year;
  98.         }
  99.         if (month != from.month) { 
  100.             return month - from.month;
  101.         }
  102.         return day - from.day;
  103.     }
  104. }

具体调用：

  1. public class MyDateTest { 
  3.     public static void main(String[] args) { 
  4.         MyDate from = new MyDate(2020, 1, 1);
  5.         MyDate to = new MyDate(2020, 1, 3);
  7.         System.out.println(to.method(from));
  8.         System.out.printf("从 %s 到 %s 经过了 %d 天\n",from, to, to.method(from));
  9.     }
  10. }

具体结果：

在这里插入图片描述
在这里插入图片描述

两个时间之间间隔秒数

这个题目和上面的题目思想以及用法都十分的类似，都是这样考虑的问题，
在这里我就只放源代码和结果了：

类的定义：

  1. /** *计算两个时间差 */
  2. public class Mytime { 
  3.     public int hour;
  4.     public int min;
  5.     public int sec;
  7.     public Mytime(int hour, int min, int sec) { 
  8.         if (hour<0||hour>=24){ 
  9.             throw new RuntimeException("hour参数不合法");
  10.         }
  11.         if (min<0||min>=60){ 
  12.             throw new RuntimeException("min参数不合法");
  13.         }
  14.         if (sec<0||sec>=60){ 
  15.             throw new RuntimeException("sec参数不合法");
  16.         }
  17.         this.hour = hour;
  18.         this.min = min;
  19.         this.sec = sec;
  20.     }
  22.     @Override
  23.     public String toString() { 
  24.         return "Mytime{" + "hour=" + hour + ", min=" + min + ", sec=" + sec + '}';
  25.     }
  27.     public Mytime(Mytime fromTime){ 
  28.         this.hour = fromTime.hour;
  29.         this.min = fromTime.min;
  30.         this.sec = fromTime.sec;
  31.     }
  32.     public int methodTime(Mytime fromTime){ 
  33.         if (this.compareToTime(fromTime) <= 0) { 
  34.             throw new RuntimeException("from 的时间必须当前时间之前");
  35.         }
  36.         Mytime fromCopy = new Mytime(fromTime);
  37.         int count = 0;
  38.         while (fromCopy.compareToTime(this) < 0) { 
  39.             System.out.println(fromCopy);
  40.             fromCopy.increment();
  41.             count++;
  42.         }
  43.         return count;
  45.     }
  47.     //考虑进位
  48.     private void increment() { 
  49.         sec++;
  50.         if (sec < 60) { 
  51.             return;
  52.         }
  53.         min++;
  54.         sec = 0;
  55.         if (min < 60) { 
  56.             return;
  57.         }
  58.         hour++;
  59.         min =0 ;
  60.     }
  62.     private int compareToTime(Mytime fromTime) { 
  63.         if (hour != fromTime.hour) { 
  64.             return hour - fromTime.hour;
  65.         }
  66.         if (min != fromTime.min) { 
  67.             return min - fromTime.min;
  68.         }
  69.         return sec - fromTime.sec;
  70.     }
  71. }

类的调用

  1. public class MytimeTest { 
  2.     public static void main(String[] args) { 
  3.         Mytime fromTime=new Mytime(9,10,23);
  4.         Mytime toTime=new Mytime(10,10,38);
  5.         System.out.printf("从 %s 到 %s 经过了 %d 秒\n",fromTime, toTime, toTime.methodTime(fromTime));
  6.     }
  7. }

具体结果

在这里插入图片描述

两个日期和时间之间间隔时间

类的定义：

  1. package DateTime;
  2. /** *计算日期 */
  3. public class MyDate { 
  4.     private int year;
  5.     private int mon;
  6.     private int day;
  8.     public MyDate(MyDate Date) { 
  9.         this.year = Date.year;
  10.         this.mon = Date.mon;
  11.         this.day = Date.day;
  12.     }
  14.     public MyDate(int year, int mon, int day) { 
  15.         //判断参数的合法性
  16.         cheak(year, mon, day);
  17.         this.year = year;
  18.         this.mon = mon;
  19.         this.day = day;
  20.     }
  22.     @Override
  23.     public String toString() { 
  24.         return String.format("%d-%02d-%02d", year, mon, day);
  25.     }
  28.     private void cheak(int year, int mon, int day) { 
  29.         //校验参数的合法性
  30.         if (mon < 1 || mon > 12) { 
  31.             throw new RuntimeException("mon的范围是1-12");
  32.         }
  33.         int days = getMonYear(year, mon);
  34.         if (day < 1 || day > days) { 
  35.             throw new RuntimeException("day的范围是1-" + days);
  36.         }
  38.     }
  40.     private static int getMonYear(int year, int mon) { 
  41.         if (mon == 2 && IsleapYear(year)) { 
  42.             return 29;
  43.         }
  44.         return DAY[mon - 1];
  45.     }
  47.     private static boolean IsleapYear(int year) { 
  48.         return (year % 4 == 0 && year % 400 != 0) || (year % 400 == 0);
  49.     }
  51.     private static final int[] DAY = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  53.     //往后走一天
  54.     public void next() { 
  55.         day++;
  56.         if (day <= getMonYear(year, mon)) { 
  57.             return;
  58.         }
  59.         mon++;
  60.         day = 1;
  61.         if (mon <= 12) { 
  62.             return;
  63.         }
  64.         year++;
  65.         mon = 1;
  66.     }
  68.     //往前走一天
  69.     public void previous() { 
  70.         day--;
  71.         if (day > 0) { 
  72.             return;
  73.         }
  74.         mon--;
  75.         if (mon > 0) { 
  76.             day = getMonYear(year, mon);
  77.             return;
  78.         }
  79.         year--;
  80.         mon = 12;
  81.         day = getMonYear(year, mon);
  82.     }
  83. }
  85. package DateTime;
  86. /** * 计算时间 */
  87. public class MyTime { 
  88.     private int hour;
  89.     private int min;
  90.     private int sec;
  92.     public MyTime(MyTime time) { 
  93.         this.hour = time.hour;
  94.         this.min = time.min;
  95.         this.sec = time.sec;
  96.     }
  98.     public MyTime(int hour, int min, int sec) { 
  99.         cheak(hour, min, sec);
  100.         this.hour = hour;
  101.         this.min = min;
  102.         this.sec = sec;
  103.     }
  105.     //往后走1秒
  106.     public boolean next() { 
  107.         sec++;
  108.         if (sec < 60) { 
  109.             return false;
  110.         }
  111.         min++;
  112.         sec = 0;
  113.         if (min < 60) { 
  114.             return false;
  115.         }
  116.         hour++;
  117.         min = 0;
  118.         if (hour < 24) { 
  119.             return false;
  120.         }
  121.         hour = 0;
  122.         return true;
  123.     }
  125.     //往前走1秒
  126.     public boolean previous() { 
  127.         sec--;
  128.         if (sec >= 0) { 
  129.             return false;
  130.         }
  131.         min--;
  132.         sec = 59;
  133.         if (min >= 0) { 
  134.             return false;
  135.         }
  136.         hour--;
  137.         min = 59;
  138.         if (hour >= 0) { 
  139.             return false;
  140.         }
  141.         hour = 23;
  142.         return true;
  143.     }
  145.     @Override
  146.     public String toString() { 
  147.         return String.format("%02d:%02d:%02d", hour, min, sec);
  148.     }
  150.     //合法性校验
  151.     private static void cheak(int hour, int min, int sec) { 
  152.         if (hour < 0 || hour >= 24) { 
  153.             throw new RuntimeException("hour参数有问题");
  154.         }
  155.         if (min < 0 || min >= 60) { 
  156.             throw new RuntimeException("min参数有问题");
  157.         }
  158.         if (sec < 0 || sec >= 60) { 
  159.             throw new RuntimeException("sec参数有问题");
  160.         }
  161.     }
  162. }
  164. package DateTime;
  166. /** * 计算时间日期 */
  167. public class DateTime { 
  168.     private MyDate date;
  169.     private MyTime time;
  171.     public DateTime(DateTime datetime) { 
  172.         this.date = new MyDate(datetime.date);
  173.         this.time = new MyTime(0, 0, 0);
  174.     }
  176.     public DateTime(int year, int month, int day, int hour, int minute, int second) { 
  177.         this.date = new MyDate(year, month, day);
  178.         this.time = new MyTime(hour, minute, second);
  179.     }
  181.     public DateTime(int year, int month, int day) { 
  182.         this(year, month, day, 0, 0, 0);
  183.     }
  185.     public DateTime(MyDate date) { 
  186.         this.date = new MyDate(date);
  187.     }
  189.     // 向后走一秒
  190.     public void next() { 
  191.         if (time.next()) { 
  192.             date.next();
  193.         }
  194.     }
  196.     // 向前走一秒
  197.     public void previous() { 
  198.         if (time.previous()) { 
  199.             date.previous();
  200.         }
  201.     }
  203.     @Override
  204.     public String toString() { 
  205.         return String.format("%s %s", date, time);
  206.     }
  207. }
  209. package DateTime;
  211. import java.util.concurrent.TimeUnit;
  213. public class Teat { 
  214.     public static void main(String[] args) throws InterruptedException { 
  215.         DateTime datetime = new DateTime(2021, 12, 31, 23, 59, 53);
  217.         while (true) { 
  218.             System.out.println(datetime);
  219.             datetime.next();
  220.             TimeUnit.SECONDS.sleep(1);  // 让代码停顿 1 秒
  221.         }
  222.     }
  223. }

发表评论

表情：
评论列表 （有 0 条评论，255人围观）

还没有评论，来说两句吧...

相关阅读