201772020113李清华《面向对象程序设计（java）》第八周学习总结

实验六接口的定义与使用

实验时间 2018-10-18

1、实验目的与要求

(1) 掌握接口定义方法；

(2) 掌握实现接口类的定义要求；

(3) 掌握实现了接口类的使用要求；

(4) 掌握程序回调设计模式；

(5) 掌握Comparator接口用法；

(6) 掌握对象浅层拷贝与深层拷贝方法；

(7) 掌握Lambda表达式语法；

(8) 了解内部类的用途及语法要求。

2、实验内容和步骤

实验1：导入第6章示例程序，测试程序并进行代码注释。

测试程序1：

l 编辑、编译、调试运行阅读教材214页-215页程序6-1、6-2，理解程序并分析程序运行结果；

l 在程序中相关代码处添加新知识的注释。

l 掌握接口的实现用法；

l 掌握内置接口Compareable的用法。

实验代码:

package interfaces;

import java.util.*;

/**
* This program demonstrates the use of the Comparable interface.
* @version 1.30 2004-02-27
* @author Cay Horstmann
*/
public class EmployeeSortTest
{
   public static void main(String[] args)
   {
      Employee[] staff = new Employee[3];

      staff[0] = new Employee("Harry Hacker", 35000);
      staff[1] = new Employee("Carl Cracker", 75000);
      staff[2] = new Employee("Tony Tester", 38000);

Arrays.sort(staff);//对数组元素排序

      // 打印所有员工对象的信息
      for (Employee e : staff)
         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
   }
}

package interfaces;
//Employee实现内置接口Comparable
public class Employee implements Comparable<Employee>
{
private String name;
private double salary;

   public Employee(String name, double salary)
   {
      this.name = name;
      this.salary = salary;
   }

   public String getName()
   {
      return name;
   }

   public double getSalary()
   {
      return salary;
   }

   public void raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;
   }

   /**
    * Compares employees by salary
    * @param other another Employee object
    * @return a negative value if this employee has a lower salary than
    * otherObject, 0 if the salaries are the same, a positive value otherwise
    */
   //进行比较必须实现这个方法
   public int compareTo(Employee other)
   {
      return Double.compare(salary, other.salary);
   }
}

实验结果：

测试程序2：

l 编辑、编译、调试以下程序，结合程序运行结果理解程序；

 1 interface  A
 2 {
 3   double g=9.8;
 4   void show( );
 5 }
 6 class C implements A
 7 {
 8   public void show( )
 9   {System.out.println("g="+g);}
10 }
11 
12 class InterfaceTest
13 {
14   public static void main(String[ ] args)
15   {
16        A a=new C( );
17        a.show( );
18        System.out.println("g="+C.g);
19   }
20 }

 1 package e;
 2 
 3 public class InterfaceTest 
 4 {
 5     public static void main(String[ ] args)
 6     {
 7     A a=new C( );//定义一个类C的实例并赋给接口A的对象变量
 8     a.show( );
 9     System.out.println("g="+C.g);//直接调用类的属性
10     }
11 }

1 package e;
2 
3 public interface A
4 {
5       double g=9.8;
6       void show( );
7 }

package e;

public class C implements A
{
    public void show( )
    {System.out.println("g="+g);}

}

实验结果：

测试程序3：

l 在elipse IDE中调试运行教材223页6-3，结合程序运行结果理解程序；

l 26行、36行代码参阅224页，详细内容涉及教材12章。

l 在程序中相关代码处添加新知识的注释。

l 掌握回调程序设计模式；

实验代码：

 1 package timer;
 2 
 3 /**
 4    @version 1.01 2015-05-12
 5    @author Cay Horstmann
 6 */
 7 
 8 import java.awt.*;
 9 import java.awt.event.*;
10 import java.util.*;
11 import javax.swing.*;
12 import javax.swing.Timer; 
13 // 用JavaUTIL计时器解决冲突
14 
15 public class TimerTest
16 {  
17    public static void main(String[] args)
18    {  
19       ActionListener listener = new TimePrinter();
20 
21       // 构建一个调用侦听器的计时器
22       //每10秒一次 
23       Timer t = new Timer(10000, listener);
24       t.start();
25 
26       JOptionPane.showMessageDialog(null, "Quit program?");
27       System.exit(0);
28    }
29 }
30 
31 class TimePrinter implements ActionListener
32 {  
33    public void actionPerformed(ActionEvent event)
34    {  
35       System.out.println("At the tone, the time is " + new Date());
36       Toolkit.getDefaultToolkit().beep();
37    }
38 }

实验结果：

测试程序4：

l 调试运行教材229页-231页程序6-4、6-5，结合程序运行结果理解程序；

