201874040116-李鑫《面向对象程序设计（java）》第8周学习总结

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

第一部分：总结第六章理论知识
　　1.接口（interface）：　　　

　　　　接口的声明语法格式如下：

　　　　[可见度] interface 接口名称 [extends 其他的接口名] {
      　　　　  // 声明变量
   　　   　　  // 抽象方法
　　　　}

　　　　1）接口不是类，是对类的一组需求描述，由常量和抽象方法组成，不能包含实例域和静态方法
　　　　2）不能构造接口的对象，但可以声明接口的变量，接口变量必须引用实现了接口的类对象
　　　　3）接口可以象类的继承一样扩展 public interface 接口1 extends接口2 {...}
　　　　4）一个类可以实现多个接口
　　2.回调（callback）：
　　　　指出某个特定事件发生时应该采取的动作；在java.swing包中有一个Timer类，可以使用它在到达给定的时间间隔时触发一个事件。
　　3.对象克隆
　　　　当浅拷贝一个对象变量时，原始变量与拷贝变量引用同一个对象。这样，改变一个变量所引用的对象会对另一个变量产生影响。不想这样就要重新定义clone方法建立一个深拷贝。
　　4.Lambda表达式（java 8 新特性）
　　　　语法：(parameters) -> expression
　　　　1) 使用 Lambda 表达式可以使代码变的更加简洁紧凑。
　　　　2）Lambda 表达式免去了使用匿名方法的麻烦，并且给予Java简单但是强大的函数化的编程能力。
　　　　3) 即使Lambad表达式没有参数，仍然要提供空括号；如果可以推导出一个Lambda表达式的参数类型，则可以忽略其类型。
　　　　4) 函数式接口：对于有且仅有一个抽象方法，但是可以有多个非抽象方法的接口，需要这种接口的对象时，就可以提供一个lambda表达式，这种接口称为函数式接口。
　　5.方法引用
　　　　语法： class::method   例： System.out::println
　　　　1） 方法引用通过方法的名字来指向一个方法。
　　　　2） 方法引用可以使语言的构造更紧凑简洁，减少冗余代码。
　　　　　　1. 构造器引用：语法：Class::new，或者更一般的Class< T >::new
　　　　　　2. 静态方法引用： 语法：Class::static_method
　　6.内部类（inner class）
　　　　1) 内部类是定义在另一个类中的类
　　　　2）使用内部类的理由： 1.内部类方法可以访问该类定义所在的作用域中的数据，包括私有的数据
　　　　　　　　　　　　　　　2.内部类可以对同一个包中的其他类隐藏起来
　　　　　　　　　　　　　　　3.当想要定义一个回调函数且不想编写大量代码时，使用匿名内部类比较便捷
　　　　3）内部类的特殊语法规则：outerclass.this 表示外围类引用 
　　　　4）局部内部类： 被包含与方法中的类； 局部内部类就像是方法里面的一个局部变量一样，不能有public、protected、private以及static修饰符。它的作用域被限定在声明这个局部类的块中。局部类有一个优势，即对外部
　　　　　　　　　　　　　　　　　　　　　　 世界完全隐藏起来。即使外部类中的其他代码也不能访问它。除了其所在的方法之外，没有任何方法知道该局部类的存在。局部内部类只能访问被final修饰的局部变量。
　　　　5）匿名内部类： 局部内部类的进一步使用：只创建这个类的一个对象的不必命名的类。
　　　　6）静态内部类： 有时候，使用内部类只是为了把一个类隐藏在另外一个类的内部，并不需要内部类引用外围类的元素。为此，可以为内部类加上static关键字声明为静态内部类，以便取消产生的引用。
　　7.代理（proxy）
　　　　1）利用代理可以在运行时创建一个实现了一组给定接口的新类。用在编译时无法确定需要使用实现哪一个接口时才有必要使用。
　　　　2）要想创建一个代理对象，需要使用Proxy类的newProxyInstance方法

第二部分：实验部分

实验1：测试程序1

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

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

public class Employee implements Comparable<Employee> //定义实现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) //实现Comparable接口中的comparaTo方法
   {
      return Double.compare(salary, other.salary);
   }
}

 结果：

测试程序2：

public class Test{
    public static void main(String[ ] args)
    {
        A a = new C();//定义接口变量a引用了C类的对象
        a.show( );
        System.out.println("g="+C.g);
    }
}
interface  A
{
    double g=9.8;  //final 常量
    void show( );  
}
class C implements A
{
    public void show( )
    {System.out.println("g="+g);}
}

 结果；

测试程序3：

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

      // construct a timer that calls the listener
      // once every second
      // 建立一个一秒触发一次的定时器
      Timer t = new Timer(1000, listener);
      t.start();

      // keep program running until the user selects "OK"
      // 弹出信息框同时持续程序的运行直到用户按下"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();//蜂鸣
   }
}

 结果：

