1、实验目的与要求
(1) 掌握接口定义方法；
(2) 掌握实现接口类的定义要求；
(3) 掌握实现了接口类的使用要求；
(4) 掌握程序回调设计模式；
(5) 掌握Comparator接口用法；
(6) 掌握对象浅层拷贝与深层拷贝方法；
(7) 掌握Lambda表达式语法；
(8) 了解内部类的用途及语法要求。
2、实验内容和步骤
实验1： 导入第6章示例程序，测试程序并进行代码注释。
测试程序1：
编辑、编译、调试运行阅读教材214页-215页程序6-1、6-2，理解程序并分析程序运行结果；
在程序中相关代码处添加新知识的注释。
掌握接口的实现用法；
掌握内置接口Compareable的用法。
package interfaces; import java.util.*; /** * 这个程序演示了可比接口的使用。 * @version 1.30 2004-02-27 * @author Cay Horstmann */ public class EmployeeSortTest { public static void main(String[] args) { //new 新建一个Employee 数组对象 给staff所引用 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); //对staff进行排序的方法 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; //某个类定义了一个只能在该类内部才能访问的，名叫name的字符串变量 private double salary; //某个类定义了一个只能在该类内部才能访问的，名叫salary的字符串变量 //利用构造方法初始化各个域 public Employee(String name, double salary) { this.name = name; this.salary = salary; } //Name访问器 public String getName() { return name; } //Salary访问器 public double getSalary() { return salary; } //调用方法，改写工资数据 public void raiseSalary(double byPercent) { double raise = salary * byPercent / 100; salary += raise; } /** * 用工资比较员工 * @一个雇员对象参数 * @如果雇员工资较低，则返回负值 * otherObject, 0 if the salaries are the same, a positive value otherwise * 如果工资相同，则以正值计算 */ //用这个对象与other进行比较。如果这个对象小于other，则返回负值；如果相等则返回0；否则返回正值 public int compareTo(Employee other) { return Double.compare(salary, other.salary); } }
测试程序2：
编辑、编译、调试以下程序，
| 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); } } |
//创建一个接口A interface A { //给g赋值一个双精度型值 double g=9.8; //一个用户自定义函数名,完成输出操作 void show( ); }
//C是类名，implements是实现A与java之间的接口
class C implements A
{
//展示信息
public void show( ) //输出g的值 {System.out.println("g="+g);} }
class InterfaceTest
{
public static void main(String[ ] args)
{
//C是A的子类,实例化一个子类对象a
A a=new C( ); //显示子类对象a a.show( ); //输出C中输出的结果 System.out.println("g="+C.g); } }
测试程序3：
在elipse IDE中调试运行教材223页6-3，结合程序运行结果理解程序；
26行、36行代码参阅224页，详细内容涉及教材12章。
在程序中相关代码处添加新知识的注释。
掌握回调程序设计模式；
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) { //TimePrinter实现了ActionLister ActionListener listener = new TimePrinter(); //构建一个调用侦听器的计时器 // 每10秒一次 Timer t = new Timer(10000, listener); //t对象调用start方法 t.start(); //显示包含一条消息和OK按钮的对话框 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：
调试运行教材229页-231页程序6-4、6-5，结合程序运行结果理解程序；
在程序中相关代码处添加新知识的注释。
掌握对象克隆实现技术；
掌握浅拷贝和深拷贝的差别。
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 { // call Object.clone() //任何Object都是可以执行克隆(clone)方法的 Employee cloned = (Employee) super.clone();
// 继承object类 // 克隆可变字段 cloned.hireDay = (Date) hireDay.clone(); //string没有克隆功能 return cloned; } /** * 把雇佣日定在指定的日期 * @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 + "]"; } }
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 //放入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(); } } }
实验2： 导入第6章示例程序6-6，学习Lambda表达式用法。
调试运行教材233页-234页程序6-6，结合程序运行结果理解程序；
在程序中相关代码处添加新知识的注释。
将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. * //这个程序演示了lambda表达式的用法。 * @version 1.0 2015-05-12 * @author Cay Horstmann */ public class LambdaTest { public static void main(String[] args) { //初始化一个数组String[] planets 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)); //打印出Arrays.toString方法 System.out.println("Sorted by length:"); Arrays.sort(planets, (first, second) -> first.length() - second.length()); System.out.println(Arrays.toString(planets)); 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: 编程练习
编制一个程序，将身份证号.txt 中的信息读入到内存中；
按姓名字典序输出人员信息；
查询最大年龄的人员信息；
查询最小年龄人员信息；
输入你的年龄，查询身份证号.txt中年龄与你最近人的姓名、身份证号、年龄、性别和出生地；
查询人员中是否有你的同乡。
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"; } }
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.Arrays; import java.util.Collections; import java.util.Scanner; public class Test { 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:\\java\\身份证号.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("1.字典排序 "); System.out.println("2.输出年龄最大和年龄最小的人 "); System.out.println("3.寻找同乡 "); System.out.println("4.寻找年龄相近的人 "); System.out.println("5.退出 "); String m = scanner.next(); switch (m) { case "1": Collections.sort(studentlist); System.out.println(studentlist.toString()); break; case "2": 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 "3": 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 "4": 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 "5 ": isTrue = false; System.out.println("退出程序!"); break; default: System.out.println("输入有误"); } } } public static int agenear(int age) { int j=0,min=53,value=0,ok=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; ok=i; } } return ok; } }
实验4：内部类语法验证实验
实验程序1：
编辑、调试运行教材246页-247页程序6-7，结合程序运行结果理解程序；
了解内部类的基本用法。
package innerClass; import java.awt.*; import java.awt.event.*; import java.util.*; import javax.swing.*; import javax.swing.Timer; /** * 这个程序演示了内部类的使用。 * @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(); //保持程序运行直到用户选择“OK” JOptionPane.showMessageDialog(null, "Quit program?"); System.exit(0); } } /** * 按规定时间打印时间的钟 */ class TalkingClock { private int interval; private boolean beep; /** * 构造一个会说话的钟 * PARAM间隔消息间的间隔（毫秒） * 如果时钟应该发出嘟嘟声 */ 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：
编辑、调试运行教材254页程序6-8，结合程序运行结果理解程序；
了解匿名内部类的用法。
package anonymousInnerClass; import java.awt.*; import java.awt.event.*; import java.util.*; import javax.swing.*; import javax.swing.Timer; /** *这个程序演示匿名内部类。 * @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); } } /** *按规定时间打印时间的钟 */ class TalkingClock { /** * Starts the clock. //启动时钟 * @param interval the interval between messages (in milliseconds) //PARAM间隔消息间的间隔（毫秒） * @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：
在elipse IDE中调试运行教材257页-258页程序6-9，结合程序运行结果理解程序；
了解静态内部类的用法。
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 //PARAM值的浮点数数组 * @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); } }
总结：
一、接口：
Java为了克服单继承的缺点，Java使用了接口， 一个类可以实现一个或多个接口。
在Java程序设计语言中，接口不是类，而是对类 的一组需求描述，由常量和一组抽象方法组成。 接口中不包括变量和有具体实现的方法。
只要类实现了接口，则该类要遵从接口描述的统 一格式进行定义，并且可以在任何需要该接口的 地方使用这个类的对象。
类似建立类的继承关系，接口也可以扩展。
接口的扩展技术使得从具有较高通用性的接口存在多条链延伸到具有较高专用性的接口。
（1）通常接口的名字以able或ible结尾；
(2）可以使用extends来继承接口的常量和抽象方 法，扩展形成新的接口；
（3）接口中的所有常量必须是public static final，方法必须是public abstract，这是 系统默认的，不管你在定义接口时，写不写 修饰符都是一样的。
接口与抽象类的区别:
（1）接口不能实现任何方法，而抽象类可以。
（2）类可以实现许多接口，但只有一个父类。
（3）接口不是类分级结构的一部分，无任何联 系的类可以实现相同的接口
二、回调(callback)：
一种程序设计模式，在这种模 式中，可指出某个特定事件发生时程序应该采取 的动作。
三、Object类的Clone方法：
当拷贝一个对象变量时，原始变量与拷贝变量 引用同一个对象。这样，改变一个变量所引用 的对象会对另一个变量产生影响。
四、 浅层拷贝与深层拷贝：
浅层拷贝：被拷贝对象的所有常量成员和基本类 型属性都有与原来对象相同的拷贝值，而若成员 域是一个对象，则被拷贝对象该对象域的对象引 用仍然指向原来的对象。 深层拷贝：被拷贝对象的所有成员域都含有与原 来对象相同的值,且对象域将指向被复制过的新对 象，而不是原有对象被引用的对象。换言之，深 层拷贝将拷贝对象内引用的对象也拷贝一遍。
五、 Java中对象克隆的实现：
在子类中实现Cloneable接口。
为了获取对象的一份拷贝，可以利用Object类 的clone方法。
在子类中覆盖超类的clone方法，声明为 public。
在子类的clone方法中，调用super.clone()。
对象克隆要点：
–在类中实现Cloneable接口。
–为了获取对象的一份拷贝，使用Object类的clone 方法。
–在类中覆盖超类的clone方法，声明为public。
–在类的clone方法中，调用super.clone()。
六、Lambda表达式：
Java Lambda 表达式是Java 8 引入的一个新的功能，主要用途是提供一个函数化的语法来简化编码。