201871010136赵艳强《面向对象程序设计（Java）》第八周学习总结

201871010136-赵艳强《面向对象程序设计（Java）》第八周学习总结

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

第一部分：总结理论知识 

抽象类：

      用abstract来声明,没有具体实例对象的类，不能用new来创建对象。可包含常规类所包含的任何东西。抽象类必须由子类继承，如果abstract类的子类不是抽象类，那么子类必须重写父类中所有的abstract方法。

接口：

      用interface声明，是抽象方法和常量值定义的集合。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的定义。接口中只能定义抽象方法，而且这些方法默认为是public的。只要类实现了接口，就可以在任何需要该接 口的地方使用这个类的对象。此外，一个类可以实现多个接口。

 接口与抽象类的区别：

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

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

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

接口的定义方法：

      在Java程序设计语言中，接口不是类，而是对类的一组需求描述，由常量和一组抽象方法组成。接口中不包括变量和有具体实现的方法。只要类实现了接口，则该类要遵从接口描述的统一格式进行定义，并且可以在任何需要该接口的地方使用这个类的对象。

接口的实现：

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

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

回调(callback)：

       一种程序设计模式，在这种模式中，可指出某个特定事件发生时程序应该采取的动作。当拷贝一个对象变量时，原始变量与拷贝变量引用同一个对象。这样，改变一个变量所引用 的对象会对另一个变量产生影响。如果要创建一个对象新的copy，它的最初状态与 original一样，但以后可以各自改变状态，就需要使用Object类的clone方法。Object类的clone()方法是一个native方法。Object类中的clone()方法被protected修饰符修饰。这意味着在用户编写的代码中不能直接调用它。如果要直接应用clone()方法，就需覆盖clone()方法，并要把clone()方法的属性设置为public。  Object.clone()方法返回一个Object对象。必须进行强制类型转换才能得到需要的类型。

在java.swing包中有一个Timer类，可以使用它在到达给定的时间间隔时触发一个事件。

浅层拷贝：

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

深层拷贝：

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

 Java中对象克隆的实现：

     在子类中实现Cloneable接口。为了获取对象的一份拷贝，可以利用Object类的clone方法。在子类中覆盖超类的clone方法，声明为public。在子类的clone方法中，调用super.clone()。

1、 lambda表达式

(1)Java Lambda 表达式是 Java 8 引入的一个新的功能，主 要用途是提供一个函数化的语法来简化编码。

(2)Lambda 表达式的语法基本结构 (arguments) -> body

(3)有如下几种情况： 1、参数类型可推导时，不需要指定类型，如 (a) -> System.out.println(a)  

2、 只有一个参数且类型可推导时，不强制写 (), 如 a -> System.out.println(a)    

3、 参数指定类型时，必须有括号，如 (int a) -> System.out.println(a)    

4、参数可以为空，如 () -> System.out.println(“hello”)    

5、 body 需要用 {} 包含语句，当只有一条语句时 {} 可省略。

内部类：是定义在一个类内部的类。

使用内部类的原因有以下三个：内部类方法可以访问该类定义所在的作用域中 的数据，包括私有数据。内部类能够隐藏起来，不为同一包中的其他类 所见。

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

      内部类可以直接访问外部类的成员，包括 private成员，但是内部类的成员却不能被外部 类直接访问。内部类并非只能在类内定义，也可以在程序块内 定义局部内部类。如果构造参数的闭圆括号跟一个开花括号，表明正 在定义的就是匿名内部类。

第二部分：实验部分

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

测试程序1：

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

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

3）掌握接口的实现用法；掌握内置接口Compareable的用法。

第二部分：实验部分

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

测试程序1：6-1,6-2代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

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    //EmployeeSortTest关联Employee; {    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());    } }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

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：

编辑、编译、调试以下程序，结合程序运行结果理解程序；

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

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：

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

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

3）在程序中相关代码处添加新知识的注释。掌握回调程序设计模式；

代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

package timer;   /**    @version 1.02 2017-12-14    @author Cay Horstmann */   import java.awt.*; import java.awt.event.*; import java.util.Date;   import javax.swing.*;   public class TimerTest {     public static void main(String[] args)    {        ActionListener listener = new TimePrinter();         //构造一个定时器为listener             //10秒一次       Timer t = new Timer(1000, listener);       t.start();         // keep program running until the user selects "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();    } }

　运行结果如下：

 回调程序：

     一种程序设计模式，在这种模式中，可指出某个特定的时间发生时程序应该采取的动作。

在Java.swing包中有一个timer类，可以使用他在给定的时间间隔触发一个事件。

测试程序4：

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

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

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

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

代码如下：

 CloneTest类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

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)//未实现cloneable接口，抛出一个异常        {            e.printStackTrace();        }    } }

　　Employee类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

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    {             //调用对象克隆       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();               // 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 + "]";    } }

运行结果如下：

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

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

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

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

代码如下： 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

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));                     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?");       System.exit(0);            } }

运行结果如下：

实验3: 编程练习 

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

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

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

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

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

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

代码如下：

