题目集1~3总结Blog

一.前言

本篇文章将对我近期Java语言学习情况以及三次题目集作业进行分析总结。

   题目集一：学习Java语言的入门题目，涉及if语句，for语句等多个常用知识点，可以通过这些题目学习Java语言的基本语法，巩固基础，题目数量适中，难度比较简单，适合作为Java语言的入门练习。

   题目集二：学习Java语言的入门题目，涉及boolean类型，if语句，for语句，组数等多个常用知识点，通过这些题目，可以加深对Java语言的认知，并且学习到Java语言特有的数据类型，题目数量适中，难度比较简单，适合作为Java语言的入门练习。

   题目集三：学习Java语言的进阶题目，涉及到Java语言中特有的类的运用以及正则表达式的运用，通过这些题目，可以引起我们对面向对象的思考，初步理解面向对象的思想，题目数量较少，但难度对于初学者较大，尤其是正则表达式的部分，刚拿到题目时，不知该从何处下手。

 

 

二.设计与分析

1.对题目集一 7-8 的题目分析：

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

 

输入格式:

 

在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[1,200]。

 

输出格式:

 

（1）如果输入数据非法，则输出“Wrong Format”； （2）如果输入数据合法，但三条边不能构成三角形，则输出“Not a triangle”； （3）如果输入数据合法且能够成等边三角形，则输出“Equilateral triangle”； （3）如果输入数据合法且能够成等腰直角三角形，则输出“Isosceles right-angled triangle”； （5）如果输入数据合法且能够成等腰三角形，则输出“Isosceles triangle”； （6）如果输入数据合法且能够成直角三角形，则输出“Right-angled triangle”； （7）如果输入数据合法且能够成一般三角形，则输出“General triangle”。

 

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 c=input.nextDouble();
        if(a>200||a<1||b>200|b<1||c>200||c<1)
            System.out.println("Wrong Format");
        else if(a+b<=c||a+c<=b||b+c<a)
            System.out.println("Not a triangle");
        else if(a==b&&a==c&&b==c)
             System.out.println("Equilateral triangle");
        else if(a==b&&Math.pow(a,2.0)+Math.pow(b,2.0)==Math.pow(c,2.0)||b==c&&Math.pow(c,2.0)+Math.pow(b,2.0)==Math.pow(a,2.0)||a==c&&Math.pow(a,2.0)+Math.pow(c,2.0)==Math.pow(b,2.0))
             System.out.println("Isosceles right-angled triangle");
        else if(a==b||a==c||b==c)
             System.out.println("Isosceles triangle");
        else if(Math.pow(a,2.0)+Math.pow(b,2.0)==Math.pow(c,2.0)||Math.pow(c,2.0)+Math.pow(b,2.0)==Math.pow(a,2.0)||Math.pow(a,2.0)+Math.pow(c,2.0)==Math.pow(b,2.0))
            System.out.println("Right-angled triangle");
        else
            System.out.println("General triangle");
    }
}

 

       本题要求判断三角形类型，首先声明数据：a,b,c分别表示三角形的三条边，再通过if语句判断各三角形类型，若a,b,c的输入超出范围则输出Wrong Format；否则，若abc无法构成三角形，则输出Not a triangle；否则，若满足三边相等，则输出Equilateral triangle；否则，若满足两边相等且这两边的平方和等于第三边的平方，则输出Isosceles right-angled triangle；否则，若满足两边相等，则输出Isosceles triangle；否则，若满足两边的平方和等于第三边的平方，则输出Right-angled triangle；否则，则输出General triangle。本题需通过if-else语句判断三角形类型，难度较易，但也让我熟悉了Java语言的基本语法。

 

2.对题目集二 7-4 的题目分析：

输入年月日的值（均为整型数），输出该日期的下一天。 其中：年份的合法取值范围为[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) ; //求输入日期的下一天

 

输入格式:

在一行内输入年月日的值，均为整型数，可以用一到多个空格或回车分隔。

输出格式: 

1. 当输入数据非法及输入日期不存在时，输出“Wrong Format”；
2. 当输入日期合法，输出下一天，格式如下：Next date is:年-月-日

