|
项目 |
内容 |
|
这个作业属于哪个课程 |
https://www.cnblogs.com/nwnu-daizh/ |
|
这个作业的要求在哪里 |
https://www.cnblogs.com/nwnu-daizh/p/11552848.html |
|
作业的学习目标 |
1. 掌握类与对象的基础概念，理解类与对象的关系； 2. 掌握对象与对象变量的关系； 3. 掌握预定义类Date、LocalDate类的常用API； 4. 掌握用户自定义类的语法规则，包括实例域、静态域、构造器方法、更改器方法、访问器方法、静态方法、main方法、方法参数的定义要求；（重点、难点） 5. 掌握对象的构造方法、定义方法及使用要求；（重点）； 6. 理解重载概念及用法； 掌握包的概念及用法 |
第一部分：总结第四章理论知识：
第4章 对象与类
4.1 类和对象的基本概念
描述了类和对象的基本概念，以及类之间的关系介绍。
程序中的很多对象来自于标准库，还有一些自定义的。
结构化程序设计：通过设计一系列的过程(算法)，选择合适的存储方式来解决问题。 算法+数据结构
4.1.1 类/封装/继承
类是构造对象的模板，由类构造对象的过程称为创建类的实例。
封装：也称为数据隐藏。从形式上看，封装不过是将数据和行为组合在一个包中，并对对象的使用者隐藏了数据的实现方式。优点4.2.3
实例域：对象中的数据。
方法：操纵数据的过程。
对于每个特定的对象都有一组特定的实例域值。这些值的集合就是这个对象的当前状态。
实现封装的关键在与绝对不能让类中的方法直接地访问其他类的实例域。程序仅通过对象的方法与对象数据进行交互。这是提高重用性和可靠性的关键。
继承：通过扩展一个类来建立另外一个新的类。
在扩展一个已有的类时，这个扩展后的新类具有所扩展的类的全部属性和方法。
Java中一个源文件只能包含一个公有类并且文件名必须与共有类匹配。
4.1.2 对象的特性
对象的行为：对象的方法。同一个类的所有对象实例，具有相同的方法而获得家族式的相似性。
对象的状态：当使用方法时对象如何响应。对象的状态描述当前对象的特征信息，状态只能通过调用方法来改变（否则说明封装性遭到了破坏）。
对象标识：对象的状态并不能完全描述一个对象。每个对象都有一个唯一的身份。
4.1.3 类之间的关系
依赖：use-a ，类A的方法操纵类B的对象，A依赖赖于B。相互依赖最少，耦合度最小。
聚合：has-a ，类A的对象包含类B的对象。
继承：is-a ，一般到特殊，
使用UML绘制类图，描述类之间的关系。
4.2 如何使用类
4.2.1 对象与对象变量
所有的Java对象都存储在堆中。
使用构造器构造并初始化对象。
对象变量并不包含一个对象，对象变量的值只是对存储在别处某个对象的引用。new的返回值也是一个引用。当一个对象包含另一个对象变量时，这个变量依然仅包含指向另一个堆对象的指针。
（引用相当于指针，内存地址）
Date date= new Date();
Date dead=null;
如果dead=date，则dead引用了与date相同对象。
4.2.2 不鼓励使用的方法
当类库设计者意识到某个方法不应该存在时，就把它标记为不鼓励使用，虽然在程序中仍然可以使用，但编译时会出现警告，而且有可能会在未来的类库版本中删除。
4.3 设计类
4.3.1 构造器
访问级别：方法可以访问所属类的私有特性，
构造器：与类同名；至少一个；不限制参数数量；没有返回值；总是使用new操作来调用。
4.3.2 实例域
将所有的数据域设为私有，同时设置访问器与更改器实现对数据域的访问和修改。
私有的数据域、公有的更改器与访问器实现了封装，带来的好处有：
1：可以改变内部实现，除了该类的方法之外不会影响其他代码
2：更改器方法可以执行错误检查
如果访问器要返回一个可变对象的引用，需要先对对象克隆，然后返回克隆后的对象。如下列情况
Employee em= ... ; Date d= em.getDate(); getDate作为访问器返回了em中一个私有的日期对象，但d也引用了相同的对象，对d操作可以改变em中的值，破坏了封装。
final实例域
可以将实例域定义为final，构建对象时必须对其初始化，且之后的操作中不能在对其修改。
final修饰符大多应用于基本类型或不可变类的域(类中的每个方法都不改变其对象如String类)
4.3.3 方法
对外的方法设置为公有，类内的辅助方法设置为私有。
对于类的设计者而言，公有的方法一定不可以删去，因为其他的代码可能访问到，私有的可以被删去
4.3.4 静态域
将域定义为static，则类中只有一个这样的域，每个对象共享静态域，即使没有对象域也会存在，它属于类不属于对象。使用类名访问。 Math.PI
静态常量：public static final double PI，静态常量不会被修改，所以设置为public
4.3.5 静态方法
通过类使用，不能对对象使用。
因为静态方法不能操作对象，所以不能在静态方法中访问实例域。但是可以访问类中的静态域。
当一个方法不需要访问对象状态，其参数都通过显示参数提供或只需访问类中的静态域则可设置为静态方法。
l 工厂方法
静态方法的一种用途。
如NumberFormat.getCurrnecyInstance(); NumberFormat.getPercentInstance();
无法命名构造器，构造器的名字必须与类名相同，但这里希望得到货币实例和百分比时采用不同的名字。
当使用构造器时，无法改变所构造的对象类型。
4.3.6 方法参数
按值调用：接收调用者提供的值；按引用调用：接收调用者提供的变量地址。
方法可以修改传递引用所对应的变量值，而不能修改传递值调用所对应的变量值。
Java总是按值调用。方法得到的所有参数值是一个拷贝，对象引用及其他的拷贝同时引用一个对象，方法不能修改传递给它的任何参数变量的内容。
"引用"是一个需要内存A存储的"值"，方法的参数获得了该"值"的一个副本存储在新的内存B中，方法结束后内存B弃用，仍然没有更改原来内存A中的"值"。
方法内使用的参数与传进去的参数在不同的内存中存储了相同的"引用"的值，该"引用"又指向了某内存块，该内存块实际记录对象里各个实例域的值，对方法内使用的参数的"引用"使用更改器，改变的是内存块中的值，原来的"引用"也是指向这块存储内容变化过的内存块，所以实现了改变对象参数的状态。
public static void swap(Employee x,Employee y)
{
Employee temp=x; x=y;y=temp;
}
并不会交换传入的两个对象。因为x和y并没有引用原来的对象，而是复制了原来对象的"值(地址)"，交换的是x和y
即使是swap(int x,int y)也不会成功。
或者说，按值传递传进去的是变量本身存储的值(对象的值是地址)的副本；按引用传递传进去的是参数本身的地址(基本类型)或者参数存储的地址指向的那一块值(对象)，即变量本身。
4.4 对象构造
4.4.1 重载
多个方法具有相同的名字、不同的参数。方法名与参数类型叫做方法的签名。
返回类型不属于方法签名，不能有两个名字相同、参数类型相同却返回不同类型值的方法。
4.4.2 默认域初始化
如果在构造器中没有显式的给域赋初值，会自动为域赋为默认值。
局部变量必须明确初始化，而域如果没有初始化会被自动初始化为默认值。
4.4.3 无参数的构造器
对象由无参数构造器创建时，状态会设置为适当的默认值。
只有类中没有提供任何构造器的时候，系统才会提供一个默认的构造器。也就是说如果提供了一个带参数的构造器而未提供不带参数的，系统不会自动提供不带参数的构造器，在使用不带参数的构造器时会报错。
4.4.4 显示域初始化
确保不管怎样调用构造器，每个实例域都可以被设置为一个有意义的初值是一种很好的设计习惯。
初始值不一定是常量。可以调用方法对域进行初始化。
4.4.5 调用另一个构造器
构造器的第一个语句形如 this(...)，这个构造器将调用同一个类的另一个构造器，括号内为参数列表，根据参数选择是哪一个构造器。
public Employee(double s)
{
//calls Employee(String,double)...
this("Employee ",s);
...
}
4.4.6 初始化块
在一个类的声明中，可以包含多个代码块，只要构造类的对象，这些块就会被执行。如：
Class Employee
{
private static int nextID; private int id;
private String name;
{id=nextID} //初始化块 public Employee()... public Employee(String s,int i)..
}
无论执行哪个构造器，都会先执行 id=nextID代码块
4.4.7 构造器的处理步骤
基于上述多个途径下的步骤：
1：所有数据域被初始化为默认值。
2：按照在类声明中出现的次序，依次指向所有域初始化语句和初始化块。
3：如果构造器第一行调用了第二个构造器，则执行第二个构造器主体。
4：执行这个构造器的主体。
4.4.8 对象析构
Java有自动的垃圾回收，不支持析构器。
finalize方法将在垃圾回收器清除对象之前调用，在实际应用中不要依赖使用finalize方法回收任何短缺的资源，因为很难知道这个方法什么时候才能够调用。
对于需要在使用完毕后立刻被关闭的资源(如文件)，在对象用完时应用close方法来完成清理操作。
4.5 包
Java允许使用包将类组织起来，同时可以确保类名唯一性。
为了保证包名的绝对唯一性，Sun公司建议将公司的因特网域名以逆序的形式作为包名。并对不同的项目使用不同的子包。
4.5.1 类的导入
java.lang包被默认导入。
一个类可以使用所属包中的所有类，以及其他包中的公有类。
使用import 语句导入一个特定的类或者整个包 如 import java.util.*;
import java.util.* 与import java.util.Date; 相比对代码的大小没有任何负面影响。
使用星号只能导入一个包，而非以其前缀的所有包。
大多数情况下只导入所需的包，但在发生命名冲突时需要考虑。如果只用一个则把那一个精准导入，否则在使用类时前面加上完整的包名。
import语句的唯一好处是便捷。
Eclipse中 Source – Organize Imports Pagckage
4.5.2 静态导入
import不仅可以导入类，还可以导入静态方法和静态域。
如 import static java.lang.System.*; 则可直接使用out.println(...);
4.5.3 将类放入包中
在源文件的开头，写上 package 包名 ;
4.5.4 包的作用域
变量显示private，
类、方法、变量若没有设置访问修饰符则包中的所有方法都可以访问。
包密封机制将各种包混杂在一起，不能再向这个包添加类了。
4.6 类路径
类存储在文件系统的子目录中。类的路径必须与包名匹配。
类文件也可以存储在JAR(Java归档)文件中。在一个JAR文件中，可以包含多个压缩形式的类文件和子目录。
为了使类能够被多个程序共享，需要以下几点：
1：把类放到一个目录中，这个目录是包树状结构的基目录。
2：将JAR文件放在一个目录中
3：设置类路径。类路径是所有包含类文件的路径的集合。基目录/当前目录/JAR文件
编译器定位文件，如果引用了一个类而没支出这个类所在的包，编译器首先查找包含这个类的包，并询查所有import执行，确定其中是否包含了被引用的类。如果找到一个以上的类就会产生编译错误，类必须是唯一的，而import语句的次序却无关紧要。
之后还要查看源文件是否比类文件新，如果是那么源文件就会被自动地重新编译。由于只能导入其他包中的公有类而一个源文件只包含一个共有类，所以编译器很容易定位源文件。如果从当前包中导入了一个类，编译器就要搜索当前包中的所有源文件，以便确定哪个源文件定义了这个类。
4.7 文档注释
4.7.1 注释的插入
javadoc，可以由源文件生产一个HTML文档。 javadoc utility从下面几个特性中抽取信息：
包
公有类和接口
公有的和受保护的构造器及方法
公有的和受保护的域
注释以/** 开始 以 */结束 。自由格式文本。标记由@开始
4.7.2 类注释
类注释必须放在import之后，类定义之前。
4.7.3 方法注释
方法注释必须放在所描述的方法之前，除通用标记之外还可以使用下面的标记
@param 变量描述 可占据多行，可使用html标记，但一个方法的所有@param标记必须放在一起
@return 描述 对当前方法添加 return 部分，可跨多行可使用html标记
@throws类描述 这个标记将添加一个注释，用于表示这个方法可能抛出异常。、
4.7.4 域注释
只需要对公有域(通常只的是静态常量)建立文档
4.7.5 通用注释
以下可用在类文档的注释中
@auther 姓名
@version 版本
@since 始于
@deprecated 类、方法、变量等添加不再使用的注释
@see 引用 用于类、方法中，添加一个超链接。
4.7.6 包与概述注释
可以直接将类、方法和变量注释放在java源文件中，只要以/** ..*/为界就可以了。但想要产生包注释就需要在每个包目录添加一个单独的文件：
1：提供一个以package.html命名的html文件，在body里的所有文本都会被抽取
2：提供一个以package-info.java命名的java文件，这个文件必须包含一个初始的以/** .. */为界定的Javadoc注释，跟随在一个包语句之后。它不应该包含更多的代码或注释。
还可以为所有的源文件添加一个概述性的注释，该注释放置在一个名为overview.html的文件中，并包含在所有源文件的父目录中。body里的所有文本都会被抽取。
4.8 类设计技巧
1：一定要保证数据私有
2：一定要对数据初始化
3：不要在类中使用过多的基本类型
4：不是所有的域都需要设置独立的域访问器和域更改器
5：将职责过多的类进行分解
6：类名和方法名要能够体现它们的职责
第二部分：实验部分
实验名称：实验三 类与对象的定义及使用
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
程序代码如下：
package shiyan;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("请输入身份证号18位！");
Scanner in = new Scanner(System.in);
String ID = in.nextLine();
String s1,s2,s3;
int i = 6;
s1 = ID.substring(i, i+4);
s2 = ID.substring(i+4, i+6);
s3 = ID.substring(i+6, i+8);
System.out.println(s1+"-"+s2+"-"+s3);
}
}
运行结果如下：
实验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)
程序代码如下：
(1)
package shiyan;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;
public class Xueshen{
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)
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;
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;
}
}
运行结果如下：
实验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代码如下：
(1)
package shiyan;
import java.time.*;//导入java.time包//
public class EmployeeTest {
public static void main(String[] args)
{
//构造一个Employee数组，并填入三个雇员对象
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);
// 用Employee类的raiseSalary方法将每个雇员的薪水提高5%
for (Employee e : staff)
e.raiseSalary(5);
// 调用getName方法、getSalary方法和getHireDay方法将每一个雇员的信息打印出来
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;
}
//调用raiseSalary方法的对象的salary实例域设置为新值
public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / 100;
salary += raise;
}
}
运行结果如下：
（2）
package shiyan;
import java.time.LocalDate;
public class Student {
private String name; //实例域定义
private double salary; //实例域定义
private LocalDate hireDay; //实例域定义
public Student(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;
}
运行结果如下：
（3）
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());
}
}
运行结果如下：
（4）l 参考教材104页EmployeeTest.java，设计StudentTest.java，定义Student类，包含name（姓名）、sex（性别）、javascore（java成绩）三个字段，编写程序，从键盘输入学生人数，输入学生信息，并按以下表头输出学生信息表：
姓名 性别 java成绩
public class StudentTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
Student[] staff = new Student[3]; //构造了一个Employee数组，并填入了三个雇员对象
staff[0]= new Student("tiexiaoxi", "female", 18);
staff[1] = new Student("lixian", "male", 98);
staff[2]= new Student("zhangjie", "male", 97);
for (Student e : staff)
System.out.println("name=" + e.getName() + ",sex=" + e.getSex() + ",javascore="
+ e.getJavascore()); //调用getName方法、getSex方法以及getJavascore法将每个雇员的信息打印出来
}
}
class Student //Employee类
{
private String name; //三个雇员对象的私有实例域
private String sex;
private int javascore;
public Student(String n, String s, int score)
{
name = n;
sex = s;
javascore = score;
}
public String getName()
{
return name;
}
public String getSex()
{
return sex;
}
public int getJavascore()
{
return javascore;
}
}
运行结果如下：
实验2 测试程序2（5分）
l 编辑、编译、调试运行程序4-3（教材116）；
l 结合程序运行结果，理解程序代码，掌握静态域（netxtId）与静态方法（getNextId）的用法，在相关代码后添加注释；
理解Java单元（类）测试的技巧。
代码如下：
/**
* 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数组 )
Employee[] staff = new Employee[3]; //构造了一个Employee 数组，并填入三个雇员对象
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) //调用getName 方法，getId方法和getSalary方法将每个雇员的信息打印出来
{
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() //实例域name的访问器方法
{
return name;
}
public double getSalary() //实例域Salary的访问器方法
{
return salary;
}
public int getId() //实例域Id的访问方法
{
return id;
}
public void setId()
{
id = nextId; // set id to next available id （将id设置为下一个可用id ）
nextId++;
}
public static int getNextId() //实例域NextId的访问方法
{
return nextId; // returns static field （返回静态字段）
}
public static void main(String[] args) // unit test （单元测试 ）
{
Employee e = new Employee("Harry", 50000);
System.out.println(e.getName() + " " + e.getSalary());
}
}
运行结果如下：
实验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（5分）
编辑、编译、调试运行程序4-5（教材129）；
l 结合程序运行结果，理解程序代码，掌握Java用户自定义类的用法，掌握对象构造方法及对象使用方法，在相关代码后添加注释。
代码如下：
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) //foreach循环
System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
+ e.getSalary());
}
}
class Employee
{
private static int nextId; //静态域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); //this用来引用当前对象
}
// 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() //实例域name的访问器方法
{
return name;
}
public double getSalary() //实例域Salary的访问器方法
{
return salary;
}
public int getId() //实例域Id的访问器方法
{
return id;
}
}
运行结果如下：
实验2 测试程序5（5分）
编辑、编译、调试运行程序4-6、4-7（教材135）；
l 结合程序运行结果，理解程序代码，掌握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
Employee 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.*;
// import statements come after the package statement
/**
* @version 1.11 2015-05-08
* @author Cay Horstmann
*/
public class Employee //Employee类放置在com.horstmann.corejava包中
{
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()
{
return name;
}
public double getSalary()
{
return salary;
}
public LocalDate getHireDay()
{
return hireDay;
}
public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / 100;
salary += raise;
}
}
运行结果如下：
第三部分：实验总结：
在实验课上,我们完成多个实验,在这个阶段的学习中,我从认识到熟悉,而后到能够自主运用,通过对Java的了解,我发现它确实有很多方便之处,它集抽象性、封装性、继承性和多态性于一体实现了代码重用和代码扩充,提高了软件开发的效率。对于我们这个专业来说学好Java语言是很重要的,所以在实验的过程中我都尽力理解java编程思想、掌握基本技巧,尽量学到最多的知识,学习程序设计目的就是培养描述实际问题的程序化解决方案的关键技能,java面向对象程序设计是一门实践性比较强的课程,在实际中,我们必须把理论和实践结合起来。在实验中,我们理解理论课上的知识,然后运用到实际的操作中,我们必须在现有的理论的基础上,进行实践。