l 在程序中相关代码处添加新知识的注释。

l 掌握对象克隆实现技术；

l 掌握浅拷贝和深拷贝的差别。

 1 package clone;
 2 
 3 /**
 4  * This program demonstrates cloning.
 5  * @version 1.10 2002-07-01
 6  * @author Cay Horstmann
 7  */
 8 public class CloneTest
 9 {
10    public static void main(String[] args)
11    {
12       //try...catch...语句，try代码区如果有错误，就会返回所写异常的处理。
13       //提高程序的健壮性
14       try
15       {
16          Employee original = new Employee("John Q. Public", 50000);
17          original.setHireDay(2000, 1, 1);
18          Employee copy = original.clone();
19          copy.raiseSalary(10);
20          copy.setHireDay(2002, 12, 31);
21          System.out.println("original=" + original);
22          System.out.println("copy=" + copy);
23       }
24       catch (CloneNotSupportedException e)
25       {
26          e.printStackTrace();
27       }
28    }
29 }

 1 package clone;
 2 
 3 import java.util.Date;
 4 import java.util.GregorianCalendar;
 5 
 6 public class Employee implements Cloneable
 7 {
 8    private String name;
 9    private double salary;
10    private Date hireDay;
11 
12    public Employee(String name, double salary)
13    {
14       this.name = name;
15       this.salary = salary;
16       hireDay = new Date();
17    }
18 
19    public Employee clone() throws CloneNotSupportedException//无论目标类是否实现了Cloneable接口，只要调用到了Object.clone()，比如通过super.clone()，那么就必须处理或者抛出CloneNotSupportedException，因为Object.clone()有throws这个异常，有抛的就必然有接的。
20 
21    {
22       // call Object.clone()
23       Employee cloned = (Employee) super.clone();
24 
25       // clone mutable fields
26       cloned.hireDay = (Date) hireDay.clone();
27 
28       return cloned;
29    }
30 
31    /**
32     * Set the hire day to a given date. 
33     * @param year the year of the hire day
34     * @param month the month of the hire day
35     * @param day the day of the hire day
36     */
37    public void setHireDay(int year, int month, int day)
38    {
39       Date newHireDay = new GregorianCalendar(year, month - 1, day).getTime();
40       
41       // 实例字段突变示例
42       hireDay.setTime(newHireDay.getTime());
43    }
44 
45    public void raiseSalary(double byPercent)
46    {
47       double raise = salary * byPercent / 100;
48       salary += raise;
49    }
50 
51    public String toString()
52    {
53       return "Employee[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]";
54    }
55 }

实验结果：

实验2：导入第6章示例程序6-6，学习Lambda表达式用法。

l 调试运行教材233页-234页程序6-6，结合程序运行结果理解程序；

l 在程序中相关代码处添加新知识的注释。

l 将27-29行代码与教材223页程序对比，将27-29行代码与此程序对比，体会Lambda表达式的优点。

 1 package lambda;
 2 
 3 import java.util.*;
 4 
 5 import javax.swing.*;
 6 import javax.swing.Timer;
 7 
 8 /**
 9  * This program demonstrates the use of lambda expressions.
10  * @version 1.0 2015-05-12
11  * @author Cay Horstmann
12  */
13 public class LambdaTest
14 {
15    public static void main(String[] args)
16    {
17       String[] planets = new String[] { "Mercury", "Venus", "Earth", "Mars", 
18             "Jupiter", "Saturn", "Uranus", "Neptune" };
19       System.out.println(Arrays.toString(planets));
20       System.out.println("Sorted in dictionary order:");
21       Arrays.sort(planets);
22       System.out.println(Arrays.toString(planets));
23       System.out.println("Sorted by length:");
24       Arrays.sort(planets, (first, second) -> first.length() - second.length());
25       System.out.println(Arrays.toString(planets));
26       //Lambda表达式      
27       Timer t = new Timer(1000, event ->
28          System.out.println("The time is " + new Date()));
29       t.start();   
30          
31       // 保持程序运行直到用户选择“OK” 
32       JOptionPane.showMessageDialog(null, "Quit program?");
33       System.exit(0);         
34    }
35 }

实验结果：

注：以下实验课后完成

实验3: 编程练习

l 编制一个程序，将身份证号.txt 中的信息读入到内存中；

l 按姓名字典序输出人员信息；

l 查询最大年龄的人员信息；

l 查询最小年龄人员信息；

l 输入你的年龄，查询身份证号.txt中年龄与你最近人的姓名、身份证号、年龄、性别和出生地；

l 查询人员中是否有你的同乡。