import java.util.Scanner;
public class Main{
        public static boolean isLeapYear(int year) {
        boolean isLeapYear = (year % 4 == 0 && year % 100 !=0 )||year % 400 == 0;
        return isLeapYear;
        }
    public static void nextDate(int year,int month,int day) {
        int[] k=new int[]{31,28,31,30,31,30,31,31,30,31,30,31};
        if(year%4==0&&year%100!=0||year % 400 == 0){
                k[1]=29;
                if(month!=12){
                if(day==k[month-1]){
                    
                    month=month+1;
                    day=1;    
                }
                else{
                    day=day+1;
                }
                }
             else if(month==12){
                  if(day==k[month-1]){
                    year=year+1;
                    month=1;
                    day=1;    
                }
                else{
                    day=day+1;
                }
                }
        }
        else{
                            if(month!=12){
                if(day==k[month-1]){
                    month=month+1;
                    day=1;    
                }
                else{
                    day=day+1;
                }
                }
             else if(month==12){
                   if(day==k[month-1]){
                    year=year+1;
                    month=month+1;
                    day=1;    
                }
                else{
                    day=day+1;
                }
                }
        }
        System.out.println("Next date is:"+year+"-"+month+"-"+day );
        }
            
     //求输入日期的下一天
    public static boolean checkInputValidity(int year,int month,int day){
        int[] p=new int[]{31,29,31,30,31,30,31,31,30,31,30,31};
        int[] q=new int[]{31,28,31,30,31,30,31,31,30,31,30,31};
        if(isLeapYear(year)){
            boolean checkInputValidity=year>=1820&&year<=2020&&month>0&&month<=12&&day<=p[month-1]&&day>0;
            return checkInputValidity;
        }
        else{
            boolean checkInputValidity=year>=1820&&year<=2020&&month>0&&month<=12&&day<=q[month-1]&&day>0;
            return checkInputValidity;
        }
                    
    }//判断输入日期是否合法，返回布尔值
    public static void main(String[] args){
        Scanner IN=new Scanner(System.in);
        Main in=new Main();
        int year=IN.nextInt();
        int month=IN.nextInt();
        int day=IN.nextInt();
        
   if(in.checkInputValidity(year,month,day)) {
            in.nextDate( year, month, day);
   }
        else 
            System.out.println("Wrong Format");
    }
}

本题要求实现求下一天，主要考察对Java中方法的使用，在这里，我需要构造四个方法：

public static void main(String[] args)；
public static boolean isLeapYear(int year) ；
public static boolean checkInputValidity(int year,int month,int day)；
public static void nextDate(int year,int month,int day) ；

在isLeapYear方法中通过布朗类型判断所输入的年份是否为闰年；
在checkInputValidity方法中通过布朗类型判断输入年份是知否合法；
在 nextDate方法中，首先判断输入的年份是否为闰年，若为闰年，则定义的日期数组中，二月的日期定为29天，若不为闰年，则仍为28天，然后进行特殊的日期的判断，若输入月份为12月且日期为12月的最后一天，则输出年份加一，且月份为1月，日期为1；若输入的月份为其他月份的最后一天，则输出的月份加1，日期为1；若输入不满足以上情况，则日期加1.

在主方法中输入年份月份日期，再调用checkInputValidity方法判断该日期是否合法，若合法，则输出下一天，若不合法，则输出Wrong Format。

本题需要通过各方法的灵活使用完成所需要求，难度适中，通过这道题的练习，让我初步掌握了对Java中方法的使用。

 

3.对题目集二 7-5 的题目分析：

输入年月日的值（均为整型数），同时输入一个取值范围在[-10,10] 之间的整型数n，输出该日期的前n天（当n > 0时）、该日期的后n天（当n<0时）。
其中年份取值范围为 [1820,2020] ,月份取值范围为[1,12] ,日期取值范围为[1,31] 。
注意：不允许使用Java中任何与日期有关的类或方法。

输入格式:

在一行中输入年月日的值以及n的值，可以用一个或多个空格或回车分隔。

