201871010114李岩松《面向对象程序设计（java）》第四周学习总结

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

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

4.1 类和对象的基本概念

描述了类和对象的基本概念，以及类之间的关系介绍。

程序中的很多对象来自于标准库，还有一些自定义的。

结构化程序设计：通过设计一系列的过程(算法)，选择合适的存储方式来解决问题。 算法+数据结构

4.1.1 类/封装/继承

类是构造对象的模板，由类构造对象的过程称为创建类的实例。

封装：也称为数据隐藏。从形式上看，封装不过是将数据和行为组合在一个包中，并对对象的使用者隐藏了数据的实现方式。优点4.2.3

实例域：对象中的数据。

方法：操纵数据的过程。

对于每个特定的对象都有一组特定的实例域值。这些值的集合就是这个对象的当前状态。

实现封装的关键在与绝对不能让类中的方法直接地访问其他类的实例域。程序仅通过对象的方法与对象数据进行交互。这是提高重用性和可靠性的关键。

继承：通过扩展一个类来建立另外一个新的类。

在扩展一个已有的类时，这个扩展后的新类具有所扩展的类的全部属性和方法。

Java中一个源文件只能包含一个公有类并且文件名必须与共有类匹配。

4.1.2 对象的特性

对象的行为：对象的方法。同一个类的所有对象实例，具有相同的方法而获得家族式的相似性。

对象的状态：当使用方法时对象如何响应。对象的状态描述当前对象的特征信息，状态只能通过调用方法来改变（否则说明封装性遭到了破坏）。

对象标识：对象的状态并不能完全描述一个对象。每个对象都有一个唯一的身份。

4.1.3 类之间的关系

依赖：use-a ，类A的方法操纵类B的对象，A依赖赖于B。相互依赖最少，耦合度最小。

聚合：has-a ，类A的对象包含类B的对象。

继承：is-a ，一般到特殊，

使用UML绘制类图，描述类之间的关系。

4.2 如何使用类

4.2.1 对象与对象变量

所有的Java对象都存储在堆中。

使用构造器构造并初始化对象。

对象变量并不包含一个对象，对象变量的值只是对存储在别处某个对象的引用。new的返回值也是一个引用。当一个对象包含另一个对象变量时，这个变量依然仅包含指向另一个堆对象的指针。

（引用相当于指针，内存地址）

Date date= new Date();
Date dead=null;
如果dead=date，则dead引用了与date相同对象。

4.2.2 不鼓励使用的方法

当类库设计者意识到某个方法不应该存在时，就把它标记为不鼓励使用，虽然在程序中仍然可以使用，但编译时会出现警告，而且有可能会在未来的类库版本中删除。

4.3 设计类

4.3.1 构造器

访问级别：方法可以访问所属类的私有特性，

构造器：与类同名；至少一个；不限制参数数量；没有返回值；总是使用new操作来调用。

4.3.2 实例域

将所有的数据域设为私有，同时设置访问器与更改器实现对数据域的访问和修改。

私有的数据域、公有的更改器与访问器实现了封装，带来的好处有：

1：可以改变内部实现，除了该类的方法之外不会影响其他代码

2：更改器方法可以执行错误检查

如果访问器要返回一个可变对象的引用，需要先对对象克隆，然后返回克隆后的对象。如下列情况

Employee em= ... ; Date d= em.getDate(); getDate作为访问器返回了em中一个私有的日期对象，但d也引用了相同的对象，对d操作可以改变em中的值，破坏了封装。

final实例域

可以将实例域定义为final，构建对象时必须对其初始化，且之后的操作中不能在对其修改。

final修饰符大多应用于基本类型或不可变类的域(类中的每个方法都不改变其对象如String类)

4.3.3 方法

对外的方法设置为公有，类内的辅助方法设置为私有。

对于类的设计者而言，公有的方法一定不可以删去，因为其他的代码可能访问到，私有的可以被删去

4.3.4 静态域

将域定义为static，则类中只有一个这样的域，每个对象共享静态域，即使没有对象域也会存在，它属于类不属于对象。使用类名访问。 Math.PI

静态常量：public static final double PI，静态常量不会被修改，所以设置为public

4.3.5 静态方法

通过类使用，不能对对象使用。

因为静态方法不能操作对象，所以不能在静态方法中访问实例域。但是可以访问类中的静态域。

