Java初学者最近三次作业的心得体会

　　作为一个初学者，简单的谈一下自己的作业心得体会。如果你是完全没有接触过Java的学习，本篇博文可能会有些收获，如果你已经学习Java有一段时间了，那么可以放弃这篇文章了，因为这篇文章讲解的是基本的东西，甚至因为学习深度原因可能会有所错误，仅作为了解Java入门的浅显资料。

Java的基础结构我就不多赘述了，网络上有非常详细的资料，我平常最多使用的是菜鸟教程https://www.runoob.com/java/java-tutorial.html，可以简单了解非常基础。

直接进入正题

初学者的最近的三次作业例题：

　　（1）第一次作业例题：

　　(代码仅作参考)

　　统计最大数出现次数

　　编写程序读取一系列整数，找出它们的最大数，然后计算该数的出现次数，假定输入以0结束。

 import java.util.Scanner;

 public class Main {

     public static void main(String[] args) {
         Scanner input = new Scanner(System.in);
         int[] complete;
         int max = 0;
         int i=0;
         int n=0;
         int count = 0;
         complete = new int[10];
         do {

             complete[i] = input.nextInt();
             i++;
             n++;
         }while(complete[i-1]!=0);
         for (i = 0; i<n; i++) {
             if(max==complete[i])
                 count++;
             else if(complete[i]>max) {
                 max=complete[i];
                 count=1;
             }
         }
         System.out.println("The largest number is " + max);
         System.out.print("The occurrence count of the largest number is " + count);
     }

 }

第一次作业代码示例

（2）第二次作业例题

求下一天：

输入年月日的值（均为整型数），输出该日期的下一天。 其中：年份的合法取值范围为[1820,2020] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] 。 注意：不允许使用Java中和日期相关的类和方法。

要求：Main类中必须含有如下方法，签名如下：

public static void main(String[] args)；//主方法

public static boolean isLeapYear(int year) ;//判断year是否为闰年，返回boolean类型

public static boolean checkInputValidity(int year,int month,int day);//判断输入日期是否合法，返回布尔值

public static void nextDate(int year,int month,int day) ; //求输入日期的下一天

 import java.util.Scanner;
 public class Main {

     public static void main(String[] args) {
         Scanner input = new Scanner(System.in);
         int year = input.nextInt();
         int month = input.nextInt();
         int day = input.nextInt();
         if(checkInputValidity(year,month,day)) {
             System.out.println("Wrong Format");
         }
         else {
             nextDate(year,month, day);

         }

     }
     public static boolean isLeapYear(int year) {
         boolean a = false;
         if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
             a = true;
         return a;
     }
     public static boolean checkInputValidity(int year,int month,int day) {
         boolean a = false;
         if (year < 1820 || year > 2020 || month < 1 || month > 12 || day < 1 || day > 31||((!isLeapYear(year)&&month==2&&day>28)))
             a = true;
         return a;
     }
     public static void nextDate(int year,int month,int day) {
         int a[]= {31,29,31,30,31,30,31,31,30,31,30,31};//闰年日期
         int b[]= {31,28,31,30,31,30,31,31,30,31,30,31};//非闰年日期
         if(month==12&&day==31) {
             year++;
             month=1;
             day=1;
         }
         else if(isLeapYear(year)) {
             if(day==a[month-1]) {
                 month++;
                 day=1;
             }
             else
                 day++;
         }
         else {
             if(day==b[month-1]) {
                 month++;
                 day=1;
             }
             else
                 day++;
         }
         System.out.println("Next date is:"+year+"-"+month+"-"+day);
     }

 }

第二次作业代码示例

（3）第三次作业例题

日期类设计：