输出格式:

1. 当输入的年、月、日以及n的值非法时，输出“Wrong Format”；
2. 当输入数据合法时，输出“n days ago is:年-月-日”

import java.util.Scanner;
public class Main{
        public static boolean isLeapYear(int year) {
        boolean isLeapYear = (year % 4 == 0 && year % 100 !=0 )||year % 400 == 0;
        return isLeapYear;
        }
        public static boolean checkInputValidity(int year,int month,int day){
        int[] p=new int[]{31,29,31,30,31,30,31,31,30,31,30,31};
        int[] q=new int[]{31,28,31,30,31,30,31,31,30,31,30,31};
        if(isLeapYear(year)){
            boolean checkInputValidity=year>=1820&&year<=2020&&month>0&&month<=12&&day<=p[month-1]&&day>0;
            return checkInputValidity;
        }
        else{
            boolean checkInputValidity=year>=1820&&year<=2020&&month>0&&month<=12&&day<=q[month-1]&&day>0;
            return checkInputValidity;
        }
        }
       public static void Date(int year,int month,int day,int n){
           
        int[] k=new int[]{31,28,31,30,31,30,31,31,30,31,30,31};
        if(year%4==0&&year%100!=0||year % 400 == 0){
                k[1]=29;
                if(month!=12&&month!=1){
                if(day<=n&&n>0){
                    month=month-1;
                    day=k[month-1]-n+day;    
                }
                else if(day>n&&n>0){
                    day=day-n;
                }
                else if(day>=k[month-1]+n&&n<0){
                    day=0-n-(k[month-1]-day);
                    month=month+1;
                }
                else if(day<=k[month-1]+n&&n<0)
                    day=day-n;
                }
             else if(month==12){
                     if(day<=n&&n>0){
                    month=month-1;
                    day=k[month-1]-n+day;    
                }
                else if(day>=n&&n>0){
                    day=day-n;
                }
                else if(day>=k[month-1]+n&&n<0){
                    day=0-n-(k[month-1]-day);
                    month=1;
                    year=year+1;
                }
                else if(day<=k[month-1]+n&&n<0)
                    day=day-n;
                }
        
           else if(month==1){
               if(day<=n&&n>0){
                    year=year-1;
                   month=12;
                    day=k[month-1]-n+day;    
                }
                else if(day>=n&&n>0){
                    day=day-n;
                }
                else if(day>=k[month-1]+n&&n<0){
                    day=0-n-(k[month-1]-day);
                    month=1;
                    year=year+1;
                }
                else if(day<=k[month-1]+n&&n<0)
                    day=day-n;
                }
           }
        else{
                            if(month!=12&&month!=1){
                if(day<=n&&n>0){
                    month=month-1;
                    day=k[month-1]-n+day;    
                }
                else if(day>=n&&n>0){
                    day=day-n;
                }
                else if(day>=k[month-1]+n&&n<0){
                    day=0-n-(k[month-1]-day);
                    month=month+1;
                }
                else if(day<=k[month-1]+n&&n<0)
                    day=day-n;
                }
        
             else if(month==12){
                    if(day<=n&&n>0){
                    month=month-1;
                    day=k[month-1]-n+day;    
                }
                else if(day>=n&&n>0){
                    day=day-n;
                }
                else if(day>=k[month-1]+n&&n<0){
                    day=0-n-(k[month-1]-day);
                    month=1;
                    year=year+1;
                }
                else if(day<=k[month-1]+n&&n<0)
                    day=day-n;
                
                }
            else if(month==1){
               if(day<=n&&n>0){
                    year=year-1;
                   month=12;
                    day=k[month-1]-n+day;    
                }
                else if(day>=n&&n>0){
                    day=day-n;
                }
                else if(day>=k[month-1]+n&&n<0){
                    day=0-n-(k[month-1]-day);
                    month=1;
                    year=year+1;
                }
                else if(day<=k[month-1]+n&&n<0)
                    day=day-n;
                }
        }
        System.out.println(n+" days ago is:"+year+"-"+month+"-"+day );
       }     
        public static void main(String[] args){
        Scanner IN=new Scanner(System.in);
        Main in=new Main();
        int year=IN.nextInt();
        int month=IN.nextInt();
        int day=IN.nextInt();
        int n=IN.nextInt();
   if(in.checkInputValidity(year,month,day)) {
            in.Date(year,month,day,n);
   }
        else 
            System.out.println("Wrong Format");
    }
}

