1. 最大的问题在于：没有恪守单一职责原理，代码中的许多方法如：isLeapYear,checkInputValidity,geNextDate方法，他们都没有做到单一职责，有的同时具有输出功能，有的甚至能改变某些变量的值，这确实是我认为最大的问题。
2. 变量命名还不是很规范，如mon_maxnum,借我老师的话评价，“这属于垃圾代码”......

典例精析

日期类设计

• 设计一个类DateUtil，该类有三个私有属性year、month、day（均为整型数），其中，year∈[1820,2020] ,month∈[1,12] ,day∈[1,31] , 除了创建该类的构造方法、属性的getter及setter方法外，需要编写如下方法：
  public boolean checkInputValidity();//检测输入的年、月、日是否合法
  public boolean isLeapYear(int year);//判断year是否为闰年
  public DateUtil getNextNDays(int n);//取得year-month-day的下n天日期
  public DateUtil getPreviousNDays(int n);//取得year-month-day的前n天日期
  public boolean compareDates(DateUtil date);//比较当前日期与date的大小（先后）
  public boolean equalTwoDates(DateUtil date);//判断两个日期是否相等
  public int getDaysofDates(DateUtil date);//求当前日期与date之间相差的天数
  public String showDate();//以“year-month-day”格式返回日期值

应用程序共测试三个功能：

1. 求下n天
2. 求前n天
3. 求两个日期相差的天数

下面是我用powerdesigner设计的类图：

初次使用就被这软件给征服了，以后需要设计的类多的时候，感觉会特别有用。

下面将详细的介绍我的整个分析过程：

1. 填补完基础的方法，如每个私有成员的getter,setter方法。
2. checkInputValid方法，判断日期是否有效，若无效，主函数中可直接输出错误提示并return;减少程序运行时间
3. isLeapYear方法，根据判断闰年的方法，返回相应的布尔值
4. getNextNDays方法，有两种思路：
   一：关键在于2月份，主要判断当天日期是否在2月份之后（或之前），在结合该年是否为闰年。
   二：第二种思路就是以年份来考虑，总变化天数为n天后的日期加上今年已发生的天数，后面直接用总天数对每一年进行处理，以此类推，年份循环结束后继续月份循环，月份循环结束后，天数可以直接算出来。
   相较而言，第二种思路逻辑更清晰一点
5. getPreviousNDays方法，类似于getNextNDays方法，不过多赘述了。
6. compareDates方法，按照年月日顺序分别比较即可。
7. equalTwoDates方法，直接比较两个日期的年月日。
8. getDaysofDates方法，此处沿用getNextNDays跟getPreviousDates的方法，分别对应的求出总天数，然后固定一方的年份，另一方逐渐增加（或减少）天数向其逼近至相等，然后也是年循环结束弄月循环，月循环结束，最后比较二者的天数，求出最终结果。
9. showDate方法，这里值得注意的是，它返回的是String类型，所以要到主程序查看它是在什么情况下被调用的，以此写出合适的代码。

