201871010123-吳麗麗《面向對象程序設計（Java）》第四周學習總結

時間 2019-11-18

原文原文鏈接

201871010123-吳麗麗《面向對象程序設計（Java）》第四周學習總結html

項目	內容
這個做業屬於哪一個課程	https://www.cnblogs.com/nwnu-daizh/
這個做業的要求在哪裏	https://www.cnblogs.com/nwnu-daizh/p/11552848.html
做業的學習目標	1. 掌握類與對象的基礎概念，理解類與對象的關係；java 2. 掌握對象與對象變量的關係；編程 3. 掌握預約義類Date、LocalDate類的經常使用API；數組 4. 掌握用戶自定義類的語法規則，包括實例域、靜態域、構造器方法、更改器方法、訪問器方法、靜態方法、main方法、方法參數的定義要求；（重點、難點）dom 5. 掌握對象的構造方法、定義方法及使用要求；（重點）；ide 6. 理解重載概念及用法；函數掌握包的概念及用法單元測試

第一部分：總結第四章理論知識學習

1.類與對象的基礎概念測試

A:什麼是類？

a)類是具備相同屬性和行爲的一組對象的集合

b)類（class）是描述對象的模板，它定義一類對象所能擁有的數據和能完成的操做，在面向對象的程序設計中，類是構造程序的基本單元。

c)每一個類由一組結構化的數據（稱做實例域）和在其上的一組操做（稱爲方法）構成。

B:什麼是對象？

a）對象是具體實體，具備明肯定義的狀態和行爲。

b)對象的三個主要特徵：

-行爲（behavior）：能夠對對象施加什麼操做（方法）？

-狀態（state）：當施加哪些方法時，對象如何如何響應？

-標識（identity）：如何辨別具體相同行爲與狀態的不一樣對象?

2.類與對象的關係

a)類是對象，事物的描述和抽象，是具備相同屬性和行爲的對象集合。對象則是該類事物的實例。　　　　

b)類是一個靜態的概念，類自己不攜帶任何數據。當沒有爲類建立任何對象時，類自己不存在於內存空間中。對象是一個動態的概念。每個對象都存在着有別於其它對象的屬於本身的獨特的屬性和行爲。對象的屬性能夠隨着它本身的行爲而發生改變。

3.類之間的關係：

a）依賴(use-a):若是一個類中的方法操做了另外一個類的對象，那麼這個類就依賴於另外一個類。

b）聚合（has-a）：類A的對象包含類B的對象

c）繼承（is-a）：表示一個特定類和一個通常類之間的關係。通常來講，若是類A繼承了類B，那麼類A不只繼承了類B的方法和狀態，並且還有屬於本身的方法和狀態。

4.預約義類的使用

a）已學過的預約義類：Math類、math類、String類、Scanner類等，掌握練習預約義類API的技術方法。

b）要使用預約義類的方法，只需知道方法名和參數便可，無需瞭解它的內部實現過程。

c）使用預約義類須要在程序開始處使用import命令導入該類所在的包路徑。

5.對象與對象變量

1）對象

a）在OOP中，要想使用對象，需先構造對象，並初始化對象狀態，而後經過對象調用類中的辦法。

b）java中，用構造器（constructor）構造並初始化對象。

c)構造器是類中一個特殊方法，該方法名與類名相同。

d）構造並初始化對象的格式：

new 構造器名（參數）

2）對象變量

a)若是要屢次使用初始化的對象，可將初始化的對象放在一個對象變量中。

格式： Date birthday = new Date();

b)對象變量保存了對象後，可用對象變量引用對象。

注：對象變量不能空引用。也能夠顯示的將變量對象設置爲null，表面這個對象變量目前沒有引用任何對象。

6.用戶自定義類

（1）類的定義包括兩部份內容：聲明和類體

（2）類體由兩部分構成：

一爲實體域（或成員變量）定義；二爲方法定義。

（3）域的定義

a）實例域（成員變量）：類定義時實例域部分所定義的變量。實例域在整個類內都有效。

b）局部變量：方法體中定義的變量和方法的參數。只在定義它的方法內有效。

（4）實例域的隱藏性

局部變量與實例域名字相同時，則實例域被隱藏，即在這個方法內暫時失效。

7.掌握用戶自定義類的語法規則，包括靜態域、構造器方法、更改器方法、訪問器方法、靜態方法、main方法、方法參數的定義要求

