项目

内容

这个作业属于哪个课程

<任课教师博客主页链接>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）:如何辨别具有相同行为与状态的不同对象？不同对象？

5.类之间的关系：依赖，聚合，继承

二.构造方法：无返回类型，方法名与类同名默认构造方法：如果类内没有定义该类的构造方法；这默认生成默认的无参的构造方法；倘若类内有定义一个或者多个构造方法这系统不默认生成无参构造方法；

　　1.创建对象   格式：Class_Name    Object_name

　　　　　　　　　　　　Class   A;

　　　　　　　　 new Class_Name:返回的是该类在堆区中开辟内存的引用；对象的引用在栈区中，对象的实体在堆区中；

　　2.使用对象 对象操作自身的变量：格式：对象.变量

　　　　　　　　对象操作自身的函数：格式：对象.函数名（）

　　3.对象的引用和实体   Class   A；   Class B;

　　　　　　　       　A    a  =   new    A();

　　　　　　　　       A    b=a;//注意b中存放着是a的值；b即为a的引用；

三. 用户自定义类

1.Employee类 :在源文件中，只能有一个public类，并且文件名与public类类名相同，但可以有任意数目的非公有类。

2.多个源文件的使用 :编译多个源文件的程序时，只需javac 含主方法的文件 即可，编译器会自动查找编译使用到的类。并且，若之前编译过，若java编译器发现Employee.java较之前Employee.class有更新，会再编译新版本。

3.剖析Employee类:  强烈建议将实例子域标记为private。private确保只有类自身的方法能访问该实例域。一般将方法标记为public。public意味任何类的任何方法都可调用本方法。

4.从构造器开始 :必须注意在所有方法中不要命名与实例域同名的变量，否则局部变量会屏蔽同名实例域。

隐式参数与显式参数 方法中，关键字this表示隐式参数。Java中，所有方法必须在类内部定义，但并不表示它们是内联方法，是否将某个方法设置为内联方法是Java虚拟机的任务。

5.封装的优点: 获得实例域的值，用get set 方法（域访问器方法/域更改器方法）好处：不要编写返回 引用可变对象 的访问器方法，要返回一个可变对象的引用，应首先对它进行克隆(clone方法)。

可以改变内部实现，除了该类的方法外，不影响其它代码。更改器方法内部可以写错误检查等语句。

6.基于类的访问权限  一个方法可以访问所属类的所有对象的私有数据，而不仅限于访问隐式参数的私有特性。

7.私有方法 :可以设置一些辅助方法为private的，并且由于不会被其他类调用，所以可以随时删去。

8.final实例域 : final修饰符修饰的实例域必须在构建对象时初始化，即确保在构造器执行之后这个实例域被赋值。一般用来修饰基本类型域、或不可变类的域，否则容易造成混淆。

四，静态域和方法

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（10分）

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

输入样例:  34080019810819327X

输出样例: 1981-08-19

程序代码：

实验1  任务2（25分）

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)

程序代码：

程序代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;
 
public class Main {
    // private static Student students[];
 
    private static ArrayList<Student> list;
 
    public static void main(String[] args) {
        list = new ArrayList<>();
        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;
        while ((result = br.readLine()) != null) {
            Student student = new Student();
            student.setName(result.substring(13));
            student.setID(result.substring(0,12));
            list.add(student);
        }
        br.close();
    }
 
    public static Student findStudentByName(String name) {
        for (Student student : list) {
            if (student.getName().equals(name)) {
                return student;
            }
        }
        return null;
 
    }
 
    public static Student findStudentById(String Id) {
        for (Student student : list) {
            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（10分）

1.4-2程序代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
import 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数组，并有三个雇员对象；
 
      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%
      for (Employee e : staff)
         e.raiseSalary(5);                    //调用raiseSalary的方法提高雇员薪水15%；
 
      // 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                             //定义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);   //根据参数设置日期，参数分别为年月日；
   }                                          //构造Employee类的对象，并声明局部变量name,salary,hireday;
 
   public String getName()
   {
      return name;                            //取得name属性的值；
   }
 
   public double getSalary()
   {
      return salary;                          //取得salsry属性的值；
   }
 
   public LocalDate getHireDay()
   {
      return hireDay;                        //取得hireday属性的值；
   }
 
   public void raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;                       //调用方法的对象salary实例域设置为新值；
   }
}

运行结果