下面是我的代码：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int year = 0;
        int month = 0;
        int day = 0;

        int choice = input.nextInt();

        if (choice == 1) { // test getNextNDays method
            int m = 0;
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            DateUtil date = new DateUtil(year, month, day);

            if (!date.checkInputValidity()) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            m = input.nextInt();

            if (m < 0) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            System.out.print(date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " next " + m + " days is:");
            System.out.println(date.getNextNDays(m).showDate());
        } else if (choice == 2) { // test getPreviousNDays method
            int n = 0;
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            DateUtil date = new DateUtil(year, month, day);

            if (!date.checkInputValidity()) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            n = input.nextInt();

            if (n < 0) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            System.out.print(
                    date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " previous " + n + " days is:");
            System.out.println(date.getPreviousNDays(n).showDate());
        } else if (choice == 3) {    //test getDaysofDates method
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            int anotherYear = Integer.parseInt(input.next());
            int anotherMonth = Integer.parseInt(input.next());
            int anotherDay = Integer.parseInt(input.next());

            DateUtil fromDate = new DateUtil(year, month, day);
            DateUtil toDate = new DateUtil(anotherYear, anotherMonth, anotherDay);

            if (fromDate.checkInputValidity() && toDate.checkInputValidity()) {
                System.out.println("The days between " + fromDate.showDate() +
                        " and " + toDate.showDate() + " are:"
                        + fromDate.getDaysofDates(toDate));
            } else {
                System.out.println("Wrong Format");
                System.exit(0);
            }
        }
        else{
            System.out.println("Wrong Format");
            System.exit(0);
        }
    }
}
class DateUtil{
    private int year,month,day;
    private int yearDay=365;
    int [] mon_maxday={0,31,28,31,30,31,30,31,31,30,31,30,31};
    public DateUtil(){

    }
    public DateUtil(int year,int month ,int day){
        this.year=year;
        this.day=day;
        this.month=month;
    }
    public int getYear() { return year; }
    public int getMonth() {
        return month;
    }
    public int getDay() {
        return day;
    }
    public void setYear(int year) {
        this.year = year;
    }
    public void setMonth(int month) {
        this.month = month;
    }
    public void setDay(int day) {
        this.day = day;
    }
    public boolean checkInputValidity(){//检测输入的年、月、日是否合法
        if(isLeapYear(year))
            mon_maxday[2]=29;
        if(year<1820||year>2020||month>12||month<1||day<1||day>mon_maxday[month]){
            return false;
        }
        return true;
    }
    public boolean isLeapYear(int year){//判断year是否为闰年
        if((year%100!=0&&year%4==0)||(year%400==0)){
            mon_maxday[2]=29;
            yearDay++;
            return true;
        }
        return false;
    }
    public DateUtil getNextNDays(int n){//取得year-month-day的下n天日期
        while(n > 365){//为什么不先讨论n<0&&n>365:n>365时只需要对年进行讨论，再对天进行讨论
            if(this.isLeapYear(year) && month<=2){//这一年是闰年且月份小于等于2
                if(month==2&&day==29){
                    day = 1;
                    month = 3;
                }
                year++;
                n=n-366;
            }
            else if(this.isLeapYear(year+1) && month>2){//下一年是闰年且月份大于二
                year++;
                n=n-366;
            }
            else{
                year++;
                n=n-365;
            }
        }//先对年进行讨论
        while(n>0&&n<365) { //n<365时
                for (int i = 0; i < n; i++) {
                    day++;
                    if (this.isLeapYear(year) && month == 2) { //与上面一样再讨论闰年和月份等于2的情况
                        if (day > 29) {
                            month++;
                            day = 1;
                        }
                    } else if (day > mon_maxday[month]){//月份不为2的情况
                        month++;
                        day = 1;
                        if (month > 12) { //最后一个月的情况
                            month = 1;
                            year++;
                        }
                    }
                }
            }
        return this;
    }
    public DateUtil getPreviousNDays(int n){
        DateUtil d = new DateUtil(this.year,this.month,this.day);
        for (int i = 0; i < n; i++) {
            if(this.isLeapYear(year))//判断是否为闰年
                mon_maxday[2] = 29;
            else
                mon_maxday[2] = 28;
            d.day--;
            if(d.day == 0){//日期减为0
                d.month--;
                if(d.month == 0){//月份减为0
                    d.year--;
                    d.month = 12;
                }
                d.day = mon_maxday[d.month];
            }

        }
        return d;
    }

    public boolean compareDates(DateUtil date){
            if(this.year > date.getYear())
                return true;
            else if(this.year == date.year && this.month > date.month)
                return true;
            else {
                if(this.month>date.month)
                    return true;
                else if(this.month<date.month)
                    return false;
                else{
                    if(this.day>date.day)
                        return true;
                    else if(this.day<date.day)
                        return false;
                }
            }
            return true;
        }
        public boolean equalTwoDates(DateUtil date){
            return this.year == date.year && this.month == date.month && this.day == date.day;
        }
    public int getDaysofDates(DateUtil date){
    int res = 0;
        if(this.equalTwoDates(date))
            return 0;
        if(this.compareDates(date)){
            while(true){
            if(isLeapYear(date.year))
                mon_maxday[2] = 29;
            else
                mon_maxday[2] = 28;
            date.day++;
            if(date.day == mon_maxday[date.month]+1){
                date.month++;
                date.day = 1;
            }
            if(date.month == 13){
                date.year++;
                date.month=1;
            }
            if(date.year == year && date.month == month && date.day == day){
                break;
            }
            res++;
        }
        }else{
        while(true){
            if(isLeapYear(year))
                mon_maxday[2] = 29;
            else
                mon_maxday[2] = 28;
            day++;
            if(day == mon_maxday[month] + 1){
                month++;
                day = 1;
            }
            if(month == 13){
                year++;
                month = 1;
            }
            if(date.year == year && date.month == month && date.day == day){
                break;
            }
            res++;
        }

    }
        return res + 1;
}

    public String showDate(){
        return this.year + "-" + this.month + "-" + this.day;
    }

}

踩坑心得

因为较为习惯了C/C++,换成Java很多地方容易出错，这里我列举一下自己的几种错误：