a）實例域：可將實例域定義爲final,構建對象時必須初始化這樣的域。

b）靜態域：絕大多數面向對象程序設計語言中，靜態域被稱爲類域。若是將域定義爲static，每一個類中只有一個這樣的域。而每一個對象對於全部的實例域卻都有本身的一份拷貝。

c）靜態方法：靜態方法是一種不能向對象實時操做的方法。可使用對象或類名調用靜態方法。

d）構造器方法:構造器與類同名。構造器老是伴隨着new操做符的執行被調用，而不能對一個已經存在的對象調用構造器來達到從新設置實例域的目的。

e）更改器方法：一個類中對實例域進行修改的方法，一般更改器方法名前綴爲set。調用更改器方法後對象的狀態會改變。

f）訪問器方法：只訪問對象而不修改對象的方法。

g）main方法：main方法不對任何對象進行操做。靜態的main方法將執行並建立程序所須要的對象。

8.重載

多個方法有相同的名字、不一樣的類型、不一樣的參數、便產生了重載。Java容許重載任何方法，而不僅是構造器方法。

9.包

1）Java容許使用包將類組織起來。藉助包能夠方便地組織本身的代碼，並將本身的代碼與別人提供的代碼庫分開管理。並且使用包能夠確保類名的惟一性。

2）包做用域

a）類中標記爲public的部分能夠被任意類使用；

b）類中標記爲private的部分只能在類中使用；

c）若是沒有爲類、方法或實例域指定訪問控制修飾符public或private，這部分能夠被同一包中的全部方法訪問。

10.文檔註釋技術

a）類註釋

b）方法註釋

c）域註釋

d）通用註釋

e）包與概述註釋

第二部分：實驗部分

實驗名稱：實驗三類與對象的定義及使用

1. 實驗目的：

(1) 熟悉PTA平臺線上測試環境；

(2) 理解用戶自定義類的定義；

(3) 掌握對象的聲明；

(4) 學會使用構造函數初始化對象；

(5) 使用類屬性與方法的使用掌握使用；

(6) 掌握package和import語句的用途。

2.實驗步驟與內容

實驗1 任務1

公民身份證號碼按照GB11643—1999《公民身份證號碼》國家標準編制，由18位數字組成：前6位爲行政區劃分代碼，第7位至14位爲出生日期碼，第15位至17位爲順序碼，第18位爲校驗碼。從鍵盤輸入1個身份證號，將身份證號的年月日抽取出來，按年-月-日格式輸出。注意：輸入使用Scanner類的nextLine()方法，以避免出錯。

輸入樣例:

34080019810819327X

輸出樣例:

1981-08-19

程序代碼以下：

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		System.out.println("please input your ID:");
		String s1 = in.nextLine();
		String s2,s3,s4;
		s2 = s1.substring(6, 10);
		s3 =s1.substring(10, 12);
		s4 = s1.substring(12, 14);
		System.out.println(s2+"-"+s3+"-"+s4);

	}

}

　　程序運行以下：

實驗1 任務二

studentfile.txt文件內容是某班同窗的學號與姓名，利用此文件編制一個程序，將studentfile.txt文件的信息讀入到內存，並提供兩類查詢功能：（1）輸入姓名查詢學號；（2）輸入學號查詢姓名。要求程序具備友好人機交互界面。

編程建議：

（1）從文件中讀入學生信息，能夠編寫以下函數：

public static void StudentsFromFile(String fileName))

（2）輸入姓名查找學生學號，能夠編寫以下函數：

public static String findStudent(String name)

（3）輸入學號查找學生姓名，能夠編寫以下函數：

public static String findStudent(String ID)

程序代碼以下：

package Package;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;