package Six;

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<Student> studentlist;
public static void main(String[] args) {
studentlist = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
File file = new File("D:\\身份证号.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("e.退出");
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 "e":
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 Six;

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 了解内部类的基本用法。

  6-7 代码：

package innerClass;
 2 
 3 import java.awt.*;
 4 import java.awt.event.*;
 5 import java.util.*;
 6 import javax.swing.*;
 7 import javax.swing.Timer;
 8 
 9 /**
10  * This program demonstrates the use of inner classes.
11  * @version 1.11 2015-05-12
12  * @author Cay Horstmann
13  */
14 public class InnerClassTest
15 {
16    public static void main(String[] args)
17    {
18       TalkingClock clock = new TalkingClock(1000, true);
19       clock.start();
20 
21       // 保持程序运行知道用户选择OK；
22       JOptionPane.showMessageDialog(null, "Quit program?");
23       System.exit(0);
24    }
25 }
26 
27 /**
28  * A clock that prints the time in regular intervals.
29  */
30 class TalkingClock
31 {
32    private int interval;
33    private boolean beep;
34 
35    /**
36     * Constructs a talking clock
37     * @param interval the interval between messages (in milliseconds)
38     * @param beep true if the clock should beep
39     */
40    public TalkingClock(int interval, boolean beep)
41    {
42       this.interval = interval;
43       this.beep = beep;
44    }
45 
46    /**
47     * Starts the clock.
48     */
49    public void start()
50    {
51       ActionListener listener = new TimePrinter();
52       Timer t = new Timer(interval, listener);
53       t.start();
54    }
55 
56    public class TimePrinter implements ActionListener
57    {
58       public void actionPerformed(ActionEvent event)
59       {
60          System.out.println("At the tone, the time is " + new Date());
61          if (beep) Toolkit.getDefaultToolkit().beep();
62       }
63    }
64 }

程序测试结果：

实验程序2：

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

l 掌握匿名内部类的用法。

  6-8 代码：
import java.awt.*;
 2 import java.awt.event.*;
 3 import java.util.*;
 4 import javax.swing.*;
 5 import javax.swing.Timer;
 6 
 7 /**
 8  * This program demonstrates anonymous inner classes.
 9  * @version 1.11 2015-05-12
10  * @author Cay Horstmann
11  */
12 public class AnonymousInnerClassTest
13 {
14    public static void main(String[] args)
15    {
16       TalkingClock clock = new TalkingClock();
17       clock.start(1000, true);
18 
19      // 保持程序运行知道用户选择OK；
20       JOptionPane.showMessageDialog(null, "Quit program?");
21       System.exit(0);
22    }
23 }
24 
25 /**
26  * A clock that prints the time in regular intervals.
27  */
28 class TalkingClock
29 {
30    /**
31     * Starts the clock.
32     * @param interval the interval between messages (in milliseconds)
33     * @param beep true if the clock should beep
34     */
35     //匿名内部类；
36    public void start(int interval, boolean beep)
37    {
38       ActionListener listener = new ActionListener()
39          {
40             public void actionPerformed(ActionEvent event)
41             {
42                System.out.println("At the tone, the time is " + new Date());
43                if (beep) Toolkit.getDefaultToolkit().beep();
44             }
45          };
46       Timer t = new Timer(interval, listener);
47       t.start();
48    }
49 }

程序测试结果：

实验程序3：

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

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

  6-9 代码：

package staticInnerClass;
 2 
 3 /**
 4  * This program demonstrates the use of static inner classes.
 5  * @version 1.02 2015-05-12
 6  * @author Cay Horstmann
 7  */
 8 public class StaticInnerClassTest
 9 {
10    public static void main(String[] args)
11    {
12       double[] d = new double[20];
13       for (int i = 0; i < d.length; i++)
14          d[i] = 100 * Math.random();
15       ArrayAlg.Pair p = ArrayAlg.minmax(d);
16       System.out.println("min = " + p.getFirst());
17       System.out.println("max = " + p.getSecond());
18    }
19 }
20 
21 class ArrayAlg
22 {
23    /**
24     * A pair of floating-point numbers
25     */
26    public static class Pair
27    {
28       private double first;
29       private double second;
30 
31       /**
32        * Constructs a pair from two floating-point numbers
33        * @param f the first number
34        * @param s the second number
35        */
36       public Pair(double f, double s)
37       {
38          first = f;
39          second = s;
40       }
41 
42       /**
43        * Returns the first number of the pair
44        * @return the first number
45        */
46       public double getFirst()
47       {
48          return first;
49       }
50 
51       /**
52        * Returns the second number of the pair
53        * @return the second number
54        */
55       public double getSecond()
56       {
57          return second;
58       }
59    }
60 
61    /**
62     * Computes both the minimum and the maximum of an array
63     * @param values an array of floating-point numbers
64     * @return a pair whose first element is the minimum and whose second element
65     * is the maximum
66     */
67    public static Pair minmax(double[] values)
68    {
69       double min = Double.POSITIVE_INFINITY;
70       double max = Double.NEGATIVE_INFINITY;
71       for (double v : values)
72       {
73          if (min > v) min = v;
74          if (max < v) max = v;
75       }
76       return new Pair(min, max);
77    }
78 }

程序测试结果：

实验总结：

通过这一章的学习基本掌握了接口的定义方法，实现了接口类的使用要求，理解程序回调设计模式，掌握了Comparator接口用法：学会了Lambda表达式与内部类。也学会了建立浅拷贝与深拷贝，在学长的讲解过程中我也知道了关于接口定义的很多知识。在课后的实验过程中也是有了进一步的加深理解，课后我会练习编写，加强自己的编程能力。