Java博客作业

Posted 2023-03-26 cmzs

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java博客作业相关的知识，希望对你有一定的参考价值。

一、前言

对于我来说，自己学习一门新的语言难度是十分大的，在一边学习一边完成作业的过程中，我学习到了很多关于java语言的使用技巧，但也由于不够熟练而导致作业的完成度不高,对此我只能通过以后的继续学习来增强自己的能力，更好地完成作业。

PTA的第一次作业总体来说难度系数不是很大，但题量很大。前四题都是考查if else选择结构，拥有C语言的基础，完成起来比较轻松，唯一困难的就是自己学习java的语法。但是从5，6题难度上升，当时也卡了我很久，现在看来其实也没有特别难，只是当时刚接触java，很难想到思路。后面几题除了第十题没太看明白之外，都有一定的思路，但是难以达到想象中的效果。
第二次作业题量大，时间紧，总体难度系数有所上涨，主要还是考查if else语句的使用与嵌套，但个别题目我使用了switch结构。更多考查了我们对条件的判断，如第五题和第九题。其中第九题考查了方法的使用。
第三次作业题量小，但难度大幅度上升，主要考查了对类的定义设计与使用。

二、设计与分析

挑选个别题目进行分析

第一次作业

7-1 计算年利率

输入格式: 输入一个整数。

输出格式: 实际利率=x.xx%

思路：使用if else嵌套来完成

源码如下：

import java.util.Scanner;
public class Main
    public static void main(String[] args)
    
        Scanner a = new Scanner (System.in);
        int y=a.nextInt();
        double level;
        double n=7.7;
        if(y>0)
        
            if (y<=1)
                level=n/2;
            else if (y<=3)
                level=n*0.7;
            else if(y<=5)
                level=n;
            else level=1.1*n;
            System.out.printf("实际利率=");
            System.out.printf("%.2f",level);
            System.out.print("%");
        
        else 
        System.out.println("error");

7-2 身体质量指数（BMI）测算

体重是反映和衡量一个人健康状况的重要标志之一，过胖和过瘦都不利于健康，BMI（身体质量指数）计算方法：体重（以千克为单位）除以身高（以米为单位）的平方。中国成人正常的BMI应在18.5-24之间，如果小于 18.5为体重不足，如果大于等于24为超重，大于等于28为肥胖。请编写程序，测算身体状态。

思路：同样还是使用if else嵌套来完成

源码如下：

import java.util.Scanner;
public class Main
    public static void main(String[] args)
    
        Scanner a =new Scanner(System.in);
        double w=a.nextDouble();
        double h=a.nextDouble();
        if(w<0||h<0||w>727||h>2.72)
            System.out.println("input out of range");
         else
             double BMI=w/(h*h);
             if(BMI<18.5)
                 System.out.println("thin");
             else if(BMI<24)
                 System.out.println("fit");
             else if(BMI<28)
                 System.out.println("overweight");
             else System.out.println("fat");

7-3 九九乘法表(双重循环)

打印九九乘法表。

输入格式：一个整数n。

输出格式：乘法表的前n行。

思路：使用for循环的嵌套

源码如下：

import java.util.Scanner;
public class Main
    public static void main(String[] args)
    
        Scanner a =new Scanner(System.in);
        int n=a.nextInt();
        if(n>9||n<1)
            System.out.println("INPUT ERROR.");
        else 
            int i,j;
        for(i=1;i<=n;i++)
          for (j=1;j<=i;j++) 
              if(j!=i)
               System.out.printf(i+"X"+j+"="+i*j+"\\t"); 
             else
               System.out.printf(i+"X"+j+"="+i*j);
          
             

       System.out.println();

7-5 去掉重复的字符

输入一个字符串，输出将其中重复出现的字符去掉后的字符串

输入格式：一行字符串

输出格式：去掉重复字符后的字符串

思路：一开始想了很久也没想出来，后面通过翻书和查阅资料学习了charAt方法及StringBuffer类的attend方法写了出来

