201871010108-高文利《面向对象程序设计（java）》第四周学习总结

项目	内容
这个作业属于哪个课程	<任课教师博客主页链接> https://www.cnblogs.com/nwnu-daizh/
这个作业的要求在哪里	<作业链接地址> https://www.cnblogs.com/nwnu-daizh/p/11552848.html
作业学习目标	掌握类与对象的基础概念，理解类与对象的关系； 掌握对象与对象变量的关系； 掌握预定义类Date、LocalDate类的常用API； 掌握用户自定义类的语法规则，包括实例域、静态域、构造器方法、更改器方法、访问器方法、静态方法、main方法、方法参数的定义要求；（重点、难点） 掌握对象的构造方法、定义方法及使用要求；（重点）； 理解重载概念及用法； 掌握包的概念及用法；

第一部分：总结第四章理论知识

一．1.类：类是构造对象的模板。类定义了一组对象所能拥有的数据和能完成的操作。

每个类由一组结构化的数据（实例域：对象中的数据）和在其上的一组操作构成（方法）。

类是构造程序的基本单元。

2.对象：三个主要特性：行为（可以对对象施加的操作和方法）、状态（施加方法时，对象的响应）、标识（辨别具有相同行为和状态的不同对象）。

3.识别类：过程化程序设计，必须要从顶部的main函数开始编写程序。

Oop：首先从设计类开始，然后往每一类中添加方法。

识别类的简单方法：分析问题的过程中寻找名词，而方法对应着动词。

4.类与对象的关系：

5.类之间的关系：依赖（如果一个类的方法操纵另一个类的对象，就说一个类依赖另一个类）、聚合（类A的对象包含类B的对象）、继承（一个一般类和一个特殊类之间的关系。若类A继承类B，那么类A不仅继承类B的方法和状态，还有属于自己的方法和状态）。

二．预定义类：使用预定义需要在程序开始时使用import命令导入该类所在的包路径。

1.在00P中，要想使用对象，需先构造对象，并初始化对象状态，然后通过对像调用类中的方法。Java中，用构造器构造并初始化对象。构造器是类中一个特殊方法，该方法名与类名相同。

构造并初始化对象的格式:new  构造器名(参数)

2.对象初始化示例（Date类：定义在Java标准类库的java.util包内）

初始化Date类对象:

new Date();
System.out.println(new Date());

可以将类中一个方法用于新创健的对象:
String S new Date().toString();

3.对象变量：若想多次使用初始化的对象，可将初始化后的对象存放在一个对象变量中。Data birthday=new Data();

对象变量保存了对象后，可用对象变量引用对象，例如:

System.out.println (birthday.toStrine());

可将一个对象变量设置为null。

4.LocalDate类：（最新的日历类，位于Java.time包）。

5.更改器方法和访问器方法：

更改器方法:一个类中对实例域进行修改的方法，通常更改器方法名前缀为set。（ Gregorian Calendar类的setTime方法，用来设日历对象所表示的时间点）

访问器方法: -个类中对实例域进行访问的方法，通常访问器方法名前缀为get。（LocalDate类的getYear ( )方法，用来返回实例对象的年份）

三:用户自定义类：类的定义包含：声明和类体（实例域定义（成员变量），方法定义）。

1.域的定义：

实例域（整个类内都有效）：类定义时实例域部分所定义的变量。

局部变量（只在定义它的方法内有效）：方法体中定义的变量和方法的参数。

局部变量和实例域名字相同时，则实例域被隐藏，即在这个方法内暂时失效。

2.私有实例域的访问器和更改器：

获得或设置私有实例域的值：一个私有的数据域；一个公有的域访问器方法；一个公有的域更改器方法。（改变该类的内部实现后，除了该类的方法外，不会影响其他代码；更改器方法可以执行错误检查，然后对域直接赋值）

3.Final实例域：此类域构建对象时必须初始化。该域无更改器。

Final修饰符多用于不可变类的域（类中的每个方法都不会改变其对象，例如String类）。

4.方法的定义：方法声明（名字、类型、参数等属性的说明）和方法体（局部变量定义和java语句）。

方法的类型描述的是返回值类型，无返回值时类型为void。

重载：一个类中可以有多个方法具有相同的名字，不同的类型，不同的参数（参数的不同体现在类型和个体的不同）

5.构造器（构造方法）：用于构造并初始化对象

构造器的名字必给与它所在的类名字相同

每个类可以有一个以 上的构造器

构造器可以有0个、1个、或1个以上的参数

构造器没有返回值

构造器总是被new运算符调用.

6.基于类的访问权限：类中方法可以访问所属该类对象的私有数据。

四．静态域和静态方法：

1.静态域：用static修饰的域。对于静态域，每个类中只有一个这样的域，类的私有对象都公用该域。2.

静态常量：在Math类中定义一个静态常量Math.PI

