简体中文 繁體中文 English 日本語 Deutsch 한국 사람 بالعربية TÜRKÇE português คนไทย Français

开启辅助访问 切换到宽版

站内搜索

搜索

活动公告

通知：是的！我们正在计划一个大动作！
11-02 12:46
通知：Telegram 推送频道https://t.me/+2tB3a7aKXlw2YjA1 及时接收第一手论坛帖子信息～
10-23 09:32
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，将及时处理！
10-23 09:31
通知：加入QQ社群吧 https://qm.qq.com/q/QZibQd1hiq
10-23 09:28
通知：签到时间调整为每日4:00（东八区）
10-23 09:26
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

使用Eclipse开发天数计算系统从基础日期操作到高级时间处理从简单天数差到复杂工作日计算的完整项目实战

威震华夏关云长

3万

主题

349

科技点

3万

积分

大区版主

木柜子打湿

积分
31898

三倍冰淇淋无人之境【一阶】财Doro小樱（小丑装）立华奏以外的星空【二阶】⑨的冰沙
发表于 2025-9-18 14:10:17 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
1. 项目概述和目标

天数计算系统是一个常见的实用工具，广泛应用于项目管理、财务计算、日程安排等领域。本项目的目标是开发一个功能全面的天数计算系统，能够处理从简单的日期差计算到复杂的工作日计算等各种需求。

项目主要功能包括：

• 基本日期操作（创建、格式化、解析）
• 简单天数差计算
• 高级时间处理（时间段计算、日期加减）
• 工作日计算（排除周末和节假日）
• 自定义工作日规则

通过本项目的开发，读者将全面掌握Java中日期时间处理的各个方面，并学会如何在Eclipse环境中构建一个完整的应用程序。

2. 环境搭建（Eclipse配置）

2.1 安装Eclipse IDE

1. 访问Eclipse官方网站（https://www.eclipse.org/）
2. 下载适合你操作系统的Eclipse IDE for Enterprise Java Developers版本
3. 安装Eclipse（解压下载的文件即可）

2.2 配置Java开发环境

1. 确保已安装JDK（推荐JDK 8或更高版本）
2. 在Eclipse中配置JDK：打开Eclipse，选择”Window” > “Preferences”在左侧树形菜单中，展开”Java” > “Installed JREs”点击”Add”按钮，选择已安装的JDK目录
3. 打开Eclipse，选择”Window” > “Preferences”
4. 在左侧树形菜单中，展开”Java” > “Installed JREs”
5. 点击”Add”按钮，选择已安装的JDK目录

• 打开Eclipse，选择”Window” > “Preferences”
• 在左侧树形菜单中，展开”Java” > “Installed JREs”
• 点击”Add”按钮，选择已安装的JDK目录

2.3 创建新项目

1. 在Eclipse中，选择”File” > “New” > “Java Project”
2. 输入项目名称，例如”DayCalculator”
3. 选择合适的JRE版本
4. 点击”Finish”完成项目创建

2.4 项目结构设计

在项目中创建以下包结构：

• com.daycalculator.core：核心计算逻辑
• com.daycalculator.ui：用户界面
• com.daycalculator.util：工具类
• com.daycalculator.exception：自定义异常
• com.daycalculator.test：测试类

3. 基础日期操作

3.1 Java日期API介绍

Java提供了多种日期时间API，主要包括：

• java.util.Date：早期的日期类
• java.util.Calendar：提供更丰富的日期操作
• java.text.SimpleDateFormat：日期格式化和解析
• Java 8引入的java.time包：现代日期时间API

3.2 日期创建和格式化

让我们创建一个基础日期操作类，演示日期的创建和格式化：
  2. package com.daycalculator.core;
  4. import java.text.SimpleDateFormat;
  5. import java.util.Date;
  6. import java.util.Calendar;
  8. public class BasicDateOperations {
  9.    
  10.     // 获取当前日期
  11.     public static Date getCurrentDate() {
  12.         return new Date();
  13.     }
  14.    
  15.     // 使用Calendar创建特定日期
  16.     public static Date createSpecificDate(int year, int month, int day) {
  17.         Calendar calendar = Calendar.getInstance();
  18.         calendar.set(year, month - 1, day); // 月份从0开始
  19.         return calendar.getTime();
  20.     }
  21.    
  22.     // 格式化日期
  23.     public static String formatDate(Date date, String pattern) {
  24.         SimpleDateFormat sdf = new SimpleDateFormat(pattern);
  25.         return sdf.format(date);
  26.     }
  27.    
  28.     // 默认格式化日期 (yyyy-MM-dd)
  29.     public static String formatDefaultDate(Date date) {
  30.         return formatDate(date, "yyyy-MM-dd");
  31.     }
  32. }
复制代码

3.3 日期解析和验证

接下来，我们添加日期解析和验证的方法：
  2. package com.daycalculator.core;
  4. import java.text.ParseException;
  5. import java.text.SimpleDateFormat;
  6. import java.util.Date;
  8. public class DateParser {
  9.    
  10.     // 解析日期字符串
  11.     public static Date parseDate(String dateStr, String pattern) throws ParseException {
  12.         SimpleDateFormat sdf = new SimpleDateFormat(pattern);
  13.         sdf.setLenient(false); // 严格解析，不允许非法日期
  14.         return sdf.parse(dateStr);
  15.     }
  16.    
  17.     // 使用默认格式解析日期 (yyyy-MM-dd)
  18.     public static Date parseDefaultDate(String dateStr) throws ParseException {
  19.         return parseDate(dateStr, "yyyy-MM-dd");
  20.     }
  21.    
  22.     // 验证日期字符串是否有效
  23.     public static boolean isValidDate(String dateStr, String pattern) {
  24.         try {
  25.             parseDate(dateStr, pattern);
  26.             return true;
  27.         } catch (ParseException e) {
  28.             return false;
  29.         }
  30.     }
  31.    
  32.     // 使用默认格式验证日期字符串
  33.     public static boolean isValidDefaultDate(String dateStr) {
  34.         return isValidDate(dateStr, "yyyy-MM-dd");
  35.     }
  36. }
复制代码

4. 简单天数差计算

4.1 基本天数差计算方法

计算两个日期之间的天数差是一个常见需求。我们可以使用以下几种方法：

1. 使用Date类和毫秒差计算
2. 使用Calendar类
3. 使用Java 8的java.time包

4.2 考虑时区因素

在计算日期差时，时区是一个重要因素。我们需要确保两个日期在相同的时区下进行比较。

4.3 代码实现

