201871010108-高文利《面向对象程序设计（java）》第八周学习总结

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

 

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

 

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

在Java中,接口不是类而是对类的一组需求描述。由常量和一组抽象方法组成。

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

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

2.自定义接口的声明：

public interface接口名

{....}

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

接口也可以扩展。

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

{......}

说明：通常接口的名字以able或ible结尾，可以使用extends来继承接口的常量和抽象方

法，扩展形成新的接口。

接口中的所有常量必须是public static final,方法必须是public abstracts（系统默认）。

接口的实现：在类声明时用implements关键字声明使用一个或多个接口

c1ass Employee implements Printable

一个类使用了某个接口，那么这个类必须实现该接口的所有方法，即为这些方法提供方法体。

一个类可以实现多个接口，接口间应该用逗号分隔。

class Employee implements cloneable Comparable

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

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

接口抽象方法的访问控制符已指定为publics，所以类在实现时，必须显式地使用public修饰符。

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

Camparable x = new Camparable(..);//ERROR

Camparable x= new Emploee(..) ;//OK

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

if (anQbject instanceof Canparable)

{...}

4.抽象类与接口的区别：接口不能实现任何方法，而抽象类可以。

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

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

5.回调:指出某个特定事件发生时程序应该采取的动作。

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

Timer(int interval, ActionListener listener)

void start()

void stop()

Comparator接口：所在包：java.util.*

Comparator接口定义：

Public interface Comparator{

int compare(T o1,T o2);

.....

}

用途：处理字符串按长度进行排序的操作

 

二．对象克隆：

 

1.Object类的Clone方法：

 

当拷贝一个对象变量时，原始变量与拷贝变量引用同一个对象。这样,改变一个变量所引用的对象会对另一个变里产生影响。

 

如果要创建一个对象新的copy,它的最初状态与original一样，但以后可以各自改变状态，就需要使用0bject类的clone方法。

 

 

 

 

public class Object{

protected native Object clone( throws CloneNotSupportedException）

}

Object类的clone()方法是一个native方法.

Object类中的clone()方法被protected修饰符修饰.如果要直接应用clone()方法。就需覆

盖clone()方法。并要把clone()方法的属性设置为public.

Object. Clone()方法返回一个object对象.必须进行强制类型转换才能得到需要的类型.

2.浅层拷贝和深层拷贝

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

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

3.Java中对象克隆的实现：

在子类中实现Cloneable接口。为了获取对象的一份拷贝，可以利用0bject类的clone方法。

在子类中覆盖超类的clone方法，声明为public。

在子类的clone方法中，调用super . clone()。

 

三.Lambda表达式

 

1.Lambda表达式的语法基本结构

 

(arguments) -> body

 

有如下几种情况:

 

参数类型可推导时.不需要指定类型。如：(a)-> System.out.println(a)

 

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

 

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

 

参数可以为空.如()-> System.out.pintln("hello")

 

body需要用{}包含语句.当只有一条语句时{}可省略

 

2.函数式接口( Functionallnterface)

 

只有一个方法的接口，这类接口的目的是为了一个单一的操作。常见的接口如: ActionListener,

 

Runnable, Comparator都是函数式接口，并且都标注了注解@Functionallnterface。

 

函数式接口用作表示lambda表达式的类型。

 

四．内部类：

1.内部类(inner class)是定义在一个类内部的类。外层的类成为外部类(outer class).内部类主要用于事件处理。

使用内部类的原因有以下三个:

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

内部类能够隐藏起来,不为同一包中的其他类

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

内部类的声明：

[修饰符]class outerClass{

[修饰符] class innerClass{

...

}

...

}

内部类可以直接访问外部类的成员，包括private 成员。但是内部类成员却不能被外部类直接访问。

在内部类对象保存了一个对外部类对象的引用，当内部类的成员方法中访问某一变量时，如果在该方法和内部类中都未定义过这个变量，内部类中对变量的引用会被传递给外部类对象的引用。

2.局部内部类：

内部类并非只能在类内定义,也可以在程序块内定义局部内部类。例如,在方法中,甚至在for循环体内部。

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

3.匿名内部类：

若只创建类的一个对象,则不必为该类命名，这种类称为匿名内部类。

由于匿名类没有类名,所以匿名类不能有构造器，取而代之的是将构造器参数传递给超类的构造器。

若匿名内部类实现接口时,则匿名内部类不能有任何构造参数。

如果构造参数的闭圆括号跟一个开花括号，表明正在定义的就是匿名内部类。

4.静态内部类：

如果用static修饰一个内部类,这个类就相当于是一个外部定义的类，所以static的内部类

中可声明static成员,但非static的内部类中的成员是不能声明为static的。static的内部

类不能再使用外部类的非s tatid的成员变量。static内部类很少使用。

 

 

 

 

第二部分：实验部分

实验1：测试程序1（5分）

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

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

掌握接口的实现用法；

掌握内置接口Compareable的用法。

EmployeeSortTest.java

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

　　Employee.java

package interfaces;

public class Employee implements 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)//Employee类提供compareTo方法
   {
      return Double.compare(salary, other.salary);//根据雇员的薪水比较
   }
}

　　

 

 小结：使用接口对Employee类实例数组实现排序。

