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 编辑、编译、调试以下程序，结合程序运行结果理解程序；

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

 class InterfaceTest
 {
   public static void main(String[ ] args)
   {
        A a=new C( );
        a.show( );
        System.out.println("g="+C.g);
   }
 }

 package e;

 public class InterfaceTest
 {
     public static void main(String[ ] args)
     {
     A a=new C( );//定义一个类C的实例并赋给接口A的对象变量
     a.show( );
     System.out.println("g="+C.g);//直接调用类的属性
     }
 }

 package e;

 public interface A
 {
       double g=9.8;
       void show( );
 }

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 掌握回调程序设计模式；

实验代码：

 package timer;

 /**
    @version 1.01 2015-05-12
    @author Cay Horstmann
 */

 import java.awt.*;
 import java.awt.event.*;
 import java.util.*;
 import javax.swing.*;
 import javax.swing.Timer;
 // 用JavaUTIL计时器解决冲突

 public class TimerTest
 {
    public static void main(String[] args)
    {
       ActionListener listener = new TimePrinter();

       // 构建一个调用侦听器的计时器
       //每10秒一次
       Timer t = new Timer(10000, listener);
       t.start();

       JOptionPane.showMessageDialog(null, "Quit program?");
       System.exit(0);
    }
 }

 class TimePrinter implements ActionListener
 {
    public void actionPerformed(ActionEvent event)
    {
       System.out.println("At the tone, the time is " + new Date());
       Toolkit.getDefaultToolkit().beep();
    }
 }

实验结果：

测试程序4：

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

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

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

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

 package clone;

 /**
  * This program demonstrates cloning.
  * @version 1.10 2002-07-01
  * @author Cay Horstmann
  */
 public class CloneTest
 {
    public static void main(String[] args)
    {
       //try...catch...语句，try代码区如果有错误，就会返回所写异常的处理。
       //提高程序的健壮性
       try
       {
          Employee original = new Employee("John Q. Public", 50000);
          original.setHireDay(2000, 1, 1);
          Employee copy = original.clone();
          copy.raiseSalary(10);
          copy.setHireDay(2002, 12, 31);
          System.out.println("original=" + original);
          System.out.println("copy=" + copy);
       }
       catch (CloneNotSupportedException e)
       {
          e.printStackTrace();
       }
    }
 }

 package clone;

 import java.util.Date;
 import java.util.GregorianCalendar;

 public class Employee implements Cloneable
 {
    private String name;
    private double salary;
    private Date hireDay;

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

    public Employee clone() throws CloneNotSupportedException//无论目标类是否实现了Cloneable接口，只要调用到了Object.clone()，比如通过super.clone()，那么就必须处理或者抛出CloneNotSupportedException，因为Object.clone()有throws这个异常，有抛的就必然有接的。

    {
       // call Object.clone()
       Employee cloned = (Employee) super.clone();

       // clone mutable fields
       cloned.hireDay = (Date) hireDay.clone();

       return cloned;
    }

    /**
     * Set the hire day to a given date.
     * @param year the year of the hire day
     * @param month the month of the hire day
     * @param day the day of the hire day
     */
    public void setHireDay(int year, int month, int day)
    {
       Date newHireDay = new GregorianCalendar(year, month - 1, day).getTime();

       // 实例字段突变示例
       hireDay.setTime(newHireDay.getTime());
    }

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

    public String toString()
    {
       return "Employee[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]";
    }
 }

实验结果：

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

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

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

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

 package lambda;

 import java.util.*;

 import javax.swing.*;
 import javax.swing.Timer;

 /**
  * This program demonstrates the use of lambda expressions.
  * @version 1.0 2015-05-12
  * @author Cay Horstmann
  */
 public class LambdaTest
 {
    public static void main(String[] args)
    {
       String[] planets = new String[] { "Mercury", "Venus", "Earth", "Mars",
             "Jupiter", "Saturn", "Uranus", "Neptune" };
       System.out.println(Arrays.toString(planets));
       System.out.println("Sorted in dictionary order:");
       Arrays.sort(planets);
       System.out.println(Arrays.toString(planets));
       System.out.println("Sorted by length:");
       Arrays.sort(planets, (first, second) -> first.length() - second.length());
       System.out.println(Arrays.toString(planets));
       //Lambda表达式
       Timer t = new Timer(1000, event ->
          System.out.println("The time is " + new Date()));
       t.start();   

       // 保持程序运行直到用户选择“OK”
       JOptionPane.showMessageDialog(null, "Quit program?");
       System.exit(0);
    }
 }

