201871010113-刘兴瑞《面向对象程序设计（java）》第四周学习总结

项目	内容
这个作业属于哪个课程	<任课教师博客主页链接>https://www.cnblogs.com/nwnu-daizh/
这个作业的要求在哪里	<作业链接地址>https://www.cnblogs.com/nwnu-daizh/p/11435127.html
作业学习目标	掌握类与对象的基础概念，理解类与对象的关系； 掌握对象与对象变量的关系； 掌握预定义类Date、LocalDate类的常用API； 掌握用户自定义类的语法规则，包括实例域、静态域、构造器方法、更改器方法、访问器方法、静态方法、main方法、方法参数的定义要求； 掌握对象的构造方法、定义方法及使用要求；（重点）； 理解重载概念及用法； 掌握包的概念及用法；

第一部分：总结第四章理论知识：在第四章的内容中，我们学习的内容是有关类，对象，包的知识。具体分为以下几个部分：（1）面向对象程序设计概述 （2）类的定义 （3）静态域和方法 （4）方法参数 （5）对象构造 （6）包 （7）类路径 （8）文档注释 （9）类设计技巧

一：面向对象程序设计概述

假设你面对现实世界的一个对象，你不会把它的属性和处理方法分开，程序设计也是一样。面向对象程序设计(00P): 一种新的程序思维方法，这种方法更接近人类处理现实世界问题的自然表示方法。面向对象的语言有: C+, Smalltalk, Java等。面向对象程序设计的几个主要概念:抽象数据类型、类和对象、封装、类层次(子类)、继承性、多态性。

1.对象：

对象的三个主要特征：行为（behaviar）:可以对对象施加哪些操作（方法）状态（state）：当施加哪些方法时，对象如何响应？标识（ident ity）:如何辨别具有相同行为与状态的不同对象？不同对象？

二：类的定义

1.什么是类

类是具有相同性和行为的一组对象的集合，类（ass）是描述对象的模板，它定义一类对象所能拥有的数据和能完成的操作，在面向对象的程序设计中，类是构造程序的基本单元。每个类由一组结构化的数据称作实例）和在其上的一组操作称为方法）构成

2.如何识别类

过程化程序设计，必须从顶部的main函数开始编写程序。

00P的思路是:首先从设计类开始，然后再每个类里添方法。

识别类的简单规则是在分析问题过程中寻找名词，而类的方法则对应着动词。

3.类和对象的关系：

4.类之间的关系:

依赖:如果一个类中的方法操作了另一个类的对象，那么这个类就依赖于另个类。

聚合:类A的对象包含类的的对象。

继承:表示一个特定类和一个一般类之间的关系。

5.对象初始化示例：
Date类
定义在Java标准类库的java. util包内

初始化Date类对象的实例：new Date( ):System. out. println(new Date( ));

可以将类中个方法用于新创建的对象：String s=new Date (). toString ();

6.对象变量

如果要多次使用初始化的对象。可将初始化后的对象存放在一个对象变量中。格式: Date birthday =new Date( ):

对象变量保存了对象后。可用对象变量引用对象，例如:System. out. println (birthday. toStrine()) ;

可将一个对象变量设量为null, 表示该对象变量未引用任何对象。例如: deadline nnll;