源码如下：

import java.util.Scanner;
public class Main
    public static void main(String[] args) 
        Scanner a=new Scanner(System.in);
        String b=a.nextLine();
        StringBuffer x=new StringBuffer();
        int i;
        for(i=0;i<b.length();i++) 
            char c=b.charAt(i);
            if(b.indexOf(c)==i) 
                x.append(c);
            
        
        System.out.println(x);

7-7 有重复的数据

输入格式：你的程序首先会读到一个正整数n,n∈[1,100000]，然后是n个整数。

输出格式：如果这些整数中存在重复的，就输出：YES 否则，就输出：NO

思路：使用了两个for循环进行嵌套，在eclipse上运行没有问题，但在pta上报错，说内存超限或运行超时，不知道如何改进

源码如下：

import java.util.Scanner; 
        public class Main 
            public static void main(String[] args) 
                Scanner a=new Scanner(System.in);
                 int n=a.nextInt();
                    int[] aa=new int[n];  
                for(int j=0;j<aa.length;j++)
                    aa[j]=a.nextInt();
        int flag=0;
                for(int i=0;i<aa.length;i++)
                    for(int j=i+1;j<aa.length;j++)
                    
                        if(aa[i]==aa[j])
                        flag=1;
                    
                        
                if(flag==1)
                    System.out.printf("YES");
                else System.out.printf("NO");

第二次作业

7-1 长度质量计量单位换算

长度、质量的计量有多重不同的计算体系，有标准的国际单位制：千克与米，也有各个国家自己的计量方法如：磅、英寸；1磅等于0.45359237千克，1英寸等于0.0254米，请编写程序实现国际单位制与英制之间的换算。

输入格式：两个浮点数，以空格分隔，第一个是质量（以千克为单位）、第二个是长度（以米为单位）。例如：0.45359237 0.0254。

输出格式：两个浮点数，以空格分隔，第一个是质量（以磅为单位）、第二个是长度（以英寸为单位）。例如：1.0 1.0。

思路：乍一看题目好像很简单，但是实则有一个大坑，输出时要强制转换成float类型，否则全错

源码如下：

import java.util.*;
    public class Main
        public static void main(String[] args) 
                Scanner input=new Scanner(System.in);
            double a=input.nextDouble();  
            double b=input.nextDouble();
         double h=a/0.45359237;
        double l=b/0.0254;
  System.out.printf((float)h+" "+(float)l);

7-2 奇数求和

计算一个数列中所有奇数的和。

输入格式：十个整数，以空格分隔。例如：1 2 3 4 5 6 7 8 9 0。

输出格式：输入数列中所有奇数之和。例如：25。

思路：使用for循环输入一个有十个元素的数组，再使用for循环和if语句判断元素的奇偶，如果是奇数就相加

源码如下：

import java.util.*;
    public class Main
            public static void main(String[] args)    
                Scanner input=new Scanner(System.in);
              int[] a=new int[10];
              for(int i=0;i<10;i++)
                  a[i]=input.nextInt();
               int sum=0;
               for(int j=0;j<10;j++)
                 
                  if(a[j]%2!=0)
                     sum+=a[j];
                     
                     System.out.println(sum);

7-4 游戏角色选择

思路：可以使用if else嵌套，也可以使用switch结构，这里我为了简洁选择了switch结构

源码如下：

    import java.util.*;
    public class Main
        public static void main(String[] args) 
            Scanner input=new Scanner(System.in);
            int a=input.nextInt();
            int b=input.nextInt();
            if(a<1||a>4||b<1||b>3)
                System.out.print("Wrong Format");
            else
            switch(a)
                case 1:
                  System.out.print("人类 ");
                 break;
            case 2:
             System.out.print("精灵 ");
            break;
            case 3:
                System.out.print("兽人 ");
                 break;
            case 4:
                System.out.print("暗精灵 ");
                 break;
    
            switch(b)
                case 1:
                  System.out.println("战士");
                 break;
            case 2:
             System.out.println("法师");
            break;
            case 3:
                System.out.println("射手");
                 break;