当一个方法不需要访问对象状态，其参数都通过显示参数提供或只需访问类中的静态域则可设置为静态方法。

l  工厂方法

静态方法的一种用途。

如NumberFormat.getCurrnecyInstance(); NumberFormat.getPercentInstance();

无法命名构造器，构造器的名字必须与类名相同，但这里希望得到货币实例和百分比时采用不同的名字。

当使用构造器时，无法改变所构造的对象类型。

4.3.6 方法参数

按值调用：接收调用者提供的值；按引用调用：接收调用者提供的变量地址。

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

Java总是按值调用。方法得到的所有参数值是一个拷贝，对象引用及其他的拷贝同时引用一个对象，方法不能修改传递给它的任何参数变量的内容。

"引用"是一个需要内存A存储的"值"，方法的参数获得了该"值"的一个副本存储在新的内存B中，方法结束后内存B弃用，仍然没有更改原来内存A中的"值"。

方法内使用的参数与传进去的参数在不同的内存中存储了相同的"引用"的值，该"引用"又指向了某内存块，该内存块实际记录对象里各个实例域的值，对方法内使用的参数的"引用"使用更改器，改变的是内存块中的值，原来的"引用"也是指向这块存储内容变化过的内存块，所以实现了改变对象参数的状态。

public static void swap(Employee x,Employee y)
{
   Employee temp=x; x=y;y=temp;
}
并不会交换传入的两个对象。因为x和y并没有引用原来的对象，而是复制了原来对象的"值(地址)"，交换的是x和y
即使是swap(int x,int y)也不会成功。

或者说，按值传递传进去的是变量本身存储的值(对象的值是地址)的副本；按引用传递传进去的是参数本身的地址(基本类型)或者参数存储的地址指向的那一块值(对象)，即变量本身。

4.4 对象构造

4.4.1 重载

多个方法具有相同的名字、不同的参数。方法名与参数类型叫做方法的签名。

返回类型不属于方法签名，不能有两个名字相同、参数类型相同却返回不同类型值的方法。

4.4.2 默认域初始化

如果在构造器中没有显式的给域赋初值，会自动为域赋为默认值。

局部变量必须明确初始化，而域如果没有初始化会被自动初始化为默认值。

4.4.3 无参数的构造器

对象由无参数构造器创建时，状态会设置为适当的默认值。

只有类中没有提供任何构造器的时候，系统才会提供一个默认的构造器。也就是说如果提供了一个带参数的构造器而未提供不带参数的，系统不会自动提供不带参数的构造器，在使用不带参数的构造器时会报错。

4.4.4 显示域初始化

确保不管怎样调用构造器，每个实例域都可以被设置为一个有意义的初值是一种很好的设计习惯。

初始值不一定是常量。可以调用方法对域进行初始化。

4.4.5 调用另一个构造器

构造器的第一个语句形如 this(...)，这个构造器将调用同一个类的另一个构造器，括号内为参数列表，根据参数选择是哪一个构造器。

public Employee(double s)
{ 
　　//calls Employee(String,double)...
　　this("Employee ",s);
　　...
}

4.4.6 初始化块

在一个类的声明中，可以包含多个代码块，只要构造类的对象，这些块就会被执行。如：

Class Employee
{
　　private static int nextID;
　　private int id;
　　private String name;
　　{id=nextID} //初始化块
　　public Employee()...
　　public Employee(String s,int i)..
}
无论执行哪个构造器，都会先执行 id=nextID代码块

4.4.7 构造器的处理步骤

基于上述多个途径下的步骤：

1：所有数据域被初始化为默认值。

2：按照在类声明中出现的次序，依次指向所有域初始化语句和初始化块。

3：如果构造器第一行调用了第二个构造器，则执行第二个构造器主体。

4：执行这个构造器的主体。

4.4.8 对象析构

Java有自动的垃圾回收，不支持析构器。

finalize方法将在垃圾回收器清除对象之前调用，在实际应用中不要依赖使用finalize方法回收任何短缺的资源，因为很难知道这个方法什么时候才能够调用。

对于需要在使用完毕后立刻被关闭的资源(如文件)，在对象用完时应用close方法来完成清理操作。

4.5 包

Java允许使用包将类组织起来，同时可以确保类名唯一性。

为了保证包名的绝对唯一性，Sun公司建议将公司的因特网域名以逆序的形式作为包名。并对不同的项目使用不同的子包。