让我们创建一个天数差计算类：
  2. package com.daycalculator.core;
  4. import java.util.Calendar;
  5. import java.util.Date;
  6. import java.util.TimeZone;
  8. public class DateDifferenceCalculator {
  9.    
  10.     // 使用Date类计算天数差（不考虑时间部分）
  11.     public static int calculateDaysBetween(Date startDate, Date endDate) {
  12.         // 重置时间部分为00:00:00
  13.         Date start = resetTime(startDate);
  14.         Date end = resetTime(endDate);
  15.         
  16.         // 计算毫秒差
  17.         long diff = end.getTime() - start.getTime();
  18.         
  19.         // 转换为天数
  20.         return (int) (diff / (24 * 60 * 60 * 1000));
  21.     }
  22.    
  23.     // 重置日期的时间部分为00:00:00
  24.     private static Date resetTime(Date date) {
  25.         Calendar calendar = Calendar.getInstance();
  26.         calendar.setTime(date);
  27.         calendar.set(Calendar.HOUR_OF_DAY, 0);
  28.         calendar.set(Calendar.MINUTE, 0);
  29.         calendar.set(Calendar.SECOND, 0);
  30.         calendar.set(Calendar.MILLISECOND, 0);
  31.         return calendar.getTime();
  32.     }
  33.    
  34.     // 使用Calendar类计算天数差
  35.     public static int calculateDaysBetweenWithCalendar(Date startDate, Date endDate) {
  36.         Calendar startCalendar = Calendar.getInstance();
  37.         startCalendar.setTime(startDate);
  38.         
  39.         Calendar endCalendar = Calendar.getInstance();
  40.         endCalendar.setTime(endDate);
  41.         
  42.         // 重置时间部分
  43.         resetTimeCalendar(startCalendar);
  44.         resetTimeCalendar(endCalendar);
  45.         
  46.         // 计算完整的天数差
  47.         int days = 0;
  48.         while (startCalendar.before(endCalendar)) {
  49.             startCalendar.add(Calendar.DAY_OF_MONTH, 1);
  50.             days++;
  51.         }
  52.         
  53.         return days;
  54.     }
  55.    
  56.     // 重置Calendar的时间部分
  57.     private static void resetTimeCalendar(Calendar calendar) {
  58.         calendar.set(Calendar.HOUR_OF_DAY, 0);
  59.         calendar.set(Calendar.MINUTE, 0);
  60.         calendar.set(Calendar.SECOND, 0);
  61.         calendar.set(Calendar.MILLISECOND, 0);
  62.     }
  63.    
  64.     // 考虑时区的天数差计算
  65.     public static int calculateDaysBetweenWithTimeZone(Date startDate, Date endDate, TimeZone timeZone) {
  66.         Calendar startCalendar = Calendar.getInstance(timeZone);
  67.         startCalendar.setTime(startDate);
  68.         
  69.         Calendar endCalendar = Calendar.getInstance(timeZone);
  70.         endCalendar.setTime(endDate);
  71.         
  72.         // 重置时间部分
  73.         resetTimeCalendar(startCalendar);
  74.         resetTimeCalendar(endCalendar);
  75.         
  76.         // 计算完整的天数差
  77.         int days = 0;
  78.         while (startCalendar.before(endCalendar)) {
  79.             startCalendar.add(Calendar.DAY_OF_MONTH, 1);
  80.             days++;
  81.         }
  82.         
  83.         return days;
  84.     }
  85. }
复制代码

5. 高级时间处理

5.1 Java 8日期时间API

Java 8引入了全新的日期时间API，位于java.time包中，提供了更直观、更强大的日期时间处理能力。主要类包括：

• LocalDate：表示日期（年月日）
• LocalTime：表示时间（时分秒）
• LocalDateTime：表示日期时间
• ZonedDateTime：带时区的日期时间
• Period：表示日期间隔
• Duration：表示时间间隔

5.2 时间段计算

使用Java 8的API，我们可以更方便地计算时间段：
  2. package com.daycalculator.core;
  4. import java.time.LocalDate;
  5. import java.time.Period;
  6. import java.time.temporal.ChronoUnit;
  8. public class AdvancedDateOperations {
  9.    
  10.     // 使用Java 8 API计算两个日期之间的天数差
  11.     public static long calculateDaysBetweenJava8(LocalDate startDate, LocalDate endDate) {
  12.         return ChronoUnit.DAYS.between(startDate, endDate);
  13.     }
  14.    
  15.     // 计算两个日期之间的月数差
  16.     public static long calculateMonthsBetweenJava8(LocalDate startDate, LocalDate endDate) {
  17.         return ChronoUnit.MONTHS.between(startDate, endDate);
  18.     }
  19.    
  20.     // 计算两个日期之间的年数差
  21.     public static long calculateYearsBetweenJava8(LocalDate startDate, LocalDate endDate) {
  22.         return ChronoUnit.YEARS.between(startDate, endDate);
  23.     }
  24.    
  25.     // 使用Period计算日期间隔
  26.     public static Period calculatePeriodBetween(LocalDate startDate, LocalDate endDate) {
  27.         return Period.between(startDate, endDate);
  28.     }
  29.    
  30.     // 获取Period中的年、月、日
  31.     public static String getPeriodDetails(Period period) {
  32.         return String.format("%d 年, %d 月, %d 日",
  33.             period.getYears(), period.getMonths(), period.getDays());
  34.     }
  35. }
复制代码

5.3 日期加减操作
  2. package com.daycalculator.core;
  4. import java.time.LocalDate;
  5. import java.time.temporal.ChronoUnit;
  7. public class DateArithmeticOperations {
  8.    
  9.     // 日期加天数
  10.     public static LocalDate addDays(LocalDate date, long days) {
  11.         return date.plusDays(days);
  12.     }
  13.    
  14.     // 日期减天数
  15.     public static LocalDate subtractDays(LocalDate date, long days) {
  16.         return date.minusDays(days);
  17.     }
  18.    
  19.     // 日期加月数
  20.     public static LocalDate addMonths(LocalDate date, long months) {
  21.         return date.plusMonths(months);
  22.     }
  23.    
  24.     // 日期减月数
  25.     public static LocalDate subtractMonths(LocalDate date, long months) {
  26.         return date.minusMonths(months);
  27.     }
  28.    
  29.     // 日期加年数
  30.     public static LocalDate addYears(LocalDate date, long years) {
  31.         return date.plusYears(years);
  32.     }
  33.    
  34.     // 日期减年数
  35.     public static LocalDate subtractYears(LocalDate date, long years) {
  36.         return date.minusYears(years);
  37.     }
  38.    
  39.     // 使用ChronoUnit进行日期加减
  40.     public static LocalDate addUnits(LocalDate date, long amount, ChronoUnit unit) {
  41.         return date.plus(amount, unit);
  42.     }
  43.    
  44.     public static LocalDate subtractUnits(LocalDate date, long amount, ChronoUnit unit) {
  45.         return date.minus(amount, unit);
  46.     }
  47. }
复制代码

6. 工作日计算

6.1 工作日概念和规则

工作日通常指周一到周五，不包括周末（周六和周日）。在某些情况下，还需要排除法定节假日。

6.2 排除周末的计算
  2. package com.daycalculator.core;
  4. import java.time.DayOfWeek;
  5. import java.time.LocalDate;
  6. import java.time.temporal.ChronoUnit;
  7. import java.util.List;
  8. import java.util.stream.Collectors;
  9. import java.util.stream.Stream;
  11. public class WorkdayCalculator {
  12.    
  13.     // 计算两个日期之间的工作日数（排除周末）
  14.     public static long calculateWorkdaysBetween(LocalDate startDate, LocalDate endDate) {
  15.         long daysBetween = ChronoUnit.DAYS.between(startDate, endDate) + 1; // 包含开始日期
  16.         
  17.         // 计算完整的周数和剩余天数
  18.         long fullWeeks = daysBetween / 7;
  19.         long remainingDays = daysBetween % 7;
  20.         
  21.         // 计算周末天数
  22.         long weekendDays = fullWeeks * 2;
  23.         
  24.         // 计算剩余天数中的周末天数
  25.         LocalDate currentDate = startDate.plusDays(fullWeeks * 7);
  26.         for (int i = 0; i < remainingDays; i++) {
  27.             if (isWeekend(currentDate)) {
  28.                 weekendDays++;
  29.             }
  30.             currentDate = currentDate.plusDays(1);
  31.         }
  32.         
  33.         return daysBetween - weekendDays;
  34.     }
  35.    
  36.     // 判断是否是周末
  37.     private static boolean isWeekend(LocalDate date) {
  38.         DayOfWeek day = date.getDayOfWeek();
  39.         return day == DayOfWeek.SATURDAY || day == DayOfWeek.SUNDAY;
  40.     }
  41.    
  42.     // 获取两个日期之间的所有工作日
  43.     public static List<LocalDate> getWorkdaysBetween(LocalDate startDate, LocalDate endDate) {
  44.         return Stream.iterate(startDate, date -> date.isBefore(endDate) || date.isEqual(endDate), date -> date.plusDays(1))
  45.                 .filter(date -> !isWeekend(date))
  46.                 .collect(Collectors.toList());
  47.     }
  48. }