public class Main {
    private static Student students[];
    public static void main(String[] args) {
        students=new Student[50];
        Scanner in = new Scanner(System.in);
        try {
            readFile("studentfile.txt");
            System.out.println("請選擇操做，1按姓名，2按學號，3退出");
            int i;
            while ((i = in.nextInt()) != 3) {
                switch (i) {
                case 1:
                    System.out.println("請輸入姓名");
                    String name = in.next();
                    Student student = findStudentByName(name);
                    if (student == null) {
                        System.out.println("沒找到");
                    } else {
                        System.out.println(student.toString());
                    }
                    System.out.println("請選擇操做，1按姓名，2按學號，3退出");
                    break;
                case 2:
                    System.out.println("請輸入學號");
                    String id = in.next();
                    Student student1 = findStudentById(id);
                    if (student1 == null) {
                        System.out.println("沒找到");
                    } else {
                        System.out.println(student1.toString());

                    }
                    System.out.println("請選擇操做，1按姓名，2按學號，3退出");
                    break;

                default:
                    System.out.println("輸入有誤");
                    System.out.println("請選擇操做，1按姓名，2按學號，3退出");
                    break;
                }

            }
        } catch (IOException e) {
            // TODO 自動生成的 catch 塊
            e.printStackTrace();
        }finally {
            in.close();
        }

    }

    public static void readFile(String path) throws IOException {
        FileReader reader = new FileReader(path);
        BufferedReader br = new BufferedReader(reader);
        String result;
        int i=0;
        while ((result = br.readLine()) != null) {
            Student student = new Student();
            student.setName(result.substring(13));
            student.setID(result.substring(0,12));
            students[i]=student;
            i++;
        }
        br.close();
    }

    public static Student findStudentByName(String name) {
        for (Student student : students) {
            if (student.getName().equals(name)) {
                return student;
            }
        }
        return null;

    }

    public static Student findStudentById(String Id) {
        for (Student student : students) {
            if (student.getID().equals(Id)) {
                return student;
            }
        }
        return null;

    }
}

class Student {
    private String name;
    private String ID;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getID() {
        return ID;
    }

    public void setID(String iD) {
        ID = iD;
    }

    @Override
    public String toString() {
        // TODO 自動生成的方法存根
        return "姓名是：" + name + "學號是：" + ID;
    }
}

程序運行結果以下：

實驗2 導入第4章示例程序並測試。

測試程序1：

l 編輯、編譯、調試運行程序4-2（教材104頁）；

l 結合程序運行結果，掌握類的定義與類對象的用法，並在程序代碼中添加類與對象知識應用的註釋；

l 嘗試在項目中編輯兩個類文件（Employee.java、 EmployeeTest.java ），編譯並運行程序。

l 參考教材104頁EmployeeTest.java，設計StudentTest.java，定義Student類，包含name（姓名）、sex（性別）、javascore（java成績）三個字段，編寫程序，從鍵盤輸入學生人數，輸入學生信息，並按如下表頭輸出學生信息表：

姓名性別 java成績

程序4-2代碼以下：

import java.time.*;     //導入java.time的包

/**
 * This program tests the Employee class.
 * @version 1.13 2018-04-10
 * @author Cay Horstmann
 */
public class EmployeeTest
{
   public static void main(String[] args)
   {
      // 用三個employee對象填充staff數組
      Employee[] staff = new Employee[3];     

      staff[0] = new Employee("Carl Cracker", 75000, 1987, 12, 15);
      staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
      staff[2] = new Employee("Tony Tester", 40000, 1990, 3, 15);

      // raise everyone's salary by 5%    給每人漲5%的工資
      for (Employee e : staff)     //進行foreach循環
         e.raiseSalary(5);

      // print out information about all Employee objects
      for (Employee e : staff)
         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay=" 
            + e.getHireDay());
   }
}

class Employee
{
   private String name;   //實例域定義
   private double salary;  //實例域定義
   private LocalDate hireDay;  //實例域定義

   public Employee(String n, double s, int year, int month, int day)     //構造器的定義
   {
      name = n;
      salary = s;
      hireDay = LocalDate.of(year, month, day);
   }

   public String getName()    //實例域name的訪問器方法
   {
      return name;
   }

   public double getSalary()  //實例域Salary的訪問器方法
   {
      return salary;
   }

   public LocalDate getHireDay()  ////實例域HireDay的訪問器方法
   {
      return hireDay;
   }

   public void raiseSalary(double byPercent)   
   {
      double raise = salary * byPercent / 100;
      salary += raise;
   }

　程序運行結果以下

EmployeeTest.java

