526互联

oop题目集01-03小结

发布时间 2023-03-26 23:30:25作者: tiam_sy


oop训练集一

* 计算年利率

* 身体质量指数测算

* 九九乘法表（双循环）

* 快递运费

* 去掉重复字符

* 统计一个子串在整串中出现的次数

* 有重复数据

* 从一个字符串中移除包含在另一个字符串中的字符

* Prime Numbers

* GPS数据处理

* 求定积分

* 列出最简真分数序列*

oop训练集二

* 长度质量计算单位换算

* 奇数求和

* 房产税计算2022

* 游戏角色选择

* 学号识别

* 巴比伦法求平方根近似值

* 二进制数值提取

* 判断三角形类型

* 求下一天

oop训练集三

* 创建圆类型

* 创建账户类Account

* 定义日期类

* 日期类设计

一，关于Java

 

　　新的学期我们学习了Java语言，对于第一次接触这一类语言的我来说起初确实有点挑战(思维方式仍然停留在C语言的面向程序设计)。Java语言和上学期所学的C语言有很大的相似之处，但是也有很多不同的地方，C语言为面向程序设计，而Java为面向对象设计，三次作业的题目便是将思维从面向程序转化为面向对象的过程。

 

二，　前言

 

　　这三次训练集中,其中第一次的题量较大，但是题目难度较小，让我们初步感受了Java的编程语言和环境，主要考察的知识点内容有：数据的输入输出，使用Scanner读取数据，if-else语句的应用，for循环的使用，字符串的语法运用，字符数组的使用等；

　　第二次训练集的题量适中，难度较于第一次训练集也有所提升。主要考察的知识点内容有：字符串函数的应用，类的构造，以及方法的调用，闰年的判断等；

　　第三次训练集相比于前两次训练集难度较大，是前两次训练集知识点的综合应用，这一题目集的最后一题也是上一题目集的迭代，多个类的设计，多个方法的构造；

　　总之，这三次的题目集的难度逐层深入，一步步引导我们将思维从面向程序设计转化为面向对象设计。

三， 设计与分析

oop训练集二：二进制数值提取

题目：

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

 

输入格式:

 

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

 

输出格式:

 

将输入的序列去掉非0、1字符以及结尾符的数据内容，
注：结束符-1之后的0\1字符忽略不计。
例如：00011。

本题源代码如下

import java.util.Scanner;

public class Main{
    
    public static void main(String []args){
        Scanner input=new Scanner(System.in);
        String s=input.nextLine();
        String a="";
        int n=s.length();
        int flag=0;
        for(int i=0;i<n;i++)
        {
            if(s.charAt(i)=='0'||s.charAt(i)=='1')
                a=a+s.charAt(i);
            if(s.charAt(i)=='-'&&s.charAt(i+1)=='1')
            {   
                flag=1;
                break;
            }
        }
        if(flag==1)
        System.out.print(a);
        else
             System.out.print("Wrong Format");
    }
}

　　本题小结：本题通过s.length判断原字符串的长度，接着通过方法s.charAt(index),提取字符串中获取子串，相当于将原字符串转换为字符数组，通过index下标判断每一个字符所在的位置，再将获取的字符储存到新的字符串a之中，最后进行输出。

oop题目集二：判断三角形类型

题目：

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

输入格式:

在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[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.Scanner;

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();;
        double wc=0.000001;
        if(a<=200&&a>=1&&b<=200&&b>=1&&c<=200&&c>=1)
        {
            if(a+b>c&&c+b>a&&a+c>b)
            {
                if(a==b&&b==c)
                    System.out.print("Equilateral triangle");
                else if((a==b)&&(a*a+b*b<c*c+wc&&a*a+b*b>c*c-wc))
                    System.out.print("Isosceles right-angled triangle");
                else if((c==b)&&(c*c+b*b<a*a+wc&&c*c+b*b>a*a-wc))
                    System.out.print("Isosceles right-angled triangle");
                else if((c==a)&&(c*c+a*a<b*b+wc&&c*c+a*a>b*b-wc))
                    System.out.print("Isosceles right-angled triangle");
                else if(a==b||a==c||b==c)
                    System.out.print("Isosceles triangle");
                else if((a*a+b*b)==c*c)
                    System.out.print("Right-angled triangle");
                else if((a*a+c*c)==b*b)
                    System.out.print("Right-angled triangle");
                else if((b*b+c*c)==a*a)
                    System.out.print("Right-angled triangle");
                else
                    System.out.print("General triangle");
            }
            else
                System.out.print("Not a triangle");
        }
        else
            System.out.print("Wrong Format");
       

    }
}