复制代码

6.3 排除节假日的计算
  2. package com.daycalculator.core;
  4. import java.time.LocalDate;
  5. import java.util.HashSet;
  6. import java.util.List;
  7. import java.util.Set;
  8. import java.util.stream.Collectors;
  9. import java.util.stream.Stream;
  11. public class HolidayWorkdayCalculator extends WorkdayCalculator {
  12.    
  13.     private Set<LocalDate> holidays = new HashSet<>();
  14.    
  15.     // 添加节假日
  16.     public void addHoliday(LocalDate date) {
  17.         holidays.add(date);
  18.     }
  19.    
  20.     // 批量添加节假日
  21.     public void addHolidays(List<LocalDate> holidayList) {
  22.         holidays.addAll(holidayList);
  23.     }
  24.    
  25.     // 移除节假日
  26.     public void removeHoliday(LocalDate date) {
  27.         holidays.remove(date);
  28.     }
  29.    
  30.     // 判断是否是节假日
  31.     public boolean isHoliday(LocalDate date) {
  32.         return holidays.contains(date);
  33.     }
  34.    
  35.     // 判断是否是工作日（不是周末也不是节假日）
  36.     public boolean isWorkday(LocalDate date) {
  37.         return !isWeekend(date) && !isHoliday(date);
  38.     }
  39.    
  40.     // 计算两个日期之间的工作日数（排除周末和节假日）
  41.     public long calculateWorkdaysBetweenWithHolidays(LocalDate startDate, LocalDate endDate) {
  42.         return Stream.iterate(startDate, date -> date.isBefore(endDate) || date.isEqual(endDate), date -> date.plusDays(1))
  43.                 .filter(date -> isWorkday(date))
  44.                 .count();
  45.     }
  46.    
  47.     // 获取两个日期之间的所有工作日（排除周末和节假日）
  48.     public List<LocalDate> getWorkdaysBetweenWithHolidays(LocalDate startDate, LocalDate endDate) {
  49.         return Stream.iterate(startDate, date -> date.isBefore(endDate) || date.isEqual(endDate), date -> date.plusDays(1))
  50.                 .filter(date -> isWorkday(date))
  51.                 .collect(Collectors.toList());
  52.     }
  53.    
  54.     // 计算从开始日期开始的第n个工作日
  55.     public LocalDate getNthWorkday(LocalDate startDate, int n) {
  56.         LocalDate currentDate = startDate;
  57.         int workdayCount = 0;
  58.         
  59.         while (workdayCount < n) {
  60.             currentDate = currentDate.plusDays(1);
  61.             if (isWorkday(currentDate)) {
  62.                 workdayCount++;
  63.             }
  64.         }
  65.         
  66.         return currentDate;
  67.     }
  68. }
复制代码

6.4 自定义工作日规则
  2. package com.daycalculator.core;
  4. import java.time.DayOfWeek;
  5. import java.time.LocalDate;
  6. import java.util.HashSet;
  7. import java.util.List;
  8. import java.util.Set;
  9. import java.util.stream.Collectors;
  10. import java.util.stream.Stream;
  12. public class CustomWorkdayCalculator {
  13.    
  14.     private Set<DayOfWeek> weekendDays = new HashSet<>();
  15.     private Set<LocalDate> holidays = new HashSet<>();
  16.     private Set<LocalDate> workdaysOnWeekend = new HashSet<>(); // 周末中的特殊工作日
  17.    
  18.     public CustomWorkdayCalculator() {
  19.         // 默认周末是周六和周日
  20.         weekendDays.add(DayOfWeek.SATURDAY);
  21.         weekendDays.add(DayOfWeek.SUNDAY);
  22.     }
  23.    
  24.     // 设置周末日
  25.     public void setWeekendDays(Set<DayOfWeek> days) {
  26.         weekendDays.clear();
  27.         weekendDays.addAll(days);
  28.     }
  29.    
  30.     // 添加周末日
  31.     public void addWeekendDay(DayOfWeek day) {
  32.         weekendDays.add(day);
  33.     }
  34.    
  35.     // 移除周末日
  36.     public void removeWeekendDay(DayOfWeek day) {
  37.         weekendDays.remove(day);
  38.     }
  39.    
  40.     // 添加节假日
  41.     public void addHoliday(LocalDate date) {
  42.         holidays.add(date);
  43.     }
  44.    
  45.     // 批量添加节假日
  46.     public void addHolidays(List<LocalDate> holidayList) {
  47.         holidays.addAll(holidayList);
  48.     }
  49.    
  50.     // 移除节假日
  51.     public void removeHoliday(LocalDate date) {
  52.         holidays.remove(date);
  53.     }
  54.    
  55.     // 添加周末中的特殊工作日
  56.     public void addWorkdayOnWeekend(LocalDate date) {
  57.         workdaysOnWeekend.add(date);
  58.     }
  59.    
  60.     // 移除周末中的特殊工作日
  61.     public void removeWorkdayOnWeekend(LocalDate date) {
  62.         workdaysOnWeekend.remove(date);
  63.     }
  64.    
  65.     // 判断是否是周末
  66.     public boolean isWeekend(LocalDate date) {
  67.         return weekendDays.contains(date.getDayOfWeek());
  68.     }
  69.    
  70.     // 判断是否是节假日
  71.     public boolean isHoliday(LocalDate date) {
  72.         return holidays.contains(date);
  73.     }
  74.    
  75.     // 判断是否是周末中的特殊工作日
  76.     public boolean isWorkdayOnWeekend(LocalDate date) {
  77.         return workdaysOnWeekend.contains(date);
  78.     }
  79.    
  80.     // 判断是否是工作日
  81.     public boolean isWorkday(LocalDate date) {
  82.         if (isWeekend(date)) {
  83.             return isWorkdayOnWeekend(date);
  84.         } else {
  85.             return !isHoliday(date);
  86.         }
  87.     }
  88.    
  89.     // 计算两个日期之间的工作日数
  90.     public long calculateWorkdaysBetween(LocalDate startDate, LocalDate endDate) {
  91.         return Stream.iterate(startDate, date -> date.isBefore(endDate) || date.isEqual(endDate), date -> date.plusDays(1))
  92.                 .filter(date -> isWorkday(date))
  93.                 .count();
  94.     }
  95.    
  96.     // 获取两个日期之间的所有工作日
  97.     public List<LocalDate> getWorkdaysBetween(LocalDate startDate, LocalDate endDate) {
  98.         return Stream.iterate(startDate, date -> date.isBefore(endDate) || date.isEqual(endDate), date -> date.plusDays(1))
  99.                 .filter(date -> isWorkday(date))
  100.                 .collect(Collectors.toList());
  101.     }
  102.    
  103.     // 计算从开始日期开始的第n个工作日
  104.     public LocalDate getNthWorkday(LocalDate startDate, int n) {
  105.         LocalDate currentDate = startDate;
  106.         int workdayCount = 0;
  107.         
  108.         while (workdayCount < n) {
  109.             currentDate = currentDate.plusDays(1);
  110.             if (isWorkday(currentDate)) {
  111.                 workdayCount++;
  112.             }
  113.         }
  114.         
  115.         return currentDate;
  116.     }
  117. }
复制代码

7. 完整项目实现

7.1 项目结构设计

现在，让我们整合所有组件，构建一个完整的天数计算系统。