实验结果：

注：以下实验课后完成

实验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+"\t"+sex+"\t"+age+"\t"+number+"\t"+province+"\n";
    }
}

实验结果：

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

实验程序1：

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

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

 package innerClass;

 import java.awt.*;
 import java.awt.event.*;
 import java.util.*;
 import javax.swing.*;
 import javax.swing.Timer;

 /**
  * This program demonstrates the use of inner classes.
  * @version 1.11 2015-05-12
  * @author Cay Horstmann
  */
 public class InnerClassTest
 {
    public static void main(String[] args)
    {
       TalkingClock clock = new TalkingClock(1000, true);
       clock.start();

       // keep program running until user selects "Ok"
       JOptionPane.showMessageDialog(null, "Quit program?");
       System.exit(0);
    }
 }

 /**
  * A clock that prints the time in regular intervals.
  */
 class TalkingClock
 {
    private int interval;
    private boolean beep;

    /**
     * Constructs a talking clock
     * @param interval the interval between messages (in milliseconds)
     * @param beep true if the clock should beep
     */
    public TalkingClock(int interval, boolean beep)
    {
       this.interval = interval;
       this.beep = beep;
    }

    /**
     * Starts the clock.
     */
    public void start()
    {
       ActionListener listener = new TimePrinter();
       Timer t = new Timer(interval, listener);
       t.start();
    }

    public class TimePrinter implements ActionListener
    {
       public void actionPerformed(ActionEvent event)
       {
          System.out.println("At the tone, the time is " + new Date());
          if (beep) Toolkit.getDefaultToolkit().beep();
       }
    }
 }

实验结果：

实验程序2：

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

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

 package anonymousInnerClass;

 import java.awt.*;
 import java.awt.event.*;
 import java.util.*;
 import javax.swing.*;
 import javax.swing.Timer;

 /**
  * This program demonstrates anonymous inner classes.
  * @version 1.11 2015-05-12
  * @author Cay Horstmann
  */
 public class AnonymousInnerClassTest
 {
    public static void main(String[] args)
    {
       TalkingClock clock = new TalkingClock();
       clock.start(1000, true);

       // keep program running until user selects "Ok"
       JOptionPane.showMessageDialog(null, "Quit program?");
       System.exit(0);
    }
 }

 /**
  * A clock that prints the time in regular intervals.
  */
 class TalkingClock
 {
    /**
     * Starts the clock.
     * @param interval the interval between messages (in milliseconds)
     * @param beep true if the clock should beep
     */
    public void start(int interval, boolean beep)
    {
       ActionListener listener = new ActionListener()
          {
             public void actionPerformed(ActionEvent event)
             {
                System.out.println("At the tone, the time is " + new Date());
                if (beep) Toolkit.getDefaultToolkit().beep();
             }
          };
       Timer t = new Timer(interval, listener);
       t.start();
    }
 }

实验程序3：

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

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

 package staticInnerClass;

 /**
  * This program demonstrates the use of static inner classes.
  * @version 1.02 2015-05-12
  * @author Cay Horstmann
  */
 public class StaticInnerClassTest
 {
    public static void main(String[] args)
    {
       double[] d = new double[20];
       for (int i = 0; i < d.length; i++)
          d[i] = 100 * Math.random();
       ArrayAlg.Pair p = ArrayAlg.minmax(d);
       System.out.println("min = " + p.getFirst());
       System.out.println("max = " + p.getSecond());
    }
 }

 class ArrayAlg
 {
    /**
     * A pair of floating-point numbers
     */
    public static class Pair
    {
       private double first;
       private double second;

       /**
        * Constructs a pair from two floating-point numbers
        * @param f the first number
        * @param s the second number
        */
       public Pair(double f, double s)
       {
          first = f;
          second = s;
       }

       /**
        * Returns the first number of the pair
        * @return the first number
        */
       public double getFirst()
       {
          return first;
       }

       /**
        * Returns the second number of the pair
        * @return the second number
        */
       public double getSecond()
       {
          return second;
       }
    }

    /**
     * Computes both the minimum and the maximum of an array
     * @param values an array of floating-point numbers
     * @return a pair whose first element is the minimum and whose second element
     * is the maximum
     */
    public static Pair minmax(double[] values)
    {
       double min = Double.POSITIVE_INFINITY;
       double max = Double.NEGATIVE_INFINITY;
       for (double v : values)
       {
          if (min > v) min = v;
          if (max < v) max = v;
       }
       return new Pair(min, max);
    }
 }

实验总结：

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