（1） 前言
- 题集一
- 知识点：主要是基础知识的运用，eg：if语句，for语句，循环语句，数据的输入输出，字符串及其一些常用的方法的运用，以及对double，float，int等类型的使用，运用到一些实例之中。
- 题量：9题
- 难度：偏容易
- 题集二
- 知识点：对数据结合生活的适当处理
- 题量：4题
- 难度：中等
- 题集三
- 知识点：类的创建及其运用
- 题量：4题
- 难度：中等
（2）部分题目的设计与分析
- 题目集2的7-2
题目：串口字符解析
RS232是串口常用的通信协议，在异步通信模式下，串口可以一次发送5~8位数据，收发双方之间没有数据发送时线路维持高电平，相当于接收方持续收到数据“1”（称为空闲位），发送方有数据发送时，会在有效数据（5~8位，具体位数由通信双方提前设置）前加上1位起始位“0”，在有效数据之后加上1位可选的奇偶校验位和1位结束位“1”。请编写程序，模拟串口接收处理程序，注：假定有效数据是8位，奇偶校验位采用奇校验。
输入格式:
由0、1组成的二进制数据流。例如：11110111010111111001001101111111011111111101111
输出格式:
过滤掉空闲、起始、结束以及奇偶校验位之后的数据，数据之前加上序号和英文冒号。
如有多个数据，每个数据单独一行显示。
若数据不足11位或者输入数据全1没有起始位，则输出"null data"，
若某个数据的结束符不为1，则输出“validate error”。
若某个数据奇偶校验错误，则输出“parity check error”。
若数据结束符和奇偶校验均不合格，输出“validate error”。
如：11011或11111111111111111。
例如：
1:11101011
2:01001101
3:validate error
源码如下：
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
String n=input.nextLine();
int x = n.length();
int a=0;
int z=1;
char[]b=new char[100];
for(int i=0;i<x;i++){
b[i]=n.charAt(i);
if(b[i]=='1'){
a++;
}
}
if(a==x||x<11){
System.out.println("null data");
}
else{
for(int i=0;i<x;i++){
if(b[i]=='0'&&i+10<x){
int k=0;
String str =n.substring(i+1,i+9);
for(int j=i+1;j<=i+9;j++){
if(b[j]=='1'){
k++;
}
}
if(z!=1){
System.out.printf("\n");
}
if(k%2!=0&&b[i+10]=='1'){
System.out.printf("%d:%s",z,str);
z++;
}
else if(k%2==0&&b[i+10]=='1'){
System.out.printf("%d:parity check error",z);
z++;
}
else{
System.out.printf("%d:validate error",z);
z++;
}
i=i+10;
}
}
}
}
}设计与分析：先用str.length来判断是否满足11位数的基本要求，再str.charAt（）提取每一个数储存到一个char类型的数组中，再对字符串数组按照顺序进行对0的一个判断，并且判断该位后面仍然有10个数，将该0值的后9位进行String的一个转化，对0值后面的10位数进行含有1值的统计，若统计结果为奇数数则输出parity check error，为偶数则输出转化后的string类型的字符串，若0后的第十位数字的值不为1，则输出validate error。此为一轮循环，下一个循环则跳到0值后的11位重新进行循环。
- 题目集3的7-1
7-1 用类解一元二次方程式
定义一个代表一元二次方程ax2+bx+c=0的类QuadraticEquation，其属性为三个系数a、b、c（均为私有属性），类中定义的方法参考main方法中的代码。main方法源码+我自己所写的方法：
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
double a = Double.parseDouble(input.next());
double b = Double.parseDouble(input.next());
double c = Double.parseDouble(input.next());
if(a == 0){
System.out.println("Wrong Format");
System.exit(0);
}
//create a QuadraticEquation object
QuadraticEquation equation = new QuadraticEquation(a, b, c);
//get value of b * b - 4 * a * c
double discriminant = equation.getDiscriminant();
System.out.println("a=" + equation.getA() +
",b=" + equation.getB() +
",c=" + equation.getC()+":");
if (discriminant < 0) {
System.out.println("The equation has no roots.");
}
else if (discriminant == 0)
{
System.out.println("The root is " +
String.format("%.2f", equation.getRoot1()));
}
else // (discriminant >= 0)
{
System.out.println("The roots are " +
String.format("%.2f", equation.getRoot1())
+ " and " + String.format("%.2f", equation.getRoot2()));
}
}
}
class QuadraticEquation{
private double a;
private double b;
private double c;
public QuadraticEquation(double a,double b,double c) {
this.a = a;
this.b = b;
this.c = c;
}
public double getDiscriminant() {
return b*b-4*a*c;
}
public double getA() {
return a;
}
public double getB() {
return b;
}
public double getC() {
return c;
}
public double getRoot1() {
return (-b+Math.sqrt(b*b-4*a*c))/(2*a);
}
public double getRoot2() {
return (-b-Math.sqrt(b*b-4*a*c))/(2*a);
}
}
设计与分析：本题较简单，只需要对b*b-4*a*c的值进行判断，再用求根公式即可，主要考察简单的类的设计基础
- 题目集3的7-2
7-2 日期类设计
参考题目集二中和日期相关的程序，设计一个类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天
- 求两个日期相差的天数
题目所给的main函数以及我自己所写的类方法：
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;
}
}
}
}
}设计与分析：最开始看到这个感觉特别复杂，实际上也确实复杂，需要判断很多东西，首先要设置一个数字对每一个月份的天数进行一个定义，其次要判断年份是否为闰年，因为闰年的二月有29天，再对输入的日期根据题目所给范围进行一个合法性的一个判断，每次年份进行加减时都需要重新判断并且对月份的数组进行更改，对于当前日期的后几天和前几天的一个日期输出，先要根据所给的n天进行年，月的越界的一个判断，如果超过当前日期到下一年或上一年的天数，则需要对下一年或上一年进行判断闰年与否，再对n减去该天数所剩下的日子进行年，月的判断，若小于一年，则从1月（前几天的话就是12月）开始逐个月份的去删减直至n为0，最后得到最终的答案。而两个日期相差的天数跟上面几乎是一样的，首先判断是否是同一年，若是，则从小的日期计算到下一年的日子，再判断是否年大于1，是则判断闰年与否进行增加天数（365或355）直至加至同一年，再判断月份之间的差距和天数的差距。
- 题目集3的7-3
参考题目7-2的要求，设计如下几个类：DateUtil、Year、Month、Day，其中年、月、日的取值范围依然为：year∈[1900,2050] ,month∈[1,12] ,day∈[1,31] , 设计类图如下：
应用程序共测试三个功能：
- 求下n天
- 求前n天
- 求两个日期相差的天数
我的源代码：
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.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.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(fromDate.getDaysofDates(toDate));
} else {
System.out.println("Wrong Format");
System.exit(0);
}
}
else{
System.out.println("Wrong Format");
System.exit(0);
}
}
}
class DateUtil{
Day d = new Day();
public DateUtil() {
}
public DateUtil(int year,int month,int day) {
d.day = day;
d.month.month = month;
d.month.year.year = year;
}
public Day getDay() {
return d;
}
public void setDay(Day day) {
d = day;
}
public boolean checkInputValidity() {
boolean a;
if(d.validat()&&d.month.validat()&&d.month.year.validat()) {
a = true;
}
else {
a = false;
}
return a;
}
public DateUtil getPreviousNDays(int n) {
int[] m = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
int day1 = d.day;
int month1 = d.month.month;
int year1 = d.month.year.year;
int k;
if(d.month.year.isLeapYear()) {
k = 366;
m[2] = 29;
}
else {
k = 365;
}
int a = 0;
for(int i=1;i<d.month.month;i++) {
a = a + m[i];
}
a = a + d.day;
if(n>a) {
n = n-a;
year1 = year1-1;
month1 = 12;
day1 = 31;
d.month.year.yearReduction();
if(d.month.year.isLeapYear()) {
k = 366;
m[2] = 29;
}
else {
k = 365;
}
while(n-k>0) {
n = n-k;
year1 = year1-1;
d.month.year.yearReduction();
if(d.month.year.isLeapYear()) {
k = 366;
m[2] = 29;
}
else {
k = 365;
}
}
while(n>m[month1]) {
n -=m[month1];
month1 = month1-1;
}
day1 =m[month1]-n;
}
else {
if(d.month.year.isLeapYear()) {
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 = d.day;
int month1 = d.month.month;
int year1 = d.month.year.year;
int k;
int a = 0;
if(d.month.year.isLeapYear()) {
k = 366;
m[2] = 29;
}
else {
k = 365;
}
for(int i=1;i<d.month.month;i++) {
a = a + m[i];
}
a = a + d.day;
if(n>k-a) {
n = n-(k-a);
year1++;
d.month.year.yearIncrement();
month1 = 1;
day1 = 1;
if(d.month.year.isLeapYear()) {
k = 366;
m[2] = 29;
}
else {
k = 365;
m[2] = 28;
}
while(n-k>0) {
n = n-k;
year1 ++;
d.month.year.yearIncrement();
if(d.month.year.isLeapYear()) {
k = 366;
m[2] = 29;
}
else {
k = 365;
m[2] = 28;
}
}
while(n>m[month1]) {
n -= m[month1];
month1++;
}
day1 = n;
}
else {
if(d.month.year.isLeapYear()) {
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(d.month.year.year<toDate.d.month.year.year) {
if(d.month.year.isLeapYear()) {
k1 = 366;
m[2] = 29;
}
else {
k1 = 365;
}
for(int i=1;i<d.month.month;i++) {
duringday +=m[i];
}
duringday += d.day;
duringday = k1-duringday;
while(toDate.d.month.year.year-d.month.year.year>1) {
d.month.year.yearIncrement();
if(d.month.year.isLeapYear()) {
k1 = 366;
}
else {
k1 = 365;
}
duringday +=k1;
}
if(toDate.d.month.year.isLeapYear()) {
m[2] = 29;
}
else {
m[2] = 28;
}
for(int i=1;i<toDate.d.month.month;i++) {
duringday = duringday + m[i];
}
duringday +=toDate.d.day ;
}
else {
if(d.month.year.isLeapYear()) {
m[2] = 29;
}
else {
m[2] = 28;
}
if(d.month.month<toDate.d.month.month) {
duringday = m[d.month.month]-d.day;
while(toDate.d.month.month-d.month.month>1) {
d.month.monthIncrement();
duringday +=m[d.month.month];
}
duringday +=toDate.d.day;
}
else {
duringday = toDate.d.day-d.day;
}
}
}
else {
if(d.month.year.year>toDate.d.month.year.year) {
if(toDate.d.month.year.isLeapYear()) {
k1 = 366;
m[2] = 29;
}
else {
k1 = 365;
}
for(int i=1;i<toDate.d.month.month;i++) {
duringday = duringday + m[i];
}
duringday = duringday + toDate.d.day;
duringday = k1-duringday;
while(d.month.year.year-toDate.d.month.year.year>1) {
toDate.d.month.year.yearIncrement();
if(toDate.d.month.year.isLeapYear()) {
k1 = 366;
}
else {
k1 = 365;
}
duringday +=k1;
}
if(d.month.year.isLeapYear()) {
m[2] = 29;
}
else {
m[2] = 28;
}
for(int i=1;i<d.month.month;i++) {
duringday = duringday + m[i];
}
duringday +=d.day ;
}
else {
if(d.month.year.isLeapYear()) {
m[2] = 29;
}
else {
m[2] = 28;
}
if(d.month.month>toDate.d.month.month) {
duringday = m[toDate.d.month.month]-toDate.d.day;
while(d.month.month-toDate.d.month.month>1) {
toDate.d.month.monthIncrement();
duringday +=m[toDate.d.month.month];
}
duringday +=d.day;
}
else {
duringday =d.day-toDate.d.day;
}
}
}
}
return duringday;
}
public String showDate() {
String str1 = ""+d.month.year.year+"-"+d.month.month+"-"+d.day;
return str1;
}
public boolean equalTwoDates(DateUtil date) {
if(date.d.month.year.year==d.month.year.year&&date.d.day==d.day&&date.d.month.month==d.month.month) {
return true;
}
else {
return false;
}
}
public boolean compareDates(DateUtil date) {
if(d.month.year.year>date.d.month.year.year) {
return false;
}
else if(d.month.year.year<date.d.month.year.year){
return true;
}
else {
if(d.month.month>date.d.month.month) {
return false;
}
else if(d.month.month<date.d.month.month) {
return true;
}
else {
if(d.day>date.d.day) {
return false;
}
else {
return true;
}
}
}
}
}
class Day {
int day;
Month month = new Month();
int[] m = new int[]{31,28,31,30,31,30,31,31,30,31,30,31};
public Day(){
}
public Day(int year,int month,int day) {
this.day = day;
this.month.month = month;
this.month.year.year = year;
}
public void setMonth(Month value) {
month = value;
}
public void setvalue(int value) {
day = value;
}
public void dayIncrement() {
day++;
}
public void dayReduction() {
day--;
}
public int getValue() {
return day;
}
public Month getMonth() {
return month;
}
public void resetMin() {
day = 1;
}
public void resetMax() {
if(month.year.isLeapYear()) {
m[1] = 29;
}
day = m[month.month-1];
}
public boolean validat()
{
if(month.year.isLeapYear()) {
m[1] = 29;
}
if(day>0&&day<=m[month.month-1])
return true;
else return false;
}
}
class Month{
int month;
Year year = new Year();
public Month() {
}
public Month(int yearValue,int monthValue) {
month = monthValue;
year.year = yearValue;
}
public int getValue() {
return month;
}
public void setValue(int monthValue) {
month = monthValue;
}
public Year getYear() {
return year;
}
public void setYear(Year year) {
this.year = year;
}
public void monthIncrement() {
month++;
}
public void monthReduction() {
month--;
}
public void resetMin() {
month = 1;
}
public void resetMax() {
month = 12;
}
public boolean validat()
{
if(month>0&&month<=12) {
return true;
}
else{
return false;
}
}
}
class Year{
int year;
public Year() {
}
public Year(int year) {
this.year = year;
}
public int getValue() {
return year;
}
public void setValue(int value) {
this.year = value;
}
public void yearIncrement() {
year++;
}
public void yearReduction() {
year--;
}
public boolean isLeapYear() //判断year是否为闰年，返回boolean类型；
{
if((year%4 == 0&&year%100 != 0)||(year%400 == 0))
return true;
else return false;
}
public boolean validat()
{
if(year>=1900&&year<=2050)
return true;
else return false;
}
}分析与设计：本题是基于7-2题的基础的升级版，相比于7-2具有耦合性更低的特点，一环扣一环，另外设计了三个类，Year，Month，Day，总体的思路与第二题无异，要修改很多东西，有些不能直接用，需要不用的连续调用，也是很复杂。
（3）踩坑心得
题集二7-2：一开始不知道要怎么去把一连串的数字分开进行判断，上网查阅资料才知道了charAt（）这个方法，才得以进行下去，而第二个问题是不知道奇偶校检，请教了同学才知道是9位数中1的个数加上第十位的1的总和的奇偶。解决问题后就主要是在格式的方面不对，后面慢慢调整就成功了。
题集三7-1：比较清楚了类的一个基本的设计，题目并没有什么难度，直接就过了
题集三7-2：真的是很复杂，做的很烦躁，需要判定的东西太多，非常考验耐心和思路是否全面，很需要注意细节，一个细节没注意就没办法通过，根据测试点知道自己哪里错了一点点的改，但是也学会了很多东西。
题集三7-3：本题我并不是满分，有两个关于月份越界的测试点没有通过，实在是找不到，很感谢有eclipse这样的软件，调用类的方法时容易多了，虽然修改的过程很疲惫，但是更加熟悉类，方法之间的使用。
（4）改进建议
题集二的7-2：串口可以一次发送5~8位数据，可以增加一个串口数据的位数的一个额外判断
题集三的7-1：我认为可以增加复数的根的情况
题集三的7-2和7-3：我觉得很完美了
（5）总结
对于三次的题目集，分别注重了基础和新的知识的结合，题集一，让我逐渐从c语言转换到Java的一个模式，而题集二进行了一个更深度的一个基础知识的运用，对数据的一些处理，题集三则对新学的知识“类”进行了练习，总得来说算是适应了Java这门语言，开始吸收关于Java独有的知识，对于类，方法的运用也有了一定的掌握，希望将来即使在打代码的过程很烦躁，也能清晰的列出自己对于题目的一个思路，不要轻易的说放弃，坚持不懈！对于目前网课，也希望自己可以更集中注意力，该记笔记的时候就记笔记，不要懒，课后和课堂的作业要认真去做，认真观看慕课的课程，进行一个预习和掌握，关于实验也要尽心尽力，希望自己可以学好Java这门语言。
扫一扫
3036
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