项目结构如下：
  2. DayCalculator/
  3. ├── src/
  4. │   ├── com/
  5. │   │   └── daycalculator/
  6. │   │       ├── core/
  7. │   │       │   ├── BasicDateOperations.java
  8. │   │       │   ├── DateParser.java
  9. │   │       │   ├── DateDifferenceCalculator.java
  10. │   │       │   ├── AdvancedDateOperations.java
  11. │   │       │   ├── DateArithmeticOperations.java
  12. │   │       │   ├── WorkdayCalculator.java
  13. │   │       │   ├── HolidayWorkdayCalculator.java
  14. │   │       │   └── CustomWorkdayCalculator.java
  15. │   │       ├── ui/
  16. │   │       │   ├── MainFrame.java
  17. │   │       │   ├── DateDifferencePanel.java
  18. │   │       │   ├── WorkdayCalculatorPanel.java
  19. │   │       │   └── HolidayManagerPanel.java
  20. │   │       ├── util/
  21. │   │       │   ├── DateUtils.java
  22. │   │       │   └── HolidayLoader.java
  23. │   │       ├── exception/
  24. │   │       │   └── DateParseException.java
  25. │   │       └── test/
  26. │   │           └── DateCalculatorTest.java
  27. │   └── resources/
  28. │       └── holidays.properties
  29. └── lib/
复制代码

7.2 核心类设计

让我们创建一个核心服务类，整合所有功能：
  2. package com.daycalculator.core;
  4. import java.time.LocalDate;
  5. import java.time.ZoneId;
  6. import java.util.Date;
  7. import java.util.List;
  8. import java.util.TimeZone;
  9. import java.util.HashSet;
  10. import java.util.Set;
  12. public class DayCalculatorService {
  13.    
  14.     private CustomWorkdayCalculator workdayCalculator;
  15.    
  16.     public DayCalculatorService() {
  17.         this.workdayCalculator = new CustomWorkdayCalculator();
  18.     }
  19.    
  20.     // 基本日期操作
  21.    
  22.     public Date getCurrentDate() {
  23.         return BasicDateOperations.getCurrentDate();
  24.     }
  25.    
  26.     public Date createSpecificDate(int year, int month, int day) {
  27.         return BasicDateOperations.createSpecificDate(year, month, day);
  28.     }
  29.    
  30.     public String formatDate(Date date, String pattern) {
  31.         return BasicDateOperations.formatDate(date, pattern);
  32.     }
  33.    
  34.     public String formatDefaultDate(Date date) {
  35.         return BasicDateOperations.formatDefaultDate(date);
  36.     }
  37.    
  38.     public Date parseDate(String dateStr, String pattern) throws Exception {
  39.         try {
  40.             return DateParser.parseDate(dateStr, pattern);
  41.         } catch (Exception e) {
  42.             throw new Exception("日期解析错误: " + e.getMessage(), e);
  43.         }
  44.     }
  45.    
  46.     public Date parseDefaultDate(String dateStr) throws Exception {
  47.         try {
  48.             return DateParser.parseDefaultDate(dateStr);
  49.         } catch (Exception e) {
  50.             throw new Exception("日期解析错误: " + e.getMessage(), e);
  51.         }
  52.     }
  53.    
  54.     public boolean isValidDate(String dateStr, String pattern) {
  55.         return DateParser.isValidDate(dateStr, pattern);
  56.     }
  57.    
  58.     public boolean isValidDefaultDate(String dateStr) {
  59.         return DateParser.isValidDefaultDate(dateStr);
  60.     }
  61.    
  62.     // 日期差计算
  63.    
  64.     public int calculateDaysBetween(Date startDate, Date endDate) {
  65.         return DateDifferenceCalculator.calculateDaysBetween(startDate, endDate);
  66.     }
  67.    
  68.     public int calculateDaysBetweenWithCalendar(Date startDate, Date endDate) {
  69.         return DateDifferenceCalculator.calculateDaysBetweenWithCalendar(startDate, endDate);
  70.     }
  71.    
  72.     public int calculateDaysBetweenWithTimeZone(Date startDate, Date endDate, String timeZoneId) {
  73.         return DateDifferenceCalculator.calculateDaysBetweenWithTimeZone(
  74.             startDate, endDate, TimeZone.getTimeZone(timeZoneId));
  75.     }
  76.    
  77.     // Java 8 日期操作
  78.    
  79.     public LocalDate convertToLocalDate(Date date) {
  80.         return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
  81.     }
  82.    
  83.     public Date convertToDate(LocalDate localDate) {
  84.         return Date.from(localDate.atStartOfDay(ZoneId.systemDefault()).toInstant());
  85.     }
  86.    
  87.     public long calculateDaysBetweenJava8(LocalDate startDate, LocalDate endDate) {
  88.         return AdvancedDateOperations.calculateDaysBetweenJava8(startDate, endDate);
  89.     }
  90.    
  91.     public long calculateMonthsBetweenJava8(LocalDate startDate, LocalDate endDate) {
  92.         return AdvancedDateOperations.calculateMonthsBetweenJava8(startDate, endDate);
  93.     }
  94.    
  95.     public long calculateYearsBetweenJava8(LocalDate startDate, LocalDate endDate) {
  96.         return AdvancedDateOperations.calculateYearsBetweenJava8(startDate, endDate);
  97.     }
  98.    
  99.     public String calculatePeriodBetween(LocalDate startDate, LocalDate endDate) {
  100.         return AdvancedDateOperations.getPeriodDetails(
  101.             AdvancedDateOperations.calculatePeriodBetween(startDate, endDate));
  102.     }
  103.    
  104.     // 日期算术运算
  105.    
  106.     public LocalDate addDays(LocalDate date, long days) {
  107.         return DateArithmeticOperations.addDays(date, days);
  108.     }
  109.    
  110.     public LocalDate subtractDays(LocalDate date, long days) {
  111.         return DateArithmeticOperations.subtractDays(date, days);
  112.     }
  113.    
  114.     public LocalDate addMonths(LocalDate date, long months) {
  115.         return DateArithmeticOperations.addMonths(date, months);
  116.     }
  117.    
  118.     public LocalDate subtractMonths(LocalDate date, long months) {
  119.         return DateArithmeticOperations.subtractMonths(date, months);
  120.     }
  121.    
  122.     public LocalDate addYears(LocalDate date, long years) {
  123.         return DateArithmeticOperations.addYears(date, years);
  124.     }
  125.    
  126.     public LocalDate subtractYears(LocalDate date, long years) {
  127.         return DateArithmeticOperations.subtractYears(date, years);
  128.     }
  129.    
  130.     // 工作日计算
  131.    
  132.     public void setWeekendDays(List<java.time.DayOfWeek> days) {
  133.         workdayCalculator.setWeekendDays(new HashSet<>(days));
  134.     }
  135.    
  136.     public void addHoliday(LocalDate date) {
  137.         workdayCalculator.addHoliday(date);
  138.     }
  139.    
  140.     public void addHolidays(List<LocalDate> holidayList) {
  141.         workdayCalculator.addHolidays(holidayList);
  142.     }
  143.    
  144.     public void removeHoliday(LocalDate date) {
  145.         workdayCalculator.removeHoliday(date);
  146.     }
  147.    
  148.     public void addWorkdayOnWeekend(LocalDate date) {
  149.         workdayCalculator.addWorkdayOnWeekend(date);
  150.     }
  151.    
  152.     public void removeWorkdayOnWeekend(LocalDate date) {
  153.         workdayCalculator.removeWorkdayOnWeekend(date);
  154.     }
  155.    
  156.     public long calculateWorkdaysBetween(LocalDate startDate, LocalDate endDate) {
  157.         return workdayCalculator.calculateWorkdaysBetween(startDate, endDate);
  158.     }
  159.    
  160.     public List<LocalDate> getWorkdaysBetween(LocalDate startDate, LocalDate endDate) {
  161.         return workdayCalculator.getWorkdaysBetween(startDate, endDate);
  162.     }
  163.    
  164.     public LocalDate getNthWorkday(LocalDate startDate, int n) {
  165.         return workdayCalculator.getNthWorkday(startDate, n);
  166.     }
  167. }
复制代码

7.3 用户界面设计