7-5 学号识别

学校的学号由8位数字组成，前两位是入学年份（省略了20）；第3、4位是学院编号，01代表材料学院，02代表机械学院，03代表外语学院，20代表软件学院；第5、6位是学院内部班级编号，最后两位是班级内部学号。如：18011103，入学年份是2018年，材料学院，11班，03号

输入格式:

8位数字组成的学号。例如：18011103
注意：输入学号不是8位或者学院编号不是01、02、03、20其中之一，属于非法输入

输出格式：学号每一项的完整说明。例如：

入学年份：2018年
学院：材料学院
班级：11
学号：03

注意：如非法输入，输出“Wrong Format"

思路：题目不长，难度不小。一开始我想把学号用数组存储，但我就困在了如何判断数组的两位数上，最后还是换成了字符串来存储，用substring方法来截取字符串的不同位数，同时还使用了equals方法来判断两个字符串是否相等，再进入if else选择。不过判断条件上好像出了一点问题，导致我只能使用最繁琐的方法进行输出，但所幸结果没有太大问题。然而第二个测试点一直过不去，百思不得其解

源码如下：

import java.util.*;
public class Main
    public static void main(String[] args) 
        Scanner input=new Scanner(System.in);
        String a=input.nextLine();
        if (a.length() != 8)
            System.out.print("Wrong Format");
        else
            String yuan=a.substring(2,4);
            String year = a.substring(0,2);
            String cls = a.substring(4,6);
            String number = a.substring(6,8); 
     if(yuan.equals("01")||yuan.equals("02")||yuan.equals("03")||yuan.equals("20"))
            
                if(yuan.equals("01"))
            
                    System.out.println("入学年份：20"+year+"年");
                    System.out.println("学院：材料学院");
                    System.out.println("班级："+cls);
                    System.out.println("学号："+number); 
            
                else if(yuan.equals("02"))
                
                    System.out.println("入学年份：20"+year+"年");
                    System.out.println("学院：机械学院");
                    System.out.println("班级："+cls);
                    System.out.println("学号："+number);
                
                else if(yuan.equals("03"))
                
                    System.out.println("入学年份：20"+year+"年");
                    System.out.println("学院：外语学院");
                    System.out.println("班级："+cls);
                    System.out.println("学号："+number);
                
                else if(yuan.equals("04"))
                
                    System.out.println("入学年份：20"+year+"年");
                    System.out.println("学院：软件学院");
                    System.out.println("班级："+cls);
                    System.out.println("学号："+number);
            
            else   System.out.println("Wrong Format");

    7-7 二进制数值提取

在一个字符串中提取出其中的二进制数值序列。

输入格式:

一个由0、1构成的序列，以-1为结束符，非0、1字符视为正常输入，但忽略不计，未包含结束符的序列视为非法输入。例如：abc00aj014421-1

思路：一开始以为只是单纯地将0、1提取出来，但仔细一看题目发现了非法输入的要求，才觉得事情不太简单，最后也是使用了charAt方法

源码如下：