Compareable接口不是类，而是对类的一种需求描述，只能包含常量和一组抽象方法。只进行方法声明，不提供方法实现。

 

 

实验1：测试程序2（5分）

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

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接口的所有方法。

 

 

实验1：测试程序3（5分）

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

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

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

掌握回调程序设计模式；

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

      //构造一个名为listener的定时器
      //每隔10秒通告一次
      var timer = new Timer(1000, listener);
      timer.start();//定时器启动

      //程序一直运行，直到点击OK按钮停止
      JOptionPane.showMessageDialog(null, "Quit program?");
      //程序启动后，会立即显示一个包含“Quit program？”的对话框。10秒之后，第一条定时器消息会显示出来
      System.exit(0);
   }
}

class TimePrinter implements ActionListener//TimePrinter类声明使用ActionListener接口
{  
   public void actionPerformed(ActionEvent event)//ActionEvent参数提供了事件的基本信息
   {  
      System.out.println("At the tone, the time is " 
         + Instant.ofEpochMilli(event.getWhen()));
      Toolkit.getDefaultToolkit().beep();//发出一声铃响
   }
}

　　

 

 小结：java.swing包内的Timer类，可以使用它在到达给定时间间隔是发出通告。

回调时某个特定事件发生时应该采取的动作。

 

实验1：测试程序4（5分）

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

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

掌握对象克隆实现技术；

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

CloneTest.java

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();//创建与original一样最初状态新对象copy，但为了可以各自有自己不同的状态，使用clone方法
      copy.raiseSalary(10);
      copy.setHireDay(2002, 12, 31);
      System.out.println("original=" + original);
      System.out.println("copy=" + copy);
   }
}

　　Employee.java

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();
   }
   //将clone重新定义为public，再调用super.clone(),返回正确的类型
   //如果在一个对象上调用clone，但这个对象没有实现Cloneable接口，Object类的clone方法就会抛出一个CloneNotSupportedException
   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();
      
      //可变实例域的例子
      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：（10分）

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

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

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

将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());//推导一个lambda表达式的参数类型
      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);         
   }
}

　　

 

 以上程序显示了如何在一个比较器和一个动作监听器中使用lambda表达式

 

实验3：编程练习（25分）

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

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

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

查询最小年龄人员信息；

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

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

Main.java

package Test;

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 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;imax)
                 {
                     max=j; 
                     k1=i;
                 }
                 if(j 
 

　　Student.java

package Test;

public class Student implements Comparable {

    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：

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

了解内部类的基本用法。

package innerClass;

import java.awt.*;
import java.awt.event.*;
import java.time.*;

import javax.swing.*;

/**
 * This program demonstrates the use of inner classes.
 * @version 1.11 2017-12-14
 * @author Cay Horstmann
 */
public class InnerClassTest
{
   public static void main(String[] args)
   {
      var clock = new TalkingClock(1000, true);
      clock.start();

      // keep program running until the 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()
   {
      var listener = new TimePrinter();
      var timer = new Timer(interval, listener);
      timer.start();
   }

   public class TimePrinter implements ActionListener
   {
      public void actionPerformed(ActionEvent event)
      {
         System.out.println("At the tone, the time is " 
            + Instant.ofEpochMilli(event.getWhen()));
         if (beep) Toolkit.getDefaultToolkit().beep();
      }
   }
}

　　

 

 

实验程序2：

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

 掌握匿名内部类的用法。

package anonymousInnerClass;

import java.awt.*;
import java.awt.event.*;
import java.time.*;

import javax.swing.*;

/**
 * This program demonstrates anonymous inner classes.
 * @version 1.12 2017-12-14
 * @author Cay Horstmann
 */
public class AnonymousInnerClassTest
{
   public static void main(String[] args)
   {
      var clock = new TalkingClock();
      clock.start(1000, true);

      // keep program running until the 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)
   {
      var listener = new ActionListener()
         {
            public void actionPerformed(ActionEvent event)
            {
               System.out.println("At the tone, the time is " 
                  + Instant.ofEpochMilli(event.getWhen()));
               if (beep) Toolkit.getDefaultToolkit().beep();
            }
         };
      var timer = new Timer(interval, listener);
      timer.start();
   }
}

　　

 

 

实验程序3：

在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)
   {
      var values = new double[20];
      for (int i = 0; i < values.length; i++)
         values[i] = 100 * Math.random();
      ArrayAlg.Pair p = ArrayAlg.minmax(values);
      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);
   }
}

　　

 

 

实验总结：（10分）

通过本周的学习，掌握实现了接口类的知识及其应用，理解了程序回调设计模式，掌握并理解Comparator接口知识及用法，掌握对象浅层拷贝与深层拷贝方法与Lambda表达式语法，了解内部类的用途及语法要求。有些知识的掌握还不太熟练，希望可以充分理解并应用这些知识。