参考题目集二中和日期相关的程序，设计一个类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.求两个日期相差的天数

 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 static final DateUtil DateUtil = null;
     int a[] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };// 闰年日期
     int b[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };// 非闰年日期
     private int year;
     private int month;
     private int day;
     public int getYear() {
         return year;
     }
     public void setYear(int year) {
         this.year = year;
     }
     public int getMonth() {
         return month;
     }
     public void setMonth(int month) {
         this.month = month;
     }
     public int getDay() {
         return day;
     }
     public void setDay(int day) {
         this.day = day;
     }
     public DateUtil(int year2, int month2, int day2) {
         year = year2;
         month = month2;
         day = day2;
     }
     public boolean checkInputValidity() {//检测输入的年、月、日是否合法
         boolean a = true;
         if (year < 1820 || year > 2020 || month < 1 || month > 12 || day < 1 || day > 31||((!isLeapYear(year)&&month==2&&day>28))||((isLeapYear(year)&&month==2&&day>29)))
             a = false;
         return a;
     }
     public boolean isLeapYear(int year) {//判断year是否为闰年
         boolean a = false;
         if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
             a = true;
         return a;
     }
     public DateUtil getNextNDays(int n) {//取得year-month-day的下n天日期
         DateUtil date = new DateUtil(year, month, day);
         long c = (long) n;
         long d = (long) date.day;
         long sum = c + d;
         while(sum>a[date.month-1]||sum>b[date.month-1]) {
             if(isLeapYear(date.year)) {//瑞年
                 while(sum>a[date.month-1]) {//计算瑞年天
                     sum = sum -a[date.month -1];
                     if(date.month == 12) {
                         date.year++;
                         date.month=1;
                         if(!isLeapYear(date.year)) {
                             break;
                         }
                     }else {
                         date.month++;
                     }
                 }

             } else{//非瑞年
                 while(sum>b[date.month-1]) {//计算非瑞年天
                     sum = sum -b[date.month -1];
                     if(date.month == 12) {
                         date.year++;
                         date.month=1;
                         if(isLeapYear(date.year)) {
                             break;
                         }
                     }else {
                         date.month++;
                     }
                 }

             }
         }
         int Sum = new Long(sum).intValue();
         date.day = Sum;
         return date;

     }
     public DateUtil getPreviousNDays(int n) {//取得year-month-day的前n天日期
         DateUtil date = new DateUtil(year, month, day);
         int sum = n;
         if(n!=0) {
             date.day--;
         }

         if(sum>date.day) {//减去原始天数
             sum = sum -date.day;
             date.month--;
             if(isLeapYear(date.year)) {
                 date.day = a[date.month-1];
             }else {
                 date.day = b[date.month-1];
             }
         }else if(sum==date.day) {
             sum=0;
             if(date.month==1) {
                 date.year--;
                 date.month=12;
                 if(isLeapYear(date.year)) {
                     date.day = a[date.month-1];
                 }else {
                     date.day = b[date.month-1];
                 }
             }
             date.month--;
             if(isLeapYear(date.year)) {
                 date.day = a[date.month-1];
             }else {
                 date.day = b[date.month-1];
             }

         }
         while(sum>=date.day) {
             if(isLeapYear(date.year)) {//瑞年
                 while(sum>=date.day) {
                     if(date.month==1) {
                         date.year--;
                         date.month=12;
                         if(sum>=b[date.month-1]) {
                             date.day = b[date.month-1];
                             sum = sum-date.day;
                         }else {
                             date.day = b[date.month-1];
                             sum = date.day-sum;
                         }
                     }
                     else if(sum>=a[date.month-1]) {
                         date.day = a[date.month-1];
                         sum = sum-date.day;
                         date.month--;
                     }
                     else {
                         date.day = a[date.month-1];
                         sum = date.day-sum;
                         date.month--;
                     }

                     if(!isLeapYear(date.year)) {
                         break;
                     }
                 }
             }else {//非瑞年
                 while(sum>=date.day) {
                     if(date.month==1) {
                         date.year--;
                         date.month=12;
                         if(sum>=b[date.month-1]) {
                             date.day = b[date.month-1];
                             sum = sum-date.day;
                         }else {
                             date.day = b[date.month-1];
                             sum = date.day-sum;
                         }
                     }
                     else if(sum>=b[date.month-1]) {
                         date.day = b[date.month-1];
                         sum = sum-date.day;
                         date.month--;
                     }
                     else {
                         date.day = b[date.month-1];
                         sum = date.day-sum;
                         date.month--;
                     }

                     if(isLeapYear(date.year)) {
                         break;
                     }
                 }
             }
         }
         date.day =date.day-sum;
         return date;
     }
     public boolean compareDates(DateUtil date) {//比较当前日期与date的大小（先后）
         boolean a = false;
         if(year>date.year||year==date.year&&month>date.month||year==date.year&&month==date.month&&date.day>day) {
             a = true;
         }
         return a;
     }
     public boolean equalTwoDates(DateUtil date) {//判断两个日期是否相等
         boolean a = false;
         if(year==date.year&&month==date.month&&date.day==day) {
             a = true;
         }
         return a;
     }
     public int getDaysofDates(DateUtil date) {//求当前日期与date之间相差的天数
         int sum = 0;
         if(!equalTwoDates(date)) {
             if(!compareDates(date)) {//date.year>year
                 while(date.year>year) {
                     if(isLeapYear(year)) {
                         year++;
                         sum+=366;
                     }else {
                         year++;
                         sum+=365;
                     }

                 }
                 if(isLeapYear(year)) {
                     while(date.month>month) {
                         sum+=a[month-1];
                         month++;
                     }
                 }else {
                     while(date.month>month) {
                         sum+=b[month-1];
                         month++;
                     }
                 }if(day>date.day) {
                     sum+=day-date.day;
                 }else{
                     sum+=date.day-day;
                 }
             }else {//year>date.year
                 while(year>date.year) {
                     if(isLeapYear(date.year)) {
                         date.year++;
                         sum+=366;
                     }
                     else {
                         date.year++;
                         sum+=365;
                     }
                 }
                 if(isLeapYear(date.year)) {
                     while(month>date.month) {
                         sum+=a[date.month-1];
                         date.month++;
                     }
                 }else {
                     while(month>date.month) {
                         sum+=b[date.month-1];
                         date.month++;
                     }
                 }
                 if(day>date.day) {
                     sum+=day-date.day;
                 }else{
                     sum+=date.day-day;
                 }
             }
         }
         return sum;
     }
     public String showDate() {//以“year-month-day”格式返回日期值
         return year+"-"+month+"-"+day;
     }

 }