 1 package test
 2 
 3 public class EmployeeTest
 4 {
 5    public static void main(String[] args)
 6    {
 7       // 用三個employee對象填充staff數組
 8       Employee[] staff = new Employee[3];     
 9 
10       staff[0] = new Employee("Carl Cracker", 75000, 1987, 12, 15);
11       staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
12       staff[2] = new Employee("Tony Tester", 40000, 1990, 3, 15);
13 
14       // raise everyone's salary by 5%    給每人漲5%的工資
15       for (Employee e : staff)     //進行foreach循環
16          e.raiseSalary(5);
17 
18       // print out information about all Employee objects
19       for (Employee e : staff)
20          System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay=" 
21             + e.getHireDay());
22    }
23 }

程序運行結果以下：

Employee.java

 1 import java.time.LocalDate;
 2 
 3 
 4 public class Employee {
 5     
 6 
 7 
 8    private String name;   //實例域定義
 9    private double salary;  //實例域定義
10    private LocalDate hireDay;  //實例域定義
11 
12    public Employee(String n, double s, int year, int month, int day)     //構造器的定義
13    {
14       name = n;
15       salary = s;
16       hireDay = LocalDate.of(year, month, day);
17    }
18 
19    public String getName()    //實例域name的訪問器方法
20    {
21       return name;
22    }
23 
24    public double getSalary()  //實例域Salary的訪問器方法
25    {
26       return salary;
27    }
28 
29    public LocalDate getHireDay()  ////實例域HireDay的訪問器方法
30    {
31       return hireDay;
32    }
33 
34    public void raiseSalary(double byPercent)   
35    {
36       double raise = salary * byPercent / 100;
37       salary += raise;
38    }
39 }

程序運行結果以下

按如下表頭輸出學生信息表：

姓名性別 java成績

代碼以下：

 1 import java.util.Scanner;
 2 
 3 public class student {
 4     String name;
 5     String sex;
 6     double javascore;
 7     public static void main(String[] args) {
 8         System.out.println("請輸入學生人數");
 9         Scanner su = new Scanner(System.in);
10         int totalStudent = su.nextInt();
11         student[] stus= new student[totalStudent];
12         for(int i=0;i<totalStudent;i++) {
13             student s =new student();
14             stus[i]=s;
15             System.out.println("請輸入第+「i"+"個學生的姓名");
16             s.name = su.next();
17             System.out.println("請輸入第+「i"+"個學生的性別");
18             s.sex = su.next();
19             System.out.println("請輸入第+「i"+"個學生的java成績");
20             s.javascore = su.nextDouble();
21         
22         }
23         printstudent(stus);
24         su.close();
25     }
26 
27     public static void printstudent(student[] s) {
28         System.out.println("姓名\t性別\tjava成績");
29         for(int i=0;i<s.length;i++) {
30             System.out.println(s[i].name+"\t"+s[i].sex+"\t"+s[i].javascore);
31          }
32     }
33 }

運行結果以下：

實驗2

測試程序2：

l 編輯、編譯、調試運行程序4-3（教材116）；

l 結合程序運行結果，理解程序代碼，掌握靜態域（netxtId）與靜態方法（getNextId）的用法，在相關代碼後添加註釋；

理解Java單元（類）測試的技巧。

代碼以下：

 1 /**
 2  * This program demonstrates static methods.
 3  * @version 1.02 2008-04-10
 4  * @author Cay Horstmann
 5  */
 6 public class StaticTest
 7 {
 8    public static void main(String[] args)
 9    {
10       // fill the staff array with three Employee objects  (用三個employee對象填充staff數組 )
11       Employee[] staff = new Employee[3];                //構造了一個Employee 數組，並填入三個僱員對象
12 
13       staff[0] = new Employee("Tom", 40000);
14       staff[1] = new Employee("Dick", 60000);
15       staff[2] = new Employee("Harry", 65000);
16 
17       // print out information about all Employee objects    （打印有關全部員工對象的信息 ）
18       for (Employee e : staff)       //調用getName 方法，getId方法和getSalary方法將每一個僱員的信息打印出來
19       {
20          e.setId();
21          System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
22             + e.getSalary());                        
23       }
24 
25       int n = Employee.getNextId(); // calls static method    （經過類名調用靜態方法 ）
26       System.out.println("Next available id=" + n);
27    }
28 }
29 
30 class Employee
31 {
32    private static int nextId = 1;     
33 
34    private String name;     //實例域定義
35    private double salary;
36    private int id;
37 
38    public Employee(String n, double s)     //構造器定義
39    {
40       name = n;
41       salary = s;
42       id = 0;
43    }
44 
45    public String getName()        //實例域name的訪問器方法
46    {
47       return name;
48    }
49 
50    public double getSalary()    //實例域Salary的訪問器方法
51    {
52       return salary;
53    }
54 
55    public int getId()          //實例域Id的訪問方法
56    {
57       return id;
58    }
59 
60    public void setId()
61    {
62       id = nextId; // set id to next available id    （將id設置爲下一個可用id ）
63       nextId++;
64    }
65 
66    public static int getNextId()        //實例域NextId的訪問方法
67    {
68       return nextId; // returns static field    （返回靜態字段）
69    }
70 
71    public static void main(String[] args) // unit test    （單元測試 ）
72    {
73       Employee e = new Employee("Harry", 50000);
74       System.out.println(e.getName() + " " + e.getSalary());
75    }
76 }