　　本题小结：本题主要通过if-else语句，对不同的情况进行判断。在做本题时遇到的困难是：在判断等腰直角三角形时，没有了解到有误差范围，平方值的和需要在一定范围内才能判断，判断条件为：

a*a+b*b<c*c+wc&&a*a+b*b>c*c-wc　　(wc=0.000001)

oop题目集二：求下一天

输入年月日的值（均为整型数），输出该日期的下一天。 其中：年份的合法取值范围为[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 void main(String[] args) {
         Scanner input = new Scanner(System.in);
         int year = input.nextInt();
         int month = input.nextInt();
         int day = input.nextInt();
         nextDate(year,month,day);
     }
     
    public static boolean isLeapYear(int year) {
        boolean isLeapYear;
        isLeapYear=(year % 4 == 0 && year % 100 !=0 )||year % 400 == 0;
    
        return isLeapYear;
    }
    
    public static boolean checkInputValidity(int year,int month,int day) {
        boolean checkInputValidity;
        int[] a={0,31,29,31,30,31,30,31,31,30,31,30,31};
       
        if(isLeapYear(year)==false)
            a[2] = 28;
        checkInputValidity=(year>=1820&&year<=2020&&month>0&&month<=12&&day>=1&&day<=a[month]);
         
        return checkInputValidity;
    }
     
    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)==false)
            a[2] = 28;
        if(checkInputValidity(year,month,day)==true) {
            if(month==12) {
                if(day==a[month]) {
                    year = year+1;
                    month = 1;
                    day=1;
                }
                else{
                    month=month;
                    day =day +1;
                }
            }
            else {
                if(day==a[month]) {
                    month = month + 1;
                    day = 1;
                }
                else{
                    month=month;
                    day = day+1;
                }
            }
            System.out.println("Next date is:"+year+"-"+month+"-"+day);
        }
        else
            System.out.println("Wrong Format");
    }
}

　　本题小结：在这一题中第一次接触了boolean类型，Booleanl类型函数的返回值为false/true,所以可以用这个类型判断年份是否是闰年，如果是返回true,否则返回false;定义一个函数nextDate求解下一天，共分为三种情况：跨年，跨月，跨日，分情况进行讨论；

oop训练集三：定义日期类

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

输入格式:

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

输出格式:

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

根据本题要求，可绘制出对应的类图如下

 

 本题源代码如下

import java.util.Scanner;
public class Main{
    
    public static void main(String []args){
        
        Scanner intput=new Scanner(System.in);
        int year=intput.nextInt();
        int month=intput.nextInt();
        int day=intput.nextInt();
        Date.getNextDate(year,month,day);
    }
}
 class Date{
    
    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 static boolean isLeapYear(int year){
         boolean isLeapYear;
         isLeapYear=(year%4==0&&year%100!=0)||(year%400==0);
         return isLeapYear;
     }
     
     public static boolean checkIputValidity(int year,int month,int day){
         boolean checkIputValidity;
         checkIputValidity=year>=1900&&year<=2000&&month>=1&&month<=12&&day>=1&&day<=31;
         return checkIputValidity;
     }
     
     public static void getNextDate(int year,int month,int day){
         int[]mon_maxnum=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
         if(isLeapYear(year)==true)
             mon_maxnum[2]=29;
         if(checkIputValidity(year,month,day)==false)
             System.out.print("Date Format is Wrong");
         else if(isLeapYear(year)==false&&day>=29&&month==2){
             System.out.print("Date Format is Wrong");//平年
         }
         else if(isLeapYear(year)==true&&day>=30&&month==2){
             System.out.print("Date Format is Wrong");//闰年
         }
         else{
             if(month==12&&day==31){ //跨年
                year=year+1;
                 month=1;
                 day=1;
             }
             else if(month!=12&&day==mon_maxnum[month]){//跨月
                 month=month+1;
                 day=1;
             }
             else if(day!=mon_maxnum[month]){//跨日
                 day=day+1;
             }
             System.out.printf("Next day is:%d-%d-%d",year,month,day);
             }
     }
}import java.util.Scanner;
public class Main{
    
