201871010126 王亚涛《面向对象程序设计（Java）》第八周实验总结

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

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

第六章接口、lambda表达式与内部类

6.1接口

使用interface来定义一个接口。接口定义同类的定义类似，也是分为接口的声明和接口体，其中接口体由常量定义和方法定义两部分组成。定义接口的基本格式如下：

[修饰符] interface 接口名 [extends 父接口名列表]{

[public] [static] [final] 常量; //全局常量
[public] [abstract] 方法;　　//抽象方法
}

修饰符：可选，用于指定接口的访问权限，可选值为public。如果省略则使用默认的访问权限。
接口名：必选参数，用于指定接口的名称，接口名必须是合法的Java标识符。一般情况下，要求首字母大写。
extends 父接口名列表：可选参数，用于指定要定义的接口继承于哪个父接口。当使用extends关键字时，父接口名为必选参数。
方法：接口中的方法只有定义而没有被实现。

抽象类：用abstract来声明,没有具体实例对象的类，不能用new来创建对象。

6.2接口示例

6.2.1接口与回调

回调：回调是一种双向的调用模式，也就是说，被调用的接口被调用时也会调用对方的接口，例如A要调用B，B在执行完又要调用A。

6.2.2Comparator接口

java.utils包下的Comparator接口。

该接口代表一个比较器，java数组工具类和集合工具类中提供对sort方法排序就是使用Comparator接口来处理排序的。

Comparator接口中有一个方法int compare(T o1, T o2)。这个方法返回值是int类型，如果返回值小于0，说明比较结果是o1<o2，如果返回值等于0，说明比较结果是o1=o2,如果返回值大于0，则说明比较结果是o1>o2。既然是接口，那么我们就可以实现它，来自定义其中对比较规则，即可实现在一个List列表中将元素按照某个属性进行排序。

6.2.3 对象克隆

克隆：

两种不同的克隆方法：浅克隆（shallowclone）和深克隆(deepclone) 。在Java语言中，数据类型分为基本数据类型和引用类型，其中引用数据类型主要包括类、接口、数组等复杂的数据类型。浅克隆和深克隆的主要区别在于是否支持引用类型的成员变量的复制。

1、浅克隆的一般步骤：

1）.被复制的类需要实现Clonable接口。该接口为标记接口，里边不含任何的方法。

2）.覆盖clone()方法，访问修饰符设为public，方法中调用super.clone()方法得到需要的复制对象。

这就是浅克隆，两个对象引用分别指向的是不同的堆内存空间。这里我们能看到，在学生这个类里面的所有成员变量都是基本数据类型，所以这个时候使用浅克隆是完全没有问题的，因为成员变量不涉及到引用数据类型。

深克隆和浅克隆的区别就是在一个类里边如果有引用类型的变量的话，依然使用浅克隆的方法进行对象引用的复制，那么出现的结果就是对象里的引用类型变量只是变量的复制，实际上并没有为复制的引用类型变量重新开辟空间。所以，为了达到真正的复制对象，针对引用类型变量不单单是变量的复制，我们需要将引用类型变量可复制化，并且还要修改clone()方法。

Eg：在学生类里边加入地址类：

6.3lambda表达式

Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

使用 Lambda 表达式可以使代码变的更加简洁紧凑。

语法
lambda 表达式的语法格式如下：

(parameters) -> expression
或
(parameters) ->{ statements; }
以下是lambda表达式的重要特征:

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

6.4内部类

定义：将一个类定义在另一个给类里面或者方法里面，这样的类就被称为内部类。
内部类可以分为四种:成员内部类、局部内部类、匿名内部类、静态内部类，下面我们逐一介绍这四种内部类

成员内部类的访问权限

成员内部类前可加上四种访问修饰符。
private：仅外部类可访问。
protected：同包下或继承类可访问。
default：同包下可访问。
public：所有类可访问。

静态内部类对象的创建一般是外部类.内部类类名 = new 外部类.内部类();
成员内部类对象的创建一般是外部类.内部类类名 = 外部类对象名.new 内部类();

6.5 代理

代理(Proxy)是一种设计模式,提供了间接对目标对象进行访问的方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的功能上,增加额外的功能补充,即扩展目标对象的功能.

这就符合了设计模式的开闭原则，即在对既有代码不改动的情况下进行功能的扩展。

静态代理：在使用静态代理时,被代理对象与代理对象需要一起实现相同的接口或者是继承相同父类，因此要定义一个接口或抽象类.

静态代理总结:
优点：可以做到在不修改目标对象的功能前提下,对目标功能扩展.
缺点:

因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护.

动态代理：

动态代理的主要特点就是能够在程序运行时JVM才为被代理对象生成代理对象。

常说的动态代理也叫做JDK代理也是一种接口代理，JDK中生成代理对象的代理类就是Proxy，所在包是java.lang.reflect

