冯志霞201771010107《面向对象程序设计（java）》第四周学习总结

2021-06-18 20:03

阅读：395

标签：ack 要求 adl read 面向对象 rac gets 1.0 dea

实验四类与对象的定义及使用

实验时间 2018-9-20

1、实验目的与要求

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

(2) 掌握对象的声明；

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

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

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

学习总结如下：

类与对象的概念。

类：是构造对象的模板或蓝图。由类构造对象的过程称为创建类的实例。

对象：想要使用oop，一定要清楚对象的三个特性：

1）对象的行为：对象的行为使用可调用的方法定义的。

·2）对象的状态：每个对象都保存着描述当前特征的信息。

3）对象标识：如何辨明具有相同行为的相似性。

对象与对象变量的关系

Java中想使用对象就必须先构造对象，并指定其初始状态。

通过实验掌握了预定义类的基本使用方法，熟悉Math类、String类、math类、Scanner 类、LocalDate类的常用API。

1）对象与对象变量。

在Java语言中，使用构造器构造新实例。构造器是类中一个特殊的方法，生成并初始化对象，它的方法名与类名相同。

想要构造一个Data对象（定义在java.util中），需要在构造器前加上new操作符：new Data（）

Data deadline；该语句错误。

可将一个对象变量设置为null，表示该对象变量未引用任何变量，如deadlin=null。

更改器与访问器。

更改器：修改实例域。前缀set，更改当前类中的属性。

访问器：更改实例域。前缀get。

掌握用户自定义类的语法规则，包括实例域、静态域、构造器方法、更改器方法、访问器方法、静态方法、main方法、方法参数的定义要求

(1)实例域：可将实例域定义为final,构建对象时必须初始化这样的域。

(2)静态域：绝大多数面向对象程序设计语言中，静态域被称为类域。如果将域定义为static，每个类中只有一个这样的域。而每个对象对于所有的实例域却都有自己的一份拷贝。

(3)静态方法：静态方法是一种不能向对象实时操作的方法。可以使用对象调用静态方法。

(4)构造器方法:构造器与类同名。构造器总是伴随着new操作符的执行被调用，而不能对一个已经存在的对象调用构造器来达到重新设置实例域的目的。

(5)更改器方法：调用更改器方法后对象的状态会改变。

(6)访问器方法：只访问对象而不修改对象的方法。

(7)main方法：main方法不对任何对象进行操作。静态的main方法将执行并创建程序所需要的对象。

2、实验内容和步骤

实验1 测试以下程序，掌握文件输入输出程序设计技术（文件输入输出，教材61-62）.

 1 import java.io.*;
 2 
 3 import java.util.*;
 4 
 5 public class FileWriteReadTest {
 6 
 7        public static void main(String[] args) throws IOException{
 8 
 9               //写入文件演示
10 
11               PrintWriter out = new PrintWriter("myfile.txt");
12 
13               out.println("姓名 高数 Java 数据结构 平均成绩 总成绩");
14 
15               out.println("张三 20 30 40 0 0");
16 
17               out.println("李四 50 60 70 0 0");
18 
19               out.close();//输出完毕，需要close
20 
21               //读入文件演示
22 
23               Scanner in = new Scanner(new File("myfile.txt"));//为myfile.txt这个File创建一个扫描器in
24 
25               int number = 1;//行号
26 
27               System.out.println(in.nextLine());
28 
29               while(in.hasNextLine()){//判断扫描器是否还有下一行未读取，该循环把文件的每一行都读出
30 
31                      String line = in.nextLine();//读出myfile.txt的下一行
32 
33                      System.out.print("第"+(++number)+"行的内容: ");              
34 
35                      Scanner linescanner = new Scanner(line);//行内容建立扫描器
36 
37                      linescanner.useDelimiter(" ");//使用空格作为分隔符
38 
39                      String name = linescanner.next();
40 
41                      String math = linescanner.next();
42 
43                      String java = linescanner.next();
44 
45                      String ds = linescanner.next();
46 
47                      String avg = linescanner.next();
48 
49                      String total = linescanner.next();
50 
51                      System.out.println("name="+name+"  math="+math+"  java="+java+"  ds="+ds+"  avg"+avg+"  total="+total);
52 
53               }
54 
55               in.close();//读入完毕，最后需要对其进行close。
56 
57        }    
58 
59 }

技术分享图片
l 编辑、编译、调试运行程序4-2（教材104页）；
测试程序1：实验2 导入第4章示例程序并测试。

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.12 2015-05-08
 * @author Cay Horstmann
 */