7.更改器方法和访问器方法
更改器方法:一个类中对实例域进行修改的方法,通常更改器方法名前缀为set(）。访问器方法:一个类中对实例域进行访问的方法，通常访问器方法名前缀为get()。

8.用户自定义类

类是用来创建对象的模板和蓝图，它包含被创建对象的状态描述和方法定义。类的定义包含两部分：声明和类体。类由两部分构成：实力域定义和方法定义。

9.域的定义

实例城(成员变量):类定义时实例城部分所定义的变量。实力域在整个类内都有效。

局部变量:方法体中定义的变量和方法的参数。局部变量只在定义它的方法内有效。当局部变量与实力域名字相同时，实力域被隐藏。

私有实例域的访问器和更改器：

有时需要获得或设置私有实例域的值，此时需提供下面三项内容：一个私有的数据域; 一个公有的域访问器方法: 一个公有的域更改器方法。

10.final实例域

可以将实例域定义为final,此类域构建对象时必须初始化。即必须确保在构造器执行之后，这个域的值被设置，并且在后面操作中，不能再对它的值进行修改，即该域无更改器。
final修饰符多应用于基本数据类型域，或不可变类的域。如果类中的每个方法都不会改变对象，这种类就是不可变的类。例如，String类。
对于可变类，使用final修饰符可能会造成混乱。

11.方法定义

方法定义分为两部分：方法声明和方法体。方法声明：名字，类型，属性的说明。方法体：有局部变量定义和Java语句组成。

格式为：

方法声明部分{

方法体}

12.重载：一个类中可以有多种方法有相同的名字，不同的类型，不同的参数。

13.构造器
也叫构造方法，是类中一种特殊的方法，其作用是用来构造并初始化对象。
构造器的名字必须与它所在的类名字相同；每个类可以有一个以上的构造器；构造器可以有0个、1个、或1个以上的参数；构造器没有返回位:构造器总是被new运算符调用.

三，静态域和方法

1.静态域
用stati c修饰的域为静态域，也叫类域，否则为实例域。
对于静态域，每个类中只有一个这样的域，类的所有对象都共享该域。
2.静态常量
静态变量使用的比较少，但静态常量却使用的比较多.另一个使用比较多的静态常量是System out;
3.静态方法
用stati c修饰的方法叫静态方法或类方法，静态方法可通过类名或对象来调用，而其他方法只能通过对象来调用。
静态方法不能操作对象，不能在静态方法中访问实例域。但静态方法可以访问自身类中的静态域。
可以认为静态方法是没有thi s参数的方法，而在一个非静态方法中, this参数是表示这个对象/对象构造器的隐式参数。
可使用对象词用静态方法但容易造成泪淆.因此建议使用类名。而不是对象来词用静态方法.一般在下面两种情况下使用静态方法:一个方法不需要访问对象状态.其所得郜效都是遇过显式参数提供。一个方法只需要访问类的静态域。
4 .main方法
main方法是一个静态方法，启动程序时，静态main方法将执行并创建程序所需的对象。
每一个类可以有一个main方法，这是一个常用于对类进行单元测试的技巧。

四，方法参数

1.程序设计语言的方法参数传递方式
方法参数传递方式有两种:值调用:表示方法(函效)接受的是调用者提供的值。引用调用 :方法(函数)接收的是调用者提供的地址。
方法可以修改传递引用所对应的变量值，而不能修改传递值调用所对应的变量值。
2. Java语言的值调用
Java值调用，即:方法得到的是所有参效值的一个拷贝，方法不能修改传递给它的任何参效变量的内容。
3. Java语言的参数类型
Java中方法参数共有两种类型:基本数据类型:数值、布尔值; 对象
一个方法不可能修改一 个基本数据类型的参数而对象作为参数就不同了，虽然不能修改对象的引用(地址) ,但可以修改对象的具体状态。
Java中方法的対象参数采用的是值传递。
Java方法参数的使用情况为:
一个方法不能修改一个基本数据类型的参效(即数值型和布尔型) ；
一个方法可以改变-一个对象参效的状态；
一个方法不能实现让对象参数引用-个新的对象。

五，对象构造

1.对象的定义
使用一个类创建了一个对象时，即创造了这个类的一个实例，只有通过对象才可以访问该类的公有实例域,调用类中公有的方法。
定义对象包括对象的声明和创建对象两部分。(1)对象的声明:类的名字Student wanghong;Student liwei; (2)创建对象即为声明的对象分配内存，用new 运算符和构造方法为对象分配内存。
声明和创建也可一次完成。 类定义的变量中含有静态变量时，该类所有对象的静态变量里共享局一存贮单元。
2.默认域初始化
如果在构造方法中没有明确地给某个字段赋值，
那么此字段会被自动赋以一个默认值。数位型: 0；布尔型: false；对象引用: null
3.无参数的构造器
很多类都含有一个无参数的构造器当对象由无参教构造器创建时，其状态会被设量为适当的默认位。
如果编写了-个没有构造器的类。则系统会自动为该类提供一个无参数的构造器。 其名字为类名。无参.方法体为空。该构造器将对象的实例域设重为默认值.
如果类中提供了至少一个构造器。 但没有提供无参数的构造器。则在构造对象如果没有提供构造参数就会被视为不合法-
4显式域初始化
由于类的构造器可以重较。所以可以采用多种形式设量类的实例域的初始状态。确保不管怎样调用构造器。每个实例城都可以被设重为一个有意义的初位.
在类定义中，可直接将一个常数赋给个域。 5.初始化块
为实例域初始化可如下方法：在构造器中设置值；声明的同时赋值；用初始化块.
不管是哪个构造器初始化对象,初始化块首先被运行，然后构造器的主体部分被执行。
如果对类的静态域进行初始化的代码比较复杂，可以使用静态初始化块来初始化静态域。
6.对象析构与finalize方法
由于Java有自动的垃圾回收器，不需要人工回收内存，Java不支持析构器。
可以为任何一-个类添加finalize方法，该方法将在垃圾回收器清除对象之前调用。
在实际使用中,不要依赖于finalize方法回收任何短缺的资源，这是因为很难知道这个方法什么时候才能被调用。

六，包
Java常常把多个类放在一起。 形成一个包.使用包的主要原因是确保类名的惟一性.
从编译器的角度来看，每一个都拥有独立的类集合。
1.类的导入
一个类可以直接使用它所在包中的所有类，也可以使用来自其它包中的所有pablic类。
访问其它包中的类有两种方式:(1)类名前加上完整的包名(不常用)例如：Java.util.Date today;（2）利用import语句导入特定的类(常用)
2.静态导入
从Java SE 5.0开始，import语可不仅可以导入类，还增加了导入静态方法和静态域的功能。
3将类放入包中
要把类放入一个包中，首先用package语句指明包的名字，且该语句应为程序的第一条语句，然后才是定义类的语句。
如果源文件中不使用package语句指明包名，文件的类将属于默认包。
当一个源文件中使用了package语句时。那么这个包中所有的类文件都必须放在与包名相匹配的子录中。
4.包作用域
类中标记为public的部分可以被任意类使用；
类中标记为private的部分只能在类内使用:
如果没有为类、方法或实例城指定访问控制修饰符public或private.这部分可以被同包中的所有方法访问.
如果实例城不标记为private.将默认为包可见。这样做会破坏类的封装性。

七，类路径
类存储在文件系统的子目录中，类的路径必须与包名匹配。
Java中类路径包括:
——基目录 : /home/user/classdir或c:\classes;
——当前目录:. ;
——JAR文件: /home/user/archives/archive.jar或
c:\archives\archive.jar.
在命令行方式下，设置类路径，使用-classpath(或cp)选项指定类路径。

第二部分：实验部分

实验名称：实验三 类与对象的定义及使用

1.  实验目的：

(1) 熟悉PTA平台线上测试环境；

(2) 理解用户自定义类的定义；

(3) 掌握对象的声明；

(4) 学会使用构造函数初始化对象；

(5) 使用类属性与方法的使用掌握使用；

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

3. 实验步骤与内容：

实验1  任务1

公民身份证号码按照GB11643—1999《公民身份证号码》国家标准编制，由18位数字组成：前6位为行政区划分代码，第7位至14位为出生日期码，第15位至17位为顺序码，第18位为校验码。从键盘输入1个身份证号，将身份证号的年月日抽取出来，按年-月-日格式输出。注意：输入使用Scanner类的nextLine()方法，以免出错。

输入样例:34080019810819327X

输出样例:1981-08-19

程序代码如下：

package json;
import java.util.*;

public class Id {

	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 num = in.nextLine();
		String year = num.substring(6, 10);//截取年
		String month = num.substring(10, 12);//截取月
		String day = num.substring(12, 14);//截取日
		System.out.println(year+"-"+month+"-"+day);
		in.close();//关闭流
	}

}