让我们创建一个简单的Swing用户界面：
  2. package com.daycalculator.ui;
  4. import javax.swing.*;
  5. import java.awt.*;
  6. import java.awt.event.ActionEvent;
  7. import java.awt.event.ActionListener;
  8. import java.time.LocalDate;
  9. import java.time.format.DateTimeFormatter;
  10. import java.time.format.DateTimeParseException;
  11. import java.util.Arrays;
  12. import java.util.HashSet;
  13. import java.util.Set;
  14. import java.util.TimeZone;
  16. public class MainFrame extends JFrame {
  17.    
  18.     private DayCalculatorService service;
  19.     private JTabbedPane tabbedPane;
  20.    
  21.     public MainFrame() {
  22.         service = new DayCalculatorService();
  23.         initUI();
  24.     }
  25.    
  26.     private void initUI() {
  27.         setTitle("天数计算系统");
  28.         setSize(800, 600);
  29.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  30.         setLocationRelativeTo(null);
  31.         
  32.         tabbedPane = new JTabbedPane();
  33.         
  34.         // 添加各个功能面板
  35.         tabbedPane.addTab("日期差计算", new DateDifferencePanel(service));
  36.         tabbedPane.addTab("工作日计算", new WorkdayCalculatorPanel(service));
  37.         tabbedPane.addTab("节假日管理", new HolidayManagerPanel(service));
  38.         
  39.         add(tabbedPane, BorderLayout.CENTER);
  40.     }
  41.    
  42.     public static void main(String[] args) {
  43.         SwingUtilities.invokeLater(() -> {
  44.             MainFrame frame = new MainFrame();
  45.             frame.setVisible(true);
  46.         });
  47.     }
  48. }
  50. class DateDifferencePanel extends JPanel {
  51.    
  52.     private DayCalculatorService service;
  53.     private JTextField startDateField;
  54.     private JTextField endDateField;
  55.     private JButton calculateButton;
  56.     private JTextArea resultArea;
  57.    
  58.     public DateDifferencePanel(DayCalculatorService service) {
  59.         this.service = service;
  60.         initUI();
  61.     }
  62.    
  63.     private void initUI() {
  64.         setLayout(new BorderLayout(10, 10));
  65.         setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
  66.         
  67.         // 输入面板
  68.         JPanel inputPanel = new JPanel(new GridLayout(2, 2, 5, 5));
  69.         
  70.         inputPanel.add(new JLabel("开始日期 (yyyy-MM-dd):"));
  71.         startDateField = new JTextField();
  72.         inputPanel.add(startDateField);
  73.         
  74.         inputPanel.add(new JLabel("结束日期 (yyyy-MM-dd):"));
  75.         endDateField = new JTextField();
  76.         inputPanel.add(endDateField);
  77.         
  78.         // 按钮面板
  79.         JPanel buttonPanel = new JPanel();
  80.         calculateButton = new JButton("计算");
  81.         calculateButton.addActionListener(new CalculateButtonListener());
  82.         buttonPanel.add(calculateButton);
  83.         
  84.         // 结果面板
  85.         resultArea = new JTextArea(10, 30);
  86.         resultArea.setEditable(false);
  87.         JScrollPane scrollPane = new JScrollPane(resultArea);
  88.         
  89.         // 添加组件
  90.         add(inputPanel, BorderLayout.NORTH);
  91.         add(buttonPanel, BorderLayout.CENTER);
  92.         add(scrollPane, BorderLayout.SOUTH);
  93.     }
  94.    
  95.     private class CalculateButtonListener implements ActionListener {
  96.         @Override
  97.         public void actionPerformed(ActionEvent e) {
  98.             try {
  99.                 String startDateStr = startDateField.getText();
  100.                 String endDateStr = endDateField.getText();
  101.                
  102.                 if (startDateStr.isEmpty() || endDateStr.isEmpty()) {
  103.                     JOptionPane.showMessageDialog(DateDifferencePanel.this,
  104.                         "请输入开始日期和结束日期", "错误", JOptionPane.ERROR_MESSAGE);
  105.                     return;
  106.                 }
  107.                
  108.                 DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
  109.                 LocalDate startDate = LocalDate.parse(startDateStr, formatter);
  110.                 LocalDate endDate = LocalDate.parse(endDateStr, formatter);
  111.                
  112.                 // 计算各种日期差
  113.                 long daysBetween = service.calculateDaysBetweenJava8(startDate, endDate);
  114.                 long monthsBetween = service.calculateMonthsBetweenJava8(startDate, endDate);
  115.                 long yearsBetween = service.calculateYearsBetweenJava8(startDate, endDate);
  116.                 String periodBetween = service.calculatePeriodBetween(startDate, endDate);
  117.                
  118.                 // 显示结果
  119.                 StringBuilder result = new StringBuilder();
  120.                 result.append("日期差计算结果:\n\n");
  121.                 result.append("天数差: ").append(daysBetween).append(" 天\n");
  122.                 result.append("月数差: ").append(monthsBetween).append(" 个月\n");
  123.                 result.append("年数差: ").append(yearsBetween).append(" 年\n");
  124.                 result.append("详细间隔: ").append(periodBetween).append("\n");
  125.                
  126.                 resultArea.setText(result.toString());
  127.                
  128.             } catch (DateTimeParseException ex) {
  129.                 JOptionPane.showMessageDialog(DateDifferencePanel.this,
  130.                     "日期格式错误，请使用 yyyy-MM-dd 格式", "错误", JOptionPane.ERROR_MESSAGE);
  131.             } catch (Exception ex) {
  132.                 JOptionPane.showMessageDialog(DateDifferencePanel.this,
  133.                     "计算错误: " + ex.getMessage(), "错误", JOptionPane.ERROR_MESSAGE);
  134.             }
  135.         }
  136.     }
  137. }
  139. class WorkdayCalculatorPanel extends JPanel {
  140.    
  141.     private DayCalculatorService service;
  142.     private JTextField startDateField;
  143.     private JTextField endDateField;
  144.     private JButton calculateButton;
  145.     private JTextArea resultArea;
  146.     private JComboBox<String> weekendRuleCombo;
  147.     private JCheckBox excludeHolidaysCheck;
  148.    
  149.     public WorkdayCalculatorPanel(DayCalculatorService service) {
  150.         this.service = service;
  151.         initUI();
  152.     }
  153.    
  154.     private void initUI() {
  155.         setLayout(new BorderLayout(10, 10));
  156.         setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
  157.         
  158.         // 输入面板
  159.         JPanel inputPanel = new JPanel(new GridLayout(4, 2, 5, 5));
  160.         
  161.         inputPanel.add(new JLabel("开始日期 (yyyy-MM-dd):"));
  162.         startDateField = new JTextField();
  163.         inputPanel.add(startDateField);
  164.         
  165.         inputPanel.add(new JLabel("结束日期 (yyyy-MM-dd):"));
  166.         endDateField = new JTextField();
  167.         inputPanel.add(endDateField);
  168.         
  169.         inputPanel.add(new JLabel("周末规则:"));
  170.         weekendRuleCombo = new JComboBox<>(new String[]{
  171.             "周六周日为周末", "仅周日为周末", "周五周六为周末", "自定义周末"
  172.         });
  173.         inputPanel.add(weekendRuleCombo);
  174.         
  175.         excludeHolidaysCheck = new JCheckBox("排除节假日");
  176.         inputPanel.add(excludeHolidaysCheck);
  177.         inputPanel.add(new JLabel()); // 占位
  178.         
  179.         // 按钮面板
  180.         JPanel buttonPanel = new JPanel();
  181.         calculateButton = new JButton("计算工作日");
  182.         calculateButton.addActionListener(new CalculateButtonListener());
  183.         buttonPanel.add(calculateButton);
  184.         
  185.         // 结果面板
  186.         resultArea = new JTextArea(10, 30);
  187.         resultArea.setEditable(false);
  188.         JScrollPane scrollPane = new JScrollPane(resultArea);
  189.         
  190.         // 添加组件
  191.         add(inputPanel, BorderLayout.NORTH);
  192.         add(buttonPanel, BorderLayout.CENTER);
  193.         add(scrollPane, BorderLayout.SOUTH);
  194.     }
  195.    
  196.     private class CalculateButtonListener implements ActionListener {
  197.         @Override
  198.         public void actionPerformed(ActionEvent e) {
  199.             try {
  200.                 String startDateStr = startDateField.getText();
  201.                 String endDateStr = endDateField.getText();
  202.                
  203.                 if (startDateStr.isEmpty() || endDateStr.isEmpty()) {
  204.                     JOptionPane.showMessageDialog(WorkdayCalculatorPanel.this,
  205.                         "请输入开始日期和结束日期", "错误", JOptionPane.ERROR_MESSAGE);
  206.                     return;
  207.                 }
  208.                
  209.                 DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
  210.                 LocalDate startDate = LocalDate.parse(startDateStr, formatter);
  211.                 LocalDate endDate = LocalDate.parse(endDateStr, formatter);
  212.                
  213.                 // 设置周末规则
  214.                 int weekendRuleIndex = weekendRuleCombo.getSelectedIndex();
  215.                 switch (weekendRuleIndex) {
  216.                     case 0: // 周六周日为周末
  217.                         service.setWeekendDays(Arrays.asList(
  218.                             java.time.DayOfWeek.SATURDAY,
  219.                             java.time.DayOfWeek.SUNDAY));
  220.                         break;
  221.                     case 1: // 仅周日为周末
  222.                         service.setWeekendDays(Arrays.asList(
  223.                             java.time.DayOfWeek.SUNDAY));
  224.                         break;
  225.                     case 2: // 周五周六为周末
  226.                         service.setWeekendDays(Arrays.asList(
  227.                             java.time.DayOfWeek.FRIDAY,
  228.                             java.time.DayOfWeek.SATURDAY));
  229.                         break;
  230.                     case 3: // 自定义周末
  231.                         // 这里可以添加更复杂的自定义周末设置界面
  232.                         JOptionPane.showMessageDialog(WorkdayCalculatorPanel.this,
  233.                             "自定义周末功能待实现", "提示", JOptionPane.INFORMATION_MESSAGE);
  234.                         return;
  235.                 }
  236.                
  237.                 // 如果需要排除节假日，添加一些示例节假日
  238.                 if (excludeHolidaysCheck.isSelected()) {
  239.                     // 这里应该从数据库或配置文件加载节假日
  240.                     // 这里仅添加几个示例节假日
  241.                     service.addHoliday(LocalDate.of(2023, 1, 1)); // 元旦
  242.                     service.addHoliday(LocalDate.of(2023, 1, 21)); // 春节
  243.                     service.addHoliday(LocalDate.of(2023, 1, 22)); // 春节
  244.                     service.addHoliday(LocalDate.of(2023, 10, 1)); // 国庆节
  245.                 }
  246.                
  247.                 // 计算工作日
  248.                 long workdays = service.calculateWorkdaysBetween(startDate, endDate);
  249.                
  250.                 // 显示结果
  251.                 StringBuilder result = new StringBuilder();
  252.                 result.append("工作日计算结果:\n\n");
  253.                 result.append("工作日数量: ").append(workdays).append(" 天\n");
  254.                
  255.                 // 获取所有工作日列表
  256.                 java.util.List<LocalDate> workdayList = service.getWorkdaysBetween(startDate, endDate);
  257.                 result.append("\n工作日列表 (前10个):\n");
  258.                 for (int i = 0; i < Math.min(10, workdayList.size()); i++) {
  259.                     result.append(workdayList.get(i).toString()).append("\n");
  260.                 }
  261.                 if (workdayList.size() > 10) {
  262.                     result.append("... 共 ").append(workdayList.size()).append(" 个工作日\n");
  263.                 }
  264.                
  265.                 resultArea.setText(result.toString());
  266.                
  267.             } catch (DateTimeParseException ex) {
  268.                 JOptionPane.showMessageDialog(WorkdayCalculatorPanel.this,
  269.                     "日期格式错误，请使用 yyyy-MM-dd 格式", "错误", JOptionPane.ERROR_MESSAGE);
  270.             } catch (Exception ex) {
  271.                 JOptionPane.showMessageDialog(WorkdayCalculatorPanel.this,
  272.                     "计算错误: " + ex.getMessage(), "错误", JOptionPane.ERROR_MESSAGE);
  273.             }
  274.         }
  275.     }
  276. }
  278. class HolidayManagerPanel extends JPanel {
  279.    
  280.     private DayCalculatorService service;
  281.     private JTextField holidayField;
  282.     private JButton addButton;
  283.     private JButton removeButton;
  284.     private JTextArea holidayListArea;
  285.     private JButton loadSampleHolidaysButton;
  286.    
  287.     public HolidayManagerPanel(DayCalculatorService service) {
  288.         this.service = service;
  289.         initUI();
  290.     }
  291.    
  292.     private void initUI() {
  293.         setLayout(new BorderLayout(10, 10));
  294.         setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
  295.         
  296.         // 输入面板
  297.         JPanel inputPanel = new JPanel(new GridLayout(1, 2, 5, 5));
  298.         
  299.         inputPanel.add(new JLabel("节假日日期 (yyyy-MM-dd):"));
  300.         holidayField = new JTextField();
  301.         inputPanel.add(holidayField);
  302.         
  303.         // 按钮面板
  304.         JPanel buttonPanel = new JPanel(new GridLayout(1, 3, 5, 5));
  305.         addButton = new JButton("添加节假日");
  306.         addButton.addActionListener(new AddButtonListener());
  307.         removeButton = new JButton("移除节假日");
  308.         removeButton.addActionListener(new RemoveButtonListener());
  309.         loadSampleHolidaysButton = new JButton("加载示例节假日");
  310.         loadSampleHolidaysButton.addActionListener(new LoadSampleHolidaysListener());
  311.         buttonPanel.add(addButton);
  312.         buttonPanel.add(removeButton);
  313.         buttonPanel.add(loadSampleHolidaysButton);
  314.         
  315.         // 节假日列表面板
  316.         holidayListArea = new JTextArea(10, 30);
  317.         holidayListArea.setEditable(false);
  318.         JScrollPane scrollPane = new JScrollPane(holidayListArea);
  319.         
  320.         // 添加组件
  321.         add(inputPanel, BorderLayout.NORTH);
  322.         add(buttonPanel, BorderLayout.CENTER);
  323.         add(scrollPane, BorderLayout.SOUTH);
  324.     }
  325.    
  326.     private void updateHolidayList() {
  327.         // 由于我们的服务类没有提供获取节假日列表的方法，这里暂时显示示例文本
  328.         holidayListArea.setText("节假日列表功能待实现\n\n" +
  329.             "已添加的节假日将影响工作日计算结果。\n" +
  330.             "使用'加载示例节假日'按钮添加一些示例节假日。");
  331.     }
  332.    
  333.     private class AddButtonListener implements ActionListener {
  334.         @Override
  335.         public void actionPerformed(ActionEvent e) {
  336.             try {
  337.                 String holidayStr = holidayField.getText();
  338.                
  339.                 if (holidayStr.isEmpty()) {
  340.                     JOptionPane.showMessageDialog(HolidayManagerPanel.this,
  341.                         "请输入节假日日期", "错误", JOptionPane.ERROR_MESSAGE);
  342.                     return;
  343.                 }
  344.                
  345.                 DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
  346.                 LocalDate holidayDate = LocalDate.parse(holidayStr, formatter);
  347.                
  348.                 // 添加节假日
  349.                 service.addHoliday(holidayDate);
  350.                
  351.                 // 清空输入框
  352.                 holidayField.setText("");
  353.                
  354.                 // 更新节假日列表
  355.                 updateHolidayList();
  356.                
  357.                 JOptionPane.showMessageDialog(HolidayManagerPanel.this,
  358.                     "节假日添加成功", "成功", JOptionPane.INFORMATION_MESSAGE);
  359.                
  360.             } catch (DateTimeParseException ex) {
  361.                 JOptionPane.showMessageDialog(HolidayManagerPanel.this,
  362.                     "日期格式错误，请使用 yyyy-MM-dd 格式", "错误", JOptionPane.ERROR_MESSAGE);
  363.             } catch (Exception ex) {
  364.                 JOptionPane.showMessageDialog(HolidayManagerPanel.this,
  365.                     "添加失败: " + ex.getMessage(), "错误", JOptionPane.ERROR_MESSAGE);
  366.             }
  367.         }
  368.     }
  369.    
  370.     private class RemoveButtonListener implements ActionListener {
  371.         @Override
  372.         public void actionPerformed(ActionEvent e) {
  373.             try {
  374.                 String holidayStr = holidayField.getText();
  375.                
  376.                 if (holidayStr.isEmpty()) {
  377.                     JOptionPane.showMessageDialog(HolidayManagerPanel.this,
  378.                         "请输入要移除的节假日日期", "错误", JOptionPane.ERROR_MESSAGE);
  379.                     return;
  380.                 }
  381.                
  382.                 DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
  383.                 LocalDate holidayDate = LocalDate.parse(holidayStr, formatter);
  384.                
  385.                 // 移除节假日
  386.                 service.removeHoliday(holidayDate);
  387.                
  388.                 // 清空输入框
  389.                 holidayField.setText("");
  390.                
  391.                 // 更新节假日列表
  392.                 updateHolidayList();
  393.                
  394.                 JOptionPane.showMessageDialog(HolidayManagerPanel.this,
  395.                     "节假日移除成功", "成功", JOptionPane.INFORMATION_MESSAGE);
  396.                
  397.             } catch (DateTimeParseException ex) {
  398.                 JOptionPane.showMessageDialog(HolidayManagerPanel.this,
  399.                     "日期格式错误，请使用 yyyy-MM-dd 格式", "错误", JOptionPane.ERROR_MESSAGE);
  400.             } catch (Exception ex) {
  401.                 JOptionPane.showMessageDialog(HolidayManagerPanel.this,
  402.                     "移除失败: " + ex.getMessage(), "错误", JOptionPane.ERROR_MESSAGE);
  403.             }
  404.         }
  405.     }
  406.    
  407.     private class LoadSampleHolidaysListener implements ActionListener {
  408.         @Override
  409.         public void actionPerformed(ActionEvent e) {
  410.             try {
  411.                 // 添加一些示例节假日
  412.                 service.addHoliday(LocalDate.of(2023, 1, 1));   // 元旦
  413.                 service.addHoliday(LocalDate.of(2023, 1, 21));  // 春节
  414.                 service.addHoliday(LocalDate.of(2023, 1, 22));  // 春节
  415.                 service.addHoliday(LocalDate.of(2023, 1, 23));  // 春节
  416.                 service.addHoliday(LocalDate.of(2023, 1, 24));  // 春节
  417.                 service.addHoliday(LocalDate.of(2023, 1, 25));  // 春节
  418.                 service.addHoliday(LocalDate.of(2023, 1, 26));  // 春节
  419.                 service.addHoliday(LocalDate.of(2023, 1, 27));  // 春节
  420.                 service.addHoliday(LocalDate.of(2023, 4, 5));   // 清明节
  421.                 service.addHoliday(LocalDate.of(2023, 5, 1));   // 劳动节
  422.                 service.addHoliday(LocalDate.of(2023, 6, 22));  // 端午节
  423.                 service.addHoliday(LocalDate.of(2023, 6, 23));  // 端午节
  424.                 service.addHoliday(LocalDate.of(2023, 6, 24));  // 端午节
  425.                 service.addHoliday(LocalDate.of(2023, 9, 29));  // 中秋节
  426.                 service.addHoliday(LocalDate.of(2023, 9, 30));  // 中秋节
  427.                 service.addHoliday(LocalDate.of(2023, 10, 1));  // 国庆节
  428.                 service.addHoliday(LocalDate.of(2023, 10, 2));  // 国庆节
  429.                 service.addHoliday(LocalDate.of(2023, 10, 3));  // 国庆节
  430.                 service.addHoliday(LocalDate.of(2023, 10, 4));  // 国庆节
  431.                 service.addHoliday(LocalDate.of(2023, 10, 5));  // 国庆节
  432.                 service.addHoliday(LocalDate.of(2023, 10, 6));  // 国庆节
  433.                
  434.                 // 更新节假日列表
  435.                 updateHolidayList();
  436.                
  437.                 JOptionPane.showMessageDialog(HolidayManagerPanel.this,
  438.                     "示例节假日加载成功", "成功", JOptionPane.INFORMATION_MESSAGE);
  439.                
  440.             } catch (Exception ex) {
  441.                 JOptionPane.showMessageDialog(HolidayManagerPanel.this,
  442.                     "加载失败: " + ex.getMessage(), "错误", JOptionPane.ERROR_MESSAGE);
  443.             }
  444.         }
  445.     }
  446. }