    public static void main(String []args){
        
        Scanner intput=new Scanner(System.in);
        int year=intput.nextInt();
        int month=intput.nextInt();
        int day=intput.nextInt();
        Date.getNextDate(year,month,day);
    }
}
 class Date{
    
    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 static boolean isLeapYear(int year){
         boolean isLeapYear;
         isLeapYear=(year%4==0&&year%100!=0)||(year%400==0);
         return isLeapYear;
     }
     
     public static boolean checkIputValidity(int year,int month,int day){
         boolean checkIputValidity;
         checkIputValidity=year>=1900&&year<=2000&&month>=1&&month<=12&&day>=1&&day<=31;
         return checkIputValidity;
     }
     
     public static void getNextDate(int year,int month,int day){
         int[]mon_maxnum=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
         if(isLeapYear(year)==true)
             mon_maxnum[2]=29;
         if(checkIputValidity(year,month,day)==false)
             System.out.print("Date Format is Wrong");
         else if(isLeapYear(year)==false&&day>=29&&month==2){
             System.out.print("Date Format is Wrong");//平年
         }
         else if(isLeapYear(year)==true&&day>=30&&month==2){
             System.out.print("Date Format is Wrong");//闰年
         }
         else{
             if(month==12&&day==31){ //跨年
                year=year+1;
                 month=1;
                 day=1;
             }
             else if(month!=12&&day==mon_maxnum[month]){//跨月
                 month=month+1;
                 day=1;
             }
             else if(day!=mon_maxnum[month]){//跨日
                 day=day+1;
             }
             System.out.printf("Next day is:%d-%d-%d",year,month,day);
             }
     }
}

　　本题小结：这一道题目实际上是上oop训练集二求下一天的迭代，只不过这里需要我们定义一个新的类（这也是我第一次接触类似的题目），而上一道题目只有一个主类，在主类中定义一些方法，而本道题需要定义一个新的类，然后在新的类中定义一系列的方法，接着继续套用上一道题所用到的方法判断下一天，最后引用新的类中的方法。

oop 训练集三：日期类设计

题目：

参考题目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”格式返回日期值
应用程序共测试三个功能：

求下n天
求前n天
求两个日期相差的天数

类图如下

 

 

本题源代码如下

import java.util.Scanner;

class DateUtil{
    private int year;
    private int month;
    private int day;
        
    public DateUtil(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;
         isLeapYear=(year%4==0&&year%100!=0)||(year%400==0);
         return isLeapYear;
     }
     
     public boolean checkInputValidity(){
         boolean checkIputValidity;
         checkIputValidity=year>=1820&&year<=2020&&month>=1&&month<=12&&day>=1&&day<=31;
         return checkIputValidity;
     }
     
     public DateUtil getNextNDays(int n){
         int[]mon_maxnum=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
            if(isLeapYear(year))
                mon_maxnum[2]=29;
        
           while(n>mon_maxnum[month]){
               n=n-mon_maxnum[month];
               if(month==12){
                   year++;
                   if(isLeapYear(year))
                       mon_maxnum[2]=29;
                   else
                       mon_maxnum[2]=28;
                   month=1;
               }
               else
                   month++;
           }
         
         for(int i=1;i<=n;i++){
                if(month==12&&day==31){ //跨年
                    year=year+1;
                    month=1;
                    day=1;
                    if(isLeapYear(year))
                        mon_maxnum[2]=29;
                    else
                        mon_maxnum[2]=28;
                 }
                else if(month!=12&&day==mon_maxnum[month]){//跨月
                    month=month+1;
                    day=1;
                }
                else if(day!=mon_maxnum[month]){//跨日
                     day=day+1;
                 }
         }
  
             DateUtil mmm=new DateUtil(year,month,day);
             return mmm;
     }
    
    public DateUtil getPreviousNDays(int n){
         int[]oop=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
         if(isLeapYear(year)==true)
             oop[2]=29;
        
          while(n>oop[month-1]){
              
               if(month==1){
                   n=n-31;
                   year=year-1;
                   if(isLeapYear(year))
                       oop[2]=29;
                   else
                       oop[2]=28;
                   month=12;
               }
               else{
                    n=n-oop[month-1];
                   month=month-1;
               }
                   
           }
        
         for(int i=1;i<=n;i++){
             if(month==1&&day==1){
                 year=year-1;
                 month=12;
                 day=31;
                 if(isLeapYear(year)==true)
                    oop[2]=29;
                 else
                     oop[2]=28;
             }
             else if(month!=1&&day==1){
                 month=month-1;
                 day=oop[month];
             }
             else if(day!=1){
                 day=day-1;
             }
         }
        
         DateUtil mmm=new DateUtil(year,month,day);
         return mmm;
    }
    