運行結果以下：

實驗2

測試程序3：

l 編輯、編譯、調試運行程序4-4（教材121）；

l 結合程序運行結果，理解程序代碼，掌握Java方法參數的用法，在相關代碼後添加註釋；

/**
 * This program demonstrates parameter passing in Java.
 * @version 1.01 2018-04-10
 * @author Cay Horstmann
 */
public class ParamTest
{
   public static void main(String[] args)
   {
      /*
       * Test 1: Methods can't modify numeric parameters（方法不能修改數值參數）
       */
      System.out.println("Testing tripleValue:");
      double percent = 10;
      System.out.println("Before: percent=" + percent);
      tripleValue(percent);     //調用方法tripleSalary
      System.out.println("After: percent=" + percent);

      /*
       * Test 2: Methods can change the state of object parameters （方法能夠更改對象參數的狀態）
       */
      System.out.println("\nTesting tripleSalary:");
      var harry = new Employee("Harry", 50000);
      System.out.println("Before: salary=" + harry.getSalary());
      tripleSalary(harry);               //調用方法tripleSalary
      System.out.println("After: salary=" + harry.getSalary());

      /*
       * Test 3: Methods can't attach new objects to object parameters
       */
      System.out.println("\nTesting swap:");
      var a = new Employee("Alice", 70000);    //定義一個類型爲var的a，並進行初始化
      var b = new Employee("Bob", 60000);
      System.out.println("Before: a=" + a.getName());
      System.out.println("Before: b=" + b.getName());
      swap(a, b);               //交換函數
      System.out.println("After: a=" + a.getName());
      System.out.println("After: b=" + b.getName());
   }

   public static void tripleValue(double x) // doesn't work（不工做）
   {
      x = 3 * x;
      System.out.println("End of method: x=" + x);
   }

   public static void tripleSalary(Employee x) // works
   {
      x.raiseSalary(200);    //x的調用
      System.out.println("End of method: salary=" + x.getSalary());
   }
        //x和y進行交換
   public static void swap(Employee x, Employee y)
   {
      Employee temp = x;
      x = y;
      y = temp;
      System.out.println("End of method: x=" + x.getName());
      System.out.println("End of method: y=" + y.getName());
   }
}

class Employee // simplified Employee class
{
   private String name;     //實例域定義
   private double salary;

   public Employee(String n, double s)  //構造器定義
   {
      name = n;
      salary = s;
   }

   public String getName()     //實例域name的訪問器方法
   {
      return name;
   }

   public double getSalary()    ////實例域Salary的訪問器方法
   {
      return salary;
   }

   public void raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;
   }
}

運行結果以下：

實驗2

測試程序4：

l 編輯、編譯、調試運行程序4-5（教材129）；

l 結合程序運行結果，理解程序代碼，掌握Java用戶自定義類的用法，掌握對象構造方法及對象使用方法，在相關代碼後添加註釋。