import java.util.*;
public class Main
    public static void main(String[] args) 
                Scanner input=new Scanner(System.in);
                String a=input.nextLine();
                int x=a.length();
                    for(int i=0;i<x;i++)
                    
                        if(a.charAt(i)==\'0\'||a.charAt(i)==\'1\')
                        System.out.print(a.charAt(i));
                        else if(a.charAt(i)==\'-\'&&a.charAt(i+1)==\'1\')
                            break;
                        if(a.charAt(i)==\'-\'&&a.charAt(i+1)!=\'1\')
                            System.out.println("Wrong Format");

7-8 判断三角形类型

输入三角形三条边，判断该三角形为什么类型的三角形。

思路：使用了if else嵌套选择

源码如下：

import java.util.Scanner;

public class Main 
    public static void main(String[] args) 
        Scanner x=new Scanner(System.in);
        double a,b,c,temp;
        a=x.nextFloat();b=x.nextFloat();c=x.nextFloat();
        if(a>b)
            temp=a;a=b;b=temp;
        
        if(a>c)
            temp=a;a=c;c=temp;
        
        if(b>c)
            temp=b;b=c;c=temp;
        
        if(a>=1&&a<=200&&b>=1&&b<=200&&c>=1&&c<=200)
            if(a+b>c)
                if(a==b&&b==c)
                    System.out.println("Equilateral triangle");
                else if(a*a+b*b-c*c<0.000001&&a==b)
                    System.out.println("Isosceles right-angled triangle");
                else if((a==b&&a!=c)||(a==c&&a!=b)||(b==c&&b!=a))
                    System.out.println("Isosceles triangle");
                else if(a*a+b*b-c*c<0.000001)
                    System.out.println("Right-angled triangle");
                else
                    System.out.println("General triangle");
            
            else
                System.out.println("Not a triangle");
        
        else
            System.out.println("Wrong Format");

7-9 求下一天

输入年月日的值（均为整型数），输出该日期的下一天。其中：年份的合法取值范围为[1820,2020] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] 。

要求：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) ; //求输入日期的下一天

思路：这道题还真是不简单，也是第一次接触到java中的方法，其实和C语言的函数是类似的，但是还是学习了一段时间。闰年的判断很简单，做过很多次了，难就难在对于下一天的判断上，要考虑多种特殊情况。思考了很久，还是决定随大流，使用数组来存放每月的天数。PTA上的答案是阉割版，这里我放出修改过后的正确代码

源码如下：

import java.util.*;
public class Main
    public static void main(String[] args) 
        // TODO 自动生成的方法存根
                Scanner input=new Scanner(System.in);
                int year=input.nextInt();
                int month=input.nextInt();
                int day=input.nextInt();
                if(checkInputValidity(year,month,day))
                    nextDate(year,month,day);
                else System.out.println("Wrong Format");
                    
    public static boolean isLeapYear(int year) 
        boolean y;
        y = ((year % 4 == 0 && year % 100 !=0 )||year % 400 == 0);
        return y;
    
    public static boolean checkInputValidity(int year, int month, int day) 
       boolean x;
        int[] a=new int[]0,31,29,31,30,31,30,31,31,30,31,30,31;
        if(!isLeapYear(year))
            a[2] = 28;
        x=(year>=1820&&year<=2020&&month>0&&month<=12&&day<=a[month]&&day>0);
       return x;
    
    public static void nextDate(int year,int month,int day) 
        int[] a=new int[]0,31,29,31,30,31,30,31,31,30,31,30,31;
        if(!isLeapYear(year))
            a[2] = 28;
        if(checkInputValidity(year,month,day)) 
            if(month==12) 
                if(day==a[month]) 
                    year = year+1;
                    month=1;
                    day=1;
                
                else
                    day++; 
                
            
            else 
                if(day==a[month]) 
                    month++;
                    day=1;
                
                else
                    day++;
                   
                
            
            System.out.println("Next date is:"+year+"-"+month+"-"+day);
        
        else  System.out.println("Date Format is Wrong");

第三次作业

终于到了激动人心的类环节，这玩意可不简单啊

7-1 创建圆形类

编写一个圆形类Circle，一个私有实型属性半径，要求写出带参数构造方法、无参构造方法、属性的getter、setter方法以及求面积、输出数据等方法，具体格式见输入、输出样例。

思路：根据类的定义写出

源码如下：

import java.util.Scanner; 
public class Main 
    public static void main(String args[])
 
    Scanner input=new Scanner(System.in);
    Main a=new Main();
    a.setRadius(input.nextDouble());
    if(a.getRadius()<0)
    System.out.print("Wrong Format");
    else 
System.out.printf("The circle\'s radius is:%.2f",(float)a.getRadius());
System.out.println("");
System.out.printf("The circle\'s area is:%.2f",(float)a.getArea());
    
  
   
    private double radius;
    public double getRadius()
    
          return this.radius;
    
    public void setRadius(double r)
   
    this.radius=r;
   
   public double getArea()
   
    double r=this.radius;
    return r*r*Math.PI;
   

public Main(double r)

this.radius=r;

public Main()

7-2 创建账户类Account

思路：这道题还是考到了float类型强制转换，以及条件的判断，难度不是很大，但是比较繁琐

源码如下：

import java.time.LocalDate;
import java.util.*;
public class Main 
     static Scanner input=new Scanner(System.in);
        private  int id=0;
        private  double balance=0;
        private double annuallnterestRate=0;
        private LocalDate dateCreated ;
        public Main() 
        public Main(int id,double balance)
            this.id = id;
            this.balance = balance;
        
        public int getId() 
            return this.id;
        
        public void setId(int id)
            this.id=id;
        
        public void setBalance(double balance) 
            this.balance=balance;
        
        public double getBalance() 
            return this.balance;
        
        public void setannuallnterestRate(double annuallnterestRate) 
            this.annuallnterestRate=annuallnterestRate;
        
        public double getannuallnterestRate() 
            return this.annuallnterestRate;
        
        public LocalDate getDateCreated() 
            return this.dateCreated;
        
        public double getMonthlyInterestRate()
            return this.balance*(this.annuallnterestRate/1200);
        
        public  double withDraw(double count)
            this.balance=balance-count;
            return this.balance;
        
        public double deposit(double count)
            this.balance=balance+count;
            return this.balance;
        

public static void main(String[] args) 
  Main a = new Main();
  a.setId(input.nextInt());
  a.setBalance(input.nextDouble());
  a.setannuallnterestRate(input.nextDouble());
  double x=input.nextDouble();
  if(x<0||x>a.getBalance())
   System.out.println("WithDraw Amount Wrong");
  else
   a.withDraw(x);
  double y=input.nextDouble();
  if(y>20000||y<0)
   System.out.println("Deposit Amount Wrong");
  else
  a.deposit(y);
  System.out.printf("The Account\'balance:%.2f",(float)a.getBalance());
  System.out.println();
  System.out.printf("The Monthly interest:%.2f",(float)a.getMonthlyInterestRate());
  System.out.println();
  System.out.println("The Account\'dateCreated:2020-07-31");

7-3 定义日期类

定义一个类Date，包含三个私有属性年（year）、月（month）、日（day），均为整型数，其中：年份的合法取值范围为[1900,2000] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] 。

