201871010111-刘佳华《面向对象程序设计（java）》第八周学习总结

201871010111-刘佳华《面向对象程序设计（java）》第八周学习总结

实验七 接口的定义与使用

实验时间 2019-10-18

第一部分：知识总结

接口的概念：

①java为了克服单继承的缺点而引入接口。

②接口不是类，而是对类的一组需求描述，这类要遵从从接口描述的统一格式进行定义。

③一个类可以实现（implement）一个或多个接口，并在需要接口的地方，随时实现相应的接口对象。

声明：接口体中包含常量定义和方法定义，接口中只进行方法的声明，不提供方法的实现。

说明：

1）通常接口的名字以-able或-ible结尾；

2）可以使用extends来继承接口的常量和抽象方法，扩展形成新的接口；

3）接口中的所有常量必须是public static final，方法必须是public abstract，这是系统默认的，不管你在定义接口时，写不写修饰符都是一样的。

接口的实现：在类声明时使用implement关键字实现一个或多个接口（用逗号隔开），且一个类若使用了某个接口，那么这个类必须实现该个接口的所有方法，即提供方法体。

说明：

（1）若实现接口的类不是抽象类，则必须实现所有接口的所有方法，即为所有的抽象方法定义方法体。

（2）一个类在实现某接口抽象方法时，必须使用完全相同的方法名、参数列表和返回值类型。

（3）接口抽象方法的访问控制符已指定为public，所以类在实现时，必须显式地使用public修饰符，否则被警告缩小了接口中定义的方法的访问控制范围。

接口的使用：

接口不能构造接口对象，但可以声明接口变量以指向一个实现了该接口的类对象。

接口与抽象类：

接口与抽象类的区别:

（1）接口不能实现任何方法，而抽象类可以。

（2）类可以实现许多接口，但只有一个父类。

（3）接口不是类分级结构的一部分，无任何联系的类可以实现相同的接口。

掌握CompareTo接口和Comparator接口使用方法

回调的定义与用法

对象克隆：

*Object类的Clone方法

*浅层拷贝与深层拷贝

浅层拷贝：被拷贝对象的所有常量成员和基本类型属性都有与原来对象相同的拷贝值，而若成员域是一个对象，则被拷贝对象该对象域的对象引用仍然指向原来的对象。

深层拷贝：被拷贝对象的所有成员域都含有与原来对象相同的值,且对象域将指向被复制过的新对象，而不是原有对象被引用的对象。换言之，深层拷贝将拷贝对象内引用的对象也拷贝一遍。

*Java中对象克隆的实现

Lambda表达式：

这是一种表示可以在将来某个时间点执行代码块的简洁方法。

Lambda表达式的语法基本结构
(arguments) -> body有如下几种情况:
●参数类型可推导时，不需要指定类型，如
(a) -> System.out.printin(a)
●只有一个参数且类型可推导时，不强制写(,如
a一> System.out.printn(a)
, 参数指定类型时，必须有括号，如(int a) -> System.out.printin(a)●参数可以为空，如() > System.out.printn("hello"), body需要用{}包含语句,当只有一 条语句时{}可省略

内部类：
●内部类可以直接访问外部类的成员保括private成员，但是内部类的成员却不能被外部类直接访问。
●在内部类对象保存了一个对外部类对象的引用，当内部类的成员方法中访问某一变量时， 如果在该方法和内部类中都未定义过这个变里，内部类中对变里的引用会被传递给外部类对象的引用。
局部内部类
●内部类并非只能在类内定义，也可以在程序块内定义局部内部类。例如，在方法中，甚至在for循环体内部。

●局部内部类不能用publi c或pr ivate访问修饰符进行声明，它的作用域被限定在声明这个局部类的块中。

匿名内部类
●若只创建类的一个对象，则不必为该类命名，这种类称为匿名内部类。
●由于匿名类没有类名，所以匿名类不能有构造器，取而代之的是将构造器参数传递给超类的构造器。若匿名内部类实现接口时，则匿名内部类不能有任何构造参数。
●如果构造参数的闭圆括号跟一个开花括号，表明正在定义的就是匿名内部类

第二部分：实验部分

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)
   {
      var 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);//实现按姓名字符串长度排序操作

      // print out information about all Employee objects
      for (Employee e : staff)
         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());//遍历输出
   }
}

EmployeeSortTest

package interfaces;

public class Employee implements Comparable<Employee>//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)//接口Comparable的compareTo方法
   {
      return Double.compare(name.length(), other.name.length() );
   }
}

Employee

运行截图如下：

测试程序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);   } }

运行截图：

测试程序3：

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

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

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

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

package timer;

/**
   @version 1.02 2017-12-14
   @author Cay Horstmann
*/

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

public class TimerTest
{
   public static void main(String[] args)
   {
       TimePrinter listener = new TimePrinter();//接口对象

      // construct a timer that calls the listener
      // once every second
       Timer timer = new Timer(1000, listener);//计时器对象（时间间隔（ms）,执行listener）；
      timer.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 "
        //         + Instant.ofEpochMilli(event.getWhen()));

      System.out.println("At the tone, the time is "
              + new Date());
      Toolkit.getDefaultToolkit().beep();//硬件环境参数
   }
}