代碼以下：

 1 import java.util.*;
 2 
 3 /**
 4  * This program demonstrates object construction.
 5  * @version 1.02 2018-04-10
 6  * @author Cay Horstmann
 7  */
 8 public class ConstructorTest
 9 {
10    public static void main(String[] args)
11    {
12       // fill the staff array with three Employee objects   (用三個employee對象填充staff數組 )
13       var staff = new Employee[3];
14 
15       staff[0] = new Employee("Harry", 40000);
16       staff[1] = new Employee(60000);
17       staff[2] = new Employee();
18 
19       // print out information about all Employee objects  （打印有關全部員工對象的信息 ）
20       for (Employee e : staff)    //foreach循環
21          System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
22             + e.getSalary());
23    }
24 }
25 
26 class Employee
27 {
28    private static int nextId;       //靜態域nextId
29 
30    private int id;
31    private String name = ""; // instance field initialization（實例字段intialization）
32    private double salary;
33   
34    // static initialization block  （靜態intialization塊）
35    static
36    {
37       var generator = new Random();
38       // set nextId to a random number between 0 and 9999   （將nextId設置爲0到999之間的隨機值）
39       nextId = generator.nextInt(10000);
40    }
41 
42    // object initialization block    （對象intialization塊）
43    {
44       id = nextId;
45       nextId++;
46    }
47 
48    // three overloaded constructors   //三個重載的構造
49    public Employee(String n, double s)
50    {
51       name = n;
52       salary = s;
53    }
54 
55    public Employee(double s)
56    {
57       // calls the Employee(String, double) constructor   
58       this("Employee #" + nextId, s);   //this用來引用當前對象
59    }
60 
61    // the default constructor      //默認的構造器（本應有但沒構造，因此係統自動默認了一個構造器
62    public Employee()
63    {
64       // name initialized to ""--see above
65       // salary not explicitly set--initialized to 0
66       // id initialized in initialization block
67    }
68 
69    public String getName()   //實例域name的訪問器方法
70    {
71       return name;
72    }
73 
74    public double getSalary()  //實例域Salary的訪問器方法
75    {
76       return salary;
77    }
78 
79    public int getId()    //實例域Id的訪問器方法
80    {
81       return id;
82    }
83 }

運行結果以下：

實驗2

測試程序5：

l 編輯、編譯、調試運行程序4-6、4-7（教材135）；

l 結合程序運行結果，理解程序代碼，掌握Java包的定義及用法，在相關代碼後添加註釋；

程序4-6代碼以下：

import com.horstmann.corejava.*; 
// the Employee class is defined in that package  （Employees類在該包中定義）

import static java.lang.System.*;   //靜態導入System類

/**
 * This program demonstrates the use of packages.
 * @version 1.11 2004-02-19
 * @author Cay Horstmann
 */
public class PackageTest
{
   public static void main(String[] args)
   {
      // because of the import statement, we don't have to use 
      // com.horstmann.corejava.Employee here
      var harry = new Employee("Harry Hacker", 50000, 1989, 10, 1);

      harry.raiseSalary(5);

      // because of the static import statement, we don't have to use System.out here
      out.println("name=" + harry.getName() + ",salary=" + harry.getSalary());
   }
}

運行結果以下：

程序4-7代碼以下：

package com.horstmann.corejava;    //將類放入包中

// the classes in this file are part of this package   （這個文件中的類就是這個包中的一部分）

import java.time.*;   //java.time包的引入

// import statements come after the package statement   （import語句位於package語句以後）

/**
 * @version 1.11 2015-05-08
 * @author Cay Horstmann
 */
public class Employee
{
   private String name;     //實例域定義
   private double salary;
   private LocalDate hireDay;

   public Employee(String name, double salary, int year, int month, int day)  //構造器定義
   {
      this.name = name;   //this用來引用當前對象
      this.salary = salary;
      hireDay = LocalDate.of(year, month, day);     
   }

   public String getName()    //實例域name的訪問器方法
   {
      return name;
   }

   public double getSalary()   //實例域Salary的訪問器方法
   {
      return salary;
   }

   public LocalDate getHireDay()   //實例域HireDay的訪問器方法
   {
      return hireDay;
   }

   public void raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;
   }
}

運行結果以下：

第三部分實驗總結

本週學了第四章，經過這周的學習，我掌握了預約義類的基本使用方法，如Math類、String類、math類、Scanner類、LocalDate類等經常使用API；大體掌握了用戶自定義類的語法規則，如實例域、靜態域、構造器方法、更改器方法、訪問器方法、靜態方法、main方法、方法參數的定義要求等。

　　但仍是有些不足，概念理解不夠深入，沒可以將理論知識掌握好，所以寫這博客園寫起來挺費勁的，在這花費了不少時間。在運行示例代碼的過程當中學到了相關知識，可是還沒理解透，理解起來有必定的難度，在學習中還有一些漏洞和疑惑，在看翁愷老師的視頻時解決了部分，但仍是感受本身有着不少的欠缺，在之後的學習中會更加努力。