201871010134-周英杰《面向对象程序设计（java）》第八周学习总结

201871010134-周英杰《面向对象程序设计（java）》八周学习总结

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

第一部分：第六章知识总结。

1.接口定义方法；

一、接口的概念：接口是一种引用的数据类型，接口只是描述应该具备的方法，没有具体的实现，不能实例化。

1. 接口的定义：

关键字：interface，不再使用class。接口的文件后缀名仍为java，编译后的文件仍叫class文件

与类的定义相同，唯一不同的是关键字

public interface MyInterface{

}

2.实现接口类的定义要求；

java 不支持多继承，如果希望一个类能同时继承两个以上的父类可以使用接口(interface)来实现多继承的效果接口是一种纯粹的 抽象类，只 包含了抽象方法和常量的定义抽象方法必须由其子类来实现implement，才能赋予新的功能子类实现接口，使用implement关键字，可以实现多个接口，接口名之间用逗号隔空。

接口与抽象类的区别：

接口是纯粹的抽象类，接口中所有 的方法都是抽象的(只有声明，没有定义)，而抽象类允许包含有定义的方法子类实现 接口用implement， 继承 抽象类用extends关键字子类可以 实现 多个接口，但只能继承一个抽象类一个子类如果实现了一个接口，就必须重写这个接口里所有的方法；抽象类的子类可以不重写抽象父类里的所有方法，但这个子类会自然成为抽象类。

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

实现接口或继承抽象类的子类必须实现接口的所有方法或抽象类的所有抽象方法。

接口中的所有方法均为抽象方法，抽象类中包含非抽象方法和抽象方法。如果一个类实现了接口，那么该子类必须实现父接口的所有方法。如果一个类继承了抽象类，那么该子类必须实现抽象类的所有抽象方法。

二、实现方案

（一）实现接口

1. 定义接口

/**
 * 接口：表示人类行为
 */
interface Behavor {
    /**
     * 抽象方法：“吃饭”方法
     */
    void eat();

    /**
     * 抽象方法：“睡觉”方法
     */
    void sleep();

2. 定义子类，实现接口

3. 定义调用类，调用方法

1 2 3 4 5 6 7

public class Main {     public static void main(String[] args) {         Person p = new Person("张三其");         p.eat();         p.sleep();     } }

（二）继承抽象类

/**
 * 子类：表示人类，实现“行为”接口
 */
class Person implements Behavor {
    /**
     * 姓名
     */
    protected String name = null;

    public Person(String name) {
        this.name = name;
    }

    //实现接口的抽象方法
    @Override
    public void eat() {
        System.out.println(name + "正在吃饭......");
    }

    //实现接口的抽象方法
    @Override
    public void sleep() {
        System.out.println(name + "正在睡觉......");
    }
}

1. 定义抽象类

/**
 * 抽象类：表示人类
 */
abstract class Person {
    /**
     * 姓名
     */
    protected String name = null;

    public Person(String name) {
        this.name = name;
    }

    /**
     * 抽象方法：吃饭
     */
    public abstract void eat();

    /**
     * 抽象方法：睡觉
     */
    public abstract void sleep();
}

2. 定义子类，继承抽象类

/**
 * 子类：学生类
 */
class Student extends Person {
    public Student(String name) {
        super(name);
    }

    //实现抽象类的抽象方法
    @Override
    public void eat() {
        System.out.println("学生" + name + "正在吃饭......");
    }