第三次作业代码示例　　

　　

初学者第一次学习Java的时候，最懵的是类与对象，而Java是面向对象的语言，什么是类，什么是对象？

对象：对象是类的一个实例，有状态和行为。

类：类是一个模板，它描述一类对象的行为和状态。

这是一般的说法，刚接触java时有些看不懂，但如果你学习过一段时间的Java回头去看这两句话却会有种恍然大悟的感觉，发现这两句话描述的十分准确，不过对于初学者来说理解这两句话就有些困难了。

举个例子让我们来理解一下面向对象与面向过程的区别：

　　就像人走路

　　面向过程可能是这样实现的，大脑中枢一级一级的传递信息，再传递给肌肉，你的左脚或者你的右脚动了动了，让后再一级一级的传递信息，你的另一只脚动了，你便实现了走路。

　　而面向对象可能是这样实现的，大脑告诉左脚：动，然后告诉另一只脚：动，你就实现了走路。

　　你的脚就可以创建一个类，它有温度等其他状态，也有内部神经传递的行为。而类是虚的抽象的，可以想象一下3D打印机，类是在电脑中创建的模型，你需要打印出来才能成为对象，它才能实现各种功能，不同对象可以根据状态区分，不仅能打印出来41码的脚，还能打印出来42码的脚。

　　我们可以清晰的看到，作业代码的长度是逐渐增加的，代码的难度也是逐渐增加的，但我们关注的重点是代码的演变，这是一个从面向过程到面向对象的演变过程。因为刚接触java时，第一次作业难度并不高，因为所有功能都能在Main类里快速实现，把Main类当成C语言的main函数一样使用，实现方法更像是面向过程的语言；第二次作业根据作业要求，让人有意识地在Main类中添加了方法，但思想上还是停留在函数上，思想上觉得方法类似于C语言函数调用；第三次作业在Main类之外又写了新类DateUtil，之后又在DateUtil的基础上写了Year、Month、Day、等类，一次次作业让我们将面向过程的思想过渡为面向对象的思想，这时候就渐渐的感觉到了两者的不同。

　　其实，面向过程与面向对象都是只是一种思维方式，根据第一次作业，我们能够用面向过程的思维方式实现代码功能，但假如后两次作业没有前置条件，我们也能用面向过程的思维方式实现代码共能，相对而言面向对象的思维方式更像是我们平常的思考方式，就好像走路，我们只要给左右脚下达命令，我们就能实现走路的目标。

　　当你理解了面向对象的思想，剩余需要注意的就是代码的严谨性。例如求日期的上N天日期，你要考虑月份减一，年份减一，瑞年与非瑞年的情况等等，常常会因为代码结构或者逻辑算法不够严谨而付出代价，这个代价往往是大量检验与修改的时间。当谈到检验呢，就不得不说代码测试的重要性，当我们的代码出现了问题。对于新手来说一般会遇到两个问题，一个是不知道自己错在哪，一个是知道哪错了不会改，前者的问题往往比后者更严重；知道了错误方式网络上有大量的教程，可不知道自己哪错了便无从下手。拥有一个好的测试方式可以快速准确的找到自己的错误点，以“上N天”为例，我检测的方式往往是特殊值，边界值，由小及大，但还是浪费了大量的时间，因为往往是屡改屡错，让人抓狂。但是如果不进行测试，单单凭借自己的思考：代码哪里出现了错误？略短的代码可能稍加思考便可找出，但随着代码复杂程度的增加，这种方式变得越来越不可能。

　　再说回代码的严谨性，如果你最开始的时候便进行了严谨的考虑，那么你后续的工作会轻松不少；如若不是，那你可能就要万里长征了。

　　在文章的最后，感谢各位可以看到这里。在Java学习中，实践大于理论，更多的实际操作，往往会得到更好的学习效果。鄙人初学四周，一些心得体会，也是希望自己未来在Java学习方面取得更好的成果。