测试程序4：

 

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


 
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 Employee clone() throws CloneNotSupportedException  
   {
      // call Object.clone() 调用Object类的clone方法 浅拷贝
      Employee cloned = (Employee) super.clone();
 
      // clone mutable fields   克隆易变字段
      cloned.hireDay = (Date) hireDay.clone();
 
      return cloned;
   }
 

   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：

 

import java.util.*;
 
import javax.swing.*;
import javax.swing.Timer;
 

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

 

结果；

lambda表达式十分简洁

实验3:编程练习：

 

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class student {

    public static void main(String[] args) throws FileNotFoundException {
        Scanner in = new Scanner(new File("E:\CSDN\身份证号.txt"));
        stu s[] = new stu[100];
        int i = 0;
        
        //数据录入
        while(in.hasNextLine())
        {
            s[i] = new stu();
            s[i].setName(in.next());
            s[i].setID(in.next());
            s[i].setSex(in.next());
            s[i].setAge(in.nextInt());
            s[i].setBrithplace(in.nextLine());
            
            i++;
        }
        in.close();
        int n;        
        int e = 1;
        Scanner k = new Scanner(System.in);
        while(e==1)
        {
            System.out.println("选择操作：
按1按姓名字典序输出人员信息
按2查询最大年龄和最小年龄的人员信息
按3输入你的年龄，查询年龄与你最近人的信息
按4查询人员中是否有你的同乡
按5退出");
            n = k.nextInt();
            switch(n)
            {
            case 1:
                selectionSortandPrint(s,i);
                break;
            case 2:
                findMaxMinage(s,i);
                break;
            case 3:
                System.out.println("输入你的年龄：
");
                findNearAge(s,i,k.nextInt());
                break;
            case 4:
                System.out.println("输入你的出生地：
");
                String find = k.next();
                String place = find.substring(0, 3);
                for (int j = 0; j < i; j++) {             
                    if (s[j].getBrithplace().substring(1,4).equals(place))
                        System.out.println("同乡
"+s[j].ToString());
                }
                break;
            case 5:
                e = 0;
                break;
            default:
                System.out.println("请输入正确的数字！");
                break;
            }
        };
        k.close();
    }
    //排序并输出
    private static void selectionSortandPrint(stu[] s, int n){
        String a = new String();
        String b = new String();
           for (int i = 0; i < n - 1; i++) {    
                int  min = i;
                for (int j = i + 1; j < n; j++) {
                    a=s[min].getName();
                    b=s[j].getName();
                      if (a.compareTo(b)==1) 
                      {
                           min = j;
                      }
                }
                if (min != i) {
                   stu tmp = s[min];
                  s[min] = s[i];
                   s[i] = tmp;
                }             
          }
           for(int i=0;i<n;i++)
            {
               System.out.print(s[i].ToString());
            }
    }
    //寻找年龄最接近的人
    private static void findNearAge(stu[] s, int i, int n) {
        int near=0,j;
        for(j=1;j<i;j++)
        {
            if(Math.abs(s[near].getAge()-n)>Math.abs(s[j].getAge()-n))
                { 
                near=j;
                }
        }
        System.out.println("年龄最接近的人的信息：
"+s[near].ToString());
    }
    //找最大年龄和最小年龄
    private static int findMaxMinage(stu[] s, int i)
    {
        int n;
        int max=0,min=0;
        for(n=0;n<i;n++)
        {
            if(s[max].getAge()<s[n].getAge())
                { 
                max=n;
                }
            if(s[min].getAge()>s[n].getAge())
                { 
                min=n;
                }
        }
        System.out.println("年龄最大的人的信息：
"+s[max].ToString());
        System.out.println("年龄最小的人的信息：
"+s[min].ToString());
        return 0;
    }
}

class stu
{
    private String name;
    private String ID;
    private String sex;
    private int age;
    private String brithplace;

    public void setID(String id){
        ID = id;
    }
    public void setName(String n) {
        name = n;
    }
    public String getID() {
        return ID;
    }
    public String getName() {
        return name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getBrithplace() {
        return brithplace;
    }
    public void setBrithplace(String brithplace) {
        this.brithplace = brithplace;
    }
    public String ToString()
    {
        return name + "	" + sex + "	" + age + "	" + ID + "	" + brithplace + "
";
    }
}

结果：

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

实验程序1：

结果：

 

实验程序2：

结果：

实验程序3：

结果：

 

实验总结：

通过这周的实验学习，掌握了接口的定义方法及使用方法；理解了程序回调设计模式的好处；掌握对象浅层拷贝与深层拷贝方法；了解了Lambda表达式的语法与使用它的好处；了解内部类的用途及语法要求。