201871010133-赵永军《面向对象程序设计（java）》第八周学习总结

201871010133-赵永军《面向对象程序设计（java）》第八周学习总结

项目	内容
这个作业属于哪个课程	https://www.cnblogs.com/nwnu-daizh/
这个作业的要求在哪里	https://www.cnblogs.com/nwnu-daizh/p/11703678.html
作业学习目标	掌握接口定义方法； 掌握实现接口类的定义要求； 掌握实现了接口类的使用要求； 理解程序回调设计模式； 掌握Comparator接口用法； 掌握对象浅层拷贝与深层拷贝方法； 掌握Lambda表达式语法； 了解内部类的用途及语法要求。

第一部分：总结第六章理论知识

1. 接口
　1) Java为了克服单继承的缺点，Java使用了接口， 一个类可以实现一个或多个接口。

　2) 在Java程序设计语言中，接口不是类，而是对类 的一组需求描述，由常量和一组抽象方法组成。

　3) 接口中不包括变量和有具体实现的方法。

　4) 只要类实现了接口，则该类要遵从接口描述的统 一格式进行定义，并且可以在任何需要该接口的 地方使用这个类的对象。

　5）声明方式： public interface 接口名 { …… }   接口体中包含常量定义和方法定义，接口中只进 行方法的声明，不提供方法的实现。

　6）类似建立类的继承关系，接口也可以扩展。 接口的扩展技术使得从具有较高通用性的接口存在 多条链延伸到具有较高专用性的接口。

　　 扩展方法： public   interface  接口1   extends接口2 {    ……           }

　7）在类声明时用implements关键字声明使用一个或 多个接口

　　　　class Employee implementsPrintable { …… }

　　 一个类使用了某个接口，那么这个类必须实现该 接口的所有方法，即为这些方法提供方法体。 一个类可以实现多个接口，接口间应该用逗号分 隔开。

　　　　class Employee implements Cloneable,Comparable

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

　　　　Comparablex = new Comparable(…);       //ERROR

　　　　Comparable  x= new Employee(…);     //OK

　　　可以用instanceof检查对象是否实现了某个接口。

　　　　 if  (anObjectinstanceofComparable) {   ……}

2. 接口与抽象类的区别:

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

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

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

3. 回调(callback)：一种程序设计模式，在这种模式中，可指出某个特定事件发生时程序应该采取的动作。 在java.swing包中有一个Timer类，可以使用它在到达给定的时间间隔时触发一个事件。

Timer(intinterval, ActionListenerlistener)

　　　　　  void start()

　　　　　   void stop()

4. Object类的Clone方法

     1）当拷贝一个对象变量时，原始变量与拷贝变量引用同一个对象。这样，改变一个变量所引用 的对象会对另一个变量产生影响。
     2）如果要创建一个对象新的copy，它的最初状态与 original一样，但以后可以各自改变状态，就需要使用Object类的clone方法。

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

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

6. Java Lambda 表达式是Java 8 引入的一个新的功能，主要用途是提供一个函数化的语法来简化编码。 Lambda表达式本质上是一个匿名方法。

　 public intadd(intx, inty) { return x + y; } 转成Lambda表达式后是： (intx, inty) -> x + y;

7.内部类(inner class)是定义在一个类内部的类。 外层的类成为外部类(outer class).

内部类主要用于事件处理。 使用内部类的原因有以下三个：

　1）内部类方法可以访问该类定义所在的作用域中的数据，包括私有数据。

　2）内部类能够隐藏起来，不为同一包中的其他类所见。

　3）想要定义一个回调函数且不想编写大量代码时， 使用匿名内部类比较便捷。

第二部分：实验部分

1、实验目的与要求

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

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

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

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

(5) 掌握Comparator接口用法；

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

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

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

2、实验内容和步骤

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

测试程序1：

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

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

3）掌握接口的实现用法；

4）掌握内置接口Compareable的用法。

实验程序如下：

 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);//调用Arrays类的sort方法（只有被static方法修饰了才可以这样调用）

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

用户自定义模块：

 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)//比较Employee与其他对象的大小
    {
       return Double.compare(salary, other.salary);//调用double的compare方法
    }
 }

程序运行结果如下：

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

  }

}

实验程序如下：

 interface  A//接口A
 {
   double g=9.8;
   void show( );
 }
 class C implements A//C实现接口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);//C实现了接口A，所以可以用C调用A中的变量
   }
 }

程序运行结果如下：

测试程序3：

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

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

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

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