Public class Math{

Public static final double PI=3.14159265;

}

System.out:

Public class System{

Public static final PrintStream out=.....;

}

3.静态方法：用static修饰的方法。可通过类名或对象来调用，而其他方法只能通过对象来调用。静态方法不能操作对象，不能在静态方法中访问实例域。但可以访问自身类中的静态域。静态方法没有this参数的方法。

使用静态方法：

一个方法不需要访问对象状态.其所需参数都是通过显式参数提供（Math.pow()）;

一个方法只需要访问类的静态域（Employee.getNextId）;

4.main方法（静态方法）：启动程序后，静态main方法将执行并创建程序所需对象。

每个类只能有一个main方法。

5。方法参数：

传递：值调用：表示函数接受的时调用着提供的值。

引用调用：函数接收的时调用者提供的地址。

方法可以修改传递引用所对应的变量值，而不能修改彻底的值调用所对应的变量值。

Java中方法参数共有两种类型：基本数据类型（数值、布尔值）、对象。

对象作为参数，可以修改对象的具体状态。

Java方法参数的使用情况：

一个方法不能修收一 个基本数据类型的参数(即数值和布尔型):

一个方法可以改变一一个对象参数的状态:

一个方法不能实现让对象参效引用一个新的对象。

五. 对象构造：

1.对象的定义：只有通过对象才可以访问该类的公有实例域、调用类中公有的方法。

定义对象包括对象的声明和创建对象。

对象的声明：类的名字   对象名字；

创建对象：为声明的对象分配内存，用new运算符和构造方法为对象分配内存。

2.类定义的变量中含有静态变量时，该类所有对象的静态变量都共用同一个存储单元。

如果在构造方法中没有明确地给某个字段赋值，那么此字段会被自动赋值一个默认值。（数值型：0，布尔型：false，对象引用：null）

3.无参数的构造器：当对象由无参数构造器创建时，其状态会被设置为是的的默认值。

如果编写了一个没有构造器的类。则系统会自动为谈类提供个无参数的构造器。其名字为奖名。无参，方法体为空。该构造器将对象的实例城设量为默认值。

如果类中提供了至少一个构造器。但没有提供无参数的构造器。则在构造对象如果没有提供构造参数就会被视为不合法.

4。显示域初始化：由于类的构造器的重载，可以使用多种形式设置类的实例域的初始状态不管怎样调用构造器，每个实例域都可以被设置为一个有意义的初值。

在类定义中，可直接将一个常数赋给一个域。

5.初始化块：实例域初始化：在构造器中设置值；声明的同时赋值；用初始化块。

6.不管哪个构造器初始化对象，初始化块首先被运行，然后构造器的主体部分被执行。

7.可以为任何一个类添加finallize方法，该方法将在垃圾回收器清除对象之前调用。

8.包：Java通常把多个类放在一起，形成一个包。使用包的主要原因是确保类名的唯一性。

类的导入：一个类可以直接使用它所在包中的所有类，也可以用来自其他包中的所有public类。

访问其他包中的类的方法：类名前加上完整的包名。

利用import语句导入特定的类（常用）。

9.静态导入：import语句不仅可以导入类，还可以导入静态方法和静态域的功能。

10.把类放入包中：首先用package语句指明包的名字，且为程序的第一条语句，然后才是定义类的语句。如果源文件中不使用package语句指明包名，源文件的类将属于默认包。

当一个源文件中使用了package语句时，那么这个包中所有的类文件都必须放在与包名相匹配的子录中。

11.包作用域：类中标记为public的部分可以被任意类使用

类中标记为private的部分只能在类内使用

如果没有为类、方法或实例域指定访问控制修饰符public或private.这部分可以被同包中的所有方法访问.

如果实例城不标记为pivate,将默认为包可见，但这样做会破坏类的封装性

12.类路径：类存储在文件系统的子目录中，类的路径必须与包名匹配。

Java中类路径包括：

基目录: /hoe/user/c1assdir或c:\c1asses；

JAR文件: /home/user/archi ves/archive. jar或c:\archives .archive. jar.

在命令行方式下，设置类路径,使用- classpath<或-cp>选项指定类路径。

第二部分：实验部分

实验名称：实验三 类与对象的定义及使用

1.  实验目的：

(1) 熟悉PTA平台线上测试环境；

(2) 理解用户自定义类的定义；

(3) 掌握对象的声明；

(4) 学会使用构造函数初始化对象；

(5) 使用类属性与方法的使用掌握使用；

(6) 掌握package和import语句的用途。

3. 实验步骤与内容：

实验1  任务1（10分）

import java.util.Scanner;

public class shengfenzheng {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.print("Input shengfenzheng:");
	    String shengfenzheng = in.nextLine();
	    String year=shengfenzheng.substring(6,10);
	    String month=shengfenzheng.substring(11,12);
	    String day=shengfenzheng.substring(13,14);
	    System.out.print(year+"-"+month+"-"+day);
	}

}

　　

