| 项目 |
内容 |
| 这个作业属于哪个课程 |
<任课教师博客主页链接>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
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
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
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类等；大致掌握了用户自定义类的语法规则，如实例域、静态域、构造器方法等。但还是有些不足，概念理解不够深刻。在运行示例代码的过程中遇到了很多障碍，这都是我的学习经验，说明我在学习中还有一些漏洞和疑惑，在以后的学习中我会更加努力。