4.5.1 类的导入

java.lang包被默认导入。

一个类可以使用所属包中的所有类，以及其他包中的公有类。

使用import 语句导入一个特定的类或者整个包 如 import java.util.*;

import java.util.* 与import java.util.Date; 相比对代码的大小没有任何负面影响。

使用星号只能导入一个包，而非以其前缀的所有包。

大多数情况下只导入所需的包，但在发生命名冲突时需要考虑。如果只用一个则把那一个精准导入，否则在使用类时前面加上完整的包名。

import语句的唯一好处是便捷。

Eclipse中 Source – Organize Imports Pagckage

4.5.2 静态导入

import不仅可以导入类，还可以导入静态方法和静态域。

如 import static java.lang.System.*; 则可直接使用out.println(...);

4.5.3 将类放入包中

在源文件的开头，写上  package  包名 ;

4.5.4 包的作用域

变量显示private，

类、方法、变量若没有设置访问修饰符则包中的所有方法都可以访问。

包密封机制将各种包混杂在一起，不能再向这个包添加类了。

4.6 类路径

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

类文件也可以存储在JAR(Java归档)文件中。在一个JAR文件中，可以包含多个压缩形式的类文件和子目录。

为了使类能够被多个程序共享，需要以下几点：

1：把类放到一个目录中，这个目录是包树状结构的基目录。

2：将JAR文件放在一个目录中

3：设置类路径。类路径是所有包含类文件的路径的集合。基目录/当前目录/JAR文件

编译器定位文件，如果引用了一个类而没支出这个类所在的包，编译器首先查找包含这个类的包，并询查所有import执行，确定其中是否包含了被引用的类。如果找到一个以上的类就会产生编译错误，类必须是唯一的，而import语句的次序却无关紧要。

之后还要查看源文件是否比类文件新，如果是那么源文件就会被自动地重新编译。由于只能导入其他包中的公有类而一个源文件只包含一个共有类，所以编译器很容易定位源文件。如果从当前包中导入了一个类，编译器就要搜索当前包中的所有源文件，以便确定哪个源文件定义了这个类。

4.7 文档注释

4.7.1 注释的插入

javadoc，可以由源文件生产一个HTML文档。 javadoc utility从下面几个特性中抽取信息：

包

公有类和接口

公有的和受保护的构造器及方法

公有的和受保护的域

注释以/** 开始 以 */结束 。自由格式文本。标记由@开始

4.7.2 类注释

类注释必须放在import之后，类定义之前。

4.7.3 方法注释

方法注释必须放在所描述的方法之前，除通用标记之外还可以使用下面的标记

@param 变量描述 可占据多行，可使用html标记，但一个方法的所有@param标记必须放在一起

@return 描述 对当前方法添加 return 部分，可跨多行可使用html标记

@throws类描述 这个标记将添加一个注释，用于表示这个方法可能抛出异常。、

4.7.4 域注释

只需要对公有域(通常只的是静态常量)建立文档

4.7.5 通用注释

以下可用在类文档的注释中

@auther 姓名

@version 版本

@since 始于

@deprecated 类、方法、变量等添加不再使用的注释

@see 引用 用于类、方法中，添加一个超链接。

4.7.6 包与概述注释

可以直接将类、方法和变量注释放在java源文件中，只要以/** ..*/为界就可以了。但想要产生包注释就需要在每个包目录添加一个单独的文件：

1：提供一个以package.html命名的html文件，在body里的所有文本都会被抽取

2：提供一个以package-info.java命名的java文件，这个文件必须包含一个初始的以/** .. */为界定的Javadoc注释，跟随在一个包语句之后。它不应该包含更多的代码或注释。

还可以为所有的源文件添加一个概述性的注释，该注释放置在一个名为overview.html的文件中，并包含在所有源文件的父目录中。body里的所有文本都会被抽取。

4.8 类设计技巧

1：一定要保证数据私有

2：一定要对数据初始化

3：不要在类中使用过多的基本类型

4：不是所有的域都需要设置独立的域访问器和域更改器

5：将职责过多的类进行分解

6：类名和方法名要能够体现它们的职责

第二部分：实验部分

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

1.  实验目的：

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

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

(3) 掌握对象的声明；

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

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

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

2.

3. 实验步骤与内容：