本题要求求前N天，主要考察对Java中方法的使用，在这里，我构造了四个方法：

public static boolean isLeapYear(int year)
public static boolean checkInputValidity(int year,int month,int day)
public static void Date(int year,int month,int day,int n)
public static void main(String[] args)

 isLeapYear与checkInputValidity方法与题目7-4中的功能相同；

Date方法需实现对前N天的求解，首先仍是判断是否为闰年，再通过if-else语句判断输入日期的前n天是否跨月或跨年，并进行相应的处理；

主方法实现对年份月份日期以及n的输入，再判断输入日期是否合法，若合法，则输出所求前n天的日期，若不合法，则输出Wrong Format。

本题需要通过各方法的灵活使用完成所需要求，同时对于逻辑思维的考察更加详尽，难度适中，通过这道题的练习，让我进一步掌握了对Java中方法的使用。

 

4.对题目集三 7-2 的题目分析

定义一个类Date，包含三个私有属性年（year）、月（month）、日（day），均为整型数，其中：年份的合法取值范围为[1900,2000] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] 。 注意：不允许使用Java中和日期相关的类和方法，否则按0分处理。

要求：Date类结构如下图所示：

输入格式:

在一行内输入年月日的值，均为整型数，可以用一到多个空格或回车分隔。

输出格式:

• 当输入数据非法及输入日期不存在时，输出“Date Format is Wrong”；
• 当输入日期合法，输出下一天，格式如下：Next day is:年-月-日

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
       Date date=new Date();
        date.setyear(input.nextInt());
        date.setmonth(input.nextInt());
        date.setday(input.nextInt());
   if(date.checkInputValidity(date.getyear(),date.getmonth(),date.getday())) {
       date.getNextDate();
            //System.out.println("Next day is:"+date.getyear()+"-"+date.getmonth()+"-"+date.getday());
       
   }
        else {
            System.out.println("Date Format is Wrong");
    }
        
    }
}
 class Date{

    private int year;
    private int month;
    private int day;
    private int []a=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};

    /*public void Date() {
        
    }*/
    public void Date(int year,int month,int day){
        this.year=year;
        this.month=month;
        this.day=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  boolean isLeapYear(int year) {
        boolean isLeapYear = (year % 4 == 0 && year % 100 !=0 )||year % 400 == 0;
        return isLeapYear;
        }
    public  boolean checkInputValidity(int year,int month,int day){
        int[] p=new int[]{31,29,31,30,31,30,31,31,30,31,30,31};
        int[] q=new int[]{31,28,31,30,31,30,31,31,30,31,30,31};
        if(isLeapYear(year)){
            boolean checkInputValidity=year>=1900&&year<=2000&&month>0&&month<=12&&day<=p[month-1]&&day>0;
            return checkInputValidity;
        }
        else{
            boolean checkInputValidity=year>=1900&&year<=2000&&month>0&&month<=12&&day<=q[month-1]&&day>0;
            return checkInputValidity;
        }
                    
    }//判断输入日期是否合法，返回布尔值
   public void getNextDate(){
         //int[] k=new int[]{31,28,31,30,31,30,31,31,30,31,30,31};
        if(year%4==0&&year%100!=0||year % 400 == 0){
                a[2]=29;
                if(month!=12){
                if(day==a[month]){
                    
                    month=month+1;
                    day=1;    
                }
                else{
                    day=day+1;
                }
                }
             else if(month==12){
                  if(day==a[month]){
                    year=year+1;
                    month=1;
                    day=1;    
                }
                else{
                    day=day+1;
                }
                }
        }
        else{
                            if(month!=12){
                if(day==a[month]){
                    month=month+1;
                    day=1;    
                }
                else{
                    day=day+1;
                }
                }
             else if(month==12){
                   if(day==a[month]){
                    year=year+1;
                    month=1;
                    day=1;    
                }
                else{
                    day=day+1;
                }
                }
        }
       /* if(checkInputValidity(year,month,day)) {
                 System.out.println("Next day is:"+year+"-"+month+"-"+day);
            
        }
             else {
                 System.out.println("Date Format is Wrong");
         }*/
        System.out.println("Next day is:"+year+"-"+month+"-"+day );
        }
    }