复制代码

7.4 测试用例

让我们创建一些测试用例来验证我们的系统：
  2. package com.daycalculator.test;
  4. import com.daycalculator.core.DayCalculatorService;
  5. import org.junit.jupiter.api.Test;
  6. import static org.junit.jupiter.api.Assertions.*;
  8. import java.time.LocalDate;
  9. import java.time.Month;
  10. import java.util.Arrays;
  11. import java.util.List;
  13. public class DateCalculatorTest {
  14.    
  15.     private DayCalculatorService service = new DayCalculatorService();
  16.    
  17.     @Test
  18.     public void testCalculateDaysBetween() {
  19.         LocalDate startDate = LocalDate.of(2023, Month.JANUARY, 1);
  20.         LocalDate endDate = LocalDate.of(2023, Month.JANUARY, 10);
  21.         
  22.         long days = service.calculateDaysBetweenJava8(startDate, endDate);
  23.         assertEquals(9, days); // 不包括开始日期
  24.     }
  25.    
  26.     @Test
  27.     public void testCalculateWorkdaysBetween() {
  28.         LocalDate startDate = LocalDate.of(2023, Month.JANUARY, 2); // 周一
  29.         LocalDate endDate = LocalDate.of(2023, Month.JANUARY, 8); // 周日
  30.         
  31.         long workdays = service.calculateWorkdaysBetween(startDate, endDate);
  32.         assertEquals(5, workdays); // 周一到周五
  33.     }
  34.    
  35.     @Test
  36.     public void testCalculateWorkdaysWithHolidays() {
  37.         LocalDate startDate = LocalDate.of(2023, Month.JANUARY, 2); // 周一
  38.         LocalDate endDate = LocalDate.of(2023, Month.JANUARY, 8); // 周日
  39.         
  40.         // 添加一个节假日（周三）
  41.         service.addHoliday(LocalDate.of(2023, Month.JANUARY, 4));
  42.         
  43.         long workdays = service.calculateWorkdaysBetween(startDate, endDate);
  44.         assertEquals(4, workdays); // 周一、周二、周四、周五
  45.     }
  46.    
  47.     @Test
  48.     public void testDateArithmetic() {
  49.         LocalDate date = LocalDate.of(2023, Month.JANUARY, 1);
  50.         
  51.         LocalDate plus10Days = service.addDays(date, 10);
  52.         assertEquals(LocalDate.of(2023, Month.JANUARY, 11), plus10Days);
  53.         
  54.         LocalDate minus2Months = service.subtractMonths(date, 2);
  55.         assertEquals(LocalDate.of(2022, Month.NOVEMBER, 1), minus2Months);
  56.         
  57.         LocalDate plus1Year = service.addYears(date, 1);
  58.         assertEquals(LocalDate.of(2024, Month.JANUARY, 1), plus1Year);
  59.     }
  60.    
  61.     @Test
  62.     public void testGetNthWorkday() {
  63.         LocalDate startDate = LocalDate.of(2023, Month.JANUARY, 1); // 周日
  64.         
  65.         // 第5个工作日应该是周五
  66.         LocalDate nthWorkday = service.getNthWorkday(startDate, 5);
  67.         assertEquals(LocalDate.of(2023, Month.JANUARY, 6), nthWorkday);
  68.     }
  69.    
  70.     @Test
  71.     public void testCustomWeekend() {
  72.         // 设置周末只有周日
  73.         service.setWeekendDays(Arrays.asList(java.time.DayOfWeek.SUNDAY));
  74.         
  75.         LocalDate startDate = LocalDate.of(2023, Month.JANUARY, 2); // 周一
  76.         LocalDate endDate = LocalDate.of(2023, Month.JANUARY, 8); // 周日
  77.         
  78.         long workdays = service.calculateWorkdaysBetween(startDate, endDate);
  79.         assertEquals(6, workdays); // 周一到周六
  80.     }
  81. }
