面向物件程式設計-終結篇 es6新增語法
總結
一．近期學習總結
1：從剛開始的java學習中，大多數的語法均是從c語言中照搬過來，其中最開始不同的是java語言的輸入與輸出。
Java語言的輸出分為：第一種：System.out.print 第二種：System.out.println 第三種：System.out.printf。這三種的區別如下：
第一種為一般的標準輸出，輸出會自動將括號中的內容轉換成字串輸出，如果括號中是一個物件的話，就會自動呼叫toString()方法。該輸出方式不會換行。如：
public class Main{
Public static void main(String[] args){
int a = 2;
System.out.print(a);
System.out.print(“a”);
System.out.print(“a”);
System.out.print(“Hello World”);
}
}
輸出結果：2aHello World
第二種System.out.println為一般的標準輸出和在輸出末尾加換行，其用法和System.out.print相同，只是在末尾加個換行符。如：
public class Main{
Public static void main(String[] args){
int a = 2;
System.out.println(a);
System.out.println(“a”);
System.out.println(“Hello World”);
}
}
輸出結果：2
a
System.out.print(“Hello World”);
第三種System.out.printf為格式化輸出，其輸出基本沿用c語言，如：
public class Main{
Public static void main(String[] args){
int A = 65;
System.out.printf("%d",A);
System.out.printf("%c",A);
System.out.printf("Hello World");
}
}
輸出結果：65AHello World。
Java語言的輸入則更為複雜一點如下
1：首先匯入Scanner包：import java.util.Scanner;
2：建立Scanner物件，實現從控制檯獲取資訊：
Scanner input/*自己定義的名字*/ = new Scanner(System.in);
3:選擇需要輸入的型別
1：int： int a = input.nextInt();
2：float： float a = input.nextFloat():
3：double double a = input.nextDouble();
4：String： String sc = input.nextLine();
5：char： char c = input.next().charAt(0);
例項如下：
import java.util.Scanner;
public class test{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int a = input.nextInt();
float b = input.nextFloat();
double c = input.nextDouble();
String sc = input.nextLine();
char e = input.next().charAt(0);
System.out.println(a+"-"+b+"-"+c+"-"+sc+"-"+e);
}
}
輸入：1 2.1 2.22 345
A
輸出：1-2.1-2.22- 345-A
- 在java學習中與c語言不同的是c語言是面向過程的程式語言而java是面向物件的語言其中最有特點的是java語言中的類和物件。關於類和物件，其中類包括屬性和方法，屬性是指一些常量或者變數，而方法為在函式實行一定目的的行為。物件，就是在主函式中建立的特定的物件，而這個物件有具有在類中定義的屬性和方法。
例：雨刷類
import java.util.Scanner;
public class Test {//主類
public static void main(String[] args) {
// TODO Auto-generated method stub
Driver driver = new Driver();
driver.work();
}
}
Lever類
View類
import java.util.Scanner;
public class Driver {
private View view = new View();
private Agent agent = new Agent();
public Driver() {
super();
// TODO Auto-generated constructor stub
}
Driver類
public Driver(View view, Agent agent) {
super();
this.view = view;
this.agent = agent;
}
public void work() {
int choice = 0;
Scanner input = new Scanner(System.in);
while(true) {
view.menu();
choice = input.nextInt();
switch(choice) {
case 1:this.agent.getLever().upPos();break;
case 2:this.agent.getLever().downPos();break;
case 3:this.agent.getDial().upPos();break;
case 4:this.agent.getDial().downPos();break;
case 0:System.exit(0);
}
this.agent.processSpeed();
view.display(this.agent.getLever().getPos(),
this.agent.getDial().getPos(),
this.agent.getBrush().getSpeed());
}
}
}
Dial類
Brush類
Agent類
public class Agent {//關聯
private Lever lever;
private Dial dial;
private Brush brush;
public Agent() {
super();
lever = new Lever(1);
dial = new Dial(1);
brush = new Brush(0);
// TODO Auto-generated constructor stub
}
public Agent(Lever lever, Dial dial, Brush brush) {
super();
this.lever = lever;
this.dial = dial;
this.brush = brush;
}
public Lever getLever() {
return lever;
}
public void setLever(Lever lever) {
this.lever = lever;
}
public Dial getDial() {
return dial;
}
public void setDial(Dial dial) {
this.dial = dial;
}
public Brush getBrush() {
return brush;
}
public void setBrush(Brush brush) {
this.brush = brush;
}
public void processSpeed() {
int speed = 0;
switch(this.lever.getPos()) {
case 1:speed = 0;break;//停止檔位
case 2: //間歇檔位
switch(this.dial.getPos()) {
case 1:speed = 4;break;//刻度盤為1
case 2:speed = 6;break;//刻度盤為2
case 3:speed = 12;break;//刻度盤為3
}break;
case 3:speed = 30;break;//低速檔位
case 4:speed = 60;break;//高速檔位
}
this.brush.setSpeed(speed);
}
}
在上述雨刷類中其中包括主類共有7個類
2.1主類主要是建立了一個物件，呼叫物件裡面的work方法。
2.2Lever類建立了一個pos屬性，並建立了構造方法，get，set，升檔，降檔的方法
2.3Brush類建立了speed屬性，建立構造方法，get，set方法
2.4Dial類建立了一個pos屬性，建立構造方法，get，set，升降刻度盤的方法
2.5View類 建立了一個輸出方法和一個選單方法
2.6Agent類 主要作用為解耦
2.7Driver類 主要作用為呼叫之前所建立的方法來實現對雨刷正常工作的需求
- java語言的三大特性；封裝，繼承，多型。
3.1：封裝性：就是把類的屬性私有化，再通過公有方法進行訪問和修改
具體實現方法 將變數定義為私有及在變數前用private修飾，如後續想要呼叫或修改該屬性則可以用get，set方法。
例項：
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Students stu = new Students(221112);
stu.print();
}
}
class Students{
private int id;
public Students(int id) {
super();
this.id = id;
}
public Students() {
super();
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public void print() {
System.out.println(id);
}
}
輸出221112
假如要更改id，在Students stu = new Students(221112);下面一行直接呼叫stu.id = 222222;編譯器會報錯。除非將Students中的private int id 改為 int id。
3.2：實現封裝的好處
3.2.1：提高程式碼的安全性
3.2.2：隱藏程式碼的細節
3.2.3：便於修改程式碼和後續程式碼的維護
3.2繼承性： 繼承就是子類繼承父類的特徵和行為，使得子類物件具有父類的例項域和方法，或子類從父類繼承方法，使得子類具有父類相同的行為，並且子類只能有一個父類，java的繼承只能進行單繼承(摒棄了c++的多繼承)，子類不能直接呼叫除了父類的私有屬性之外的方法(也可間接的呼叫方法來呼叫父類屬性)。繼承的重寫：對父類中的方法進行重寫。
例項：如
import java.util.Scanner;
class Animal{
private char[] name = new char[10];
public Animal() {
super();
}
public Animal(char[] name) {
super();
this.name = name;
}
public char[] getName() {
return name;
}
public void setName(char[] name) {
this.name = name;
}
public void sleep() {
System.out.println("動物睡覺");
}
}
class Sheep extends Animal{
}
public class test{
public static void main(String[] args) {
Sheep sheep = new Sheep();
sheep.sleep();
}
}
輸出：動物睡覺
重寫：
@Override
class Sheep extends Animal{
public void sleep() {
System.out.println("羊吃草");
}
}
輸出：羊吃草
3.3多型性：同一操作作用於不同的物件，可以有不同的解釋，產生不同的執行結果。多型中有兩種情況，向上轉型和向下轉型，向上轉型是子類到父類，向下轉型是父類到子類，兩種情況都要有繼承。Java裡的程式分為編譯階段和執行階段，當有了物件的多型性以後，我們在編譯期，只能呼叫父類中宣告的方法，但在執行期，我們實際執行的是子類重寫父類的方法。
例項：如
import java.util.Scanner;
class Animal{
private char[] name = new char[10];
public Animal() {
super();
}
public Animal(char[] name) {
super();
this.name = name;
}
public char[] getName() {
return name;
}
public void setName(char[] name) {
this.name = name;
}
public void sleep() {
System.out.println("動物睡覺");
}
public void eat() {
System.out.println("動物進食");
}
}
class Sheep extends Animal{
@Override
public void sleep() {
System.out.println("羊睡覺");
}
@Override
public void eat() {
System.out.println("羊吃草");
}
}
class Dog extends Animal{
@Override
public void sleep() {
System.out.println("狗睡覺");
}
@Override
public void eat() {
System.out.println("狗吃肉");
}
}
public class test{
public static void main(String[] args) {
Animal animal1 = new Sheep();
animal1.sleep();
animal1.eat();
Animal animal2 = new Dog();
animal2.sleep();
animal2.eat();
}
}
輸出：
羊睡覺
羊吃草
狗睡覺
狗吃肉
該例子為向上轉型。
二．題目集總結
前言：知識點：java的基本的語法如：if—else，for、while迴圈，輸入輸出，String函式，類和物件，引用的使用。
設計與分析：
第二次題目集第二個：本題首先進行一個for迴圈判斷1的個數，並將輸入的每一個數字存入陣列中，其次根據1的個數和輸入字串的長度判斷是否滿足null date的情況，如滿足則輸出null date 不滿足則進行下一步判斷，首先判斷起始點0，在將之後的值全部加起來判斷是否是奇校驗在用if-else將每一種情況輸出。
第三次題目集的第二個：首先根據題目要求並根據主函式寫出另一個Dateutil類，在這個類中根據類圖
首先建立三個私有屬性的year，month，day，在根據類圖將各個方法寫出來，其中最重要為求前n天方法，後n天方法，和兩個日期相距的天數，在求前n天方法中，先判斷是否是大於365天，在將每一種情況用if-else列出來，然後將剩餘的天數進入for迴圈中，一天天的減，在用if-else進行列舉。其中求後n天演算法基本與求前n天一致，也是先判斷是否是大於365天，在將每一種情況用if-else列出來，然後將剩餘的天數進入for迴圈中，一天天的加，在用if-else進行列舉。求相差n天時，用日期小的一天天加到日期大的，然後輸出增加的天數即為相差天數。
第三次題目集的第三個：
其主要方法與第二題無異議，基本套用第二題的演算法，只是因為增加了幾個類，每次改值的時候均需要引用，根據類圖
來設計每一個類所要的屬性與方法。
第三次第四個題目：其核心演算法與前兩題基本一致，只需根據類圖
進行設計好每一種屬性與方法。
踩坑心得：
題目集2第二題：
原始碼如下：
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
String sc = input.nextLine();
int count = 0;
int num = 1;
int check = 0;
int sum = 0;
char[] a = new char[100];
for(int i=0;i<sc.length();i++) {
a[i] = sc.charAt(i);
if(sc.charAt(i)=='1') {
count++;
}
}
if(sc.length()<11||count==sc.length()){
System.out.println("null data");
}
else{
for(int i=0;i<sc.length();i++){
if(a[i]=='0'){
for(int j=i+1;j<i+10;j++){
sum = sum + a[j];
}
check = sum % 2;
sum = 0;
if(check==1){
if(a[i+10]=='1'){
System.out.println(num+":"+sc.substring(i+1,i+9));
num = num + 1;
}
else {
System.out.println(num+":"+"validate error");
num = num + 1;
}
}
if(check==0){
if(a[i+10]=='1'){
System.out.println(num+":"+"parity check error");
num = num + 1;
}
else if (a[i+10]=='0'){
System.out.println(num+":"+"validate error");
num = num + 1;
}
}
i = i + 10;
}
}
}
}
}
該題在提交過程最大的一個錯誤是對於奇校驗的判斷，奇校驗判斷是輸入所需要的11個數裡面全部的1的個數加起來是否為奇數而不是最後一位為奇數。
第三次題目集第二題：
原始碼如下：
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 year;
private int month;
private int day;
int[] days = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
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 void setDays(int[] days) {
this.days = days;
}
public boolean checkInputValidity(){
boolean checkInputValidity;
int[] days = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
if(isLeapYear(year))
days[2] = 29;
checkInputValidity=(year>=1820&&year<=2020&&month>0&&month<=12&&day<=days[month]&&day>0);
return checkInputValidity;
}
public boolean isLeapYear(int year){
boolean isLeapYear;
isLeapYear = (year%4==0&&year%100!=0)||year%400==0;
return isLeapYear;
}
public DateUtil getNextNDays(int n) {
while(n>365) {
if(isLeapYear(year) && month <= 2 || isLeapYear(year+1) && month > 2){
if(month == 2 && day == 29){
day = 1;
month = month + 1;
}
year = year + 1;
n = n - 366;
}
else{
year++;
n = n - 365;
}
}
for(int i = 0 ; i < n ; i++) {
day++;
if(isLeapYear(year)) {
days[2] = 29;
}
if(day > days[month]) {
if(month<12) {
month = month + 1;
day = 1;
}
else {
month = 1;
year = year + 1;
day = 1;
}
}
}
return this;
}
public DateUtil getPreviousNDays(int n) {
while(n > 365){
if(isLeapYear(year)) {
year = year - 1;
n = n - 366;
}
if(!isLeapYear(year)) {
year = year - 1;
n = n - 365;
}
}
for(int i = 0 ; i < n; i++) {
if(isLeapYear(year)) {
days[2] = 29;
}
day--;
if(day <= 0) {
month = month - 1;
day = days[month];
if(month <= 0) {
day = 31;
month = 12;
year = year - 1;
}
}
}
return this;
}
public boolean compareDates(DateUtil date) {
if(year > date.getYear()) {
return true;
}
else if(year == date.getYear() && month > date.getMonth()) {
return true;
}
else if(year == date.getYear() && month == date.getMonth() && day > date.getDay()) {
return true;
}
else {
return false;
}
}
public boolean equalTwoDates(DateUtil date) {
if(year == date.getYear()) {
if(month == date.getMonth()) {
if(day == date.getDay()) {
return true;
}
}
}
return false;
}
public int getDaysofDates(DateUtil date) {
int sum = 0;
if(!compareDates(date)) {
while(true) {
day++;
sum++;
if(isLeapYear(year)) {
days[2] = 29;
}
else {
days[2] = 28;
}
if(day > days[month]) {
if(month < 12) {
month++;
day = 1;
}
else {
month = 1;
day = 1;
year++;
}
}
if(equalTwoDates(date)){
break;
}
}
}
return sum;
}
public String showDate(){
return year + "-" + month + "-" + day;
}
}
該題在提交過程中出現較大問題主要為求前n天，求相差天數，在求後n天時，因為未對最後一年有沒有過2月做校驗，導致了天數多一天，求相差天數的過程中，最開始的想法是用大的時間減去小的時間，因為未考慮周全導致算出答案錯誤，後改變演算法從小的時間一天天加到大的時間，增加的天數即為相差的天數。
第三次第三次題目：
程式碼如下：
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 Year{
private int value;
public Year() {
}
public Year(int value) {
this.value = value;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public boolean isLeapYear(int year){
boolean isLeapYear;
isLeapYear = (year%4==0&&year%100!=0)||year%400==0;
return isLeapYear;
}
public boolean validate() {
boolean validate;
validate = (value>=1900&&value<=2050);
return validate;
}
public void yearIncrement() {
this.value = value + 1;
}
public void yearReduction() {
this.value = value - 1;
}
}
class Month{
private int value;
Year year ;
public Month() {
super();
}
public Month(int yearValue,int monthValue){
this.year=new Year(yearValue);
this.value=monthValue;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public Year getYear() {
return year;
}
public void setYear(Year year) {
this.year = year;
}
public void resetMin(){
value=1;
}
public void resetMax(){
value=12;
}
public boolean validate(){
boolean validate;
validate = (value>=1&&value<=12);
return validate;
}
public void monthIncrement(){
value=value+1;
}
public void monthReduction(){
value=value-1;
}
}
class Day{
int value;
Month month;
int[] mon_maxnum = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
public Day() {
super();
}
public Day(int yearValue,int monthValue,int value){
this.month=new Month(yearValue,monthValue);
this.value=value;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public Month getMonth() {
return month;
}
public void setMonth(Month month) {
this.month = month;
}
public void restMin() {
value = 1;
}
public void restMax() {
value = mon_maxnum[month.getValue()];
}
public boolean validate() {
boolean validate;
if(this.getMonth().getYear().isLeapYear(this.getMonth().getYear().getValue()))
mon_maxnum[2]=29;
validate = (value>=1&&value<=mon_maxnum[month.getValue()]);
return validate;
}
public void dayIncrement() {
value=value+1;
}
public void dayReduction() {
value=value-1;
}
}
class DateUtil{
Day day;
int[] mon_maxnum = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
public DateUtil() {
super();
}
public DateUtil(int d,int m,int y){
this.day=new Day(d,m,y);
}
public Day getDay() {
return day;
}
public void setDay(Day day) {
this.day = day;
}
public boolean checkInputValidity(){
boolean checkInputValidity;
if(this.getDay().getMonth().getYear().isLeapYear(this.getDay().getMonth().getYear().getValue())) {
mon_maxnum[2] = 29;
}
checkInputValidity = (this.getDay().getMonth().getYear().validate()&&this.getDay().getMonth().validate()&&this.day.getValue()>=1&&this.day.getValue()<=mon_maxnum[this.getDay().getMonth().getValue()]);
return checkInputValidity;
}
public DateUtil getNextNDays(int n) {
while(n>365) {
if(this.getDay().getMonth().getYear().isLeapYear(this.getDay().getMonth().getYear().getValue()) && this.getDay().getMonth().getValue() <= 2||this.getDay().getMonth().getYear().isLeapYear(this.getDay().getMonth().getYear().getValue()+1) && this.getDay().getMonth().getValue() > 2){
if(this.getDay().getMonth().getValue() == 2 && this.day.getValue() == 29){
this.getDay().setValue(1);
this.getDay().getMonth().setValue(3);
}
this.getDay().getMonth().getYear().yearIncrement();
n = n - 366;
}
else{
this.getDay().getMonth().getYear().yearIncrement();
n = n - 365;
}
}
for(int i = 0 ; i < n ; i++) {
this.day.dayIncrement();
if(this.getDay().getMonth().getYear().isLeapYear(this.getDay().getMonth().getYear().getValue())) {
mon_maxnum[2] = 29;
}
else{
mon_maxnum[2] = 28;
}
if(this.day.getValue() > mon_maxnum[this.getDay().getMonth().getValue()]) {
if(this.getDay().getMonth().getValue()==12) {
this.getDay().getMonth().setValue(1);
this.getDay().getMonth().getYear().yearIncrement();
this.day.setValue(1);
}
else {
this.getDay().getMonth().monthIncrement();
this.day.setValue(1);
}
}
}
return this;
}
public DateUtil getPreviousNDays(int n) {
int[] mon_maxnum = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
while(n > 365){
if(this.getDay().getMonth().getYear().isLeapYear(this.getDay().getMonth().getYear().getValue())) {
this.getDay().getMonth().getYear().yearReduction();
n = n - 366;
}
if(!this.getDay().getMonth().getYear().isLeapYear(this.getDay().getMonth().getYear().getValue())) {
this.getDay().getMonth().getYear().yearReduction();
n = n - 365;
}
}
for(int i = 0 ; i < n; i++) {
if(this.getDay().getMonth().getYear().isLeapYear(this.getDay().getMonth().getYear().getValue())) {
mon_maxnum[2] = 29;
}
else{
mon_maxnum[2] = 28;
}
this.day.dayReduction();
if(this.day.getValue() <= 0) {
this.getDay().getMonth().monthReduction();
this.day.setValue(mon_maxnum[this.getDay().getMonth().getValue()]);
if(this.getDay().getMonth().getValue() <= 0) {
this.day.setValue(31);
this.getDay().getMonth().setValue(12);
this.getDay().getMonth().getYear().yearReduction();
}
}
}
return this;
}
public boolean compareDates(DateUtil date) {
if(this.getDay().getMonth().getYear().getValue() > date.getDay().getMonth().getYear().getValue()) {
return true;
}
else if(this.getDay().getMonth().getYear().getValue() == date.getDay().getMonth().getYear().getValue() && this.getDay().getMonth().getValue() > date.getDay().getMonth().getValue()) {
return true;
}
else if(this.getDay().getMonth().getYear().getValue() == date.getDay().getMonth().getYear().getValue() && this.getDay().getMonth().getValue() == date.getDay().getMonth().getValue() && this.getDay().getValue() > date.day.getValue()) {
return true;
}
else {
return false;
}
}
public boolean equalTwoDates(DateUtil date) {
if(this.getDay().getMonth().getYear().getValue() == date.getDay().getMonth().getYear().getValue()) {
if(this.getDay().getMonth().getValue() == date.getDay().getMonth().getValue()) {
if(this.getDay().getValue() == date.getDay().getValue()) {
return true;
}
}
}
return false;
}
public int getDaysofDates(DateUtil date) {
int sum = 0;
while(true) {
if(equalTwoDates(date)){
sum = 0;
break;
}
if(!compareDates(date)) {
day.dayIncrement();
sum++;
if(this.getDay().getMonth().getYear().isLeapYear(this.getDay().getMonth().getYear().getValue())) {
mon_maxnum[2] = 29;
}
else {
mon_maxnum[2] = 28;
}
if(day.getValue()>mon_maxnum[this.getDay().getMonth().getValue()]) {
if(this.getDay().getMonth().getValue() < 12) {
this.getDay().getMonth().monthIncrement();
this.getDay().setValue(1);
}
else {
this.getDay().getMonth().setValue(1);
this.getDay().setValue(1);
this.getDay().getMonth().getYear().yearIncrement();
}
}
if(equalTwoDates(date)){
break;
}
}
else {
if(equalTwoDates(date)){
sum = 0;
break;
}
date.getDay().dayIncrement();
sum++;
if(date.getDay().getMonth().getYear().isLeapYear(date.getDay().getMonth().getYear().getValue())) {
mon_maxnum[2] = 29;
}
else {
mon_maxnum[2] = 28;
}
if(date.getDay().getValue()>mon_maxnum[date.getDay().getMonth().getValue()]) {
if(date.getDay().getMonth().getValue() < 12) {
date.getDay().getMonth().monthIncrement();
date.day.setValue(1);
}
else {
date.getDay().getMonth().setValue(1);
date.getDay().setValue(1);
date.getDay().getMonth().getYear().yearIncrement();;
}
}
if(equalTwoDates(date)){
break;
}
}
}
return sum;
}
public String showDate(){
return this.getDay().getMonth().getYear().getValue() + "-" + this.getDay().getMonth().getValue() + "-" + this.getDay().getValue();
}
}
關於該題的最大的難點為怎麼引用，要更改年份必須得從day，在到month，最後才到年份，該題的演算法基本還是與第二題一致，直接將第二題的程式碼改為引用的格式。
第三次第四題:
其原始碼將第三題的原始碼改成單個的引用就可以了，不必像上一題一樣修改年份的值非常的繁瑣，這三題的演算法幾乎一致，但由於後面兩題的測試點更為複雜一點，要將前面未考慮周全的情況給補全。
改進建議：
對於第二次題目集的第二次作業，因其僅需實現一個功能，就是對輸入字串進行判斷其是否滿足哪種情況，所以我認為該題沒有什麼改進建議。
對於第三次題目集第二次作業：該題除了主類之外，僅有一個Dateutil類，未能完全的體現出java面向物件的特性，所以要將該程式碼修改出多個類，並解除程式碼的耦合性。
對於第三次題目集第三次作業：該題目雖然除了主類之後還有四個類，但是該題類設計的非常繁瑣，要想修改或檢視年份，月份，必須從day開始，這樣僅會增加工程量，對其他的並沒有什麼很大的幫助，應該將類與類之間的耦合性解除，使得單個類能獨立處理東西。
對於第三次題目集第四次作業：該題目我認為是這道題目的最佳解法，滿足程式碼的低耦合性，該種寫法也對後續更新帶來便捷。
總結:通過這三次題目集的練習，實現了從c語言到java 語言的簡單過渡。從第一次題目集基本與c語言的寫法一致，只是輸入和輸出不一樣，到第二次題目集比第一次更復雜的演算法，再到最後一次題目集對類的建立及對類與類之間方法的呼叫，這三次題目集一步一步的將我從c語言的面向程式的思想調整為java語言面向物件的思想。對於這幾次程式碼的編寫，老師引導我們使用業界裡阿里巴巴的程式碼格式，我也盡力的轉變自己的程式碼格式，以及對編寫程式碼後註釋的編寫，現在對我來說，對於多型的理解遠遠不到位，應該多去學習和領悟，對於java這麼語言僅僅依靠課上學習，課後的pta作業是遠遠不夠的，我還應該多去學習後續的課程。