本题要求通过一个类实现对下一天的求解，主要考察对Java中类的使用，在这里我构造了一个类Date；

在Date类中，首先声明年份月份日期以及每月天数的数组，再通过set,get的方法获得所需的数据，接着通过与题目集二 7-4 中相同的方法求得下一天；

同时我定义了一个Main类，在该类的主方法中，通过调用Date类输入年份月份及日期，并判断是否合法，若合法，则输出下一天，若不合法，则输出Date Format is Wrong。

本题需要通过类的使用完成所需要求，在做题的过程中，我意识到了Java语言所特有的语法，引发了我对面向对象的思考，难度适中，通过这道题的练习，让我初步掌握了对Java中类的使用。

 

5.对题目集三 7-3 的题目分析

题目要求实现一元多项式求导，在这道题目中，需要充分运用正则表达式的相关知识，但是，我对正则表达式的相关知识仍无法理解，导致这道题目无法完成，个人认为这道题目难度偏大，我会继续加强对正则表达式相关知识的学习，尽快掌握这部分的相关知识。

三.采坑心得

在完成题目集一的过程中，经常出现基本的Java语法错误，如println中“”中内容与参数衔接时忘记加+，导致出现The method getbalance() is undefined for the type 的报错；在开头未输入import java.util.Scanner;导致出现- Scanner cannot be resolved to a type的报错；public static void main(string[] args)中string的s未大写，导致出现string cannot be resolved to a type的报错，以及nextInt后未加()，导致出现nextInt cannot be resolved or is not a field的报错......通过这次的练习，让我熟悉了Java的基本语法，避免采坑。

在完成题目集二的过程中，在数组的定义中，曾经出现了不少错误，可能受到了C语言中定义数组的影响，导致在Java语言中使用数组时频繁报错，有时是没有new这个数组，有时是给数组赋值是出现语法错误；不过在方法的使用中，我发现了Java方法与C语言函数的相似性，采坑较少。

在完成题目集三的过程中，在类的使用过程中经常出现语法错误，开始在第一题的Account类中，定义了一个public Account(int id,double balance,double annualInterestRate,double a,double b)方法，因未加void导致出现Exception in thread "main" java.lang.Error: Unresolved compilation problem:The constructor Account() is undefined的报错。

 

 

四.改进建议

对于题目集三7-2中

public void Date(int year,int month,int day){
this.year=year;
this.month=month;
this.day=day;
}

这个方法在该题目中并没有作用，可以将其注释掉

 

int[] p=new int[]{31,29,31,30,31,30,31,31,30,31,30,31};
int[] q=new int[]{31,28,31,30,31,30,31,31,30,31,30,31};

定义的这两个数组可以变为{0,31,29,31,30,31,30,31,31,30,31,30,31}{0,31,28,31,30,31,30,31,31,30,31,30,31}可以避免后续操作的麻烦。

 

五.总结

本阶段的三次题目集是将我们带入Java世界的引路石，通过这三次题目集的练习，我掌握了Java语言的基本语法，掌握了方法与类的使用，引发了我对面向对象的思考，在正则表达式以及更多的Java方法仍然需要我不断地学习，同时希望老师能多讲一些实际问题的应用尤其是在实验课上，当然也很感谢老师在实验课上能够帮助我解决许多困扰已久的难题而不大多限于原理的论述，在作业方面，希望能逐级增加难度，同时给予我们自学新知识的时间；在课上课下都可以组织同学们进行相应的题目训练，以加强我们对知识的掌握。