    //实现抽象类的抽象方法
    @Override
    public void sleep() {
        System.out.println("学生" + name + "正在吃饭......");
    }
}

3. 定义调用类，调用方法

public class Main {
    public static void main(String[] args) {
        Person p = new Student("张三其");
        p.eat();
        p.sleep();
    }
}

4.理解程序回调设计模式；

回调模式：在计算机程序设计中，回调函数，或简称回调，是指通过函数参数传递到其它代码的，某一块可执行代码的引用。这一设计允许了底层代码调用在高层定义的子程序

5.掌握Comparator接口用法；

Comparator接口中有一个方法int compare(T o1, T o2)。这个方法返回值是int类型，如果返回值小于0，说明比较结果是o1<o2，如果返回值等于0，说明比较结果是o1=o2,如果返回值大于0，则说明比较结果是o1>o2。一般需要做比较的逻辑都可以使用的上Comparator。

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

假设现在有对象obj1，它包含两个子对象containedObj1和containedObj2.

浅层拷贝就是创建一个新的实例，在内存中开辟新的地址生成obj2，但是obj2的子对象却没有被拷贝obj1的子对象，而是拷贝的obj1子对象的引用。

深层拷贝就是obj2不仅拷贝了obj1并且拷贝了obj1的所有子对象。

7.掌握Lambda表达式语法；

lambda表达式的标准写法由下面几点构成：

1>以逗号分隔，以（）关闭的形参：(Dog m, Dog n)

2>箭头标记：->

3>主体部分则是一个单表达式或者声明代码块。如下是单表达式形式：Integer.compare(m.getWeight(), n.getWeight())

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

在类的内部可以定义成员变量和方法，而且在类的内部也可以定义另一个类，如果类Outer的内部在定义一个类Inner，此时Inner就成为内部类，而Outer则称为外部类。
内部类可以声明为public或private。当内部类声明为public或private，对其访问权限于成员变量和成员方法完全相同。

第二部分：实验部分

实验1：

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

      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方法对Employee对象数组进行排序

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

package interfaces;

public class Employee implements Comparable<Employee> // 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) //重写接口的compareTo方法
      {
          return Double.compare(salary, other.salary);//按照他们的工资高低进行排序
      }

    }

运行结果：

实验2：测试程序2

代码：

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

代码：

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构造器
      timer.start();    //调用timer的start方法

      // keep program running until the user selects "OK" 保持一个对话框直到使用者选择OK
      JOptionPane.showMessageDialog(null, "Quit program?");
      System.exit(0);
   }
}

class TimePrinter implements ActionListener     //TimePrinter类实现ActionListener接口
{
   public void actionPerformed(ActionEvent event)   //重写接口的方法
   {
      System.out.println("At the tone, the time is "
         + Instant.ofEpochMilli(event.getWhen()));
      Toolkit.getDefaultToolkit().beep();      //获得默认的工具箱
   }
}

运行结果：

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

package clone;

import java.util.Date;
import java.util.GregorianCalendar;
//创建深拷贝的clone方法的一个例子
public class Employee implements Cloneable   //Employee类实现接口
{
   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   //将clone重新定义为public
   {
      // call Object.clone()
      Employee cloned = (Employee) super.clone();  //为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()      //toString方法
   {
      return "Employee[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]";
   }
}

运行结果：

实验2：

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);              //调用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));

      //Lambda表达式转化为接口
      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);
   }
}

运行结果：

实验6：编程练习

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

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

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

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

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

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

代码：

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

运行结果：

实验总结：

通过一个周的学习，我大致掌握了接口的概念和实现方法，能够使用接口编写一些简单程序，并会使用comparable接口里的CompareTo和Comparator方法；初步的了解了克隆的概念，但是仍有一些问题存在，拷贝就成了我的一道难关，仍需要继续好好学习和认真听老师的讲解；还有lambda表达式可以简化程序的编写，使得程序简洁工整。还了解到了接口和继承之间的区别，object类的clone方法以及lambda表达式等。本周的实验主要还是以理解课本中的代码案例为主，老师为了节省我们的时间，自主完成实验虽然只是在以前实验的基础上添加了新的知识内容，但是自己在完成编程真的是太困难了。看来我还得好好地认认真真的继续学才好！！！

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);    //使用Arrays中的sort方法对Employee对象数组进行排序
      // print out information about all Employee objects      for (Employee e : staff)         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());   }}