复制代码

8. 扩展功能和优化

8.1 性能优化

对于大量日期计算，我们可以进行一些性能优化：
  2. package com.daycalculator.core;
  4. import java.time.LocalDate;
  5. import java.util.List;
  6. import java.util.concurrent.ConcurrentHashMap;
  7. import java.util.concurrent.ConcurrentMap;
  9. public class OptimizedWorkdayCalculator extends CustomWorkdayCalculator {
  10.    
  11.     // 缓存计算结果
  12.     private ConcurrentMap<String, Long> workdayCache = new ConcurrentHashMap<>();
  13.     private ConcurrentMap<String, List<LocalDate>> workdayListCache = new ConcurrentHashMap<>();
  14.    
  15.     @Override
  16.     public long calculateWorkdaysBetween(LocalDate startDate, LocalDate endDate) {
  17.         String cacheKey = startDate.toString() + "_" + endDate.toString();
  18.         
  19.         // 检查缓存
  20.         Long cachedResult = workdayCache.get(cacheKey);
  21.         if (cachedResult != null) {
  22.             return cachedResult;
  23.         }
  24.         
  25.         // 计算结果
  26.         long result = super.calculateWorkdaysBetween(startDate, endDate);
  27.         
  28.         // 存入缓存
  29.         workdayCache.put(cacheKey, result);
  30.         
  31.         return result;
  32.     }
  33.    
  34.     @Override
  35.     public List<LocalDate> getWorkdaysBetween(LocalDate startDate, LocalDate endDate) {
  36.         String cacheKey = startDate.toString() + "_" + endDate.toString();
  37.         
  38.         // 检查缓存
  39.         List<LocalDate> cachedResult = workdayListCache.get(cacheKey);
  40.         if (cachedResult != null) {
  41.             return cachedResult;
  42.         }
  43.         
  44.         // 计算结果
  45.         List<LocalDate> result = super.getWorkdaysBetween(startDate, endDate);
  46.         
  47.         // 存入缓存
  48.         workdayListCache.put(cacheKey, result);
  49.         
  50.         return result;
  51.     }
  52.    
  53.     // 清除缓存
  54.     public void clearCache() {
  55.         workdayCache.clear();
  56.         workdayListCache.clear();
  57.     }
  58.    
  59.     // 清除特定日期范围的缓存
  60.     public void clearCacheForRange(LocalDate startDate, LocalDate endDate) {
  61.         String cacheKey = startDate.toString() + "_" + endDate.toString();
  62.         workdayCache.remove(cacheKey);
  63.         workdayListCache.remove(cacheKey);
  64.     }
  65. }
