Java题目集1~3的总结性Blog
一、前言
知识点
- 第一次作业涉及的基本的if else、for循环、输入输出、一维数组等知识点及一些基础的数学知识；
- 第二次作业又多了一些不知道的东西，例如 IP 地址转化所用到的Integer.parseInt（）方法等，对方法在类中的书写格式有了基本了解；
- 第三次作业开始涉及类与对象的运用，体现了面向对象语言的封装性，开始对封装有了初步认识，涉及正则表达式的应用比较头疼。
难度
- 第一次作业难度一般，但因为第一次接触Java，对其语法、书写结构（尤其import 、public、class等只知道照猫画虎，尚不理解意思）不太熟悉，功能实现部分基本与C语言无异；
- 第二次作业难度集中在后面三题，对于闰年闰月的区别会影响后续的天数判断，第一题也有些问题，没有对只能输入01做识别，导致有测试点没有过；
- 第三次作业个人觉得比较难，因为是第一次接触类和对象的概念，有点搞不懂get和set方法的意义是什么，也不明白自己定义的class类和Main 与main的嵌套关系如何，大括号应该打在什么位置，private的意义等，在这些问题上掉了很多头发，另外正则表达式虽然功能强大，但要灵活运用也比较难。
题量
- 第一次作业题量虽然较多，但大多延续C语言的编程风格就可以了；
- 第二次作业题量适中，后面三题计算天数较为费时；
- 第三次作业题量虽少，但是难度很大，体现在对类的封装与正则表达式的灵活运用。
二、设计与分析
第一次作业
7-1
1 import java.util.Scanner; 2 3 public class Main 4 { 5 public static void main(String[] args) 6 { 7 Scanner input = new Scanner(System.in); 8 int a = input.nextInt(); 9 int b = input.nextInt(); 10 int sum = a + b; 11 System.out.println(sum); 12 } 13 }
觉得有必要对第一个提交的题目分析一下，因为真的提交了很多次，因为没有注意这个：
傻傻的我用eclipse里的代码根本运行不了，把包删了还是一样，原来单独的代码都是以Main作为运行命令，而不是像定义在eclipse里那样随便定义一个类（当然类名也需要易读性）。
7-2
1 import java.util.*; 2 public class Main 3 { 4 public static void main(String[] args) 5 { 6 Scanner input=new Scanner(System.in); 7 String string=input.nextLine(); 8 char l=string.charAt(0); //取输入的第一个字符 9 char letter=Character.toLowerCase(l); //将其转化为小写字母 10 11 if(letter < 'a' || letter > 'z') 12 System.out.println(letter+" is an invalid input"); 13 if(letter >= 'a' && letter <= 'c') 14 System.out.println("2"); 15 if(letter >= 'd' && letter <= 'f') 16 System.out.println("3"); 17 if(letter >= 'g' && letter <= 'i') 18 System.out.println("4"); 19 if(letter >= 'j' && letter <= 'l') 20 System.out.println("5"); 21 if(letter >= 'm' && letter <= 'o') 22 System.out.println("6"); 23 if(letter >= 'p' && letter <= 's') 24 System.out.println("7"); 25 if(letter >= 't' && letter <= 'v') 26 System.out.println("8"); 27 if(letter >= 'w' && letter <= 'z') 28 System.out.println("9"); 29 } 30 } 31
本题主要是第8.9行中string.charAt() 与 Character.toLowerCase() 的应用，先贴源码：
1 public char charAt(int index) { 2 if ((index < 0) || (index >= value.length)) { 3 throw new StringIndexOutOfBoundsException(index); 4 } 5 return value[index]; 6 }
java.lang.String.charAt()方法 返回 指定索引 处的 char值。索引范围 是从0 到length() - 1。
对于数组的索引，序列的第一个 char值 是在索引 为0，索引1，递增下去。
static int |
toLowerCase(int codePoint)
使用UnicodeData文件中的大小写映射信息将字符（Unicode代码点）参数转换为小写。 |
与C语言中使用ANSI码变换大小写还是不太一样的，与此对应的还有：
通过对上述方法的应用，很容易就确定了输入字符串的第一项并转化为小写了，接下来就是重复的比对区间了。
7-5
1 import java.util.Scanner; 2 public class Main 3 { 4 public static void main(String[] args) 5 { 6 Scanner input = new Scanner(System.in); 7 double sum = input.nextDouble(); 8 double ten = sum/10.0; 9 double five = sum%10 > 5 ? 1:0; 10 double one = sum%5; 11 double fivedime = sum%1/0.5>0 ? 1 : 0; 12 double onedime = sum%0.5; 13 double twocent = sum%0.1/0.02; 14 double onecent = sum%0.1%0.02; 15 16 System.out.println(ten+" 张十元"); 17 System.out.println(five+" 张五元"); 18 System.out.println(one+" 张一元"); 19 System.out.println(fivedime+" 个五角"); 20 System.out.println(onedime+" 个一角"); 21 System.out.println(twocent+" 个贰分"); 22 System.out.println(onedime+" 个壹分"); 23 } 24 }
第9.11行还比较有意思，使用了三目计算符：
对于条件表达式b ? x : y，先计算条件b，然后进行判断。如果b的值为true，计算x的值，运算结果为x的值;否则，计算y的值，运算结果为y的值。一个条件表达式绝不会既计算x，又计算y。条件运算符是右结合的，也就是说，从右向左分组计算。例如，a ? b : c ? d : e将按a ? b : (c ? d : e)执行。加括号（）是为了方便阅读，不加也是一样的。
三目运算符的复合使用在有些时候还是挺能简化代码的。
13.14行小小思考了一下，觉得这样应该算是比较简单的写法了吧，虽然可以设中间量存之前的运算值，但表达式不算太长，这样写虽然没有那么一眼看到底，但代码比较简单。
7-6
需要注意下结果保留了一位小数，答案为：
sum/5.0
7-7
1 import java.util.Scanner; 2 public class Main 3 { 4 public static void main(String[] args) 5 { 6 Scanner input = new Scanner(System.in); 7 int n = input.nextInt(); 8 int temp,i; 9 int a[] = new int[n]; 10 for(i=0; i<n; i++) 11 { 12 a[i] = input.nextInt(); 13 } 14 for(i=0; i<n-1; i++) 15 for(int j=0; j<n-i-1; j++) 16 { 17 if(a[j]>a[j+1]) 18 { 19 temp= a[j]; 20 a[j] = a[j+1]; 21 a[j+1] = temp; 22 } 23 } 24 System.out.print("The sorted numbers are:"); 25 for(int k=0; k<n; k++) 26 System.out.print(a[k]+" "); 27 } 28 }
冒泡排序就完事了，但会有一个测试点运行超时，后来把最后的输出循环中的i换成k就可以通过了，PTA上的测试点有点玄学，经常改一下变量名就可以过了（另外运行超时也是可很玄学的错误，以前写 C的时候运行超时会去想是不是哪里的循环嵌套得太多了，或是写了死循环出不来了，但写Java的话报这个错会去改变量名），还是尽量避免变量名复用吧，另外数组和单个变量名重复也会报错，导致Java程序运行不了。
7-8
（他来了）
1 import java.util.*; 2 public class Main 3 { 4 public static void main(String[] args) 5 { 6 Scanner input = new Scanner (System.in); 7 double a = input.nextDouble(); 8 double b = input.nextDouble(); 9 double c = input.nextDouble(); 10 11 if(a>200 || a<1 || b>200 || b<1 || c>200 || c<1) 12 System.out.println("Wrong Format"); 13 else if(a+b<=c || a+c<=b || b+c<=a) 14 System.out.println("Not a triangle"); 15 else if(a==b || a==c || b==c ) //等腰 16 { 17 if(a*a+b*b==c*c || a*a+c*c==b*b || b*b+c*c==a*a) 18 System.out.println("Isosceles right-angled triangle"); //等腰直角 19 else if(a==b && b==c && a==c) 20 System.out.println("Equilateral triangle"); //等边 21 else 22 System.out.println("Isosceles triangle"); //一般的等腰 23 } 24 else if(a*a+b*b==c*c || a*a+c*c==b*b || b*b+c*c==a*a) 25 System.out.println("Right-angled triangle"); 26 else 27 System.out.println("General triangle"); 28 29 //System.out.println("Wrong Format"); 30 } 31 32 }
- 其实是有一个测试点最终也没能过掉的，测试了很多，还是没发现问题出在哪里，于是只能根据“错的代码”讲讲我的拙见。
- 首先对三角形的判断顺序很关键，注意到测试样例中输入三边相等，输出的是等边三角形，再比如若输入的是等腰且直角三角形，则输出“等腰直角三角形”，也就是说，结果会像更难实现的方向过渡，因为等边三角形也是等腰三角形，等腰直角三角形也是直角三角形，但输出的都是前者，在符合条件的情况下，等边三角形的与等腰直角三角形的优先度高于等腰三角形和等腰三角形。
- 先判断输入是否合法（两边之和大于第三边+题目给出的范围）
- 再判断是否具有等边关系，等腰直角和等边的判断顺序可以颠倒，但输出一般的等腰三角形宜放到最后，在最外层的if else判断中，普通三角形亦宜放至最后。
第二次作业
7-1
1 import java.util.Scanner; 2 public class Main 3 { 4 public static void main(String[] args) 5 { 6 Scanner scan = new Scanner(System.in); 7 String s = scan.next(); 8 int i; 9 10 for(i=0; i<s.length(); i++) 11 if(s.substring(i,i+1)!=" ") 12 { 13 System.out.println("Wrong Format"); 14 return; 15 } 16 17 if(s.length()!=32) 18 System.out.println("Wrong Format"); 19 else 20 for(i=0; i<s.length()-7; i+=8) 21 { 22 System.out.print(Integer.parseInt(s.substring(i,i+8),2)); 23 if(i!=s.length()-8) 24 { 25 System.out.print("."); 26 } 27 } 28 } 29 }
我觉得这道题的巧妙在于第22行，运用for循环与 Integer.parseInt() 方法，保证了每次读取8位数并转化为数字。
Integer.parseInt()比较陌生，于是查了下源码：
1 #源码解析如下 2 public static int parseInt(String s, int radix) 3 4 { 5 /* 6 * WARNING: This method may be invoked early during VM initialization 7 * before IntegerCache is initialized. Care must be taken to not use 8 * the valueOf method. 9 */ 10 11 //需要转换的字符串是否为null 12 if (s == null) { 13 throw new NumberFormatException("null"); 14 } 15 //一下两个if用于判断基数(也就是进制)是否在 2~36之间，比如10进制的数字，radix就填写10 16 if (radix < Character.MIN_RADIX) { 17 throw new NumberFormatException("radix " + radix + 18 " less than Character.MIN_RADIX"); 19 } 20 21 if (radix > Character.MAX_RADIX) { 22 throw new NumberFormatException("radix " + radix + 23 " greater than Character.MAX_RADIX"); 24 } 25 26 int result = 0; //最终返回的结果的负数形式 27 boolean negative = false; //判断是否为负数 28 int i = 0, len = s.length(); 29 int limit = -Integer.MAX_VALUE; //-2147483647 默认取最大整数的取反值 30 int multmin; //用于在添加下一位数字的前判断是否溢出的值（下面有计算） 31 int digit;//当前需要追加的数字 32 33 //字符串中的是否有符号 34 if (len > 0) { 35 char firstChar = s.charAt(0); 36 if (firstChar < '0') { // Possible leading "+" or "-" 37 if (firstChar == '-') { 38 negative = true; 39 limit = Integer.MIN_VALUE; 40 } else if (firstChar != '+') 41 throw NumberFormatException.forInputString(s); 42 43 if (len == 1) // Cannot have lone "+" or "-" 44 throw NumberFormatException.forInputString(s); 45 i++; 46 } 47 //计算multmin 值 ，multmin = -214748364 负数跟整数的limit是不同的 48 multmin = limit / radix; 49 50 //开始循环追加数字，比如输入“123” 10进制数 51 while (i < len) { 52 //获取字符转换成对应进制的整数，如上，这里第一次循环获取1 53 //第二次循环获取2 54 //第三次循环获取3 55 digit = Character.digit(s.charAt(i++),radix); 56 57 if (digit < 0) { 58 throw NumberFormatException.forInputString(s); 59 } 60 /*/判断，在追加后一个数字前，判断其是否能能够在继续追加数字，比如multmin = 123 61 那么再继续追加就会变为123*10+下一个数字，就会溢出 62 */ 63 if (result < multmin) { 64 throw NumberFormatException.forInputString(s); 65 } 66 67 //第一次循环 result = 0; 68 //第二次循环 result = -10; 69 //第三次循环 result = -120; 70 result *= radix; 71 72 /* 73 用于判断下一个准备追加的数字是否可以追加，比如result现在是120,那么，如果digit是5， 74 那么追加后就会变为125，已经超过123的限制了，注意这里是limit而不是multmin 75 */ 76 if (result < limit + digit) { 77 //第一次循环 limit + digit = -214748364+1; 78 //第二次循环 limit + digit = -214748364+2; 79 //第三次循环 limit + digit = -214748364+3; 80 81 throw NumberFormatException.forInputString(s); 82 } 83 result -= digit; 84 //第一次循环 result = -1; 85 //第二次循环 result = -12; 86 //第三次循环 result = -123; 87 88 } 89 } else { 90 throw NumberFormatException.forInputString(s); 91 } 92 return negative ? result : -result; 93 //negative 值为false，所以 -result = -(-123) = 123 返回结果 94 }
/*---来自https://blog.csdn.net/fragrant_no1/article/details/83829345?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161753369016780271522473%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=161753369016780271522473&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~baidu_landing_v2~default-1-83829345.first_rank_v2_pc_rank_v29&utm_term=+Integer.parseInt%28%29%E6%BA%90%E7%A0%81---**/
将字符串参数作为带符号十进制整数来分析。除过第一个字符为 ASCII 字符中减号 '-' 表示的负数，字符串中的字符都必须是十进制数。（可以从以上代码的37行与92行看出）
7-3
由于7-4和7-5对输入是否合法的判断与7-3有重复部分，所以还是分析一下7-3。
1 import java.util.Scanner; 2 public class Main { 3 public static void main(String[] args) { 4 Scanner input = new Scanner(System.in); 5 Main ljy = new Main(); 6 int year = input.nextInt(); 7 int month = input.nextInt(); 8 int day = input.nextInt(); 9 int days = numOfDays(year,month ,day); 10 if(flag(year,month,day)==1) { 11 if(ljy.isLeapYear(year)) { 12 System.out.println(year+" is a leap year."); 13 System.out.println(year+"-"+month+"-"+day+" is "+ljy.getWhatDay(days)+"."); 14 } 15 else { 16 System.out.println(year+" is not a leap year."); 17 System.out.println(year+"-"+month+"-"+day+" is "+ljy.getWhatDay(days)+"."); 18 } 19 } 20 else System.out.println("Wrong Format"); 21 } 22 public static boolean isLeapYear(int year) { 23 boolean isLeapYear = (year % 4 == 0 && year % 100 !=0 )||year % 400 == 0; 24 return isLeapYear; 25 } 26 27 public static int numOfDays(int year,int month ,int day) { 28 int days=0; 29 int i ; 30 int []month = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31}; 31 for(i=1;i<year;i++){ 32 if(i%4==0&&i%100!=0||i%400==0) { 33 days+=366;} 34 else 35 days+=365; 36 } 37 if((year % 4 == 0 && year % 100 !=0 )||year % 400 == 0) 38 month[2]=29; 39 for(i = 1;i<month;i++){ 40 days+=month[i];
} 41 days+=day; 42 return days; 43 } 44 45 public static String getWhatDay(int days) { 46 if(days%7==0) { 47 return "Sunday"; 48 } 49 else if(days%7==1) { 50 return "Monday"; 51 } 52 else if(days%7==2) { 53 return "Tuesday"; 54 } 55 else if(days%7==3) { 56 return "Wednesday"; 57 } 58 else if(days%7==4) { 59 return "Thursday"; 60 } 61 else if(days%7==5) { 62 return "Friday"; 63 } 64 else 65 return "Saturday"; 66 67 } 68 69 public static int flag(int year,int month,int day) 70 { 71 int Flag=0; 72 int[] mon1=new int[]{0,31,29,31,30,31,30,31,31,30,31,30,31}; 73 int[] mon2=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31}; 74 if(year>=1820&&year<=2020) 75 { 76 if(month>0&&month<=12) 77 { 78 if(isLeapYear(year)) 79 { 80 if(day<=mon1[month]&&day>0) 81 Flag=1; 82 } 83 else 84 { 85 if(day<=mon2[month]&&day>0) 86 Flag=1; 87 } 88 } 89 } 90 return Flag; 91 } 92 }
解题报告所言，有几点需要注意：
- 注意闰年的情况；
- 注意每个月的最大天数；
- 注意输入数据的有效范围。
我觉得我的flag()方法中72、73行打出了闰年和非闰年的天数来判断是否输入合法比较呆，应该有更好的方法，只需要通过是否为闰年的判断在2月的天数上+1就可以了。
计算从0001年1月1日至输入日期的天数需要注意闰年天数+1。
7-4
1 import java.util.Scanner; 2 public class Main { 3 public static void main(String[] args) { 4 Scanner input = new Scanner(System.in); 5 Date d = new Date(); 6 //Main ljy = new Main(); 7 int year = input.nextInt(); 8 int month = input.nextInt(); 9 int day = input.nextInt(); 10 11 12 13 14 if(d.checkInputValidity(year, month, day)) 15 System.out.println("Next day is:"+year+"-"+month()+"-"+day()); 16 else 17 System.out.println("Date Format is Wrong"); 18 } 19 } 20 21 class Date{ 22 private int year; 23 private int month; 24 private int day; 25 int mon_maxnum[] = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31}; //非闰年下的每月最大天数 26 27 Date(){ 28 } 29 Date(int year,int month,int day){ 30 this.year = year; 31 this.month = month; 32 this.day = day; 33 } 34 35 36 37 */ 38 39 public boolean isLeapYear(int year) { 40 if((year % 4 == 0 && year % 100 !=0 ) || year % 400==0) 41 return true; 42 else 43 return false; 44 } 45 46 public boolean checkInputValidity(/*int year,int month,int day*/) //不需要传参了 47 { 48 boolean Flag=false; 49 int[] mon1=new int[]{0,31,29,31,30,31,30,31,31,30,31,30,31}; 50 int[] mon2=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31}; 51 if(year>=1900 && year<=2000) 52 { 53 if(month>0 && month<=12) 54 { 55 if(isLeapYear(year)) 56 { 57 mon_maxnum[2]=29; //放到判断是否合法的方法中 改变闰年二月的最大天数 58 if(day<=mon1[month] && day>0) 59 Flag=true; 60 } 61 else 62 { 63 if(day<=mon2[month] && day>0) 64 Flag=true; 65 } 66 } 67 } 68 return Flag; 69 } 70 71 public void nextDate(int year,int month,int day){ 72 if (month == 12 && day == 31) 73 { 74 year++; 75 month = 1; 76 day = 1; 77 } 78 else if (day == mon_maxnum[month]) 79 { 80 81 month++; 82 day = 1; 83 84 } 85 else if (day < mon_maxnum[month]) 86 { 87 day++; 88 } 89 } 90 }
程序相比7-3核心在于nextDate()方法，我设置了mon_maxnum[]数组来记录每个月的最大天数，并通过闰年判断实现了7-3中所说的简化操作（第57行），即将闰2二月的mon_maxnum改为29天。
特别注意12月31日需要单独判断，其他的就是仅判断每月的最大天数与输入天数是相同，相同则跳到下一月并将天数更新为1，否则仅将天数加1。
7-5
1 import java.util.Scanner; 2 public class Main { 3 public static void main(String[] args) { 4 Scanner input = new Scanner(System.in); 5 Date d = new Date(); 6 //Main ljy = new Main(); 7 int year = input.nextInt(); 8 int month = input.nextInt(); 9 int day = input.nextInt(); 10 11 12 13 14 if(d.checkInputValidity(year, month, day)) 15 System.out.println("Next day is:"+year+"-"+month()+"-"+day()); 16 else 17 System.out.println("Date Format is Wrong"); 18 } 19 } 20 21 class Date{ 22 private int year; 23 private int month; 24 private int day; 25 int mon_maxnum[] = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31}; //非闰年下的每月最大天数 26 27 Date(){ 28 } 29 Date(int year,int month,int day){ 30 this.year = year; 31 this.month = month; 32 this.day = day; 33 } 34 35 36 37 */ 38 39 public boolean isLeapYear(int year) { 40 if((year % 4 == 0 && year % 100 !=0 ) || year % 400==0) 41 return true; 42 else 43 return false; 44 } 45 46 public boolean checkInputValidity(/*int year,int month,int day*/) //不需要传参了 47 { 48 boolean Flag=false; 49 int[] mon1=new int[]{0,31,29,31,30,31,30,31,31,30,31,30,31}; 50 int[] mon2=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31}; 51 if(year>=1900 && year<=2000) 52 { 53 if(month>0 && month<=12) 54 { 55 if(isLeapYear(year)) 56 { 57 mon_maxnum[2]=29; //放到判断是否合法的方法中 改变闰年二月的最大天数 58 if(day<=mon1[month] && day>0) 59 Flag=true; 60 } 61 else 62 { 63 if(day<=mon2[month] && day>0) 64 Flag=true; 65 } 66 } 67 } 68 return Flag; 69 } 70 71 public static void nextDate(int year,int month,int day,int n) { 72 int[] mm={0,31,28,31,30,31,30,31,31,30,31,30,31}; 73 if (isLeapYear(year))mm[2]=29; 74 day-=n; 75 if (n>0){ 76 while (day<=0){ 77 78 79 month--; 80 if (month==0){//这边因为是mm有0的索引，因此要提前判断是否等于0 81 month+=12; 82 year--; 83 } 84 day+=mm[month]; 85 } 86 }else if (n<0){ 87 while (day>mm[month]) { 88 day-=mm[month]; 89 month++; 90 if (month==13){ 91 month-=12; 92 year++; 93 } 94 } 95 } 96 }
- 7-5相比7-4个人聚德思维难度高了很多，也可能是我这个人对进位退位比较呆，不同还是集中在getNextNday，注意到测试样例中有负数，一开始还没注意，想当然地认为next跟得肯定正数。
- 注意到80行 mm[]数组下标从0开始，要特别判断0的情况，等于0也就是退回上一年的12月了， month--;与day+=mm[month];在同一个while循环里，直到month把day欠的债还完为止。
- n为负数的情况则为逆过程，需要注意month为13的情况，即进了一年。
第三次作业
7-2
1 import java.util.Scanner; 2 public class Main { 3 public static void main(String[] args) { 4 Scanner input = new Scanner(System.in); 5 Date d = new Date(); 6 //Main ljy = new Main(); 7 int year = input.nextInt(); 8 int month = input.nextInt(); 9 int day = input.nextInt(); 10 11 d.setYear(year); 12 d.setMonth(month); 13 d.setDay(day); 14 15 16 17 d.getNextDay(/*year,month,day*/); 18 19 if(d.checkInputValidity(/*year, month, day*/)) 20 System.out.println("Next day is:"+d.getYear()+"-"+d.getMonth()+"-"+d.getDay()); 21 else 22 System.out.println("Date Format is Wrong"); 23 } 24 } 25 26 class Date{ 27 private int year; 28 private int month; 29 private int day; 30 int mon_maxnum[] = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31}; //非闰年下的每月最大天数 31 32 Date(){ 33 } 34 Date(int year,int month,int day){ 35 this.year = year; 36 this.month = month; 37 this.day = day; 38 } 39 40 public void setYear(int year) 41 {this.year = year;} 42 public void setMonth(int month) 43 {this.month = month;} 44 public void setDay(int day) 45 {this.day = day;} 46 47 public int getYear() 48 {return year;} 49 public int getMonth() 50 {return month;} 51 public int getDay() 52 {return day;} 53 54 55 public boolean isLeapYear(int year) { 56 if((year % 4 == 0 && year % 100 !=0 ) || year % 400==0) 57 return true; 58 else 59 return false; 60 } 61 62 public boolean checkInputValidity(/*int year,int month,int day*/) //不需要传参了 63 { 64 boolean Flag=false; 65 int[] mon1=new int[]{0,31,29,31,30,31,30,31,31,30,31,30,31}; 66 int[] mon2=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31}; 67 if(year>=1900 && year<=2000) 68 { 69 if(month>0 && month<=12) 70 { 71 if(isLeapYear(year)) 72 { 73 mon_maxnum[2]=29; //放到判断是否合法的方法中 改变闰年二月的最大天数 74 if(day<=mon1[month] && day>0) 75 Flag=true; 76 } 77 else 78 { 79 if(day<=mon2[month] && day>0) 80 Flag=true; 81 } 82 } 83 } 84 return Flag; 85 } 86 87 public void getNextDay(/*int year,int month,int day*/){ //无须传参 88 if (month == 12 && day == 31) 89 { 90 year++; 91 month = 1; 92 day = 1; 93 } 94 else if (day == mon_maxnum[month]) 95 { 96 97 month++; 98 day = 1; 99 100 } 101 else if (day < mon_maxnum[month]) 102 { 103 day++; 104 } 105 } 106 }
放弃了全部使用this的传参方法，而是改用set和get专门设置和获取改变后的值，其他的与第二次作业的分析（上翻）大致相同，体现了封装性。
7-3
（头疼）
这题我也有很多测试点没有过，只配过过（Wrong Fromat）......
三、踩坑心得
- 首先当然是第一次作业刚刚接触Java时的Main问题了，较简单的题可以直接在PTA上写，如果题目较难，可以在Eclipse上写好，也方便改错，但记得提交要改主类名，不过这会导致Eclipse中运行不了，所以如果想保存可以直接运行的代码，建议最后再PTA上改类名。
- 为什么会有运行超时的测试点错误？？？下次改个变量名或许就好了。
- 定义月份最大天数数组最好定义13个，第一个数据设为0，日期往回减要注意“”month==13”的情况
- get方法有返回值，不需要参数，set方法有参数，无返回值（从我第三次作业的注释中就可以看出来被整得多惨了），get方法得到的是改变后的值，配上private体现了封装性虽然很简单的问题，却的确困扰了我很久。第三次作业中的7-2中的这、这、还有这：
四、改进建议
- 第二次作业的7-3题，可以使用闰年判断在二月对应的数组最大天数+1，不需要憨憨地打出两个数组。
- 尽量使用可读性强的英文名词，少用拼音或者只有自己才看得懂的标识符，顺便还能学学英语，为以后读别人的程序做准备。
- 多查Java方法库里的源码，有助于理解底层思维，事实上某些题目也不能用Java方法库里方法，但并不妨碍稍微深入一点地了解它。
- 正则表达式还需要再多学学，毕竟功能强大，又是和常见的字符串打交道。
五、总结
- 学了一些上课没怎涉及到的方法，例如Integer.ParseInt()、string.charAt()、Character.toLowerCase()等。
- 学会了正则表达式的一点皮毛（还不太会灵活运用）。
- 初步认识了类和对象的具体应用。
- 初步认识到了封装性，set、get、private等的作用。
/*---以下部分非作业，记录下学习历程罢了，老师看到了可以直接划走---*/
- 因为前段时间准备C语言课设的答辩，没怎么在Java上花时间，导致上课做练习的时候比较懵，上课翻书还被老师怼了，只能说自己太菜了，熬了个大夜，写了两题出来，好了一点点
- 感觉Java学得挺曲折的，有点怕Java挂掉。
浙公网安备 33010602011771号