| 项目 |
内容 |
| 这个作业属于哪个课程 |
https://www.cnblogs.com/nwnu-daizh/ |
| 这个作业的要求在哪里 |
https://www.cnblogs.com/nwnu-daizh/p/11703678.html |
| 作业学习目标 |
|
第一部分：总结第六章理论知识
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：
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 private 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<n;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<i;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 private static int findMaxMinage(stu[] s, int i)
102 {
103 int n;
104 int max=0,min=0;
105 for(n=0;n<i;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表达式的语法与使用它的好处；了解内部类的用途及语法要求。
来源：oschina
链接：https://my.oschina.net/u/4339309/blog/4173205