复制代码

8.2 国际化支持

为了支持多语言，我们可以添加国际化功能：
  2. package com.daycalculator.util;
  4. import java.text.MessageFormat;
  5. import java.util.Locale;
  6. import java.util.ResourceBundle;
  8. public class I18nSupport {
  9.    
  10.     private static final String BUNDLE_NAME = "messages";
  11.     private static ResourceBundle messages;
  12.     private static Locale currentLocale = Locale.getDefault();
  13.    
  14.     static {
  15.         loadMessages();
  16.     }
  17.    
  18.     public static void setLocale(Locale locale) {
  19.         currentLocale = locale;
  20.         loadMessages();
  21.     }
  22.    
  23.     private static void loadMessages() {
  24.         try {
  25.             messages = ResourceBundle.getBundle(BUNDLE_NAME, currentLocale);
  26.         } catch (Exception e) {
  27.             // 如果找不到指定语言的资源文件，使用默认语言
  28.             messages = ResourceBundle.getBundle(BUNDLE_NAME, Locale.ENGLISH);
  29.         }
  30.     }
  31.    
  32.     public static String getMessage(String key) {
  33.         try {
  34.             return messages.getString(key);
  35.         } catch (Exception e) {
  36.             return key; // 如果找不到消息，返回键名
  37.         }
  38.     }
  39.    
  40.     public static String getMessage(String key, Object... params) {
  41.         try {
  42.             String pattern = messages.getString(key);
  43.             return MessageFormat.format(pattern, params);
  44.         } catch (Exception e) {
  45.             return key; // 如果找不到消息，返回键名
  46.         }
  47.     }
  48. }
复制代码

创建资源文件：

• messages_en.properties（英文）
• messages_zh.properties（中文）

8.3 异常处理

创建自定义异常类：
  2. package com.daycalculator.exception;
  4. public class DateParseException extends Exception {
  5.    
  6.     public DateParseException() {
  7.         super();
  8.     }
  9.    
  10.     public DateParseException(String message) {
  11.         super(message);
  12.     }
  13.    
  14.     public DateParseException(String message, Throwable cause) {
  15.         super(message, cause);
  16.     }
  17.    
  18.     public DateParseException(Throwable cause) {
  19.         super(cause);
  20.     }
  21. }
复制代码

9. 总结和展望

9.1 项目总结

本项目实现了一个功能全面的天数计算系统，包括：

• 基础日期操作（创建、格式化、解析）
• 简单天数差计算
• 高级时间处理（时间段计算、日期加减）
• 工作日计算（排除周末和节假日）
• 自定义工作日规则
• 用户界面
• 性能优化
• 国际化支持

通过这个项目，我们学习了：

• Java日期时间API的使用
• 从传统的Date和Calendar到现代的java.time包
• 如何设计灵活的工作日计算系统
• 如何构建一个完整的Java应用程序
• 性能优化技巧
• 国际化支持

9.2 未来展望

未来可以考虑的扩展方向：

1. Web界面：将系统转换为Web应用，使用Spring Boot等框架
2. 移动应用：开发Android或iOS版本
3. 云服务：将计算功能部署为云服务，提供API接口
4. 更多日期计算功能：如农历支持、工作班次计算等
5. 数据库集成：持久化节假日和工作日规则
6. 更多性能优化：如并行计算、更高效的缓存策略等

通过这个项目，我们不仅学习了Java日期时间处理的各种技术，还了解了如何构建一个完整的应用程序。希望这个项目能够帮助读者在实际工作中处理各种日期计算需求。
回复

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则

友情链接

keba
磕巴白菜
别管 别听 就是玩
二次元论坛
二次元论坛
按下F逃离世界！
次元宅社
次元宅社
开放、共创，CHANGE SEKAI！
频道订阅

频道订阅

加入社群

加入社群

联系我们|TG频道|RSS

Powered by Pixtech

© 2025 Pixtech Team.