运行结果如下图：

实验1  任务2

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  测试程序1

编辑、编译、调试运行程序4-2（教材104页）；

结合程序运行结果，掌握类的定义与类对象的用法，并在程序代码中添加类与对象知识应用的注释；

尝试在项目中编辑两个类文件（Employee.java、 EmployeeTest.java ），编译并运行程序。

参考教材104页EmployeeTest.java，设计StudentTest.java，定义Student类，包含name（姓名）、sex（性别）、javascore（java成绩）三个字段，编写程序，从键盘输入学生人数，输入学生信息，并按以下表头输出学生信息表：

姓名    性别 java成绩

程序代码如下：

package json;
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)
   {
      // fill the staff array with three Employee objects
      Employee[] staff = new Employee[3]; //用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)//for-each循环
         e.raiseSalary(5);

      // print out information about all Employee objects 打印出有关于所有Employee对象的信息
      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);
   }
   //实例域name的访问器方法
   public String getName()
   {
      return name;
   }
   //实例域salary的访问器方法
   public double getSalary()
   {
      return salary;
   }
   //实例域hireDay的访问器方法
   public LocalDate getHireDay()
   {
      return hireDay;
   }

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

运行结果如下图：

编译运行Employee.java类文件：

程序代码如下：

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);
   }
   //实例域name的访问器方法
   public String getName()
   {
      return name;
   }
   //实例域salary的访问器方法
   public double getSalary()
   {
      return salary;
   }
   //实例域hireDay的访问器方法
   public LocalDate getHireDay()
   {
      return hireDay;
   }

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