package test1;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Main{
    private static ArrayList<Student> studentlist;
    public static void main(String[] args) {
        studentlist = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);
        File file = new File("F:\身份证号.txt");
        try {
            FileInputStream fis = new FileInputStream(file);
            BufferedReader in = new BufferedReader(new InputStreamReader(fis));
            String temp = null;
            while ((temp = in.readLine()) != null) {
                
                Scanner linescanner = new Scanner(temp);
                
                linescanner.useDelimiter(" ");    
                String name = linescanner.next();
                String number = linescanner.next();
                String sex = linescanner.next();
                String age = linescanner.next();
                String province =linescanner.nextLine();
                Student student = new Student();
                student.setName(name);
                student.setnumber(number);
                student.setsex(sex);
                int a = Integer.parseInt(age);
                student.setage(a);
                student.setprovince(province);
                studentlist.add(student);

            }
        } catch (FileNotFoundException e) {
            System.out.println("学生信息文件找不到");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("学生信息文件读取错误");
            e.printStackTrace();
        }
        boolean isTrue = true;
        while (isTrue) {
            System.out.println("选择你的操作，输入正确格式的选项");
            System.out.println("A.按姓名字典排序");
            System.out.println("B.输出年龄最大和年龄最小的人");
            System.out.println("C.寻找老乡");
            System.out.println("D.寻找年龄相近的人");
            System.out.println("F.退出");
            String m = scanner.next();
            switch (m) {
            case "A":
                Collections.sort(studentlist);              
                System.out.println(studentlist.toString());
                break;
            case "B":
                 int max=0,min=100;
                 int j,k1 = 0,k2=0;
                 for(int i=1;i<studentlist.size();i++)
                 {
                     j=studentlist.get(i).getage();
                 if(j>max)
                 {
                     max=j; 
                     k1=i;
                 }
                 if(j<min)
                 {
                   min=j; 
                   k2=i;
                 }
                 
                 }  
                 System.out.println("年龄最大："+studentlist.get(k1));
                 System.out.println("年龄最小："+studentlist.get(k2));
                break;
            case "C":
                 System.out.println("老家?");
                 String find = scanner.next();        
                 String place=find.substring(0,3);
                 for (int i = 0; i <studentlist.size(); i++) 
                 {
                     if(studentlist.get(i).getprovince().substring(1,4).equals(place)) 
                         System.out.println("老乡"+studentlist.get(i));
                 }             
                 break;
                 
            case "D":
                System.out.println("年龄：");
                int yourage = scanner.nextInt();
                int near=agenear(yourage);
                int value=yourage-studentlist.get(near).getage();
                System.out.println(""+studentlist.get(near));
                break;
            case "F":
                isTrue = false;
                System.out.println("退出程序!");
                break;
                default:
                System.out.println("输入有误");

            }
        }
    }
        public static int agenear(int age) {      
        int j=0,min=53,value=0,k=0;
         for (int i = 0; i < studentlist.size(); i++)
         {
             value=studentlist.get(i).getage()-age;
             if(value<0) value=-value; 
             if (value<min) 
             {
                min=value;
                k=i;
             } 
          }    
         return k;         
      }

}

package test1;

public class Student implements Comparable<Student> {

    private String name;
    private String number ;
    private String sex ;
    private int age;
    private String province;
   
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getnumber() {
        return number;
    }
    public void setnumber(String number) {
        this.number = number;
    }
    public String getsex() {
        return sex ;
    }
    public void setsex(String sex ) {
        this.sex =sex ;
    }
    public int getage() {

        return age;
        }
        public void setage(int age) {
            // int a = Integer.parseInt(age);
        this.age= age;
        }

    public String getprovince() {
        return province;
    }
    public void setprovince(String province) {
        this.province=province ;
    }

    public int compareTo(Student o) {
       return this.name.compareTo(o.getName());
    }

    public String toString() {
        return  name+"	"+sex+"	"+age+"	"+number+"	"+province+"
";
    }    
}

实验结果：

实验4：内部类语法验证实验

实验程序1：

l 编辑、调试运行教材246页-247页程序6-7，结合程序运行结果理解程序；

