201771010124 王海珍 《对象与类的定义与使用》第四周总结

第一部分：理论部分

     面向对象程序设计概述                       对象构造

     使用预定义类                                      包

     用户自定义类                                       类路径

     静态域与静态方法                                文档注释

     方法参数                                              类设计技巧

一，本章主要介绍内容

       面向对象程序设计

       如何创建标准Java类库中的类对象

       如何编写自己的类

二，面向对象程序设计概论

       面向对象的程序是由对象组成的，每个对下对象包含对用户公开的特定功能部分和隐藏的实现部分程序中很多对象来自标准库，还有 一些是自定义的。

  （1）类

类是构造对象的模板和蓝图

  （2）对象

对象的三个主要特性

对象的行为：可以对对象施加哪些操作，或可以对对象施加哪些方法？

对象的状态：当施加那些方法时，对象如何响应？

对象的标识：如何辨别具有相同行为与状态的不同

（3）类与对象的关系

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

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

（4）对象与对象的变量关系

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

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

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

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

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

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

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

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

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

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

    五.重载 

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

  六.

 

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

七.文档注释

　　　 a.类注释

　　　　b.方法注释

　　　　c.域注释

　　　　d.通用注释

　　　　e.包与概述注释

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：

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

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

复制代码
 1 import java.time.*;
 2 
 3 /**
 4  * This program tests the Employee class.
 5  * @version 1.12 2015-05-08
 6  * @author Cay Horstmann
 7  */
 8 public class EmployeeTest
 9 {
10    public static void main(String[] args)
11    {
12       // fill the staff array with three Employee objects
13       Employee[] staff = new Employee[3];
14 
15       staff[0] = new Employee("Carl Cracker", 75000, 1987, 12, 15);
16       staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
17       staff[2] = new Employee("Tony Tester", 40000, 1990, 3, 15);
18 
19       // raise everyone's salary by 5%
20       for (Employee e : staff)
21          e.raiseSalary(5);
22 
23       // print out information about all Employee objects
24       for (Employee e : staff)
25          System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
26                + e.getHireDay());
27    }
28 }
29 
30 class Employee
31 {
32    private String name;
33    private double salary;
34    private LocalDate hireDay;
35 
36    public Employee(String n, double s, int year, int month, int day)
37    {
38       name = n;
39       salary = s;
40       hireDay = LocalDate.of(year, month, day);
41    }
42 
43    public String getName()
44    {
45       return name;
46    }
47 
48    public double getSalary()
49    {
50       return salary;
51    }
52 
53    public LocalDate getHireDay()
54    {
55       return hireDay;
56    }
57 
58    public void raiseSalary(double byPercent)
59    {
60       double raise = salary * byPercent / 100;
61       salary += raise;
62    }
63 }

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

EmployeeTest.java

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

  姓名      性别 java成绩

import java.util.Scanner;
 
 public class tudentchenji {
	String 姓名;
     String 性别;
     double java成绩;
     @SuppressWarnings("unused")
	private String 姓名3;
     public static void main(String[] args) {
         System.out.println("请输入学生人数");
         Scanner sc = new Scanner(System.in);
         int totalStudent = sc.nextInt();
         tudentchenji[] stus = new tudentchenji[totalStudent];
         for(int i=0;i<totalStudent;i++){
             tudentchenji s = new tudentchenji();
             stus[i]=s;
             System.out.println("请输入第"+(i+1)+"个学生的姓名");
             s.set姓名3(sc.next()); 
             System.out.println("请输入第"+(i+1)+"个学生的性别");
             s.性别 = sc.next();
             System.out.println("请输入第"+(i+1)+"个学生的Java成绩");
             s.java成绩 = sc.nextDouble();
         }
         printtudents(stus);
         sc.close();
     }
  
     public static void printtudents(tudentchenji[] s){
         System.out.println("姓名	性别	Java成绩");
         for(int i=0;i<s.length;i++){
             System.out.println(s[i].姓名+"	"+s[i].性别+"	"+s[i].java成绩);
         }
     }

	public String get姓名3() {
		return 姓名;
	}

	public void set姓名3(String 姓名3) {
		this.姓名 = 姓名3;
	}
 }

 

测试程序2：

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

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

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

package 王海珍;

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：

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

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

package 王海珍;
/**
 * 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("
Testing 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("
Testing 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：

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

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

package 王海珍;
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：

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

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

import static java.lang.System.out;

/**
 * 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 test
{
    private static Scanner sc;

    public static void main(String[] args) 
    {
        sc = new Scanner(System.in);
        System.out.println("输入矩形的长和宽："); 
        int x = sc.nextInt();
        int y = sc.nextInt();
        
        System.out.println("输入圆的半径："); 
        int r = sc.nextInt();
        System.out.println("矩形:"+"周长:"+Perimeter.getPerimeter(x,y)+"面积:"+Area.getArea(x,y)+"
");
        System.out.println("圆:"+"周长:"+Perimeter.getPerimeter(r)+"面积"+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+"面积"+S);
    }
}
class Perimeter
{
    public static double getPerimeter(double width, double length) 
    {
        return 2*(width + length);
    }

    public static double getPerimeter(int radius) 
    {
        return 2*3.1415926*radius;
    }
    
}
class Area
{
    public static double getArea(double width, double height)
    {
        return width * height;
    }

    public static double getArea(int radius) 
    {
        return 3.1415926*radius*radius;
    }
}

 实验结果如下所示

八，实验总结

    通过本章《对象与类》的学习 ，首先对于本章的理论知识有了初步的了解。如使用预定义类，用户自定义类，静态域与静态方法，还有方法参数，包以及文档注释等等。另外，通过实验测试程序也对本章知识有了更多的认识。