思路：其实这道题很眼熟啊，就是第二次作业的第九题，只不过上次只要求写方法，这次要求写类，事实上还是大差不差，直接上源码

源码如下：

import java.util.Scanner;
class Date
   private int year;
   private int month;
   private int day;

    public Date(int year,int month,int day)
        this.year=year;
        this.month=month;
        this.day=day;
    
    public Date() 
        int year,month,day;
    
    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 static boolean isLeapYear(int year) 
        boolean y;
        y = ((year % 4 == 0 && year % 100 !=0 )||year % 400 == 0);
        return y;
    
    public static boolean checkInputValidity(int year, int month, int day) 
       boolean x;
        int[] a=new int[]0,31,29,31,30,31,30,31,31,30,31,30,31;
        if(!isLeapYear(year))
            a[2] = 28;
        x=(year>=1900&&year<=2000&&month>0&&month<=12&&day<=a[month]&&day>0);
       return x;
    
    public static void getnextDate(int year,int month,int day) 
        int[] a=new int[]0,31,29,31,30,31,30,31,31,30,31,30,31;
        if(!isLeapYear(year))
            a[2] = 28;
        if(checkInputValidity(year,month,day)) 
            if(month==12) 
                if(day==a[month]) 
                    year = year+1;
                    month=1;
                    day=1;
                
                else
                    day++; 
                
            
            else 
                if(day==a[month]) 
                    month++;
                    day=1;
                
                else
                    day++;
                   
                
            
            System.out.println("Next day is:"+year+"-"+month+"-"+day);
        
        else  System.out.println("Date Format is Wrong");
    