实验程序如下：

 /**
    @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类接口

       //创建一个名为listener的timer数组
       // 每十秒钟一次
       Timer t = new Timer(10000, listener);//生成内置类对象
       t.start();//调用t中的start方法

       JOptionPane.showMessageDialog(null, "Quit program?");//窗口显示信息“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();//返回Toolkit方法，借助Toolkit对象控制响铃
    }
 }

程序测试结果如下：

测试程序4：

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

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

3）掌握对象克隆实现技术；

4）掌握浅拷贝和深拷贝的差别。

实验程序如下：

 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
    {
       // 调用对象克隆
       Employee cloned = (Employee) super.clone();

       // 克隆易变字段
       cloned.hireDay = (Date) hireDay.clone();

       return cloned;
    }//可能产生异常，放在try子句中

    /**
     * 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表达式用法。

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

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

3）将27-29行代码与教材223页程序对比，将27-29行代码与此程序对比，体会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);//调用Arrays类的sort方法
       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()));
       t.start();   

       // keep program running until user selects "Ok"
       JOptionPane.showMessageDialog(null, "Quit program?");//窗口显示信息“Quit program？”
       System.exit(0);
    }
 }

程序运行结果如下：

注：以下实验课后完成

实验3: 编程练习

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

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

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

4）查询最小年龄人员信息；

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

6）查询人员中是否有你的同乡

实验代码如下：

 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<Person> Personlist1;
        public static void main(String[] args) {

           Personlist1 = new ArrayList<>();

           Scanner scanner = new Scanner(System.in);
           File file = new File("C:\\Users\\lenovo\\Documents\\身份证");

                 try {
                      FileInputStream F = new FileInputStream(file);
                      BufferedReader in = new BufferedReader(new InputStreamReader(F));
                      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();
                         Person Person = new Person();
                         Person.setname(name);
                         Person.setid(id);
                         Person.setsex(sex);
                         int a = Integer.parseInt(age);
                         Person.setage(a);
                         Person.setbirthplace(place);
                         Personlist1.add(Person);

                     }
                 } 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.输入你的年龄，查询身份证号.txt中年龄与你最近人的姓名、身份证号、年龄、性别和出生地");
                     System.out.println("4：按省份找你的同乡；");
                     System.out.println("5：退出");
                     int type = scanner.nextInt();
                     switch (type) {
                     case 1:
                         Collections.sort(Personlist1);
                         System.out.println(Personlist1.toString());
                         break;
                     case 2:

                         int max=0,min=100;int j,k1 = 0,k2=0;
                         for(int i=1;i<Personlist1.size();i++)
                         {
                             j=Personlist1.get(i).getage();
                            if(j>max)
                            {
                                max=j;
                                k1=i;
                            }
                            if(j<min)
                            {
                                min=j;
                                k2=i;
                            }

                         }
                         System.out.println("年龄最大："+Personlist1.get(k1));
                         System.out.println("年龄最小："+Personlist1.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 <Personlist1.size(); i++)
                         {
                             if(Personlist1.get(i).getbirthplace().substring(1,4).equals(place))
                             {
                                 System.out.println("你的同乡："+Personlist1.get(i));
                             }
                         } 

                         break;
                     case 4:
                         System.out.println("年龄：");
                         int yourage = scanner.nextInt();
                         int close=ageclose(yourage);
                         int d_value=yourage-Personlist1.get(close).getage();
                         System.out.println(""+Personlist1.get(close));

                         break;
                     case 5:
                    isTrue = false;
                    System.out.println("再见!");
                         break;
                     default:
                         System.out.println("输入有误");
                     }
                 }
             }
             public static int ageclose(int age) {
                    int m=0;
                 int    max=53;
                 int d_value=0;
                 int k=0;
                 for (int i = 0; i < Personlist1.size(); i++)
                 {
                     d_value=Personlist1.get(i).getage()-age;
                     if(d_value<0) d_value=-d_value;
                     if (d_value<max)
                     {
                        max=d_value;
                        k=i;
                     }

                  }    return k;

              }
 }

 1 public class Person implements Comparable<Person> {
             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(Person o) {
         return this.name.compareTo(o.getname());

 }

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

 }
 }

程序运行结果如下：

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

实验程序1：

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

2）了解内部类的基本用法。

实验程序如下：

 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：

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

2）掌握匿名内部类的用法。

实验程序如下：

 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：

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

2）了解静态内部类的用法。

实验程序如下：

 /**
  * 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);
    }
 }

程序运行结果如下：

第三部分；实验总结

在本周的学习过程中，主要了解了接口，接口和继承在某些方面比较相似，但是接口又在继承的基础上发展了一些优点，克服了java单继承的缺点。在学习过程中，可能是因为接口并不是具体的类，它只是实现，所以感觉接口比继承抽象一些，不太容易理解。但通过这周的学习以及实验中对具体程序的运行，对接口有了一定的掌握。自己编写饰演的过程中，在之前的基础上有的接口等新内容，自己还是不能独立完成，在同学的帮助下才勉强完成了实验。在实验课上老师讲的克隆以及函数接口等，自己还没有太掌握，在之后的学习中，一定会继续深入学习。