201871010101-陈来弟《面向对象程序设计（java）》第四周学习总结

                                                                                                     

                                                                                                                      2019面向对象程序设计（Java）第4周学习指导及要求

 

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

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

       第四章主要讲述了对象与类的概念，有十小节内容，而这章内容也是非常重要的一章，学起来也是很困难的，如果课后不认真看书，不多加练习，那么这一章的内容就什么也学不下，这会影响后面的学习。

1.  面向对象程序设计（Object Oriented Programming，OOP）是一种计算机编程架构。OOP的一条基本原则是计算机程序由单个能够起到子程序作用的单元或对象组合而成。OOP达到了软件工程的三个主要目标：重用性、灵活性和扩展性。OOP=对象+类+继承+多态+消息，其中核心概念是类和对象。面向对象程序设计以对象为核心，该方法认为程序由一系列对象组成。类是对现实世界的抽象，包括表示静态属性的数据和对数据的操作，对象是类的实例化。对象间通过消息传递相互通信，来模拟现实世界中不同实体间的联系。在面向对象的程序设计中，对象是组成程序的基本模块。

       面向对象程序设计中的概念主要包括：对象、类、数据抽象、继承、动态绑定、数据封装、多态性、消息传递。通过这些概念面向对象的思想得到了具体的体现。

1）对象（Object) ：

可以对其做事情的一些东西。一个对象有状态、行为和标识三种属性。

2）类（class)：

一个共享相同结构和行为的对象的集合。类（Class）定义了一件事物的抽象特点。通常来说，类定义了事物的属性和它可以做到的（它的行为）。举例来说，“狗”这个类会包含狗的一切基础特征，例如它的孕育、毛皮颜色和吠叫的能力。类可以为程序提供模版和结构。一个类的方法和属性被称为“成员”。

3）封装（encapsulation)：

第一层意思：将数据和操作捆绑在一起，创造出一个新的类型的过程。第二层意思：将接口与实现分离的过程。

4）继承：

类之间的关系，在这种关系中，一个类共享了一个或多个其他类定义的结构和行为。继承描述了类之间的“是一种”关系。子类可以对基类的行为进行扩展、覆盖、重定义。

5）组合：

既是类之间的关系也是对象之间的关系。在这种关系中一个对象或者类包含了其他的对象和类。

组合描述了“有”关系。

6）多态：

类型理论中的一个概念，一个名称可以表示很多不同类的对象，这些类和一个共同超类有关。因此，这个名称表示的任何对象可以以不同的方式响应一些共同的操作集合。

7）动态绑定：

也称动态类型，指的是一个对象或者表达式的类型直到运行时才确定。通常由编译器插入特殊代码来实现。与之对立的是静态类型。

8）静态绑定：

也称静态类型，指的是一个对象或者表达式的类型在编译时确定。

9）消息传递：

指的是一个对象调用了另一个对象的方法（或者称为成员函数）。

10）方法：

也称为成员函数，是指对象上的操作，作为类声明的一部分来定义。方法定义了可以对一个对象执行那些操作。

2.  使用预定义类：

 1.1构造器：

        在Java程序设计语言中，使用构造器构造新实例。 构造器是一种特殊的方法，用来构造并初始化对象。构造器的名字应该与类名相同

 1.2对象和对象变量的区别：

        变量不是个对象，实际上对象变量的初始化只是对对象的引用，Java中，任何对象变量的值都是对存储在另外一个地方的一个对象的引用。新的操作符的返回值也是一个引用

        C ++中没有空引用 Date b; // Java的， 实际上，等同于Date* b; // C ++

        的Java中的空引用对应于C ++中的空指针

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

        clone方法获得对象的完整拷贝

1.3.LocalDate类：

    Java的类库分别包含了两个类：一个是用来表示时间点的Date类;另一个是用来表示大家熟悉的日历表示法的LocalDate类

    不要使用构造器来构造LocalDate类的对象，应当使用静态工厂方法代表你调用构造器，如下：

    LocalDate.now()会构造一个新对象，表示构造这个对象时的日期

    可以提供年，月和日来构造对应一个特定日期的对象：LocalDate.of(1999,12,31)

3. 静态域与静态方法：Java 中被static 修饰的域或方法常被称作静态的。

 1）静态域：如果将静态域定义为static，那么每个类中只有这样一个域，而每一个对象对于所有的实例域都有自己的一份拷贝本。

 2）静态常量  静态变量使用的比较少，但是静态常量却使用的比较多（在实际的开发中，静态常量可以做到:该改一处而改全处作用，大大的减少修改和出错的地方），在使用的时候，我们就可以跟使用静态变量、静态方法方法一样使用静态常量(用静态static修饰的都是可以直接用类名来使用) Math.PI来使用这个常量。如果关键字static被省略，那么PI就变成Math类的一个实例域，需要通过Math类的对象访问PI，并且每一个Math对象都有它自己的一个PI复制本。另外一个多次使用的静态常量是Java中System.out. 它在System类中声明。  我们都知道每个类对象都可以对公有域进行修改，所以，最好不要将域设计成为public ,然而，公有常量(即final域)却没有问题，因为out被声明为final, 所以，不允许再将其他的打印流赋值给它

