201871010135-张玉晶《面向对象程序设计(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. 理解重载概念及用法;
掌握包的概念及用法
第一部分:总结第四章理论知识
一. 类与对象
1.对象
a)对象是具体实体,具有明确定义的状态和行为。
b)对象的三个主要特征:
-行为(behavior):可以对对象施加什么操作(方法)
-状态(state):当施加哪些方法时,对象如何如何响应
-标识(identity):如何辨别具体相同行为与状态的不同对象
2.类
a)类是具有相同属性和行为的一组对象的集合
b)类(class)是描述对象的模板,它定义一类对象所能拥有的数据和能完成的操作,在面向对象的程序设计中,类是构造程序的基本单元。
c)每个类由一组结构化的数据(称作实例域)和在其上的一组操作(称为方法)构成。
3.类之间的关系:
a)依赖(use-a):如果一个类中的方法操作了另一个类的对象,那么这个类就依赖于另一个类。
b)聚合(has-a):类A的对象包含类B的对象
c)继承(is-a):表示一个特定类和一个一般类之间的关系。一般来说,如果类A继承了类B,那么类A不仅继承了类B的方法和状态,而且还有属于自己的方法和状态。
4.预定义类的使用
a)已学过的预定义类:Math类、math类、String类、Scanner类等,掌握练习预定义类API的技术方法。
b)要使用预定义类的方法,只需知道方法名和参数即可,无需了解它的内部实现过程。
c)使用预定义类需要在程序开始处使用import命令导入该类所在的包路径。
5.对象与对象变量
a)在OOP中,要想使用对象,需先构造对象,并初始化对象状态,然后通过对象调用类中的办法。
b)java中,用构造器(constructor)构造并初始化对象。
c)构造器是类中一个特殊方法,该方法名与类名相同。
d)构造并初始化对象的格式:new 构造器名(参数)
1)对象初始化: 初始化Date 类对象的实例
new Date();
System.out.println(new Date());
可以将类中一个方法用于新创建的对象
String s = new Date(). toString();
2)对象变量
a)如果要多次使用初始化的对象,可将初始化的对象放在一个对象变量中。
格式: Date birthday = new Date();
b)对象变量保存了对象后,可用对象变量引用对象。例:System.out.println(birthday. to String());
c)可将一个对象变量设置为null, 表示该对象变量未引用任何对象。
6.更改器方法和访问器方法
a)更改器方法:一个类中对实例域进行修改的方法,通常更改器方法名前缀set。
b)访问器方法:一个类中对实例域进行访问的方法,通常访问器方法名前缀get。
7.用户自定义类
(1)类的定义包括两部分内容:声明和类体
(2)类体由两部分构成: a)实体域(或成员变量)定义; b)方法定义。
(3)域的定义
a)实例域(成员变量):类定义时实例域部分所定义的变量。实例域在整个类内都有效。
b)局部变量:方法体中定义的变量和方法的参数。只在定义它的方法内有效。
(4)实例域的隐藏性
局部变量与实例域名字相同时,则实例域被隐藏,即在这个方法内暂时失效。
可以将实例域定义为final,该域无更改器
8.方法定义
1)方法定义包括两部分:方法声明和方法体
其格式为:方法声明体部分{
方法体
}
2)方法的声明:名字,类型和参数等属性的说明。
注:方法的类型描述的是返回值类型,无返回值是类型为void.
3)方法体:有局部变量定义和JAVA语句组成。
重载:一个类中可以有多个方法具有相同的名字,不同类型,不同参数。
9.构造器
也叫构造方法,是类中一种特殊方法,其作用是用来构造并初始化对象。
-构造器的名字必须与他所在的类名字相同;
-每个类可以有一个以上的构造器;
-构造器可以有0个,1个,或1个以上的参数;
-构造器没有返回值;
-构造器总是被new运算符调用;
-构造器可以调用另一个构造器。
10.静态域与静态方法
1)静态域:用static修饰,每个类中只有这样的一个域;
2)静态常量:Math.PI System.out.
3)静态方法:静态方法可通过类名或对象来调用。
4)main方法:一个静态方法
11.包(package)
java常常把多个类放在一起,形成一个包,使用报的主要原因是确保类名的唯一性。
1)类的导入:一个类可以直接使用他所在包中的所有类,也可以使用来自其他包中的所有publc类。
2)访问其他包种类的两种方式:
a) 类名前加上完整的包名;
b)利用import语句导入特定的类。
3)将类放入包中
a)要把类放入一个包中,首先用package指明包的名字,且语句应为程序的第一条语句,然后才是定义类的语句。
b)如果源文件中不使用package语句指明包名,源文件的类将属于默认包。
c)当一个源文件中使用了package语句时,那么这个包中所用的类文件都必须放在与包名相匹配的的子目录中。
第二部分:实验部分
实验名称:实验三 类与对象的定义及使用
1. 实验目的:
(1) 熟悉PTA平台线上测试环境;
(2) 理解用户自定义类的定义;
(3) 掌握对象的声明;
(4) 学会使用构造函数初始化对象;
(5) 使用类属性与方法的使用掌握使用;
(6) 掌握package和import语句的用途。
2. 实验步骤与内容:
实验一 任务1
公民身份证号码按照GB11643—1999《公民身份证号码》国家标准编制,由18位数字组成:前6位为行政区划分代码,第7位至14位为出生日期码,第15位至17位为顺序码,第18位为校验码。从键盘输入1个身份证号,将身份证号的年月日抽取出来,按年-月-日格式输出。注意:输入使用Scanner类的nextLine()方法,以免出错。
输入样例:
34080019810819327X
输出样例:
1981-08-19
程序代码如下:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
String s=in.next();
String y=s.substring(,);
String m=s.substring(,);
String d=s.substring(,);
System.out.println(y+"-"+m+"-"+d);
in.close();
}
}
运行结果如下:
任务2
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)
a:用对象数组做的
程序代码如下:
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;
public class Main1 {
private static Student students[];
public static void main(String[] args) {
students=new Student[];
Scanner in = new Scanner(System.in);
try {
readFile("studentfile.txt");
System.out.println("请选择操作,1按姓名,2按学号,3退出");
int i;
while ((i = in.nextInt()) != ) {
switch (i) {
case :
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 :
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=;
while ((result = br.readLine()) != null) {
Student student = new Student();
student.setName(result.substring());
student.setID(result.substring(,));
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;
}
}
运行结果如下:
b:用泛型列表做
程序代码如下:
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;
public class Main1 {
// 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()) != ) {
switch (i) {
case :
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 :
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());
student.setID(result.substring(,));
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代码如下:
import java.time.*;//导入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对象填充三个数组)
Employee[] staff = new Employee[];
staff\[\] = new Employee("Carl Cracker", , , , );
staff\[\] = new Employee("Harry Hacker", , , , );
staff\[\] = new Employee("Tony Tester", , , , );
// raise everyone's salary by 5%(给每人涨%5的工资)
for (Employee e : staff)
e.raiseSalary();
// 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
{
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 / ;
salary += raise;
}
}
运行结果如下:
2)EmployeeText.java:
import java.time.*;//导入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对象填充三个数组)
Employee[] staff = new Employee[];
staff\[\] = new Employee("Carl Cracker", , , , );
staff\[\] = new Employee("Harry Hacker", , , , );
staff\[\] = new Employee("Tony Tester", , , , );
// raise everyone's salary by 5%(给每人涨%5的工资)
for (Employee e : staff) //进行foreach循环
e.raiseSalary();
// print out information about all Employee objects
for (Employee e : staff)
System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
+ e.getHireDay());
}
}
运行结果如下:
3)employee.java:
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 / ;
salary += raise;
}
}
运行结果如下:
4)程序代码如下:
import java.util.Scanner;
public class student {
String name;
String sex;
double javascore;
public static void main(String[] args) {
System.out.println("请输入学生人数");
Scanner su = new Scanner(System.in);
int totalStudent = su.nextInt();
student[] stus= new student[totalStudent];
for(int i=;i<totalStudent;i++) {
student s =new student();
stus[i]=s;
System.out.println("请输入第+“i"+"个学生的姓名");
s.name = su.next();
System.out.println("请输入第+“i"+"个学生的性别");
s.sex = su.next();
System.out.println("请输入第+“i"+"个学生的java成绩");
s.javascore = su.nextDouble();
}
printstudent(stus);
su.close();
}
public static void printstudent(student\[\] s) {
System.out.println("姓名\\t性别\\tjava成绩");
for(int i=;i<s.length;i++) {
System.out.println(s\[i\].name+"\\t"+s\[i\].sex+"\\t"+s\[i\].javascore);
}
}
}
运行结果如下:
测试程序2:
程序代码如下:
/**
* 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
var staff = new Employee[]; //构造了一个Employee 数组,并填入三个雇员对象
staff\[\] = new Employee("Tom", );
staff\[\] = new Employee("Dick", );
staff\[\] = new Employee("Harry", );
// 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 = ;
private String name; //实例域定义
private double salary;
private int id;
public Employee(String n, double s) //构造器定义
{
name = n;
salary = s;
id = ;
}
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
nextId++;
}
public static int getNextId() //实例域NextId的访问方法
{
return nextId; // returns static field
}
public static void main(String\[\] args) // unit test
{
var e = new Employee("Harry", );
System.out.println(e.getName() + " " + e.getSalary());
}
}
运行结果如下:
测试程序3:
程序代码如下:
/**
* 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 = ;
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", );
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", ); //定义一个类型为var的a,并进行初始化
var b = new Employee("Bob", );
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 = \* x;
System.out.println("End of method: x=" + x);
}
public static void tripleSalary(Employee x) // works
{
x.raiseSalary(); //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 / ;
salary += raise;
}
}
运行结果如下:
测试程序4:
程序代码如下:
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[];
staff\[\] = new Employee("Harry", );
staff\[\] = new Employee();
staff\[\] = 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();
}
// 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;
}
}
运行结果如下:
测试程序5:
4-6 程序代码如下:
import com.horstmann.corejava.*;
// the Employee class is defined in that package (Employees类在该包中定义)
import static java.lang.System.*; //静态导入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
var harry = new Employee("Harry Hacker", , , , );
harry.raiseSalary();
// 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.*; //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用来引用当前对象
this.salary = salary;
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 / ;
salary += raise;
}
}
运行结果如下:
实验总结: 通过第四周的学习,掌握类与对象的基础概念,理解类与对象的关系;以及对象与对象变量的关系; 知道了预定义类Date、LocalDate类的常用API; 以及用户自定义类的语法规则,包括实例域、静态域(static)、构造器方法、更改器方法、访问器方法、静态方法、main方法、方法参数的定义要求; 掌握对象的构造方法、定义方法及使用要求; 理解重载概念及用法;
实例域在整个类内都有效; 局部变量,只在定义它的方法内有效;final,该域无更改器;构造器可以调用另一个构造器,构造函数返回值。
我不会的也有很多,我也会认真的看书,查资料,尽量让自己掌握的更多,继续加油。
手机扫一扫
移动阅读更方便
你可能感兴趣的文章