public class Main 
    public static void main(String[] args) 
        Scanner input=new Scanner(System.in);
        Date a=new Date();
        a.setYear(input.nextInt());
        a.setMonth(input.nextInt());
        a.setDay(input.nextInt());
        a.getnextDate(a.getYear(), a.getMonth(),a.getDay());

7-4 日期类设计

参考题目3和日期相关的程序，设计一个类DateUtil，该类有三个私有属性year、month、day（均为整型数），其中，year∈[1820,2020] ,month∈[1,12] ,day∈[1,31]

思路：毫不夸张，最难的一题，当时根本做不出来，最开始看到这个感觉特别复杂，实际上也确实复杂，需要判断很多东西，首先要设置一个数字对每一个月份的天数进行一个定义，其次要判断年份是否为闰年，因为闰年的二月有29天，再对输入的日期根据题目所给范围进行一个合法性的一个判断，每次年份进行加减时都需要重新判断并且对月份的数组进行更改，对于当前日期的后几天和前几天的一个日期输出，先要根据所给的n天进行年，月的越界的一个判断，如果超过当前日期到下一年或上一年的天数，则需要对下一年或上一年进行判断闰年与否，再对n减去该天数所剩下的日子进行年，月的判断，若小于一年，则从1月（前几天的话就是12月）开始逐个月份的去删减直至n为0，最后得到最终的答案。而两个日期相差的天数跟上面几乎是一样的，首先判断是否是同一年，若是，则从小的日期计算到下一年的日子，再判断是否年大于1，是则判断闰年与否进行增加天数（365或355）直至加至同一年，再判断月份之间的差距和天数的差距。下面放上更改过后的正确代码

