汪慧和201771010123《面向对象程序设计JAVA》第四周实验总结

第一部分：理论知识学习部分

1.类

类(class)是具有相同属性和行为的一组对象的集合，是构造程序的基本单元，是构造对象的模板或蓝图。

2.对象

对象：即数据，对象有三个特性——1.行为 2.状态 3.标识。

3.类与对象的关系

（1）类是对象，事物的描述和抽象，是具有相同属性和行为的对象集合。对象则是该类事物的实例。　　　　

（2）类是一个静态的概念，类本身不携带任何数据。当没有为类创建任何对象时，类本身不存在于内存空间中。对象是一个动态的概念。每一个对象都存在着有别于其它对象的属于自己的独特的属性和行为。对象的属性可以随着它自己的行为而发生改变。

4.识别类

传统的过程化程序设计，必须从顶部的main函数开始编写程序。在面向对象程序设计时没有所谓的“顶部”。

首先从设计类开始，然后再往每个类中添加方法。

5.封装

封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。

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

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

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

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

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

e.更改器方法：调用更改器方法后对象的状态会改变。

f.访问器方法：只访问对象而不修改对象的方法。

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

7、重载

多个方法有相同的名字、不同的参数、便产生了重载。Java允许重载任何方法，而不只是构造器方法

8、Java允许使用包将类组织起来。借助包可以方便地组织自己的代码，并将自己的代码与别人提供的代码库分开管理。而且使用包可以确保类名的唯一性。

9、文档注释

a.类注释

b.方法注释

c.域注释

d.通用注释

e.包与概述注释

10、构造器是一种特殊的方法，用来构造并初始化对象。构造器的方法名与类名相同。

第二部分：实验部分

1、实验目的与要求

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

(2) 掌握对象的声明；

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

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

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

2、实验内容和步骤

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


import java.io.*;

import java.util.*;

public class FileWriteReadTest {

public static void main(String[] args) throws IOException{

//写入文件演示

PrintWriter out = new PrintWriter("myfile.txt");

out.println("姓名 高数 Java 数据结构 平均成绩 总成绩");

out.println("张三 20 30 40 0 0");

out.println("李四 50 60 70 0 0");

out.close();//输出完毕，需要close

//读入文件演示

Scanner in = new Scanner(new File("myfile.txt"));//为myfile.txt这个File创建一个扫描器in

int number = 1;//行号

System.out.println(in.nextLine());

while(in.hasNextLine()){//判断扫描器是否还有下一行未读取，该循环把文件的每一行都读出

String line = in.nextLine();//读出myfile.txt的下一行

System.out.print("第"+(++number)+"行的内容: ");

Scanner linescanner = new Scanner(line);//行内容建立扫描器

linescanner.useDelimiter(" ");//使用空格作为分隔符

String name = linescanner.next();

String math = linescanner.next();

String java = linescanner.next();

String ds = linescanner.next();

String avg = linescanner.next();

String total = linescanner.next();

System.out.println("name="+name+"  math="+math+"  java="+java+"  ds="+ds+"  avg"+avg+"  total="+total);

}

in.close();//读入完毕，最后需要对其进行close。

}

}

结果如下图所示：

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

测试程序1：

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

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

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

程序4-2如下：

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

实验结果如下：

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

姓名    性别   java成绩

import java.util.Scanner;
public class StudentTest
{
   @SuppressWarnings("resource")
public static void main(String[] args)
   {
      Student[] staff = new Student[3];
      System.out.println("输入学生的信息:");

      Scanner in = new Scanner(System.in);
      for(int i=0;i<staff.length;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 t)
   {
      name = n;
      sex = s;
      javascore =t;
   }

   public String getName()
   {
      return name;
   }

   public String getSex()
   {
      return sex;
   }

   public int getJavaScore()
   {
      return javascore;
   }
}

结果如下图所示：

测试程序2：

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

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

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

程序4-3如下：

/**
 * This program demonstrates static methods.
 * @version 1.01 2004-02-19
 * @author Cay Horstmann
 */
public class StaticTest
{
   public static void main(String[] args)
   {
      // fill the staff array with three Employee objects
      Employee[] 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();
         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; // 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());
   }
}

运行结果如下：

测试程序3：

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

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

程序4-4如下：

/**
 * 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)
   {
      /*
       * Test 1: Methods can‘t modify numeric parameters
       */
      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
       */
      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());

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