　　运行结果如图：

编译运行EmployeeTest.java 类文件：

程序代码如下：

public class EmployeeTest
{
   public static void main(String[] args)
   {
      // fill the staff array with three Employee objects
      Employee[] staff = new Employee[3]; //用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)//for-each循环
         e.raiseSalary(5);

      // print out information about all Employee objects 打印出有关于所有Employee对象的信息
      for (Employee e : staff)
         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
            + e.getHireDay());
   }
}

　　运行结果如图：

编写的studentTest.java程序代码如下：

package json;

import java.util.Scanner;

public class StudentTest
{
	public static void main(String[] args)
	{
		Employee[] staff = new Employee[3];
		System.out.println("请输入学生：");
		Scanner in = new Scanner(System.in);
		for(int i=0;i<staff.length;i++) {
			staff[i]=new Employee(in.next(),in.next(),in.nextInt());
		}
		System.out.println("name"+" "+"sex"+" "+" "+"javascore");
		for (Employee e : staff)
			e.raiseSalary(5);
		// print out information about all Employee objects
		for (Employee e : staff)
			System.out.println(e.getName() +"   "+e.getSex()+"        "+e.getJavascore());
		in.close();
	}
}

class Employee
{
   private String name;
   private String sex;
   private int javascore;
   public Employee(String a, String b, int c)
   {
	   name = a;
	   sex = b;
	   javascore = c;
   }
   public void raiseSalary(int i) {
	   // TODO Auto-generated method stub
   }
   public String getName()
   {
	   return name;
   }
   public String getSex()
   {
	   return sex;
   }
   public int getJavascore()
   {
	   return javascore;
   }

}

运行结果如图：

实验2  测试程序2

编辑、编译、调试运行程序4-3（教材116）；

l结合程序运行结果，理解程序代码，掌握静态域（netxtId）与静态方法（getNextId）的用法，在相关代码后添加注释；

理解Java单元（类）测试的技巧。

代码如下：

package json;
/**
 * This program demonstrates static methods.
 * @version 1.02 2008-04-10
 * @author Cay Horstmann
 */
public class StaticTest
{
   public static void main(String[] args)
   {
      // fill the staff array with three Employee objects  用三个Employee对象填充staff数组
      var staff = new Employee[3];

      staff[0] = new Employee("Tom", 40000);
      staff[1] = new Employee("Dick", 60000);
      staff[2] = new Employee("Harry", 65000);

      // print out information about all Employee objects  打印出所有员工对象的信息
      for (Employee e : staff)
      {
         e.setId();
         System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
            + e.getSalary());
      }

      int n = Employee.getNextId(); // calls static method  调用静态方法
      System.out.println("Next available id=" + n);
   }
}

class Employee
{
   private static int nextId = 1;//静态域
   //实例域定义
   private String name;
   private double salary;
   private int id;

   public Employee(String n, double s)
   {
      name = n;
      salary = s;
      id = 0;
   }

