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 //定义实现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：

 

 1 public class CloneTest
 2 {
 3    public static void main(String[] args) throws CloneNotSupportedException
 4    {
 5       var original = new Employee("John Q. Public", 50000);
 6       original.setHireDay(2000, 1, 1);
 7       Employee copy = original.clone();
 8       copy.raiseSalary(10);
 9       copy.setHireDay(2002, 12, 31);
10       System.out.println("original=" + original);
11       System.out.println("copy=" + copy);
12    }
13 }
14 
15 
16  
17 import java.util.Date;
18 import java.util.GregorianCalendar;
19  
20 public class Employee implements Cloneable
21 {
22    private String name;
23    private double salary;
24    private Date hireDay;
25  
26    public Employee(String name, double salary)
27    {
28       this.name = name;
29       this.salary = salary;
30       hireDay = new Date();
31    }
32    //创建深拷贝的clone方法
33    public Employee clone() throws CloneNotSupportedException  
34    {
35       // call Object.clone() 调用Object类的clone方法 浅拷贝
36       Employee cloned = (Employee) super.clone();
37  
38       // clone mutable fields   克隆易变字段
39       cloned.hireDay = (Date) hireDay.clone();
40  
41       return cloned;
42    }
43  
44 
45    public void setHireDay(int year, int month, int day)
46    {
47       Date newHireDay = new GregorianCalendar(year, month - 1, day).getTime();
48        
49       // example of instance field mutation
50       hireDay.setTime(newHireDay.getTime());
51    }
52  
53    public void raiseSalary(double byPercent)
54    {
55       double raise = salary * byPercent / 100;
56       salary += raise;
57    }
58  
59    public String toString()
60    {
61       return "Employee[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]";
62    }
63 }

 

结果；

实验2：

 

 1 import java.util.*;
 2  
 3 import javax.swing.*;
 4 import javax.swing.Timer;
 5  
 6 
 7 public class LambdaTest
 8 {
 9    public static void main(String[] args)
10    {
11       var planets = new String[] { "Mercury", "Venus", "Earth", "Mars", 
12          "Jupiter", "Saturn", "Uranus", "Neptune" };
13       System.out.println(Arrays.toString(planets));
14       System.out.println("Sorted in dictionary order:");
15       Arrays.sort(planets);        //调用Arrays类的sort方法
16       System.out.println(Arrays.toString(planets));
17       System.out.println("Sorted by length:");
18       Arrays.sort(planets, (first, second) -> first.length() - second.length());  //lambda表达式
19       System.out.println(Arrays.toString(planets));
20              
21       var timer = new Timer(1000, event ->
22          System.out.println("The time is " + new Date()));
23       timer.start();   
24           
25       // keep program running until user selects "OK"
26       JOptionPane.showMessageDialog(null, "Quit program?");   //弹出窗口信息
27       System.exit(0);         
28    }
29 }    

 

结果；

lambda表达式十分简洁