实验1 采用个人账号登录https://pintia.cn/，使用绑定码620781加入PTA平台NWNU-2019CST1教学班（西北师范大学 计算机科学与工程学院 2018级计算机科学与技术），完成《2019秋季西北师范大学面向对象程序设计程序设计能力测试1》，测试时间50分钟。

实验2 导入第4章示例程序并测试。

测试程序1：

l  编辑、编译、调试运行程序4-2（教材104页）；

l  结合程序运行结果，掌握类的定义与类对象的用法，并在程序代码中添加类与对象知识应用的注释；

运行注释及运行结果：

l  尝试在项目中编辑两个类文件（Employee.java、 EmployeeTest.java ），编译并运行程序。

运行结果：

 

l  参考教材104页EmployeeTest.java，设计StudentTest.java，定义Student类，包含name（姓名）、sex（性别）、javascore（java成绩）三个字段，编写程序，从键盘输入学生人数，输入学生信息，并按以下表头输出学生信息表：

  姓名    性别      java成绩

代码：

package week3;

import java.util.Scanner;

public class StudentTest {
	String name;
	String sex;
	double javascore;
	public static void main(String[] args) {
		System.out.println("Please input the student number:");
		Scanner stu=new Scanner(System.in);
	    int totalStudent=stu.nextInt();
		student[] stus=new student[totalStudent];
		System.out.println("Please input name,sex,score");
		Scanner in=new Scanner(System.in);
		for(int i=0;i<stus.length;i++)
		{
			stus[i]=new student(in.next(),in.next(),in.nextFloat());
		}
		System.out.println("name"+" "+"sex"+" "+" "+"javascore");
		for(student out:stus)
			System.out.println(out.getName()+"  "+out.getSex()+"   "+out.getJavaScore());
		in.close();	
		
	}

}
class student{
	private String name;
	private String sex;
	private float javascore;
	
   
	public student(String n, String s, float m)
	 {
	          name = n;
	          sex = s;
	          javascore =m;
	 }
	public String getName()
	{
		return name;
	}
	public String getSex()
	{
		return sex;
	}
	public float getJavaScore()
	{
		return javascore;
	}
}

　　输出结果：

测试程序2：

l  编辑、编译、调试运行程序4-3（教材116）；

l  结合程序运行结果，理解程序代码，掌握静态域（netxtId）与静态方法（getNextId）的用法，在相关代码后添加注释；

l  理解Java单元（类）测试的技巧。

package week4;

/**
 * This program demonstrates static methods.
 * @version 1.02 2008-04-10
 * @author Cay Horstmann
 */
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)//调用getName 方法，getId方法和getSalary方法将每个雇员的信息打印出来
      {
         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
{
   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()  //实例域name的访问器方法
   {
      return name;
   }

   public double getSalary() //实例域Salary的访问器方法
   {
      return salary;
   }

   public int getId() //实例域Id的访问方法
   {
      return id;
   }

   public void setId()
   {
      id = nextId; // 将id设置为下一个可用id
      nextId++;
   }

   public static int getNextId()//实例域NextId的访问方法
   {
      return nextId; //返回静态字段
   }

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

运行结果：

测试程序3：

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

l  结合程序运行结果，理解程序代码，掌握Java方法参数的用法，在相关代码后添加注释；

package week4;

/**
 * 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) // 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：

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

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

      // 打印有关所有员工对象的信息 
      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;
  
   // 静态intialization块
   static
   {
      var generator = new Random();
      //将nextId设置为0到999之间的随机值）
      nextId = generator.nextInt(10000);
   }

   // 对象intialization块
   {
      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);
   }

   // 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：

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

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

4-6

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)
   {
      // 因为import语句，我们不必使用
      // 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());
   }
}

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 / 100;
      salary += raise;
   }
}

实验运行图

4. 实验总结：

   通过这个第四周的学习，在前面学习中感觉对于q前面知识还是有点欠缺，不能及时的反馈学习，而且从面向过程到面向对象的思维过渡确实理解还是 比较抽象，在学习了类之后，有学习了静态域和静态方法的用法在这一周的觉得颇有收获，觉得比较简单易懂，了解了静态域、静态常量、静态方法、工厂方法和main方法的概念，通过大量的实例更加加深了对于本周知识的理解，能够初步掌握类的构造，以后还是要加深学习的深度，多花点时间在编程练习上。