l 了解内部类的基本用法。

 1 package innerClass;
 2 
 3 import java.awt.*;
 4 import java.awt.event.*;
 5 import java.util.*;
 6 import javax.swing.*;
 7 import javax.swing.Timer;
 8 
 9 /**
10  * This program demonstrates the use of inner classes.
11  * @version 1.11 2015-05-12
12  * @author Cay Horstmann
13  */
14 public class InnerClassTest
15 {
16    public static void main(String[] args)
17    {
18       TalkingClock clock = new TalkingClock(1000, true);
19       clock.start();
20 
21       // keep program running until user selects "Ok"
22       JOptionPane.showMessageDialog(null, "Quit program?");
23       System.exit(0);
24    }
25 }
26 
27 /**
28  * A clock that prints the time in regular intervals.
29  */
30 class TalkingClock
31 {
32    private int interval;
33    private boolean beep;
34 
35    /**
36     * Constructs a talking clock
37     * @param interval the interval between messages (in milliseconds)
38     * @param beep true if the clock should beep
39     */
40    public TalkingClock(int interval, boolean beep)
41    {
42       this.interval = interval;
43       this.beep = beep;
44    }
45 
46    /**
47     * Starts the clock.
48     */
49    public void start()
50    {
51       ActionListener listener = new TimePrinter();
52       Timer t = new Timer(interval, listener);
53       t.start();
54    }
55 
56    public class TimePrinter implements ActionListener
57    {
58       public void actionPerformed(ActionEvent event)
59       {
60          System.out.println("At the tone, the time is " + new Date());
61          if (beep) Toolkit.getDefaultToolkit().beep();
62       }
63    }
64 }

实验结果：

实验程序2：

l 编辑、调试运行教材254页程序6-8，结合程序运行结果理解程序；

l 了解匿名内部类的用法。

 1 package anonymousInnerClass;
 2 
 3 import java.awt.*;
 4 import java.awt.event.*;
 5 import java.util.*;
 6 import javax.swing.*;
 7 import javax.swing.Timer;
 8 
 9 /**
10  * This program demonstrates anonymous inner classes.
11  * @version 1.11 2015-05-12
12  * @author Cay Horstmann
13  */
14 public class AnonymousInnerClassTest
15 {
16    public static void main(String[] args)
17    {
18       TalkingClock clock = new TalkingClock();
19       clock.start(1000, true);
20 
21       // keep program running until user selects "Ok"
22       JOptionPane.showMessageDialog(null, "Quit program?");
23       System.exit(0);
24    }
25 }
26 
27 /**
28  * A clock that prints the time in regular intervals.
29  */
30 class TalkingClock
31 {
32    /**
33     * Starts the clock.
34     * @param interval the interval between messages (in milliseconds)
35     * @param beep true if the clock should beep
36     */
37    public void start(int interval, boolean beep)
38    {
39       ActionListener listener = new ActionListener()
40          {
41             public void actionPerformed(ActionEvent event)
42             {
43                System.out.println("At the tone, the time is " + new Date());
44                if (beep) Toolkit.getDefaultToolkit().beep();
45             }
46          };
47       Timer t = new Timer(interval, listener);
48       t.start();
49    }
50 }

实验程序3：

l 在elipse IDE中调试运行教材257页-258页程序6-9，结合程序运行结果理解程序；

l 了解静态内部类的用法。

 1 package staticInnerClass;
 2 
 3 /**
 4  * This program demonstrates the use of static inner classes.
 5  * @version 1.02 2015-05-12
 6  * @author Cay Horstmann
 7  */
 8 public class StaticInnerClassTest
 9 {
10    public static void main(String[] args)
11    {
12       double[] d = new double[20];
13       for (int i = 0; i < d.length; i++)
14          d[i] = 100 * Math.random();
15       ArrayAlg.Pair p = ArrayAlg.minmax(d);
16       System.out.println("min = " + p.getFirst());
17       System.out.println("max = " + p.getSecond());
18    }
19 }
20 
21 class ArrayAlg
22 {
23    /**
24     * A pair of floating-point numbers
25     */
26    public static class Pair
27    {
28       private double first;
29       private double second;
30 
31       /**
32        * Constructs a pair from two floating-point numbers
33        * @param f the first number
34        * @param s the second number
35        */
36       public Pair(double f, double s)
37       {
38          first = f;
39          second = s;
40       }
41 
42       /**
43        * Returns the first number of the pair
44        * @return the first number
45        */
46       public double getFirst()
47       {
48          return first;
49       }
50 
51       /**
52        * Returns the second number of the pair
53        * @return the second number
54        */
55       public double getSecond()
56       {
57          return second;
58       }
59    }
60 
61    /**
62     * Computes both the minimum and the maximum of an array
63     * @param values an array of floating-point numbers
64     * @return a pair whose first element is the minimum and whose second element
65     * is the maximum
66     */
67    public static Pair minmax(double[] values)
68    {
69       double min = Double.POSITIVE_INFINITY;
70       double max = Double.NEGATIVE_INFINITY;
71       for (double v : values)
72       {
73          if (min > v) min = v;
74          if (max < v) max = v;
75       }
76       return new Pair(min, max);
77    }
78 }

实验总结：

通过这次试验，理解了接口和抽象类的区别，掌握了回调，对象克隆的概念。知道了浅层拷贝和深层拷贝的区别。还需要继续学习Lambda表达式，这个知识点没有掌握。