TimerTest

运行截图：

不点“确定”，每1s，输出一次结果，并且电脑蜂鸣器响一次

测试程序4：

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

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

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

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

package clone;

/**
 * This program demonstrates cloning.
 * @version 1.11 2018-03-16
 * @author Cay Horstmann
 */
public class CloneTest
{
   public static void main(String[] args) throws CloneNotSupportedException

   {    ////放入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();
      }
   }
}

CloneTest

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();
   }
   @Override
   protected Employee clone() throws CloneNotSupportedException {

       // 调用object.clone（）
             Employee cloned = (Employee) super.clone();

             // 克隆可变字段
             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 + "]";
   }
}

Employee

运行截图：

实验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)
   {
      var 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));

      var timer = new Timer(1000, event ->
         System.out.println("The time is " + new Date()));
      timer.start();   

      // 停止运行直到点击"OK"
      JOptionPane.showMessageDialog(null, "Quit program?");
      System.exit(0);
   }
}

LambdaTest

运行：

注：以下实验课后完成

实验3: 编程练习

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

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

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

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

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

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

package T;

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.Scanner;
import java.util.Collections;//对集合进行排序、查找、修改等；

public class Main {
    private static ArrayList<Citizen> citizenlist;

    public static void main(String[] args) {
        citizenlist = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);
        File file = new File("D:\\JAVA2\\WEEK8\\src\\T\\身份证号.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 birthplace = linescanner.nextLine();
                Citizen citizen = new Citizen();
                citizen.setName(name);
                citizen.setId(id);
                citizen.setSex(sex);
                // 将字符串转换成10进制数
                int ag = Integer.parseInt(age);
                citizen.setage(ag);
                citizen.setBirthplace(birthplace);
                citizenlist.add(citizen);

            }
        } catch (FileNotFoundException e) {
            System.out.println("信息文件找不到");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("信息文件读取错误");
            e.printStackTrace();
        }
        boolean isTrue = true;
        while (isTrue) {

            System.out.println("1.按姓名字典序输出人员信息");
            System.out.println("2.查询最大年龄的人员信息、查询最小年龄人员信息");
            System.out.println("3.查询人员中是否有你的同乡");
            System.out.println("4.输入你的年龄，查询文件中年龄与你最近人的姓名、身份证号、年龄、性别和出生地");
            System.out.println("5.退出");
            int nextInt = scanner.nextInt();
            switch (nextInt) {
            case 1:
                Collections.sort(citizenlist);//按name字典序排序
                System.out.println(citizenlist.toString());
                break;
            case 2:
                int max = 0, min = 100;
                int m, k1 = 0, k2 = 0;
                for (int i = 1; i < citizenlist.size(); i++) {
                    m = citizenlist.get(i).getage();
                    if (m > max) {
                        max = m;
                        k1 = i;
                    }
                    if (m < min) {
                        min = m;
                        k2 = i;
                    }
                }
                System.out.println("年龄最大：" + citizenlist.get(k1));
                System.out.println("年龄最小：" + citizenlist.get(k2));
                break;
            case 3:
                System.out.println("出生地：");
                String find = scanner.next();
                String place = find.substring(0, 3);
                for (int i = 0; i < citizenlist.size(); i++) {
                    if (citizenlist.get(i).getBirthplace().substring(1, 4).equals(place))
                        System.out.println("出生地" + citizenlist.get(i));
                }
                break;
            case 4:
                System.out.println("年龄：");
                int yourage = scanner.nextInt();
                int near = peer(yourage);
                int j = yourage - citizenlist.get(near).getage();
                System.out.println("" + citizenlist.get(near));
                break;
            case 5:
                isTrue = false;
                System.out.println("程序已退出!");
                break;
            default:
                System.out.println("输入有误");
            }
        }
    }

    public static int peer(int age) {
        int flag = 0;
        int min = 53, j = 0;
        for (int i = 0; i < citizenlist.size(); i++) {
            j = citizenlist.get(i).getage() - age;
            if (j < 0)
                j = -j;
            if (j < min) {
                min = j;
                flag = i;
            }
        }
        return flag;
    }
}

Main

package T;

public class Citizen implements Comparable<Citizen> {

    private String name;
    private String id;
    private String sex;
    private int age;
    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 String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getage() {
        return age;
    }

    public void setage(int age) {
        this.age = age;
    }

    public String getBirthplace() {
        return birthplace;
    }

    public void setBirthplace(String birthplace) {
        this.birthplace = birthplace;
    }

    public int compareTo(Citizen other) {
        return this.name.compareTo(other.getName());
    }

    public String toString() {
        return name + "\t" + sex + "\t" + age + "\t" + id + "\t" + birthplace + "\n";
    }
}

Citizen

运行结果：

 实验心得体会：

通过一个周的学习，我大致掌握了接口的概念和实现方法，能够使用接口编写一些简单程序，并会使用comparable接口里的CompareTo和Comparator方法；初步的了解了克隆的概念，但是仍有一些小问题（深层拷贝和浅层拷贝的地方），仍需要学习和老师的讲解；还有lambda表达式可以简化程序的编写，使得程序简洁工整。