public class EmployeeTest {
    public static void main(String[] args) {
        // 用三个Employee对象填充staff数组
        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)
            e.raiseSalary(5);

        //打印出员工反对的信息
        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;
    }

}

技术分享图片

/**
 * @version 1.10 1999-11-13
 * @author Cay Horstmann
 */

public class Employee
{
   private String name;
   private double salary;

   public native void raiseSalary(double byPercent);

   public Employee(String n, double s)
   {
      name = n;
      salary = s;
   }

   public void print()
   {
      System.out.println(name + " " + salary);
   }

   static
   {
      System.loadLibrary("Employee");
   }
}

import java.util.*;
  public class StudentTest
  {
public static void main(String[] args)
     {
      Student[] staff = new Student[4];
       System.out.println("请输入学生姓名、性别、Java成绩");
       
       Scanner in = new Scanner(System.in); 
       for(int i=0;i) {
           staff[i]=new Student(in.next(),in.next(),in.nextInt());
       }
       System.out.println("name"+"sex"+"javascore");
 
       for (Student e: staff)
          System.out.println(e.getName()+e.getSex()+e.getjavaScore());
    }
 }
 
 class Student
 {
    private String name;
    private String sex;
  private int javascore;
 
    public Student(String n, String s, int j)
    {
       name = n;
      sex = s;
       javascore =j;
    }
 
    public String getName()
    {
       return name;
   }
 
    public String getSex()
    {
       return sex;
    }
 
    public int getjavaScore()
    {
       return javascore;
    }
 }

技术分享图片

测试程序2：

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

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

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

/**
    /**
         * This program demonstrates static methods.
         * @version 1.01 2004-02-19
         * @author Cay Horstmann
         */
        public class StaticTest
        {
           public static void main(String[] args)
           {
              //用三个Employee对象填充staff数组
              Employee[] staff = new Employee[3];

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

              //打印出员工反对的信息
              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
        {
           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; //返回static域
           }

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

    }

技术分享图片

测试程序3：

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

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

/**
     * This program demonstrates parameter passing in Java.
     * @version 1.00 2000-01-27
     * @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:");
          Employee 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:");
          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);
          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 
    {
       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用户自定义类的用法，掌握对象构造方法及对象使用方法，在相关代码后添加注释。

技术分享图片

测试程序5：

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

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

技术分享图片

实验3 编写长方形类Rectangle与圆形类Circle，其中Rectangle类设置私有属性：width,length；Circle类设置私有属性radius。编写Rectangle类的带参构造函数Rectangle(int width,int length), Circle类的带参构造函数Circle(int radius)，编写两个类的toString方法(Eclipse可自动生成)。上述2个类均定义以下方法：

求周长的方法public int getPerimeter()

求面积的方法public int getArea()

在main方法中完成以下任务：

（1）输入1行长与宽，创建一个Rectangle对象；

（2）输入1行半径，创建一个Circle对象；

（3）将两个对象的周长加总输出，将两个对象的面积加总输出。

 1 import java.util.Scanner;
 2 
 3 public class Circlep2 {
 4     float pai=(float) 3.14;
 5     
 6     void yuan(float r){
 7         System.out.println("圆的面积是："+r*r*pai);
 8         System.out.println("圆的周长是："+2*pai*r);
 9     }
10     
11    
12     
13     void juxing(float chang,float kuan){
14         System.out.println("矩形的面积是："+chang*kuan);
15         System.out.println("矩形的周长是："+2*(chang+kuan));
16     }
17     
18     public static void main(String[] args) {
19         Circlep2  c2=new Circlep2();
20         Scanner sc=new Scanner(System.in);
21         
22         System.out.println("请输入圆的半径：");
23         float r=sc.nextFloat();
24         c2.yuan(r);
25         
26       
27         System.out.println("请输入矩形的长：");
28         float chang=sc.nextFloat();
29         System.out.println("请输入矩形的宽：");
30         float kuan=sc.nextFloat();
31         c2.juxing(chang, kuan);
32         
33     }
34 }

技术分享图片

总结：通过此次实验我基本掌握了文件输入输出程序的设计技术，学到了类的定义与类对象的用法，且学会了如何定义一个student类其中包含三个字段。基本掌握了静态域与静态方法的用法，掌握Java方法参数的用法，还有Java用户自定义类的用法，掌握对象构造方法及对象使用方法对Java中的类（如LocalDate类，Employee类Math类、String类、math类等）有了初步的了解，并初步掌握了用户自定义的语法规则如包括实例域、静态域、构造器方法、更改器方法、访问器方法、静态方法、main方法、方法参数的定义要求。但是最后一个实验我还没有很透彻的掌握以后会多多努力的