实验3:编程练习：

 

  1 import java.io.File;
  2 import java.io.FileNotFoundException;
  3 import java.util.Scanner;
  4 
  5 public class student {
  6 
  7     public static void main(String[] args) throws FileNotFoundException {
  8         Scanner in = new Scanner(new File("E:\\CSDN\\身份证号.txt"));
  9         stu s[] = new stu[100];
 10         int i = 0;
 11         
 12         //数据录入
 13         while(in.hasNextLine())
 14         {
 15             s[i] = new stu();
 16             s[i].setName(in.next());
 17             s[i].setID(in.next());
 18             s[i].setSex(in.next());
 19             s[i].setAge(in.nextInt());
 20             s[i].setBrithplace(in.nextLine());
 21             
 22             i++;
 23         }
 24         in.close();
 25         int n;        
 26         int e = 1;
 27         Scanner k = new Scanner(System.in);
 28         while(e==1)
 29         {
 30             System.out.println("选择操作：\n按1按姓名字典序输出人员信息\n按2查询最大年龄和最小年龄的人员信息\n按3输入你的年龄，查询年龄与你最近人的信息\n按4查询人员中是否有你的同乡\n按5退出");
 31             n = k.nextInt();
 32             switch(n)
 33             {
 34             case 1:
 35                 selectionSortandPrint(s,i);
 36                 break;
 37             case 2:
 38                 findMaxMinage(s,i);
 39                 break;
 40             case 3:
 41                 System.out.println("输入你的年龄：\n");
 42                 findNearAge(s,i,k.nextInt());
 43                 break;
 44             case 4:
 45                 System.out.println("输入你的出生地：\n");
 46                 String find = k.next();
 47                 String place = find.substring(0, 3);
 48                 for (int j = 0; j < i; j++) {             
 49                     if (s[j].getBrithplace().substring(1,4).equals(place))
 50                         System.out.println("同乡\n"+s[j].ToString());
 51                 }
 52                 break;
 53             case 5:
 54                 e = 0;
 55                 break;
 56             default:
 57                 System.out.println("请输入正确的数字！");
 58                 break;
 59             }
 60         };
 61         k.close();
 62     }
 63     //排序并输出
 64     public static void selectionSortandPrint(stu[] s, int n){
 65         String a = new String();
 66         String b = new String();
 67            for (int i = 0; i < n - 1; i++) {    
 68                 int  min = i;
 69                 for (int j = i + 1; j < n; j++) {
 70                     a=s[min].getName();
 71                     b=s[j].getName();
 72                       if (a.compareTo(b)==1) 
 73                       {
 74                            min = j;
 75                       }
 76                 }
 77                 if (min != i) {
 78                    stu tmp = s[min];
 79                   s[min] = s[i];
 80                    s[i] = tmp;
 81                 }             
 82           }
 83            for(int i=0;i)
 84             {
 85                System.out.print(s[i].ToString());
 86             }
 87     }
 88     //寻找年龄最接近的人
 89     private static void findNearAge(stu[] s, int i, int n) {
 90         int near=0,j;
 91         for(j=1;j)
 92         {
 93             if(Math.abs(s[near].getAge()-n)>Math.abs(s[j].getAge()-n))
 94                 { 
 95                 near=j;
 96                 }
 97         }
 98         System.out.println("年龄最接近的人的信息：\n"+s[near].ToString());
 99     }
100     //找最大年龄和最小年龄
101     public static int findMaxMinage(stu[] s, int i)
102     {
103         int n;
104         int max=0,min=0;
105         for(n=0;n)
106         {
107             if(s[max].getAge()<s[n].getAge())
108                 { 
109                 max=n;
110                 }
111             if(s[min].getAge()>s[n].getAge())
112                 { 
113                 min=n;
114                 }
115         }
116         System.out.println("年龄最大的人的信息：\n"+s[max].ToString());
117         System.out.println("年龄最小的人的信息：\n"+s[min].ToString());
118         return 0;
119     }
120 }
121 
122 class stu
123 {
124     private String name;
125     private String ID;
126     private String sex;
127     private int age;
128     private String brithplace;
129 
130     public void setID(String id){
131         ID = id;
132     }
133     public void setName(String n) {
134         name = n;
135     }
136     public String getID() {
137         return ID;
138     }
139     public String getName() {
140         return name;
141     }
142     public String getSex() {
143         return sex;
144     }
145     public void setSex(String sex) {
146         this.sex = sex;
147     }
148     public int getAge() {
149         return age;
150     }
151     public void setAge(int age) {
152         this.age = age;
153     }
154     public String getBrithplace() {
155         return brithplace;
156     }
157     public void setBrithplace(String brithplace) {
158         this.brithplace = brithplace;
159     }
160     public String ToString()
161     {
162         return name + "\t" + sex + "\t" + age + "\t" + ID + "\t" + brithplace + "\n";
163     }
164 }

 

结果：

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

实验程序1：

结果：

 

实验程序2：

结果：

实验程序3：

结果：

 

实验总结：

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