总结：

代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能使用动态代理，因此这也算是这种方式的缺陷。

第二部分：实验部分

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

测试程序1：

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

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

l 掌握接口的实现用法；

l 掌握内置接口Compareable的用法。

例题6.1程序代码如下：

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];

      //新建一个Employee 数组对象 给staff所引用，数组大小为三

      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());

   }

}

运行结果截图如下：

例题6.2程序代码如下：

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;//用关键字this设置员工的名字及工资

   }

   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);

   }

}

程序运行截图如下：

测试程序一总结：接口的实现

j接口在定义后，就可以在类中实现该接口。在类中实现接口可以使用关键字implements，其基本格式如下：
[修饰符] class <类名> [extends 父类名] [implements 接口列表]{
}
修饰符：可选参数，用于指定类的访问权限，可选值为public、abstract和final。
类名：必选参数，用于指定类的名称，类名必须是合法的Java标识符。一般情况下，要求首字母大写。
extends 父类名：可选参数，用于指定要定义的类继承于哪个父类。当使用extends关键字时，父类名为必选参数。
implements 接口列表：可选参数，用于指定该类实现的是哪些接口。当使用implements关键字时，接口列表为必选参数。当接口列表中存在多个接口名时，各个接口名之间使用逗号分隔。

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

}

程序代码如下：

package interfaces;

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 在程序中相关代码处添加新知识的注释。

掌握回调程序设计模式；

例题6.3程序代码如下：

package timer;

/**

   @version 1.02 2017-12-14

   @author Cay Horstmann

*/

import java.awt.*;

import java.awt.event.*;

import java.time.*;

import javax.swing.*;

public class TimerTest

{

   public static void main(String[] args)

   {

      var listener = new TimePrinter();

      // construct a timer that calls the listener构造一个调用侦听器的计时器

      // once every second每秒一次

      var timer = new Timer(1000, listener);

      timer.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 " //输出这一刻的时间

         + Instant.ofEpochMilli(event.getWhen()));

      Toolkit.getDefaultToolkit().beep();//获得默认的工具箱，得到信息并发出一声铃响；

   }

}

程序输出截图如下：

测试程序4：

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

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

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

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

例题6.4程序代码如下：

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

   {

      var 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);//输出克隆后的数据

   }

}

程序运行截图如下：

例题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()克隆程序

      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 + "]";

   }

}

程序运行截图如下：

测试程序4总结：

为什么要拷贝？

Java克隆是为了得到一个完全一致的对象。

相同点：对象完全一样。这包括里头所有的变量，对象。

不同点：对象的内存地址不一样。

深拷贝与浅拷贝

一般来说，拷贝的类型分为深拷贝与浅拷贝。

| 深拷贝：引用对象的值等信息，复制一份一样的。 |

| 浅拷贝：只复制引用，另一处修改，你当下的对象也会修改。

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

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

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

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

例题6.6程序代码如下：

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)

   {

      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();//构造一个定时器，   

      // keep program running until user selects "OK"使时间一直运行直到使用者停止

      JOptionPane.showMessageDialog(null, "Quit program?");//程序是否终止窗口

      System.exit(0);

   }

}

程序运行截图如下：

实验3: 编程练习

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

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

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

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

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

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

实验代码如下：

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 Search{

      private static ArrayList<Person> Personlist1;

       public static void main(String[] args) {

          Personlist1 = new ArrayList<>();

          Scanner scanner = new Scanner(System.in);

          File file = new File("E:\\面向对象程序设计Java\\实验\\实验六\\身份证号.txt");

                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("******************************************");

                    System.out.println("1:按姓名字典顺序输出信息；");

                    System.out.println("2:查询最大年龄与最小年龄人员信息；");

                    System.out.println("3：按省份找你的同乡；");

                    System.out.println("4:输入你的年龄,查询年龄与你最近人的信息；");

                    System.out.println("5：退出");

                    System.out.println("******************************************");

                    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;

             }

 }

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";

}

}

运行截图如下：

实验总结：

1）：掌握接口的相关知识，程序回调设计模式，Comparator接口用法，对象浅层拷贝与深层拷贝方法，Lambda表达式语以及了解内部类的用途及语法要求。

2）：在实验的过程中对所学知识点有了进一步的了解与掌握，在老师和助教的帮助下我们对Java编程有了更多发的了解。

巴特西

201871010126 王亚涛《面向对象程序设计（Java）》第八周实验总结

成员内部类的访问权限

最新文章

热门文章

巴特西

201871010126 王亚涛 《面向对象程序设计（Java）》第八周实验总结

成员内部类的访问权限

最新文章

热门文章

201871010126 王亚涛《面向对象程序设计（Java）》第八周实验总结