源码如下：（太长了所以折叠一下)

 
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 day;
    private int month;
    private int year;
    
    public DateUtil(int year,int month,int day) 
        this.day = day;
        this.month = month;
        this.year = year;
    
    
    public int getYear() 
        return year;
    
    
    public int getDay() 
        return day;
    
    
    public int getMonth() 
        return month;
    
    
    public boolean checkInputValidity() 
        boolean a;
        int[] n = new int[]0,31,28,31,30,31,30,31,31,30,31,30,31;
        if(isLeapYear(year))
        
            n[2] = 29;
        
        if(year>=1820&&year<=2020&&month>0&&month<=12&&day<=n[month]&&day>0) 
            a = true;
        
        else 
            a = false;
        
        return a;
    
    
    public static boolean isLeapYear(int year) //判断year是否为闰年，返回boolean类型；
    
        
        if((year%4 == 0&&year%100 != 0)||(year%400 == 0))
            return true;
            else return false;
    
    
    public DateUtil getPreviousNDays(int n) 
        int[] m = new int[]0,31,28,31,30,31,30,31,31,30,31,30,31;
        int day1 = day;
        int month1 = month;
        int year1 = year;
        int k;
        if(isLeapYear(year1)) 
            k = 366;
            m[2] = 29;
        
        else 
            k = 365;
        
        int a = 0;
        for(int i=1;i<month;i++) 
            a = a + m[i];
        
            a = a + day;
            if(n>a) 
                n = n-a;
                year1 = year1-1;
                month1 = 12;
                day1 = 31;
                 if(isLeapYear(year1)) 
                    k = 366;
                    m[2] = 29;
                
                else 
                    k = 365;
                
                while(n-k>0) 
                    n = n-k;
                    year1 = year1-1;
                    if(isLeapYear(year1)) 
                        k = 366;
                        m[2] = 29;
                    
                    else 
                        k = 365;
                    
                
                while(n>m[month1]) 
                    n -=m[month1];
                    month1 = month1-1;
                
                day1 =m[month1]-n;
            
            else 
                if(isLeapYear(year1)) 
                    k = 366;
                    m[2] = 29;
                
                else 
                    k = 365;
                
                if(n>day1) 
                    n = n-day1;
                    month1 = month1-1;
                    while(n>m[month1]) 
                        n = n-m[month1];
                        month1 = month1-1;
                    
                    day1 =m[month1]-n;
                
                else 
                    day1 = day1 - n;
                
            
        DateUtil beforedate = new DateUtil(year1, month1, day1);
        return beforedate;
    
    
    public DateUtil getNextNDays(int n) 
        int[] m = new int[]0,31,28,31,30,31,30,31,31,30,31,30,31;
        int day1 = day;
        int month1 = month;
        int year1 = year;
        int k;
        int a = 0;
        if(isLeapYear(year1)) 
            k = 366;
            m[2] = 29;
        
        else 
            k = 365;
        
        for(int i=1;i<month;i++) 
            a = a + m[i];
        
            a = a + day;
            if(n>k-a) 
                n = n-(k-a);
                year1++;
                month1 = 1;
                day1 = 1;
                if(isLeapYear(year1)) 
                    k = 366;
                    m[2] = 29;
                
                else 
                    k = 365;
                    m[2] = 28;
                
                while(n-k>0) 
                    n = n-k;
                    year1 ++;
                    if(isLeapYear(year1)) 
                        k = 366;
                        m[2] = 29;
                    
                    else 
                        k = 365;
                        m[2] = 28;
                    
                
                while(n>m[month1]) 
                    n -= m[month1];
                    month1++;
                
                day1 = n;
            
            else 
                if(isLeapYear(year1)) 
                    k = 366;
                    m[2] = 29;
                
                else 
                    m[2] = 28;
                    k = 365;
                
                if(n>m[month1]-day1) 
                    n = n-(m[month1]-day1);
                    month1 ++;
                    while(n>m[month1]) 
                        n = n-m[month1];
                        month1++;
                    
                    day1 = n;
                
                else 
                    day1 = day1 + n;
                
            
        DateUtil nextdate = new DateUtil(year1, month1, day1);
        return nextdate;
    
    
    public int getDaysofDates(DateUtil toDate) 
        boolean b = equalTwoDates(toDate);
        boolean a = compareDates(toDate);
        int[] m = new int[]0,31,28,31,30,31,30,31,31,30,31,30,31;
        int duringday = 0;
        int k1;
        if(b) 
            duringday = 0;
        
        else 
            if(a) 
                if(year<toDate.year) 
                    if(isLeapYear(year)) 
                        k1 = 366;
                        m[2] = 29;
                    
                    else 
                        k1 = 365;
                    
                    for(int i=1;i<month;i++) 
                        duringday +=m[i];
                    
                        duringday += day;
                        duringday = k1-duringday;
                        while(toDate.year-year>1) 
                            year++;
                            if(isLeapYear(year)) 
                                k1 = 366;
                            
                            else 
                                k1 = 365;
                            
                            duringday +=k1; 
                        
                        if(isLeapYear(toDate.year)) 
                            m[2] = 29;
                        
                        else 
                            m[2] = 28;
                        
                        for(int i=1;i<toDate.month;i++) 
                            duringday = duringday + m[i];
                        
                        duringday +=toDate.day ;
                
                else 
                    if(isLeapYear(year)) 
                        m[2] = 29;
                    
                    else 
                        m[2] = 28;
                    
                    if(month<toDate.month) 
                        duringday = m[month]-day;
                            while(toDate.month-month>1) 
                                month++;
                                duringday +=m[month];
                                
                                duringday +=toDate.day;
                    
                    else 
                    duringday = toDate.day-day;
                    
                
            
            else 
                if(year>toDate.year) 
                    if(isLeapYear(toDate.year)) 
                        k1 = 366;
                        m[2] = 29;
                    
                    else 
                        k1 = 365;
                    
                    for(int i=1;i<toDate.month;i++) 
                        duringday = duringday + m[i];
                    
                        duringday = duringday + toDate.day;
                        duringday = k1-duringday;
                        while(year-toDate.year>1) 
                            toDate.year++;
                            if(isLeapYear(toDate.year)) 
                                k1 = 366;
                            
                            else 
                                k1 = 365;
                            
                            duringday +=k1; 
                        
                        if(isLeapYear(year)) 
                            m[2] = 29;
                        
                        else 
                            m[2] = 28;
                        
                        for(int i=1;i<month;i++) 
                            duringday = duringday + m[i];
                        
                        duringday +=day ;
                
                else 
                    if(isLeapYear(year)) 
                        m[2] = 29;
                    
                    else 
                        m[2] = 28;
                    
                    if(month>toDate.month) 
                        duringday = m[toDate.month]-toDate.day;
                            while(month-toDate.month>1) 
                                toDate.month++;
                                duringday +=m[toDate.month];
                                
                                duringday +=day;
                    
                    else 
                    duringday =day-toDate.day;
                    
                
            
        
        return duringday;
    
    
    public String showDate() 
        String str1 = ""+year+"-"+month+"-"+day;
        return str1;
    
    
    public boolean equalTwoDates(DateUtil date) 
        if(date.year==year&&date.day==day&&date.month==month) 
            return true;
        
        else 
            return false;
        
    
    
    public boolean compareDates(DateUtil date) 
        if(year>date.year) 
            return false;
        
        else if(year<date.year)
            return true;
        
        else 
            if(month>date.month) 
                return false;
            
            else if(month<date.month) 
                return true;
            
            else 
                if(day>date.day) 
                    return false;
                
                else 
                    return true;

