201871010135张玉晶《面向对象程序设计（Java）》第四周学习总结

 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(6,10);
    String m=s.substring(10,12);
    String d=s.substring(12,14);
    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[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;
    }
}

运行结果如下：

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

运行结果如下：

实验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[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%（给每人涨%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()       //实例域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;
   }
}

运行结果如下：

 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[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%（给每人涨%5的工资）
      for (Employee e : staff)  //进行foreach循环
         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());
   }
}

运行结果如下：

 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 / 100;
              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=0;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=0;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[3];            //构造了一个Employee 数组，并填入三个雇员对象
 
      staff[0] = new Employee("Tom", 40000);
      staff[1] = new Employee("Dick", 60000);
      staff[2] = new Employee("Harry", 65000);
 
      // 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 = 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; // 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", 50000);
      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 = 10;
      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", 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:");
      var a = new Employee("Alice", 70000);    //定义一个类型为var的a，并进行初始化
      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());
   }
        //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 / 100;
      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[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());
    }
 }
  
 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(10000);
    }
 
    // 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", 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;
   }
}

运行结果如下：

  

  实验总结：   通过第四周的学习，掌握类与对象的基础概念，理解类与对象的关系；以及对象与对象变量的关系； 知道了预定义类Date、LocalDate类的常用API； 以及用户自定义类的语法规则，包括实例域、静态域（static)、构造器方法、更改器方法、访问器方法、静态方法、main方法、方法参数的定义要求； 掌握对象的构造方法、定义方法及使用要求； 理解重载概念及用法；

     实例域在整个类内都有效； 局部变量，只在定义它的方法内有效；final,该域无更改器；构造器可以调用另一个构造器，构造函数返回值。

    我不会的也有很多，我也会认真的看书，查资料，尽量让自己掌握的更多，继续加油。