201874040116-李鑫《面向对象程序设计（java）》第四周学习总结

2020-12-13 15:11

阅读：521

标签：登录 string available 运行程序 ogr https 继承键盘输入 raise

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

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

4.1

　　面向对象程序设计(OOP)：　　主流的程序设计范例；　　将数据放在第一位，然后再考虑操作数据的算法；　　适合于大型程序的开发。

　　类(CLASS)：　　构造对象的模板；　　由类构造对象的过程称为创建类的实例。　　

　　对象：　　有对象的行为，对象的状态，对象标识三个主要特性；　　类的实例。

　　类之间常见的三种关系：依赖(dependence)，聚合(aggregation)，继承(inheritance)。

4.2　

　　构造器：　　构造对象时使用的特殊的方法，与类同名。　　使用方法：以Data类为例，　new Date()

　　对象与对象变量：　　通过对象变量的引用多次使用同一个对象。 birthday = new Date()　　(注意：对象变量仅仅引用一个对象）

　　更改器方法：　　可能会改变对象的状态的方法。

　　访问器方法：　　只访问不改变对象的状态的方法。

4.3

　　自定义类

　　　　{

　　　　构造器；

　　　　状态；

　　　　方法；}

　　访问修饰符：public（谁都可以访问）private（除类型创建者和类型的内部方法之外的任何人都不能访问的元素）protect （继承的类可以访问以及和private一样的权限）default （包访问权限，即在整个包内均可被访问）

　　封装：　　控制用户对类的修改和访问数据的程度，可以降低程序复杂性、提高可控性。　

4.4　

　　静态域(static)：　　每个类中只有一个；　　属于类的，而不属于任何独立的对象。

　　静态常量：　　static final ‘name’ = ‘value’。

　　静态方法：　　不能对对象使用，可以访问类的静态域的方法。

　　main方法：　　静态的main方法将执行并创建程序所需要的对象。

4.5　　方法参数

4.6　　对象构造

4.7　　包

4.8　　类路径

4.9　　文档注释

4.10　类设计技巧

第二部分：实验部分

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

1. 实验目的：

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

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

(3) 掌握对象的声明；

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

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

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

3. 实验步骤与内容：

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

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

测试程序1：

编辑、编译、调试运行程序4-2（教材104页）；
结合程序运行结果，掌握类的定义与类对象的用法，并在程序代码中添加类与对象知识应用的注释；
尝试在项目中编辑两个类文件（Employee.java、EmployeeTest.java ），编译并运行程序。
参考教材104页EmployeeTest.java，设计StudentTest.java，定义Student类，包含name（姓名）、sex（性别）、javascore（java成绩）三个字段，编写程序，从键盘输入学生人数，输入学生信息，并按以下表头输出学生信息表：

姓名性别 java成绩

　　课本案例编译运行结果如下：

技术图片

改编程序代码如下：

import java.util.Scanner;

public class StudentTest 
{
       public static void main(String[] args)
       {
          // fill the staff array with three Employee objects
         //定义容量为3的数组
           Student[] stu = new Student[3]; 
           Scanner in = new Scanner(System.in);
          //从键盘向数组中赋值
          int i = 0 ;
          while(i)
          {
          stu[i] = new Student();
          stu[i].setName(in.next());
          stu[i].setSex(in.next());
          stu[i].setJavascore(in.nextInt());
          i++;
          }
          //输出数据
          for (Student e : stu)
             System.out.println("姓名" + e.getName() + ",性别" + e.getsex() + ",java成绩=" 
                + e.getjavascore());
       }
    }
    //定义Student类
    class Student
    {
       private String name;
       private String sex;
       private int javascore;

       public String getName()
       {
          return name;
       }
       
       public void setName(String n)
       {
           name = n;
       }

       public String getsex()
       {
          return sex;
       }
       
       public void setSex(String s)
       {
           sex = s;
       }

       public int getjavascore()
       {
          return javascore;
       }

       public void setJavascore(int j)
       {
           javascore = j;
       }

}

运行结果如下：

技术图片

测试程序2：

编辑、编译、调试运行程序4-3（教材116）；
结合程序运行结果，理解程序代码，掌握静态域（netxtId）与静态方法（getNextId）的用法，在相关代码后添加注释；
理解Java单元（类）测试的技巧。

添加注释后的代码：

public class StaticTest
{
   public static void main(String[] args)
   {
      // fill the staff array with three Employee objects
      var staff = new Employee[3];

      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)
      {
         e.setId(); //静态域nextId累计加3
         System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
            + e.getSalary());
      }

      int n = Employee.getNextId(); // calls static method 使用静态方法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()
   {
      return name;
   }

   public double getSalary()
   {
      return salary;
   }

   public int getId()
   {
      return id;
   }

   public void setId()  //每次调用静态域nextId加1
   {
      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
   {
      var e = new Employee("Harry", 50000);
      System.out.println(e.getName() + " " + e.getSalary());
   }
}

运行结果：

技术图片

测试程序3：

编辑、编译、调试运行程序4-4（教材121）；
结合程序运行结果，理解程序代码，掌握Java方法参数的用法，在相关代码后添加注释；

添加注释的代码：

public class ParamTest
{
   public static void main(String[] args)
   {
      /*
       * Test 1: Methods can‘t modify numeric parameters
       *///tripleValue方法只引用不改变变量的值
      System.out.println("Testing tripleValue:");
      double percent = 10;
      System.out.println("Before: percent=" + percent);
      tripleValue(percent);
      System.out.println("After: percent=" + percent);

      /*
       * Test 2: Methods can change the state of object parameters
       *///tripleSalary方法可以改变Employee类的对象的状态
      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());

      /*
       * Test 3: Methods can‘t attach new objects to object parameters
       *///swap方法影响不到变量，只能交换参数变量
      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：

编辑、编译、调试运行程序4-5（教材129）；
结合程序运行结果，理解程序代码，掌握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
      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)
         System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
            + e.getSalary());
   }
}

class Employee
{
   private static int nextId;//默认为0

   private int id;
   private String name = ""; // instance field initialization
   private double salary;
  
   // static initialization block
   static
   {
      var generator = new Random();
      // set nextId to a random number between 0 and 9999
      nextId = generator.nextInt(10000);
   }

   // object initialization block
   //初始化块（运行优先于构造器）
   {
      id = nextId;
      nextId++;
   }

   // three overloaded constructors
   //构造器1
   public Employee(String n, double s)
   {
      name = n;
      salary = s;
   }
   //构造器2
   public Employee(double s)
   {
      // calls the Employee(String, double) constructor
      this("Employee #" + nextId, s); //使用this（） 调用了构造器1
   }

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

   public double getSalary()
   {
      return salary;
   }

   public int getId()
   {
      return id;
   }
}