实验1  任务2（25分）

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;

public class pai {
	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  测试程序1（10分）

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对象填充数组
      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);

      // 给每个人的薪水增加5%
      for (Employee e : staff)//for each 循环
         e.raiseSalary(5);

      // 输出每个员工的基本信息
      for (Employee e : staff)
         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()
   {
      return name;
   }

   public double getSalary()
   {
      return salary;
   }

   public LocalDate getHireDay()
   {
      return hireDay;
   }

   public void raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;
   }
}

　　

package json;

import java.util.Scanner;

public class Student
{
    public static void main(String[] args)
    {
        Employee[] staff = new Employee[3];
        System.out.println("请输入学生：");
        Scanner in = new Scanner(System.in);
        for(int i=0;i<staff.length;i++) {
            staff[i]=new Employee(in.next(),in.next(),in.nextInt());
        }
        System.out.println("name"+" "+"sex"+" "+" "+"javascore");
        for (Employee e : staff)
            e.raiseSalary(5);

        for (Employee e : staff)
            System.out.println(e.getName() +"   "+e.getSex()+"        "+e.getJavascore());

    }
}

class Employee
{
   private String name;
   private String sex;
   private int javascore;
   public Employee(String a, String b, int c)
   {
       name = a;
       sex = b;
       javascore = c;
   }
   public void raiseSalary(int i) {

   }
   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)
   {
      // 用Employee对象填充数组
      var staff = new Employee[3];

      staff[0] = new Employee("Tom", 40000);
      staff[1] = new Employee("Dick", 60000);
      staff[2] = new Employee("Harry", 65000);

      // 使用for each循环输出每个成员信息
      for (Employee e : staff)
      {
         e.setId();
         System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
            + e.getSalary());
      }

      int n = Employee.getNextId(); //调用静态方法
      System.out.println("Next available id=" + n);
   }
}

class Employee //定义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; // 将id设置为下一个可用id
      nextId++;
   }

   public static int getNextId()
   {
      return nextId; //返回静态域
   }

   public static void main(String[] args) // unit test
   {
      var e = new Employee("Harry", 50000);
      System.out.println(e.getName() + " " + e.getSalary());
   }
}

　　

实验2  测试程序3（5分）

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)
   {
      //该方法无法修改数值参数
      System.out.println("Testing tripleValue:");
      double percent = 10;
      System.out.println("Before: percent=" + percent);
      tripleValue(percent);
      System.out.println("After: percent=" + percent);

      //该方法可以改变对象参数的状态
      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());

      //该方法可以将新对象附加到对象参数
      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) //无法工作
   {
      x = 3 * x;
      System.out.println("End of method: x=" + x);
   }

   public static void tripleSalary(Employee x) // 工作
   {
      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 // 定义Employee类
{
   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;
   }
}

　　

实验2  测试程序4（5分）

l 编辑、编译、调试运行程序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)
   {
      //用Employee对象填充数组
      var staff = new Employee[3];

      staff[0] = new Employee("Harry", 40000);
      staff[1] = new Employee(60000);
      staff[2] = new Employee();

      // 使用for each循环输出每个成员信息
      for (Employee e : staff)
         System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
            + e.getSalary());
   }
}

class Employee
{
   private static int nextId;

   private int id;
   private String name = ""; // 实例域初始化
   private double salary;
  //静态域初始化

   static
   {
      var generator = new Random();
      // 通过随机数产生nextId的值
      nextId = generator.nextInt(10000);
   }

   // 对象域的初始化
   {
      id = nextId;
      nextId++;
   }

   //三个重载构造函数
   public Employee(String n, double s)
   {
      name = n;
      salary = s;
   }

   public Employee(double s)
   {
      // calls the Employee(String, double) constructor
      this("Employee #" + nextId, s);
   }

   // 默认构造函数
   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;
   }
}

　　

实验2  测试程序4（5分）

l 编辑、编译、调试运行程序4-6、4-7（教材135）；

结合程序运行结果，理解程序代码，掌握Java包的定义及用法，在相关代码后添加注释

import com.horstmann.corejava.*;
// 把Employee类定义在包内

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
      var 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());
   }
}

　　

　　

package com.horstmann.corejava;

//这个文件中的类是是这个包的一部分

import java.time.*;

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

　　

4. 实验总结：

实验一的第二个实验有些难，写不出来，但通过助教的讲解，还是懂了好多。通过后面的几个实验，学会了类，对象，访问器等知识。通过查书本，看ppt，以及网上资源，由刚开始的不懂，最后还是慢慢理解了。有些程序是通过借鉴以及查阅书籍等工具写出来的，希望以后可以自己写出这些程序。