一,理论知识学习部分
6.1.1 接口概念
两种含义：一，Java接口，Java语言中存在的结构，有特定的语法和结构；二，一个类所具有的方法的特征集合，是一种逻辑上的抽象。前者叫做“Java接口”，后者叫做“接口”。用interface声明，是抽象方法和常量值定义的集 合。从本质上讲，接口是一种特殊的抽象类。
抽象类和接口：如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。如果你想实现多重继承，那么你必须使用接口。子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。
6.1.2接口的特性
接口可以被实例化；
实现类必须实现接口的所有方法；
实现类可以实现多个接口；
接口中的变量都是静态变量；
6.1.3抽象类和接口
如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。
如果你想实现多重继承，那么你必须使用接口。子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。
如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。
抽象类：用abstract来声明,没有具体实例对象的类，不 能用new来创建对象。
6.1.5默认方法
接口中的所有常量必须是static final，方法必须是public abstract，这是 系统默认的，不管你在定义接口时，写不写 修饰符都是一样的.
接口的实现:一个类使用了某个接口，那么这个类必须实现该 接口的所有方法，即为这些方法提供方法体。一个类可以实现多个接口，接口间应该用逗号分 隔开。
接口的使用:接口不能构造接口对象，但可以声明接口变量以指向一个实现了该接口的类对象。
可以用instanceof检查对象是否实现了某个接口。
抽象类：用abstract来声明,没有具体实例对象的类，不 能用new来创建对象。
6.2 接口示例
回调(callback)：一种程序设计模式，在这种模 式中，可指出某个特定事件发生时程序应该采取 的动作。Comparator接口所在包： java.util.*
Oject类的Clone方法:当拷贝一个对象变量时，原始变量与拷贝变量 引用同一个对象。这样，改变一个变量所引用 的对象会对另一个变量产生影响。如果要创建一个对象新的copy，它的最初状态与 original一样，但以后可以各自改变状态，就需 要使用Object类的clone方法。Object.clone()方法返回一个Object对象。必须进行强 制类型转换才能得到需要的类型。浅层拷贝与深层拷贝Java中对象克隆的实现:在子类中实现Cloneable接口。在子类的clone方法中，调用super.clone()。
6.3 lambda表达式
Java Lambda 表达式是 Java 引入的一个新的功能，主 要用途是提供一个函数化的语法来简化编码。
Lambda 表达式的语法基本结构 (arguments) -> body
有如下几种情况： 1、参数类型可推导时，不需要指定类型，如 (a) -> System.out.println(a) 只有一个参数且类型可推导时，不强制写 (), 如 a -> System.out.println(a) ， 参数指定类型时，必须有括号，如 (int a) -> System.out.println(a) ， 参数可以为空，如 () -> System.out.println(“hello”) body 需要用 {} 包含语句，当只有一条语句时 {} 可省略
内部类：是定义在一个类内部的类。使用内部类的原因有以下三个： –内部类方法可以访问该类定义所在的作用域中 的数据，包括私有数据。–内部类能够隐藏起来，不为同一包中的其他类 所见–想要定义一个回调函数且不想编写大量代码时， 使用匿名内部类比较便捷。内部类可以直接访问外部类的成员，包括 private成员，但是内部类的成员却不能被外部 类直接访问。内部类并非只能在类内定义，也可以在程序块内 定义局部内部类。如果构造参数的闭圆括号跟一个开花括号，表明正 在定义的就是匿名内部类。
二.实验部分
1、实验目的与要求
(1) 掌握接口定义方法；
(2) 掌握实现接口类的定义要求；
(3) 掌握实现了接口类的使用要求；
(4) 掌握程序回调设计模式；
(5) 掌握Comparator接口用法；
(6) 掌握对象浅层拷贝与深层拷贝方法；
(7) 掌握Lambda表达式语法；
(8) 了解内部类的用途及语法要求。
2、实验内容和步骤
实验1： 导入第6章示例程序，测试程序并进行代码注释。
测试程序1：
l 编辑、编译、调试运行阅读教材214页-215页程序6-1、6-2，理解程序并分析程序运行结果；
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);//静态方法sort
// print out information about all Employee objects
for (Employee e : staff)
System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
}
}
package interfaces;
public class Employee implements Comparable<Employee>//Employee实现JDK内置接口Comparable
{
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);//静态Double.compare方法
}
}
结果如下：
测试程序2：
l 编辑、编译、调试以下程序，结合程序运行结果理解程序；
public interface A
{
double g=9.8;
void show( );
}
class C implements A
{
public void show( )
{System.out.println("g="+g);}
}
package InterfaceTest;
public class InterfaceTest {
public static void main(String[ ] args)
{
A a=new C( );
a.show( );
System.out.println("g="+C.g);
}
}
结果如下： 
测试程序3：
l 在elipse IDE中调试运行教材223页6-3，结合程序运行结果理解程序；
l 26行、36行代码参阅224页，详细内容涉及教材12章。
l 在程序中相关代码处添加新知识的注释。
4）掌握回调程序设计模式
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;
// to resolve conflict with java.util.Timer
public class TimerTest
{
public static void main(String[] args)
{
ActionListener listener = new TimePrinter();
//实现了ActionListener的类对象
// construct a timer that calls the listener
// once every 10 seconds
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
{
Employee original = new Employee("John Q. Public", 50000);
//Employee是一个自定义类
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表达式用法。
l 调试运行教材233页-234页程序6-6，结合程序运行结果理解程序；
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" };//定义数组planets
System.out.println(Arrays.toString(planets));//静态方法
System.out.println("Sorted in dictionary order:");
Arrays.sort(planets);//Arrays.sort方法接收实验Lambda类的对象
System.out.println(Arrays.toString(planets));
System.out.println("Sorted by length:");
Arrays.sort(planets, (first, second) -> first.length() - second.length());//Lambda表达式
System.out.println(Arrays.toString(planets));
Timer t = new Timer(1000, event ->
System.out.println("The time is " + new Date()));//Lambda表达式
t.start();
// keep program running until user selects "Ok"
JOptionPane.showMessageDialog(null, "Quit program?");
System.exit(0); //返回类型
}
}
package clone;
import java.util.Date;
import java.util.GregorianCalendar;
public class Employee implements Cloneable
{
//定义三个私有属性
private String name;//string类在lang包
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()
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();
//创建一个实例字段变异的实例
// Example of instance field mutation
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 + "]";
}
}
实验3: 编程练习
l 编制一个程序，将身份证号.txt 中的信息读入到内存中；
l 按姓名字典序输出人员信息；
l 查询最大年龄的人员信息；
l 查询最小年龄人员信息；
l 输入你的年龄，查询身份证号.txt中年龄与你最近人的姓名、身份证号、年龄、性别和出生地；
|查询人员中是否有你的同乡
package ID;
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 Main{
private static ArrayList<People> Peoplelist;
public static void main(String[] args) {
Peoplelist = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
File file = new File("D:\java\1\身份证号.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 ID = linescanner.next();
String sex = linescanner.next();
String age = linescanner.next();
String place =linescanner.nextLine();
People People = new people();
People.setname(name);
People.setID(ID);
People.setsex(sex);
int a = Integer.parseInt(age);
People.setage(a);
People.setbirthplace(place);
Peoplelist.add(People);
}
} 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:查询人员中是否有你的同乡");
int nextInt = scanner.nextInt();
switch (nextInt) {
case 1:
Collections.sort( Peoplelist);
System.out.println( Peoplelist.toString());
break;
case 2:
int max=0,min=100;int j,k1 = 0,k2=0;
for(int i=1;i< Peoplelist.size();i++)
{
j= Peoplelist.get(i).getage();
if(j>max)
{
max=j;
k1=i;
}
if(j<min)
{
min=j;
k2=i;
}
}
System.out.println("年龄最大："+ Peoplelist.get(k1));
System.out.println("年龄最小："+ Peoplelist.get(k2));
break;
case 3:
System.out.println("place?");
String find = scanner.next();
String place=find.substring(0,3);
String place2=find.substring(0,3);
for (int i = 0; i < Peoplelist.size(); i++)
{
if( Peoplelist.get(i).getbirthplace().substring(1,4).equals(place))
System.out.println(Peoplelist.get(i));
}
break;
case 4:
System.out.println("年龄：");
int yourage = scanner.nextInt();
int near=agenear(yourage);
int d_value=yourage-Peoplelist.get(near).getage();
System.out.println(""+Peoplelist.get(near));
/* for (int i = 0; i < Peoplelist.size(); i++)
{
int p=Personlist.get(i).getage()-yourage;
if(p<0) p=-p;
if(p==d_value) System.out.println(Peoplelist.get(i));
} */
break;
case 5:
isTrue = false;
System.out.println("退出程序!");
break;
default:
System.out.println("输入有误");
}
}
}
public static int agenear(int age) {
int min=25,d_value=0,k=0;
for (int i = 0; i < Peoplelist.size(); i++)
{
d_value= Peoplelist.get(i).getage()-age;
if(d_value<0) d_value=-d_value;
if (d_value<min)
{
min=d_value;
k=i;
}
} return k;
}
}
package ID;
public abstract class People implements Comparable<People> {
private String name;
private String ID;
private int age;
private String sex;
private String birthplace;
public String getname() {
return name;
}
public void setname(String name) {
this.name = name;
}
public String getID() {
return ID;
}
public void setID(String ID) {
this.ID= ID;
}
public int getage() {
return age;
}
public void setage(int age) {
// int a = Integer.parseInt(age);
this.age= age;
}
public String getsex() {
return sex;
}
public void setsex(String sex) {
this.sex= sex;
}
public String getbirthplace() {
return birthplace;
}
public void setbirthplace(String birthplace) {
this.birthplace= birthplace;
}
public int compareTo(People o) {
return this.name.compareTo(o.getname());
}
public String toString() {
return name+" "+sex+" "+age+" "+ID+" "+birthplace+"
";
}
}
结果如下：
实验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);//实现了TalkingClock的类对象
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//实现ActionListener的公共类TimePrinter
{
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，结合程序运行结果理解程序；
了解匿名内部类的用法。
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();//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，结合程序运行结果理解程序；
了解静态内部类的用法。
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);
}
}
结果如下：
实验总结：
通过本次实验，以及上一周的学习，我初步对接口有了了解和认识，通过实验验证了接口在程序的作用，也学习到了在程序中如何定义接口的方法，也掌握了Comparator接口用法，但还是需要大量的理解程序和编写此类程序才能运用好这种接口，也能在此基础上掌握更多接口用法，对于对象浅层拷贝与深层拷贝的方法还不是很理解，希望在这周通过学习以及老师和学长的讲解中彻底的能理解解决这个问题。