1、编辑、编译、调试运行程序4-5（教材129）；

2、结合程序运行结果，理解程序代码，掌握Java用户自定义类的用法，掌握对象构造方法及对象使用方法，在相关代码后添加注释。

程序4-5如下：

import java.util.*;

/**
 * This program demonstrates object construction.
 * @version 1.01 2004-02-19
 * @author Cay Horstmann
 */
public class ConstructorTest
{
   public static void main(String[] args)
   {
      // fill the staff array with three Employee objects
      Employee[] 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;

   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 = generator.nextInt(10000);
   }

   // object initialization block
   {
      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
      // id initialized in initialization block
   }

   public String getName()
   {
      return name;
   }

   public double getSalary()
   {
      return salary;
   }

   public int getId()
   {
      return id;
   }
}

结果如下图所示：

测试程序5：

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

2、 结合程序运行结果，理解程序代码，掌握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)
   {
      // because of the import statement, we don‘t have to use
      // com.horstmann.corejava.Employee here
      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());
   }
}

结果如下：

实验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） 将两个对象的周长加总输出，将两个对象的面积加总输出。

package 实验三;
import java.util.Scanner;
public class 实验3 {
public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入矩形的x y：");
    int x = sc.nextInt();
    int y = sc.nextInt();
    System.out.println("矩形的c： "+Perimeter.getPerimeter(x,y));
    System.out.println("矩形的area："+Area.getArea(x,y));

    System.out.println("请输入圆的半径r：");
    int r = sc.nextInt();
    System.out.println("圆c："+Perimeter.getPerimeter(r));
    System.out.println("圆area："+Area.getArea(r));

    double c = Perimeter.getPerimeter(x,y)+Perimeter.getPerimeter(r);
    double s = Area.getArea(x,y)+Area.getArea(r);
    System.out.println("矩形与圆的c之和："+c);
    System.out.println("矩形与圆的area之和："+s);

 }
}
class Perimeter{
    public static double getPerimeter(double width, double height) {
        return 2*(width + height);
    }

    public static double getPerimeter(int r) {
        return 2*3.14*r;
    }

}
class Area{
    public static double getArea(double width, double height){
        return width * height;
 }

    public static double getArea(int r) {
        return 3.14*r*r;
    }
}

实验结果如下图所示：

 三、实验总结

通过本次实验，理解了用户自定义类的定义，掌握了对象的声明，掌握了预定义类的基本使用方法，如Math类、String类、math类、Scanner类、LocalDate类等常用API，学会了使用构造函数初始化对象，使用了类属性与方法的使用掌握使用，掌握了package和import语句的用途。  写代码仍然是自己的大问题，在今后的学习中仍需要努力。

原文地址：https://www.cnblogs.com/http-www-whh0601-cnblogs-com/p/9702975.html

时间： 2024-08-02 00:04:36

汪慧和201771010123《面向对象程序设计JAVA》第四周实验总结的相关文章

201771010123汪慧和《面向对象程序设计Java》第十八周实验总结

一.实验部分 1.实验目的与要求 (1) 综合掌握java基本程序结构: (2) 综合掌握java面向对象程序设计特点: (3) 综合掌握java GUI 程序设计结构: (4) 综合掌握java多线程编程模型: (5) 综合编程练习. 2.实验内容和步骤 任务1:填写课程课后调查问卷,网址:https://www.wjx.cn/jq/33108969.aspx. 任务2:综合编程练习 练习1:设计一个用户信息采集程序,要求如下: (1) 用户信息输入界面如下图所示: (1)用户点击提交按钮时,

201771010123汪慧和《面向对象程序设计Java》第十四周实验总结

一.理论部分 1.Swing和MVC设计模式 (1)设计模式初识 (2)模式-试图-控制器模式 (3)Swing组件的模型-试图-控制器分析 2.Java组件有内容.外观.行为三个主要元素:这三个主要元素与模型-试图-控制器模式的三部分的对应关系为: (1)内容--模型(作用:存储内容) (2)外观--视图(作用:显示内容) (3)行为--控制器(作用:处理用户输入) 3.模式-试图-控制器设计模式是Java组件设计中比较通用的设计模式,要想有效利用一些更高级的组件,必须了解组件底层的体系结构.