    public int getDaysofDates(DateUtil date){
        int[]mday=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
        int[]nday=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
        int t=0;
        int s=0;
        int c=0;
        int w=0;
        int anotherDay=date.getDay();
        int anotherYear=date.getYear();
        int anotherMonth=date.getMonth();
       
        
        if(year>anotherYear){
            t=year;
            year=anotherYear;
            anotherYear=t;
            
            s=month;
            month=anotherMonth;
            anotherMonth=s;
            
            c=day;
            day=anotherDay;
            anotherDay=c;
        }
        
        int restalldays=0;
        int alldays=day;
        int anotheralldays=anotherDay;
        int betweendays=0;
        int m=1;
        int n=1;
        int ll=year;
        int bb=0;
        int aa=0;
        int cc=0;
       for(int i=ll;ll<=anotherYear;ll++){
           if(ll==anotherYear){//年份相等
               if(month==anotherMonth){//月份相等
                    aa=anotherDay-day;
               }
               else{
                   if(isLeapYear(ll))
                   {
                       mday[2]=29;
                   }
                   bb=bb+mday[month];
                   if(month==12){
                       month=1;
                   }
                   else
                        month++;
               }
           }
           else
               continue;
       }
        while(year!=anotherYear){
            year=year+1;
            if(isLeapYear(year)){
                cc=cc+366;
            }
            else
                cc=cc+365;
        }
        
        betweendays=aa+bb+cc;
        return (betweendays);
    }
    
    public String showDate(){
        return this.year+"-"+this.month+"-"+this.day;
    }
}


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);
        }        
    }
}

 

本题小结：这一题实际上又是第三题的迭代。因为这一道题给出了写好的主函数，需要我们设计一个类，那么这个连接口处理起来就比较复杂。因为我们需要根据已经写好的代码，然后完成自己的类和方法。本题主要有三个功能：求下n天/求前n天/求两个日期相差的天数

　　求下n天时，其实更加体现了迭代这个词，原来的需求从下一天变成了求下N天 。这个功能我采用月份的循环，依次减去每个月的天数，一直到N的数小于某一个月份的总天数，然后将剩下的天数进行天数循环（利用前面的方法），最后得出结果并且输出；

　　在求前N天时，其实运用的方法和求下N天的方法一样，是一个逆向思维的过程；

　　至于第三个功能，求两个日期相差的天数：我先将这两个日期的所在的年份所度过的天数计算，然后计算前一年剩下来的天数，接着使用月份循环计算两个年份之间的天数；

四，踩坑心得

　　1.这几次作业让我映像最深刻的是 oop训练集三的最后一题 起初我设计的目算法是直接加上一个循环 一天天的推算过去 从而得到后n天或者前n天的日期 可是运行的时候两种功能都出现了运行超时的错误 ，测试点同时显示是由于整型数值边界这个测试点没有通过，便猜想是由于整型数据边界值太长导致循环次数过多，于是我便舍弃了原来的方法，将原来的按照天数循环修改成了按照月循环，从而减少了循环次数，测试点通过。修改后的代码如图所示

 

 　　所以以后不能想当然的认为逻辑没有问题整个程序就可以正常运行，这并不代表整段代码是有效率，有质量的。在编写程序时要同时保证代码的质量；

 

　　2.第二个映像比较深刻的是，在判断一个三角形是不是等腰直角三角形时，忽略了误差范围，导致该测试点没有过（原来计算机也是有误差的）

修改后的代码如图

 

五，改进建议

　　在这几次的作业后，我确实认识到代码时需要不断改进的，也了解到了代码改进的重要性，因为在一次次的迭代过程中，之前写的代码的缺点就会不断暴露出来所以并不只能为了测试点通过而认为自己的代码就没有问题，而应当考虑到后面代码的迭代过程中，代码的质量和效率；

　　例如，我们可以通过将每个月的月份储存到数组中进行应用，如图

 

 

 　　而并不是进行简单的if-else语句判断，否则后面的迭代过程中将会出现问题。

　　所以我们在写代码时，尽量要做到简单高效，为迭代过程考虑；

六，总结

　　通过这几次的作业，我初步熟悉了java的编译环境，思维也正在从原来的面向程序转向面向对象，最重要的是，我学到了在编译代码时要注意代码的质量，以及后期代码迭代的效果。

虽然说这几次的作业中，我能够基本运用以及理解java中的语法和代码，但是，我认为我对java的语法仍然十分不是很熟悉，对一些语法仍然一知半解。所以我应该花更多的时间了解java的基本语法，进一步熟悉java的编译环境和编译思维。

　　同时，我还了解了java上课的基本模式，并根据模式调整自己的学习方法和策略，这种小循环的模式可以提高我们的编译能力（就是有点痛苦），让我们每一天都过得很充实！！！