三、踩坑心得

虽然题量总的来说并不大，但是我踩过的坑还真不少。从一开始的格式错误，再到题目故意埋的陷阱，比如输出时的强制转换（float转换），具体条件的判断（点名批评日期类的题目），这些坑我都一个个踩了个遍。总结出来的心得就是做题时一定要细心，仔细看好题目的要求，是要几位小数，或者有什么固定格式，有时候就是因为急急忙忙做题没看清楚，才导致做了七八遍都是错误。而且遇到不会的题目一定要自己主动翻阅书籍，学习不同的方法来更简洁地完成题目，比如求绝对值的方法，比较字符串的方法，添加字符的方法，掌握更多的方法对于我们完成题目是非常有利的。并且一定要注意方法名中的大小写格式，避免报错。、

四、改进建议

1. 规范命名。一开始总是为了方便，用abc命名变量和方法，但是后面变量和方法多了之后很容易弄混，这就体现了规范命名的重要性。

2. 更多地使用方法，防止语句冗长。

3. 熟练掌握类的书写，方便后续阅读代码。

五、总结

通过这几次作业，让我从一窍不通到对java有了更深的理解，并且对面向对象有了一定的认识，更精进了自学的技巧，对以后的学习有很大的帮助作用。

第一次作业让我对java有了初步认识，通过自主学习，了解了java的语法，并且发现了与C语言的共通之处，方便上手。第二次作业主要考查了对方法的定义和使用，还有对于代码的严谨性，让我认识到了细心的重要。第三次作业让我们学会了类的使用，对面向对象程序设计也有了属于自己的理解。但是，我的缺点很明显集中在思维能力不足，还有不懂得如何具体用代码实现需求上。很多时候有一个想法雏形，但是不知道如何让想法变成现实。这就说明了我的知识储备还是不够，仍旧需要自发学习，填补这方面的空缺。同时，我也希望老师能够讲解一下某些难题，教授一些正确方法。

以上是关于Java博客作业的主要内容，如果未能解决你的问题，请参考以下文章

❤️响应式性感美女模特博客网站模板❤️（HTML+CSS+JavaScript-前端大作业）