201771010123汪慧和《面向对象程序设计Java》第二周学习总结

一.理论知识部分 1.标识符由字母.下划线.美元符号和数字组成, 且第一个符号不能为数字.标识符可用作: 类名.变量名.方法名.数组名.文件名等.第二部分:理论知识学习部分 2.关键字就是Java语言中已经被赋予特定意义 的一些单词. ?常见有:class.public.try.catch.if. float.import.void等. 关键字不做变量名. 3.Java有三种注释的方式:   // 注释内容由//一直到此行结束. /*和*/ 定义一个注释块.  /**开始,*/结束 这种注释方法

201771010123汪慧和《面向对象程序设计JAVA》第八周实验总结

一.理论部分 1.接口 用interface声明,是抽象方法和常量值定义的集 合.从本质上讲,接口是一种特殊的抽象类. 在Java程序设计语言中,接口不是类,而是对类 的一组需求描述,由常量和一组抽象方法组成.接口中不包括变量和实现的方法.接口体中包含常量定义和方法定义,接口中只进 行方法的声明,不提供方法的实现.通常接口的名字以able或ible结尾:接口中的所有常量必须是public static final,方法必须是public abstract,这是 系统默认的,不管你在定义接时,写不

《数据结构与面向对象程序设计》第四周学习总结

20182304 2019-2020-1 <数据结构与面向对象程序设计>第四周学习总结 教材学习内容总结 1.本章我们学习了使用并编写我们自己的类:类中有与类同名的构造方法,也可以有set,get,toSring与自己定义的方法.实例化一个对象,可通过该对象使用类里的所有方法.实例数据是每次创造一个实例后自动生成新的内存空间的变量 2.uml类图 :每个类可能包含三部分内容:类名.属性.操作(方法).UML类图有属于自己的语法,变量的类型名在变量名的后面,它们之间用冒号作为分隔符,方法的+和-

Java面向对象程序设计--Java反射机制

能够分析类的功能的程序称为反射程序,反射机制的功能相当强大,几个基本的应用是: 在运行时分析各种类的功能; 在运行时对对象进行分析... 实现繁星数组操作的代码 使用Method方法就像使用C++中的函数指针一样;  1. Class 类: 当程序运行时,Java运行时系统维持一份包含每个对象运行时类型标记的信息.这个信息标记了每个对象所属的类型.运行时类型 信息为虚拟机找到正确的函数提供了依据.但这个信息可以通过类的getClass方法得到! 1 public class TestReflec

201771010134杨其菊《面向对象程序设计java》第十周学习总结

第8章泛型程序设计学习总结 第一部分:理论知识 主要内容:   什么是泛型程序设计                   泛型类的声明及实例化的方法               泛型方法的定义                     泛型接口的定义                    泛型类型的继承规则                    通配符类型及使用方法 1:泛型类的定义 (1) 一个泛型类(generic class)就是具有一个或多个类型变量的类,即创建用类型作为参数的类.如一个泛型

201777010217-金云馨《面向对象程序设计Java》第四周总结学习

2019面向对象程序设计(Java)第4周学习指导及要求 项目 内容 这个作业属于哪个课程 <任课教师博客主页链接>https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 <作业链接地址>https://www.cnblogs.com/nwnu-daizh/p/11552848.html 作业学习目标 <填写具体目标> 掌握类与对象的基础概念,理解类与对象的关系: 掌握对象与对象变量的关系: 掌握预定义类Date.LocalDate

201871010128-杨丽霞-《面向对象程序设计java》学习总结

课程总结: 1.点击链接,完成课程问卷调查. 2.总结这门课程的学习给你带来的提升,包括以下内容:   统计在课程学习中,你学习了多少个程序案例,合计有多少行代码? 在书本案例的基础上,在相应周末的编程题没有思路的情况下,借鉴学习他人的编程过程,学习其编程思路.大概有90左右个程序案例,合计有10000行代码.    统计在课程学习中,你编写了多少个程序,合计有多少行代码? 自主编程都是在老师布置相应编程题目后,前十周是自主编程,期中考试后是与自己的编程小伙伴合作编程.15个自主编程程序,大概有