201871010106-丁宣元 《面向对象程序设计(java)》第四周学习总结

时间:2021-05-05 20:47:20

201871010106-丁宣元 《面向对象程序设计(java)》第四周学习总结

正文开头

项目

内容

这个作业属于哪个课程

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. 理解重载概念及用法;
  7. 掌握包的概念及用法;

正文内容

第一部分:总结第四章理论知识(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));
} }

运行结果:

201871010106-丁宣元 《面向对象程序设计(java)》第四周学习总结

    注: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;
}
}

运行结果:

201871010106-丁宣元 《面向对象程序设计(java)》第四周学习总结

实验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.结果

201871010106-丁宣元 《面向对象程序设计(java)》第四周学习总结

  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;
}
}
 

结果

201871010106-丁宣元 《面向对象程序设计(java)》第四周学习总结

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来打印雇工信息
}
}
 

结果

201871010106-丁宣元 《面向对象程序设计(java)》第四周学习总结

  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;
} }

 

结果:

201871010106-丁宣元 《面向对象程序设计(java)》第四周学习总结

测试程序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.结果

201871010106-丁宣元 《面向对象程序设计(java)》第四周学习总结

   测试程序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.结果

201871010106-丁宣元 《面向对象程序设计(java)》第四周学习总结

测试程序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.结果

201871010106-丁宣元 《面向对象程序设计(java)》第四周学习总结

    测试程序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.结果

201871010106-丁宣元 《面向对象程序设计(java)》第四周学习总结

      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.结果

201871010106-丁宣元 《面向对象程序设计(java)》第四周学习总结

4. 实验总结:

   通过本次实验,我学会了:(1)类,对象,类之间的关系  (2)预定义类 (3)自定义类静态域与静态方法 (4)包等 (5)尝试编写修改程序

在理论课的基础上,基于基础知识,进行实验验证,并在实验验证的基础上加深对程序的理解,进一步练习改编程序,以达到题目所需的结果。但本次实验花费大量的时间,反映出学习的问题很多。

   1.前三章知识未完全理解记住。第四章知识掌握度很低,在理解上存在很大问题,代码读懂很吃力。

   2.在PTA测试中,第一个程序要查书才写出,说明对知识的掌握程度不够;第二个程序,思路很乱。在助教的讲解下渐渐有了思路,后期自己不断理解,不断尝试,不断修改。

   3.在实验中出现导入后程序存在问题,编写也有很多的问题,在不断的请教同学,查书,不断修改后才正确。

   在以后的学习中,要对基本知识进行仔细地理解,在理解上进行实践,多次修改,多读一些代码锻炼自己。