3）静态方法：静态方法是一种不能由对象操作的方法, 例如Math类中的求取一个数的次方的pow()方法就是一个静态方法。表达式是： Math.pow(x, a),在运算时，不使用任何Math对象，换句话说，没有隐式的参数。可以认为静态方法是没有this参数的方法（在一个非静态的方法中，this参数表示这个方法的隐式参数）。

       Student 类的静态方法不能访问Id实例域，因为Id它不是静态的，Student的静态方法它不能操作对象，但是静态方法可以访问自身类中的静态域。总之就是常说的：静态方法中只能调用静态的东西，非静态的是不能使用的。

4.包作用域：

1）类中标记为public的部分可以被任意类使用；

2）类中标记为private的部分只能在类中使用；

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

4）如果实例域不标记为private，将默认为包可见，这样做会破坏类的封装性。

5. 类路径：

1）类存储在文件系统的子目录中，类得路径必须与包名匹配；

2）在命令行方式下，设置类路径，使用-classpath选项指定类路径。

第二部分：实验部分

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

1.  实验目的：

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

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

(3) 掌握对象的声明；

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

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

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

3. 实验步骤与内容：

实验1  任务1（10分）

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        String s1 = in.nextLine();
        String s2,s3,s4;
        s2 = s1.substring(6,10);
        s3 = s1.substring(10,12);
        s4 = s1.substring(12,14);
        System.out.println(s2+"-"+s3+"-"+s4);
    }
       
}

运行结果如图：

实验1  任务2（25分）

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Scanner;

public class students {

    private static ArrayList<Student> list;

    public static void main(String[] args) {

        // TODO Auto-generated method stub

        list = new ArrayList<>();

        Scanner in = new Scanner(System.in);

        try {

            readFile("studentfile.txt");  //读如文件  studentfile.txt的信息

            System.out.println("请选择操作，1按姓名，2按学号，3退出");  //首先在控制台输出  ：请选择操作，1按姓名，2按学号，3退出

            int i;

            while ((i = in.nextInt()) != 3)  //读出并转换下一个表示整型的字符序列

            {

                switch (i)  //switch语句控制菜单

                {

                case 1:  //按学生的姓名查找

                    System.out.println("请输入姓名");   //在控制台上输出：请输入姓名

                    String name = in.next();   //定义一个String类对象name，表示下一行字符串

                    Student student = findStudentByName(name);   //通过姓名查找学生的信息

                    if (student == null) {     

                        System.out.println("没找到");    //if语句判断，如果学生的信息为空，则在控制台输出： 没找到

                    } else {

                        System.out.println(student.toString());  //否则，调用toString方法输出学生的信息

                    }

                    System.out.println("请选择操作，1按姓名，2按学号，3退出");  

                    break;   //退出当前的循环

                case 2:

                    System.out.println("请输入学号");   //按学生的学号查找

                    String id = in.next();      //定义一个String类对象id，表示下一行字符串

                    Student student1 = findStudentById(id);  //通过学号查找学生的信息

                    if (student1 == null) {    ////if语句判断，如果学生的信息为空，则在控制台输出： 没找到

                        System.out.println("没找到");  

                    } else {

                        System.out.println(student1.toString());    //否则，调用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();   //最后关闭0

        }

 

    }

 

    public static void readFile(String path) throws IOException {

        FileReader reader = new FileReader(path);   //

        BufferedReader br = new BufferedReader(reader);

        String result;   //定义一个String类对象 result

        while ((result = br.readLine()) != null) {   //while循环

            Student student = new Student();

            student.setName(result.substring(13));  

            student.setID(result.substring(0,12));  //从第十三位开始，调用result对象的substring方法得到一个新的字符串

            list.add(student);  

        }

        br.close();

    }

 

    public static Student findStudentByName(String name) {  //通过姓名找学生的信息

        for (Student student : list) {

            if (student.getName().equals(name)) {  //用equals方法检测两个字符串是否相等

                return student;

            }  

        }

        return null;

 

    }

 

    public static Student findStudentById(String Id) {   //通过学号查找学生的信息

        for (Student student : list) {

            if (student.getID().equals(Id)) {    //用equals方法检测两个字符串是否相等

                return student;

            }

        }

        return null;

 

    }

}

 

class Student {

    private String name;   //String类对象name的私有的实例域

    private String ID;     //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分）导入第4章示例程序并测试。

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

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

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

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

  姓名    性别 java成绩

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)
   {
      // fill the staff array with three Employee objects
      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);

      // raise everyone's salary by 5%
      for (Employee e : staff)
         e.raiseSalary(5);

      // 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()
   {
      return name;
   }

   public double getSalary()
   {
      return salary;
   }

   public LocalDate getHireDay()
   {
      return hireDay;
   }

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

运行结果：

 

 （2）Employee:

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()
   {
      return name;
   }

   public double getSalary()
   {
      return salary;
   }

   public LocalDate getHireDay()
   {
      return hireDay;
   }

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

运行结果：

 

 （3）代码如下(EmployeeTest):

public class EmployeeTest
{
   public static void main(String[] args)
   {
      // fill the staff array with three Employee objects
      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);

      // raise everyone's salary by 5%
      for (Employee e : staff)
         e.raiseSalary(5);

      // print out information about all Employee objects
      for (Employee e : staff)
         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay=" 
            + e.getHireDay());
   }
}

运行结果：

 

 

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

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

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

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

代码如下：

/**
 * 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  //用三个employee对象填充staff数组
       Employee[] staff = new Employee[3];

      staff[0] = new Employee("Tom", 40000);
      staff[1] = new Employee("Dick", 60000);////构造Employee数组，并有三个雇员对象；
      staff[2] = new Employee("Harry", 65000);

      // print out information about all Employee objects
      for (Employee e : staff)
      {
         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         //定义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;          //构造Employee类的对象，并声明局部变量name,salary,hireday;
   }

   public String getName()
   {
      return name;     //实例域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
   {
       Employee e = new Employee("Harry", 50000);
      System.out.println(e.getName() + " " + e.getSalary());
   }
}

运行结果：

 

 

 

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

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

结合程序运行结果，理解程序代码，掌握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)
   {
      /*
       * Test 1: Methods can't modify numeric parameters
       */                                    //测试方法不能修改数值参数
      System.out.println("Testing tripleValue:");
      double percent = 10;
      System.out.println("Before: percent=" + percent);
      tripleValue(percent);    //调用 tripleValue
      System.out.println("After: percent=" + percent);

