201871010106-丁宣元 《面向对象程序设计（java)》第四周学习总结
201871010106-丁宣元 《面向对象程序设计（java)》第四周学习总结
正文开头
|
项目 |
内容 |
|
这个作业属于哪个课程 |
https://www.cnblogs.com/nwnu-daizh/ |
|
这个作业的要求在哪里 |
https://www.cnblogs.com/nwnu-daizh/p/11552848.html |
|
作业学习目标 |
|
正文内容
第一部分：总结第四章理论知识（20分）
一.面向对象程序设计概述：
1.面向对象程序设计（OOP）是一种新的程序设计思维。
（1)对象是面向对象编程的核心。
（2)对象的三个主要特征：
行为:对对象施加哪些操作或者可以使用哪些方法；
状态:加操作或者方法，对象如何应对；
标识:如何辨别具有相同行为和状态的不同对象。
2、类（class）
（1）类是具有相同属性和行为的一组对象的集合。
（2）每个类由一组结构化的数据（称作实例域）和一组操作构成。
（3）类是描述对象的模板，它定义一类对象所拥有的数据和能完成的操作，在面向对象的程序设计中，类是构造程序的基本单位。
3、识别类：oop的思路，从设计类开始，然后在每个类里面添加方法。
4、类之间的关系：
（1）依赖：一个类中的方法操作了另一个类的对象，这个类就依赖于另一个类。
（2）聚合：类A的对象包含类B的对象。
（3）继承：表示一个特定类和一个 一般类之间的关系。如果类A继承了类B，那么类A 有类B的方法与状态，也有属于自己的状态与方法。
二.使用预定义类
a.对象与对象变量:要使用对象，必须先构造对象，并指定初始状态。利用构造器(constructor)构造新实例。new 构造器名（参数）。
b.更改器方法和访问器方法：
（1）一个类中对实例域进行修改的方法，更改器前面加set；
（2）一个类中对实例域进行访问的方法，前缀get。
c.详内：（1）已学：Math类、math类、String类、Scanner类；
（2）要使用预定义类的方法，只需知道方法名和参数
（3）使用预定义类要在程序开始处用import命令导入该类所在的包路经。
三.用户自定义类：
（1）包括两部分：声明和类体
（2）类体由两部分构成：实体域（或成员变量）,方法定义
（3）域的定义：
a实例域：类定义时实例域部分所定义的变量；
b局部变量：方法体中定义的变量和方法的参数；
c实例域的隐藏性：局部变量与实例域名字相同时，则实例域被隐藏，在这个方法内暂时失效。
d实例域的有效性：在整个类内部有效，局部变量只在定义它的方法内部有效。
e私有实例域的更改器和访问器：有时需要获得或设置私有实例域的值
f final实例域：可将实例域定义为final,此类域构建对象时时必须进行初始化；在后面的操作中，不能再对它的值进行修改
(4)私有方法 :private，不会被其他类调用
四.方法定义：
a）包括方法声明和方法体；
b）方法的声明：名字，类型和参数等属性的说明：方法的类型描述的数返回值类型；
c）方法体由局部变量和Java语句构成；一个类中可以有多个方法具有相同的名字，不同的类型，不同的参数，这种情况叫重载；
五.构造器：用来构造并初始化对象。
（1）构造器的名字必须要与它所在类名字相同；
（2）每个包可以由一个以上的构造器；
（3）构造器可以由一个，一个以上的参数；
（4）构造器没有返回值；
（5）构造器总是被new运算符调用；
六.静态域与静态方法
（1）静态域：也称为类域。
如将域定义为static，每个类中只有一个这样的域。而每个对象对于所有的实例域却都有自己的一份拷贝。
（2）静态常量：静态变量用的少，但是静态常量用的多。Math.PI
（3）静态方法：不能向对象实施操作，可认为没有this参数的方法。
静态方法不能操作对象,不能在静态方法中访问实例域。但静态方法可以访问自身类中的静态域。
一个类的静态方法不可以访问非静态成员变量。(翻转课堂）
使用时间：不需要访问对象状态，参数都由显示参数提供
只需访问类的静态域
main不对任何对象进行操作
七.对象构造
1.重载：多个方法有相同名字，不同参数
2.默认域初始化：自动赋值为默认值0，flase,null
3调用另一构造器：this引用方法的隐式参数
八.类的导入
（1）静态导入：import语句不仅可以导入类，还增加了静态导入方法和静态域的功能；
（2）将类放如包中：用package语句指明报的名字，且该句应为程序的第一条语句，然后才定义类的语句；
（3）如源文件不使用package语句指明包名，源文件的类将属于默认包。
（4）当一个源文件中使用了package语句时，那么这个包中所有的类文件的都必须放在与包名相匹配的目录中；
（5）当程序中所使用的类位于不同包时，起源问价和类文件必须如下组织；
包作用域：
（1）类中标记为public的部分可以被任意类使用；
（2）类中标记为private的部分只能在类中使用；
（3）如果没有为类、方法或实例域指定访问控制修饰符public或private，这部分可以被同一包中的所有方法访问；
（4）如果实例域不标记为private，将默认为包可见，这样做会破坏类的封装性。
九.类路径：
（1）类存储在文件系统的子目录中，类得路径必须与包名匹配；
（2）在命令行方式下，设置类路径，使用-classpath选项指定类路径。
十.文档注释技术
类注释:放在import语句之后、类定义之前
方法注释:放在所述方法之前，可以使用下面的标记：@param,@return,@throws
域注释:需要对共有域(一般为静态常量)建立文档
通用注释:@author，产生一个“author”条目
@version产生一个“version”(版本)条目
@since产生一个“since”条目
包与概述注释
第二部分：实验部分
实验名称：实验三 类与对象的定义及使用
1. 实验目的：
(1) 熟悉PTA平台线上测试环境；
(2) 理解用户自定义类的定义；
(3) 掌握对象的声明；
(4) 学会使用构造函数初始化对象；
(5) 使用类属性与方法的使用掌握使用；
(6) 掌握package和import语句的用途。
3. 实验步骤与内容：
实验1
采用个人账号登录https://pintia.cn/，使用绑定码620781加入PTA平台NWNU-2019CST1教学班（西北师范大学 计算机科学与工程学院 2018级计算机科学与技术），完成《2019秋季西北师范大学面向对象程序设计程序设计能力测试1》，测试时间50分钟。
任务1 公民身份证号码按照GB11643—1999《公民身份证号码》国家标准编制，由18位数字组成：前6位为行政区划分代码，第七位至14位为出生日期码，第15位至17位为顺序码，第18位为校验码。从键盘输入1个身份证号码，将身份证号的年月日抽取出来，按年-月-日格式输出。注意：输入使用Scanner类的nextLine（）方法，以免出错。
代码：
import java.util.Scanner;
public class Birthday {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("input the ID:");
String message=in.nextLine();
System.out.print(message.substring(6, 10)+"-"+message.substring(10, 12)+"-"+message.substring(12, 14));
}
}
运行结果：
注：1.程序要用Scanner类，而Scanner类定义在工具包中，故需调用Util工具包（即import语句）。
2.String类的substring方法可以从一个较大的字符串中提取出一个子串。（注意截取位置，若有两个参数，第一个参数是开始截取的位置，第二个参数是不想复制的第一个位置）字符串第一个位置下标为0。
substring方法可以计算字串的长度。eg:s.substring(a,b)的长度是a-b。
任务二 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)
代码：
import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; public class Main2 { // 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
1.编辑、编译、调试运行程序4-2（教材104页）；
2.结合程序运行结果，掌握类的定义与类对象的用法，并在程序代码中添加类与对象知识应用的注释；
a.代码与注释
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) { Employee[] staff = new Employee[3]; // 三个Employee对象来填充staff数组 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);//第三个 for (Employee e : staff) //把每个人的工资提高5% e.raiseSalary(5); for (Employee e : staff) //调用getName,getSalary,getHireDay来打印雇工信息 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); } 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; } }
b.结果
3.尝试在项目中编辑两个类文件（Employee.java、 EmployeeTest.java ），编译并运行程序。
Employee.java
代码
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);
}
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.java
代码
public class EmployeeTest
{
public static void main(String[] args)
{
Employee[] staff = new Employee[3]; // 三个Employee对象来填充staff数组
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);//第三个
for (Employee e : staff) //把每个人的工资提高5%
e.raiseSalary(5);
for (Employee e : staff)
System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
+ e.getHireDay());//调用getName,getSalary,getHireDay来打印雇工信息
}
}
结果
4.参考教材104页EmployeeTest.java，设计StudentTest.java，定义Student类，包含name（姓名）、sex（性别）、javascore（java成绩）三个字段，编写程序，从键盘输入学生人数，输入学生信息，并按以下表头输出学生信息表：
姓名 性别 java成绩
代码
import java.util.Scanner; public class StudentTest { public static void main(String[] args) { Students[] a = new Students[3]; System.out.println("please input the messages:："); Scanner in = new Scanner(System.in); for(int i=0;i<a.length;i++) { a[i]=new Students(in.next(),in.next(),in.next()); } System.out.println("name"+" "+"sex"+" "+" "+"javascore"); for (Students e :a) System.out.println(e.getName() +" "+e.getSex()+" "+e.getJavaScore()+" "); } } class Students { private String name; private String sex; private String javascore; public Students(String n, String s, String j) { name = n; sex = s; javascore =j; } public String getName() { return name; } public String getSex() { return sex; } public String getJavaScore() { return javascore; } }
结果：
测试程序2
编辑、编译、调试运行程序4-3（教材116）；
结合程序运行结果，理解程序代码，掌握静态域（netxtId）与静态方法（getNextId）的用法，在相关代码后添加注释；理解Java单元（类）测试的技巧。
a.代码与注释
public class StaticTest { public static void main(String[] args) { // 三个employee对象填充staff数组 var staff = new Employee[3];//构造了Employee 数组 staff[0] = new Employee("Tom", 40000); staff[1] = new Employee("Dick", 60000); staff[2] = new Employee("Harry", 65000); // 打印员工信息 for (Employee e : staff) { e.setId(); System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary=" + e.getSalary());//调用getName 方法，getId方法和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 nextId++; } public static int getNextId() { return nextId; // returns static field } public static void main(String[] args) // unit test { var e = new Employee("Harry", 50000);//定义var型的e System.out.println(e.getName() + " " + e.getSalary()); } }
b.结果
测试程序3
编辑、编译、调试运行程序4-4（教材121）；
结合程序运行结果，理解程序代码，掌握Java方法参数的用法，在相关代码后添加注释；
a.代码与注释
public class ParamTest { public static void main(String[] args) { /* * Test 1: 该方法不能修改数值参数 */ System.out.println("Testing tripleValue:"); double percent = 10; System.out.println("Before: percent=" + percent); tripleValue(percent); System.out.println("After: percent=" + percent); /* * Test 2: 该方法可以改变对象参数的状态 */ System.out.println("\nTesting tripleSalary:"); var harry = new Employee("Harry", 50000);/ /定义名为Harry的类型为var初始化 System.out.println("Before: salary=" + harry.getSalary()); tripleSalary(harry); System.out.println("After: salary=" + harry.getSalary()); /* * Test 3:该方法可以将新对象附加到对象参数 */ System.out.println("\nTesting swap:"); var a = new Employee("Alice", 70000); //定义名为a的类型为var初始化 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()); } 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; } }
b.结果
测试程序4
编辑、编译、调试运行程序4-5（教材129）；
结合程序运行结果，理解程序代码，掌握Java用户自定义类的用法，掌握对象构造方法及对象使用方法，在相关代码后添加注释。
a.代码与注释
import java.util.*; 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());//调用getName 方法，getId方法和getSalary方法打印 } } class Employee//静态域nextId { 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();//定义generator为var类型 // set nextId to a random number between 0 and 9999 nextId为0到999之间的随机值 nextId = generator.nextInt(10000); } // object initialization block { 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() { return name; } public double getSalary() { return salary; } public int getId() { return id; } }
b.结果
测试程序5
编辑、编译、调试运行程序4-6、4-7（教材135）；
结合程序运行结果，理解程序代码，掌握Java包的定义及用法，在相关代码后添加注释；
4-6：
a.代码与注释
import com.horstmann.corejava.*; // the Employee class is defined in that package Employees类在该包中定义 import static java.lang.System.*; //静态导入System类 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()); } }
b.结果
4-7：
a.代码与注释
package com.horstmann.corejava; //将类放入包中 // the classes in this file are part of this package 这个文件中的类是这个包的一部分 import java.time.*; //java.time包的导入 // import statements come after the package statement 导入语句位于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用来引用当前对象 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; } }
b.结果
4. 实验总结：
通过本次实验，我学会了：（1）类，对象，类之间的关系 （2）预定义类 （3）自定义类静态域与静态方法 （4）包等 （5）尝试编写修改程序
在理论课的基础上，基于基础知识，进行实验验证，并在实验验证的基础上加深对程序的理解，进一步练习改编程序，以达到题目所需的结果。但本次实验花费大量的时间，反映出学习的问题很多。
1.前三章知识未完全理解记住。第四章知识掌握度很低，在理解上存在很大问题，代码读懂很吃力。
2.在PTA测试中，第一个程序要查书才写出，说明对知识的掌握程度不够；第二个程序，思路很乱。在助教的讲解下渐渐有了思路，后期自己不断理解，不断尝试，不断修改。
3.在实验中出现导入后程序存在问题，编写也有很多的问题，在不断的请教同学，查书，不断修改后才正确。
在以后的学习中，要对基本知识进行仔细地理解，在理解上进行实践，多次修改，多读一些代码锻炼自己。