1. 用String直接比较另一个String
   这个错误我研究了很久，因为我想String作为一个这么常用的类，一定是能够去比较的，然后我用C++STL里的string类比过来，整的一堆红色报错。
   
   C++里string 可以直接加string 或者 char
   C++里string 可以直接进行等值判断。
   java里的String比较固定（从类的定义里就可以看出Java比C++稳定）
   java的String只能跟String比较（即使值相同，结果也可能是false）
   java的String可以加char,也可以加String,但是不能加s[0]（如果说有个String s="123"）
   
   原理深究：
   因为在Java中，进行String比较时，比较的是二者的地址，尽管二者的字符串可能一模一样，但二者地址不同也会返回false.
   
   解决方案：
   使用String类的equals函数，它会比较两String的值。

2. Arraylist使用不当，直接用[ ]进行下标索引
   Arraylist的功能相当于C++STL里的vector
   
   C++里的vector可以直接用下标索引元素
   C++里的vector可以进行resize操作（这个功能可以对大量数据初始化，很重要！）
   
   Java里的ArrayList不可进行下标索引，要使用对应的get,set方法（再次体现了java的严谨）
   java里的ArrayList不可以直接改变空间，只能检测元素个数（size）
   
   解决方案:
   使用Collections.ncopies方法（需要引入Collections）方法示例：

ArrayList<T> obj = new ArrayList<T>(Collections.nCopies(count,element));//把element复制count次填入ArrayList中

综述

通过这三次的java实践，我对java有了一定的认知：

从语言本身来说，java的各种语法，编程规则，类的设计，都体现了它是一门很“成熟”的语言，特别适合多人协作，这种“成熟”在市场中很重要，然而，因为它的这种特性，C++相对java更为灵活，C++可以重载运算符，而Java不行，从算法层面上说，java得记住更多的由别人定义好的方法，而C++只需要通过改动某些类中的运算符，或重载其函数，很容易就能契合算法题的需求。但C++缺点也极其明显，就是重载之后，容易出问题，合作起来非常困难。

收获：

1. 掌握了java的基本语法
2. 初步了解一些java关于内存，引用等原理层面的东西。

近期目标：

1. 学习Java中常用的API，熟练掌握以提高效率。（非常有必要）
2. 熟悉Ideal的各种操作，用ideal练习多个类的经典项目。
3. 了解Java中的设计模式（在此过程中，同时要逐步理解多线程相关知识）

杂谈

• 2023/3/23，心情复杂
  今年，2023年，我刚入大一（现在是下学期），22年的那个寒假，chatgpt3.5横空出世，当时的我被它强大的功能给深深震撼到了，那时的我觉得自己很幸运，对比起无数的前辈们，chatgpt在我年富力强之际出现，可以帮我写文案，可以回答我的各种问题，无疑是帮了我大忙（最重要的是节省了很多时间）。这一年的我，17岁。
• 2023年的3月14日，当我还在听反诈主题宣讲课时，chatgpt4.0出来了，我去试了一下，最大的改变是能识别图片，还有实时更新网络数据，它的迭代速度肉眼可见的快，所以我认为要不了多久，视频和音频也不在话下了（现在其实已经有别的机构用chatgpt做出了相关实验）
• 我觉得悲伤的地方在于，我高考选的，认为前景不错的专业，软件工程，可能逐渐要被时代淘汰了。参考下面的链接：
  GPT的火爆，可能正在“杀死”软件工程
  即使这个UP说的不全对，只信一半的话，软件工程确实面临着很大的被时代淘汰的危机。
• 所以，客观分析一下我现在的处境：相对周围人，我是个比较“卷”的人，然而，无论我怎么去卷那些经验知识，我卷的过AI吗？即使是我认为软件行业壁垒数一数二的算法领域，AI迭代发展的也必定会超过人类（现在的chatgpt4.0参加codeforces上的比赛得分能超过一半参赛者）
• 面对这样的处境，我自然而然的联想到了一句老话：“打不过就加入”。未来时代需要的肯定是结合了AI知识的程序员，不谈创造AI，至少要懂AI，能够维修AI设备里的问题，不过这样的工作壁垒也不高，因为未来的AI肯定能根据用户的指令自我修改，而这种工作需要的不是程序员，而是“AI咒语师”。不过对于现在刚入计算机专业的我而言，大方向是肯定的，我要花时间去学会使用AI，先玩明白，再去学习相关知识。
• “迷茫的时候，就先学好眼前知识”，这句话是我高中所称作的圣经。因为高中想再多也没有用，学习一定是高中阶段的最优解，唯一的使命就是高考考好。现在到了大学，我能感受到自己拥有更多的自由，能够进行更多的选择，“学好眼前知识”成为了局部最优解，更多时候需要我去思考，思考自己的未来。

写下这篇杂谈，记录一下自己作为一个新时代的见证者，等我大四的时候，可能一切就已经翻天覆地了。