      /*
       * Test 2: Methods can change the state of object parameters
       */                      //测试方法可以更改对象参数的状态
      System.out.println("\nTesting tripleSalary:");
      Employee harry = new Employee("Harry", 50000);
      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:");
      Employee a = new Employee("Alice", 70000);
      Employee b = new Employee("Bob", 60000);
      System.out.println("Before: a=" + a.getName());
      System.out.println("Before: b=" + b.getName());
      swap(a, b);                //用交换函数交换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;
   }
}

其运行结果：

 

 

 

 

实验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)
   {
      // fill the staff array with three Employee objects         用三个employee对象填充staff数组
       Employee[] staff = new Employee[3];

      staff[0] = new Employee("Harry", 40000);
      staff[1] = new Employee(60000);             //构造Employee数组，并有三个雇员对象；
      staff[2] = new Employee();

      // print out information about all Employee objects
      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 = ""; // instance field initialization    实例字段初始化
   private double salary;
  
   // static initialization block
   static
   {
       Random generator = new Random();
      // set nextId to a random number between 0 and 9999     将nextId设置为0到999之间的随机值
      nextId = generator.nextInt(10000);
   }

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

   // the default constructor     错误的构造器
   public Employee()
   {
      // name initialized to ""--see above      名称初始化为同上
      // salary not explicitly set--initialized to 0   工资未显示设置，初始化为0
      // id initialized in initialization block   id初始化
   }

   public String getName()
   {
      return name;      //实例域name的访问器方法
   }

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

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

运行结果：

 

 

 

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

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

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

4-6  代码如下：

import com.horstmann.corejava.*;
// the Employee class is defined in that package

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      因为import语句，不需要使用com.horstmann.corejava
       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());
   }                                //由于使用了静态导入语句，在这里不需要使用System.out
}

运行结果：

 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   导入语句位于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;
   }
}

其结果如图：

4. 实验总结：（10分）

        这一章的学习内容很是重要，但同时学起来也比较困难复杂。在这一章里面，主要讲述的是对象与类，在第一小节里，是对面向对象程序设计的概述在这一节里，具体解释了什么是类，什么是对象等一系列内容，我根据老师在课堂上讲的，按照实验步骤进行程序的运行，在这一过程中，我遇到了很大的困难，我就觉得，要把学到的知识运用在实验中是非常困难的，辛亏在实验课上，有老师和助教的帮助，我解决了遇到的困难，但我同时也认识到，我的操作能力很是差，应该多加练习，为后续的学习做好准备。