| 项目 | 内容 |
| 《面向对象程序设计（java）》 | https://www.cnblogs.com/nwnu-daizh/ |
| 这个作业的要求在哪里 | https://www.cnblogs.com/nwnu-daizh/p/11552848.html |
| 作业学习目标 | 掌握类与对象的基础概念，理解类与对象的关系； 掌握对象与对象变量的关系； 掌握预定义类Date、LocalDate类的常用API； 掌握用户自定义类的语法规则，包括实例域、静态域、构造器方法、更改器方法、访问器方法、静态方法、main方法、方法参数的定义要求；（重点、难点） 掌握对象的构造方法、定义方法及使用要求；（重点）； 理解重载概念及用法； 掌握包的概念及用法； |
第一部分：总结第四章理论知识
4.1
面向对象程序设计(OOP)： 主流的程序设计范例； 将数据放在第一位，然后再考虑操作数据的算法； 适合于大型程序的开发。
类(CLASS)： 构造对象的模板； 由类构造对象的过程称为创建类的实例。
对象： 有 对象的行为，对象的状态，对象标识 三个主要特性； 类的实例。
类之间常见的三种关系：依赖(dependence)，聚合(aggregation)，继承(inheritance)。
4.2
构造器： 构造对象时使用的特殊的方法，与类同名。 使用方法：以Data类为例， new Date()
对象与对象变量： 通过 对象变量的引用 多次使用同一个对象。 birthday = new Date() (注意：对象变量仅仅引用一个对象）
更改器方法： 可能会改变对象的状态的方法。
访问器方法： 只访问不改变对象的状态的方法。
4.3
自定义类
{
构造器；
状态；
方法；}
访问修饰符：public（谁都可以访问）private（除类型创建者和类型的内部方法之外的任何人都不能访问的元素）protect （继承的类可以访问以及和private一样的权限）default （包访问权限，即在整个包内均可被访问）
封装： 控制用户对类的修改和访问数据的程度，可以 降低程序复杂性、提高可控性。
4.4
静态域(static)： 每个类中只有一个； 属于类的，而不属于任何独立的对象。
静态常量： static final ‘name’ = ‘value’。
静态方法： 不能对对象使用，可以访问类的静态域的方法。
main方法： 静态的main方法将执行并创建程序所需要的对象。
4.5 方法参数
4.6 对象构造
4.7 包
4.8 类路径
4.9 文档注释
4.10 类设计技巧
第二部分：实验部分
实验名称：实验三 类与对象的定义及使用
1. 实验目的：
(1) 熟悉PTA平台线上测试环境；
(2) 理解用户自定义类的定义；
(3) 掌握对象的声明；
(4) 学会使用构造函数初始化对象；
(5) 使用类属性与方法的使用掌握使用；
(6) 掌握package和import语句的用途。
3. 实验步骤与内容：
实验1 采用个人账号登录https://pintia.cn/，使用绑定码620781加入PTA平台NWNU-2019CST1教学班（西北师范大学 计算机科学与工程学院 2018级计算机科学与技术），完成《2019秋季西北师范大学面向对象程序设计程序设计能力测试1》，测试时间50分钟。
实验2 导入第4章示例程序并测试。
测试程序1：
-
编辑、编译、调试运行程序4-2（教材104页）；
-
结合程序运行结果，掌握类的定义与类对象的用法，并在程序代码中添加类与对象知识应用的注释；
-
尝试在项目中编辑两个类文件（Employee.java、EmployeeTest.java ），编译并运行程序。
-
参考教材104页EmployeeTest.java，设计StudentTest.java，定义Student类，包含name（姓名）、sex（性别）、javascore（java成绩）三个字段，编写程序，从键盘输入学生人数，输入学生信息，并按以下表头输出学生信息表：
姓名 性别 java成绩
课本案例编译运行结果如下：
改编程序代码如下：
import java.util.Scanner;
public class StudentTest
{
public static void main(String[] args)
{
// fill the staff array with three Employee objects
//定义容量为3的数组
Student[] stu = new Student[3];
Scanner in = new Scanner(System.in);
//从键盘向数组中赋值
int i = 0 ;
while(i<3)
{
stu[i] = new Student();
stu[i].setName(in.next());
stu[i].setSex(in.next());
stu[i].setJavascore(in.nextInt());
i++;
}
//输出数据
for (Student e : stu)
System.out.println("姓名" + e.getName() + ",性别" + e.getsex() + ",java成绩="
+ e.getjavascore());
}
}
//定义Student类
class Student
{
private String name;
private String sex;
private int javascore;
public String getName()
{
return name;
}
public void setName(String n)
{
name = n;
}
public String getsex()
{
return sex;
}
public void setSex(String s)
{
sex = s;
}
public int getjavascore()
{
return javascore;
}
public void setJavascore(int j)
{
javascore = j;
}
}运行结果如下：
测试程序2：
-
编辑、编译、调试运行程序4-3（教材116）；
-
结合程序运行结果，理解程序代码，掌握静态域（netxtId）与静态方法（getNextId）的用法，在相关代码后添加注释；
-
理解Java单元（类）测试的技巧。
添加注释后的代码：
public class StaticTest
{
public static void main(String[] args)
{
// fill the staff array with three Employee objects
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(); //静态域nextId累计加3
System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
+ e.getSalary());
}
int n = Employee.getNextId(); // calls static method 使用静态方法getNextId访问静态域
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() //每次调用静态域nextId加1
{
id = nextId; // set id to next available 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());
}
}
运行结果：
测试程序3：
-
编辑、编译、调试运行程序4-4（教材121）；
-
结合程序运行结果，理解程序代码，掌握Java方法参数的用法，在相关代码后添加注释；
添加注释的代码：
public class ParamTest
{
public static void main(String[] args)
{
/*
* Test 1: Methods can't modify numeric parameters
*///tripleValue方法只引用不改变变量的值
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
*///tripleSalary方法可以改变Employee类的对象的状态
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
*///swap方法影响不到变量，只能交换参数变量
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;
}
}运行结果：
测试程序4：
-
编辑、编译、调试运行程序4-5（教材129）；
-
结合程序运行结果，理解程序代码，掌握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
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;//默认为0
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 = generator.nextInt(10000);
}
// object initialization block
//初始化块（运行优先于构造器）
{
id = nextId;
nextId++;
}
// three overloaded constructors
//构造器1
public Employee(String n, double s)
{
name = n;
salary = s;
}
//构造器2
public Employee(double s)
{
// calls the Employee(String, double) constructor
this("Employee #" + nextId, s); //使用this（） 调用了构造器1
}
// 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;
}
}运行结果：
测试程序5：
-
编辑、编译、调试运行程序4-6、4-7（教材135）；
-
结合程序运行结果，理解程序代码，掌握Java包的定义及用法，在相关代码后添加注释；
包的位置：
运行结果：
4. 实验总结：
通过这次试验，我学会了如何通过对象的方法改变对象的状态，如何通过静态方法改变静态域的状态，怎样才能修改参数，对象的初始化，类的引用与包之间的关系。
来源：oschina
链接：https://my.oschina.net/u/4377726/blog/4170707