2.(Employee)程序代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import java.time.LocalDate;
 
 
public 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;     //构造Employee类的对象，并声明局部变量name,salary,hireday;
      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)程序代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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());
   }
}

　　

运行结果：

3.设计StudentTest程序代码：

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

　　

运行结果：

实验2  测试程序2（5分）

4-3程序代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
/**
 * 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);        //构造Employee数组，并有三个雇员对象；
      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                      //定义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;                        //构造Employee类的对象，并声明局部变量name,salary,hireday;
   }
 
   public String getName()
   {
      return name;                 //实例域name的访问器方法
   }
 
   public double getSalary()
   {
      return salary;                     //实例域salary的访问器方法
   }
 
   public int getId()
   {
      return id;                       //实例域id的访问器方法
   }
 
   public void setId()
   {
      id = nextId; // set id to next available id
      nextId++;
   }
 
   public static int getNextId()                       //实例域NextId的访问方法
   {
      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（5分）

4-4程序代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
/**
 * 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);                  //调用 tripleValue
      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 b = new Employee("Bob", 60000);    //定义类型为var的a，b，并进行初始化
      System.out.println("Before: a=" + a.getName());
      System.out.println("Before: b=" + b.getName());
      swap(a, b);                     //用交换函数交换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());
   }                                      
 
   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());  //x和y进行交换并输出
   }
}
 
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;              //实例域name的访问器方法
   }
 
   public double getSalary()
   {
      return salary;              //实例域salary访问器方法
   }
 
   public void raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;
   }
}

　运行结果:

实验2  测试程序4（5分）

4-5程序代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
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);               //构造Employee数组，并有三个雇员对象；
      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  实例字段初始化
   private double salary;
   
   // static initialization block    静态初始化
   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  对象 initialization块
   {
      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);      //this用来引用当前对象
   }
 
   // the default constructor      错误的构造器
   public Employee()
   {
      // name initialized to ""--see above 名称初始化为同上
      // salary not explicitly set--initialized to 0 工资未显示设置，初始化为0
      // id initialized in initialization block id初始化
   }
 
   public String getName()
   {
      return name;            //实例域name的访问器方法
   }
 
   public double getSalary()
   {
      return salary;    //实例域salary的访问器方法
   }
 
   public int getId()
   {
      return id;     //实例域id的访问器方法
   }
}

　运行结果：

实验2  测试程序4（5分）

4-6程序代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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      因为import语句，不需要使用com.horstmann.corejava
      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());
   }                                //由于使用了静态导入语句，在这里不需要使用System.out
}

　运行结果：

4-7程序代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package com.horstmann.corejava;
 
// the classes in this file are part of this package 这个文件中的类就是这个包中的一部分
 
import 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.salary = salary;
      hireDay = LocalDate.of(year, month, day);//根据参数设置日期，参数分别为年月日；
   }                              //构造Employee类的对象，并声明局部变量name,salary,hireday;
 
   public String getName()
   {
      return name;               //实例域name的访问器方法
   }
 
   public double getSalary()
   {
      return salary;                      //实例域salary的访问器方法
   }
 
   public LocalDate getHireDay()
   {
      return hireDay;               //实例域hireDay的访问器方法
   }
 
   public void raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;                  //调用方法的对象salary实例域设置为新值；
   }
}

　运行结果：

第三部分  实验总结

通过这周的学习，我基本了解了预定义类的基本使用方法，如Math类、String类、math类、Scanner类、LocalDate类等；大致掌握了用户自定义类的语法规则，如实例域、静态域、构造器方法等。但还是有些不足，概念理解不够深刻。在运行示例代码的过程中遇到了很多障碍，这都是我的学习经验，说明我在学习中还有一些漏洞和疑惑，在以后的学习中我会更加努力。

201871010136-赵艳强《面向对象程序设计（java）》第四周学习总结的更多相关文章

  1. 201871010136—赵艳强《面向对象程序设计（java）》第十三周学习总结

    201871010136—赵艳强<面向对象程序设计(java)>第十三周学习总结   博文正文开头格式:(2分) 项目 内容 <面向对象程序设计(java)> https:// ...

  2. 201871010136 -赵艳强《面向对象程序设计（java）》第十六周学习总结

    201871010136-赵艳强<面向对象程序设计(java)>第十六周学习总结   项目 内容 这个作业属于哪个课程 <任课教师博客主页链接>https://www.cnbl ...

  3. 201771010118马昕璐《面向对象程序设计java》第八周学习总结

    第一部分:理论知识学习部分 1.接口 在Java程序设计语言中,接口不是类,而是对类的一组需求描述,由常量和一组抽象方法组成.Java为了克服单继承的缺点,Java使用了接口,一个类可以实现一个或多个 ...

  4. 201771010134杨其菊《面向对象程序设计java》第十周学习总结

    第8章泛型程序设计学习总结 第一部分:理论知识 主要内容:   什么是泛型程序设计                   泛型类的声明及实例化的方法               泛型方法的定义      ...

  5. 201771010134杨其菊《面向对象程序设计java》第九周学习总结

                                                                      第九周学习总结 第一部分:理论知识 异常.断言和调试.日志 1.捕获 ...

  6. 201771010134杨其菊《面向对象程序设计java》第八周学习总结

    第八周学习总结 第一部分:理论知识 一.接口.lambda和内部类:  Comparator与comparable接口: 1.comparable接口的方法是compareTo,只有一个参数:comp ...

  7. 201571030332 扎西平措 《面向对象程序设计Java》第八周学习总结

    <面向对象程序设计Java>第八周学习总结   项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https: ...

  8. 20155312 张竞予 2006-2007-2 《Java程序设计》第四周学习总结

    20155312 2006-2007-2 <Java程序设计>第四周学习总结 课堂笔记 Ctrl+shift+T调出三个窗口,分别是"vi编写代码","jav ...

  9. 20155321 2016-2017-2 《Java程序设计》第四周学习总结

    20155321 2016-2017-2 <Java程序设计>第四周学习总结 教材学习内容总结 第六.七章 继承 多态 接口 相应的语法细节 继承 关键字 extends 格式 class ...

  10. 20145213《Java程序设计》第四周学习总结

    20145213<Java程序设计>第四周学习总结 教材学习内容总结 本周任务是学习面向对象的继承.接口以及之后的如何活用多态.(还真是路漫漫其修远兮啊!)教材也是延续上周艰深晦涩的语言风 ...

随机推荐

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

    项目 内容 这个作业属于哪个课程 <任课教师博客主页链接>https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 <作业链接地址>http ...

  2. Xmind最新的安装与破解教程

    参考链接:https://www.jianshu.com/p/e1693dad4dde Tips: hosts文件的默认位置:C:\Windows\System32\drivers\etc

  3. 【Ribbon篇四】Ribbon介绍（1）

    Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具. 简单的说,Ribbon是Netflix发布的开源项目,主要功能是提供客户端的软件负载均衡算法, ...

  4. 让人又爱又恨的this

    this是个神奇的东西, 既可以帮助我们把模拟的类实例化. 又可以在事件绑定里准确指向触发元素. 还可以帮助我们在对象方法中操作对象的其他属性或方法. 甚至可以在使用apply.call.bing.f ...

  5. 历届试题 青蛙跳杯子-(bfs)

    题目:http://lx.lanqiao.cn/problem.page?gpid=T448 题意:有两个字符串例如*WWBB和WWBB*,*每次能往左或右跳1-3步,与原位置的字符交换,问最少步数跳 ...

  6. csp模拟题-201903

    1.小中大(100分) #include<iostream> #include<cstdio> #define maxn 100010 using namespace std; ...

  7. 【2019.8.12 慈溪模拟赛 T2】汪哥图（wang）（前缀和）

    森林 考虑到题目中给出条件两点间至多只有一条路径. 就可以发现,这是一个森林. 而森林有一个很有用的性质. 考虑对于一棵树,点数-边数=\(1\). 因此对于一个森林,点数-边数=连通块个数. 所以, ...

  8. [SpingBoot guides系列翻译]Redis的消息订阅发布

    Redis的消息 部分参考链接 原文 CountDownLatch 概述 目的 这节讲的是用Redis来实现消息的发布和订阅,这里会使用Spring Data Redis来完成. 这里会用到两个东西, ...

  9. docker 通过中间镜像加速部署

    概要 实施 修改前的实施时间 制作编译用的镜像 测试修改后的实施时间 概要 使用 docker 打包镜像的时候, 每次耗费时间最多的就是 docker build 的过程. 特别是对于前端工程的打包, ...

  10. NLP第二课（搜索）

    最近压力太大了,持续性修改0注释的代码,变量为阿拉伯数字的代码,压力山大,摆正心态,没有那些bug,还需要我们来做些什么呢?如果一个特别出色的项目,也体现不出来你个人的出色.几句牢骚,我们今天来继续说 ...