   public String getName()
   {
      return name;
   }

   public double getSalary()
   {
      return salary;
   }

   public int getId()
   {
      return id;
   }

   public void setId()
   {
      id = nextId; // set id to next available id  将id设置为下一个可用id
      nextId++;
   }
   //静态方法
   public static int getNextId()
   {
      return nextId; // returns static field  返回静态字段
   }

   public static void main(String[] args) // unit test  单元测试
   {
      var e = new Employee("Harry", 50000);
      System.out.println(e.getName() + " " + e.getSalary());
   }
}

运行结果如下：

实验2  测试程序3

编辑、编译、调试运行程序4-4（教材121）；

l结合程序运行结果，理解程序代码，掌握Java方法参数的用法，在相关代码后添加注释；

程序代码如下：

package json;
/**
 * 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);
      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);
      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 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);
      System.out.println("End of method: salary=" + x.getSalary());
   }

   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()
   {
      return name;
   }

   public double getSalary()
   {
      return salary;
   }

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

运行结果如图：

实验2  测试程序4

编辑、编译、调试运行程序4-5（教材129）；

结合程序运行结果，理解程序代码，掌握Java用户自定义类的用法，掌握对象构造方法及对象使用方法，在相关代码后添加注释。

代码如下：

package json;
import java.util.*;

/**
 * This program demonstrates object construction.
 * @version 1.02 2018-04-10
 * @author Cay Horstmann
 */
public class ConstructorTest
{
   public static void main(String[] args)
   {
      // fill the staff array with three Employee objects 三个employee对象填充staff数组
      var staff = new Employee[3];

      staff[0] = new Employee("Harry", 40000);
      staff[1] = new Employee(60000);
      staff[2] = new Employee();

      // print out information about all Employee objects  打印有关所有员工对象的信息
      for (Employee e : staff)
         System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
            + e.getSalary());
   }
}

class Employee
{
   private static int nextId; //静态域
   //实例域定义
   private int id;
   private String name = ""; // instance field initialization  实例字段intialization
   private double salary;

   // static initialization block  静态intialization块
   static
   {
      var generator = new Random();
      // set nextId to a random number between 0 and 9999  将nextId设置为0到999之间的随机值
      nextId = generator.nextInt(10000);
   }

   // object initialization block  对象intialization块
   {
      id = nextId;
      nextId++;
   }

   // three overloaded constructors  三个重载的构造
   public Employee(String n, double s)
   {
      name = n;
      salary = s;
   }

   public Employee(double s)
   {
      // calls the Employee(String, double) constructor
      this("Employee #" + nextId, s);
   }

   // the default constructor  错误的构造器
   public Employee()
   {
      // name initialized to ""--see above
      // salary not explicitly set--initialized to 0
      // id initialized in initialization block
   }
   //方法定义
   public String getName()
   {
      return name;
   }

   public double getSalary()
   {
      return salary;
   }

   public int getId()
   {
      return id;
   }
}

运行结果如图：

实验2  测试程序4

编辑、编译、调试运行程序4-6、4-7（教材135）；

结合程序运行结果，理解程序代码，掌握Java包的定义及用法，在相关代码后添加注释；

程序4-6代码如下：

import com.horstmann.corejava.*;
// the Employee class is defined in that package

import static java.lang.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代码如下：

import java.time.LocalDate;

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.salary = salary;
      hireDay = LocalDate.of(year, month, day);
   }

   public String getName() //实例域name的访问器方法
   {
      return name;
   }

   public double getSalary() ////实例域Salary的访问器方法
   {
      return salary;
   }

   public LocalDate getHireDay()
   {
      return hireDay;
   }

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

运行结果如下图：

　

4. 实验总结：

通过对第四章知识的总结和书上实验程序导入学习，我基本懂得了类，对象，方法，静态类及其他的Java知识。在总结知识点中感觉不懂，也及时上网查了一些相关知识，加深了了解。实验过程中，遇到了一些问题，经过助教和同学的帮助解决了问题。希望以后可以更加独立的完成实验作业。总的来说这次的实验收获挺大的，希望上课时可以更加完善自己的知识体系。