学号:201771010138
姓名:邹丰蔚
《面向对象程序设计(java)》第八周学习总结
1、实验目的与要求
(1) 掌握接口定义方法;
(2) 掌握实现接口类的定义要求;
(3) 掌握实现了接口类的使用要求;
(4) 掌握程序回调设计模式;
(5) 掌握Comparator接口用法;
(6) 掌握对象浅层拷贝与深层拷贝方法;
(7) 掌握Lambda表达式语法;
(8) 了解内部类的用途及语法要求。
一、理论学习
6.1 接口:用interface声明,是抽象方法和常量值定义的集 合。从本质上讲,接口是一种特殊的抽象类。
(1)在Java程序设计语言中,接口不是类,而是对类 的一组需求描述,由常量和一组抽象方法组成。 接口中不包括变量和有具体实现的方法。
(2)接口体中包含常量定义和方法定义,接口中只进 行方法的声明,不提供方法的实现。
(3)通常接口的名字以able或ible结尾;
(4)接口中的所有常量必须是public static final,方法必须是public abstract,这是 系统默认的,不管你在定义接口时,写不写 修饰符都是一样的.
(5)接口的实现:一个类使用了某个接口,那么这个类必须实现该 接口的所有方法,即为这些方法提供方法体。一个类可以实现多个接口,接口间应该用逗号分 隔开。
(6)接口的使用:接口不能构造接口对象,但可以声明接口变量以指向一个实现了该接口的类对象。
(7)可以用instanceof检查对象是否实现了某个接口。
(8)抽象类:用abstract来声明,没有具体实例对象的类,不 能用new来创建对象。
6.2 接口示例
(1)回调(callback):一种程序设计模式,在这种模 式中,可指出某个特定事件发生时程序应该采取 的动作。
(2)Comparator接口所在包: java.util.*
(3)Object类的Clone方法:当拷贝一个对象变量时,原始变量与拷贝变量 引用同一个对象。这样,改变一个变量所引用 的对象会对另一个变量产生影响。
(4)如果要创建一个对象新的copy,它的最初状态与 original一样,但以后可以各自改变状态,就需 要使用Object类的clone方法。
(5)Object.clone()方法返回一个Object对象。必须进行强 制类型转换才能得到需要的类型。
(6)浅层拷贝与深层拷贝
(7)Java中对象克隆的实现:在子类中实现Cloneable接口。
(8)在子类的clone方法中,调用super.clone()。
6.3 lambda表达式
(1)Java Lambda 表达式是 Java 8 引入的一个新的功能,主 要用途是提供一个函数化的语法来简化编码。
(2)Lambda 表达式的语法基本结构 (arguments) -> body
(3)有如下几种情况: 1、参数类型可推导时,不需要指定类型,如 (a) -> System.out.println(a)
2、 只有一个参数且类型可推导时,不强制写 (), 如 a -> System.out.println(a)
3、 参数指定类型时,必须有括号,如 (int a) -> System.out.println(a)
4、参数可以为空,如 () -> System.out.println(“hello”)
5、 body 需要用 {} 包含语句,当只有一条语句时 {} 可省略
6.4 内部类:是定义在一个类内部的类。
(1)使用内部类的原因有以下三个: –内部类方法可以访问该类定义所在的作用域中 的数据,包括私有数据。
–内部类能够隐藏起来,不为同一包中的其他类 所见。
–想要定义一个回调函数且不想编写大量代码时, 使用匿名内部类比较便捷。
(2)内部类可以直接访问外部类的成员,包括 private成员,但是内部类的成员却不能被外部 类直接访问。
(3)内部类并非只能在类内定义,也可以在程序块内 定义局部内部类。
(4)如果构造参数的闭圆括号跟一个开花括号,表明正 在定义的就是匿名内部类。
6.5 代理(Proxy)
2、实验内容和步骤
实验1: 导入第6章示例程序,测试程序并进行代码注释。
测试程序1:
l 编辑、编译、调试运行阅读教材214页-215页程序6-1、6-2,理解程序并分析程序运行结果;
l 在程序中相关代码处添加新知识的注释。
l 掌握接口的实现用法;
掌握内置接口Compareable的用法。
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) { 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);//静态方法sort // 输出所有关于Employee对象的信息 for (Employee e : staff) System.out.println("name=" + e.getName() + ",salary=" + e.getSalary()); } }
package interfaces;
public class Employee implements Comparable<Employee>//Employee实现JDK内置接口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) { return Double.compare(salary, other.salary);//静态Double.compare方法 } }
实验结果:
测试程序2:
l 编辑、编译、调试以下程序,结合程序运行结果理解程序;
interface 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);
}
实验结果:
测试程序3:
l 在elipse IDE中调试运行教材223页6-3,结合程序运行结果理解程序;
l 26行、36行代码参阅224页,详细内容涉及教材12章。
l 在程序中相关代码处添加新知识的注释。
4)掌握回调程序设计模式
package timer;
/**
@version 1.01 2015-05-12
@author Cay Horstmann */ import java.awt.*; import java.awt.event.*; import java.util.*; import javax.swing.*; import javax.swing.Timer; // to resolve conflict with java.util.Timer public class TimerTest { public static void main(String[] args) { ActionListener listener = new TimePrinter(); //实现了ActionListener的类对象 // 构造一个timer对象存放在变量里,叫做listener // 每次间隔10秒
Timer t = new Timer(10000, listener);//定义间隔 t.start(); 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:
l 调试运行教材229页-231页程序6-4、6-5,结合程序运行结果理解程序;
l 在程序中相关代码处添加新知识的注释。
l 掌握对象克隆实现技术;
l 掌握浅拷贝和深拷贝的差别。
package clone;
/**
* This program demonstrates cloning.
* @version 1.10 2002-07-01 * @author Cay Horstmann */ public class CloneTest { public static void main(String[] args) { try //放入try中,配合后面的语句捕获异常 { Employee 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); } catch (CloneNotSupportedException e) //捕获异常 { e.printStackTrace(); } } }
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(); } public Employee clone() throws CloneNotSupportedException { // call Object.clone() Employee cloned = (Employee) super.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() { return "Employee[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]"; } }
实验结果:
实验2: 导入第6章示例程序6-6,学习Lambda表达式用法。
l 调试运行教材233页-234页程序6-6,结合程序运行结果理解程序;
l 在程序中相关代码处添加新知识的注释。
将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) { String[] planets = new String[] { "Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune" };//定义数组planets System.out.println(Arrays.toString(planets));//静态方法 System.out.println("Sorted in dictionary order:"); Arrays.sort(planets);//Arrays.sort方法接收实验Lambda类的对象 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)); Timer t = new Timer(1000, event -> System.out.println("The time is " + new Date()));//Lambda表达式 t.start(); // keep program running until user selects "Ok" JOptionPane.showMessageDialog(null, "Quit program?"); System.exit(0); //返回类型 } }
package clone;
import java.util.Date;
import java.util.GregorianCalendar; public class Employee implements Cloneable { //定义三个私有属性 private String name;//string类在lang包 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 { // call Object.clone() Employee cloned = (Employee) super.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() { return "Employee[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]"; } }
实验结果:
实验3: 编程练习
l 编制一个程序,将身份证号.txt 中的信息读入到内存中;
l 按姓名字典序输出人员信息;
l 查询最大年龄的人员信息;
l 查询最小年龄人员信息;
l 输入你的年龄,查询身份证号.txt中年龄与你最近人的姓名、身份证号、年龄、性别和出生地;
|查询人员中是否有你的同乡
Main:
package 身份证;
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.List;
import java.util.Scanner;
public class Main{
private static ArrayList<student> studentlist;
public static void main(String[] args) {
studentlist = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
File file = new File("C:\\身份证号.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 year = linescanner.next();
String province =linescanner.nextLine();
student student = student();
student.setname(name);
student.setnumber(number);
student.setsex(sex);
int a = Integer.parseInt(year);
student.setyear(year);
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("1.按姓名字典序输出人员信息:");
System.out.println("2.查询最大年龄的人员信息:");
System.out.println("3.查询最小年龄人员信息:");
System.out.println("4.输入你的年龄,查询身份证号.txt中年龄与你最近人的信息:");
System.out.println("5.查询人员中是否有你的同乡:");
int nextInt = scanner.nextInt();
switch (nextInt) {
case 1:
Collections.sort( studentlist);
System.out.println( studentlist.toString());
break;
case 2:
int MAX=0,MIN=100;int j,k1 = 0,k2=0;
for(int i=1;i< studentlist.size();i++)
{
j= studentlist.get(i).getyear();
if(j>MAX)
{
MAX=j;
k1=i;
}
System.out.println("年龄最大:"+ studentlist.get(k1));
}
break;
case 3:
int max=0,min=100;int L,m1 = 0,m2=0;
for(int i=1;i< studentlist.size();i++)
{
L= studentlist.get(i).getyear();
if(L>max)
{
max=L;
m1=i;
}
if(L<min)
{
min=L;
m2=i;
}
}
System.out.println("年龄最小:"+ studentlist.get(m2));
break;
case 4:
System.out.println("province?");
String find = scanner.next();
String province=find.substring(0,3);
String province2=find.substring(0,3);
for (int i = 0; i < studentlist.size(); i++)
{
if( studentlist.get(i).getprovince().substring(1,4).equals(province))
System.out.println(studentlist.get(i));
}
break;
case 5:
System.out.println("年龄:");
int yourage = scanner.nextInt();
int near=yearnear(yourage);
int d_value=yourage-studentlist.get(near).getyear();
System.out.println(""+studentlist.get(near));
/* for (int i = 0; i < Peoplelist.size(); i++)
{
int p=Personlist.get(i).getage()-yourage;
if(p<0) p=-p;
if(p==d_value) System.out.println(Peoplelist.get(i));
} */
break;
case 6:
isTrue = false;
System.out.println("退出程序!");
break;
default:
System.out.println("输入有误");
}
}
}
private static student student() {
// TODO Auto-generated method stub
return null;
}
public static int yearnear(int year) {
int min=25,d_value=0,k=0;
for (int i = 0; i < studentlist.size(); i++)
{
d_value= studentlist.get(i).getyear()-year;
if(d_value<0) d_value=-d_value;
if (d_value<min)
{
min=d_value;
k=i;
}
} return k;
}
}
student:
package 身份证;
public abstract class student implements Comparable<student> {
private String name;
private String number ;
private String sex ;
private String year;
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 String getyaer()
{
return year;
}
public void setyear(String year )
{
this.year=year ;
}
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"+year+"\t"+number+"\t"+province+"\n";
}
public int getyear()
{
// TODO Auto-generated method stub
return 0;
}
public void setname(String name2)
{
// TODO Auto-generated method stub
}
}
实验结果:
实验4:内部类语法验证实验
实验程序1:
l 编辑、调试运行教材246页-247页程序6-7,结合程序运行结果理解程序;
l 了解内部类的基本用法。
package innerClass;
import java.awt.*;
import java.awt.event.*; import java.util.*; import javax.swing.*; import javax.swing.Timer; /** * This program demonstrates the use of inner classes. * @version 1.11 2015-05-12 * @author Cay Horstmann */ public class InnerClassTest { public static void main(String[] args) { TalkingClock clock = new TalkingClock(1000, true);//实现了TalkingClock的类对象 clock.start(); // keep program running until 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() { ActionListener listener = new TimePrinter(); Timer t = new Timer(interval, listener); t.start(); } public class TimePrinter implements ActionListener//实现ActionListener的公共类TimePrinter { public void actionPerformed(ActionEvent event) { System.out.println("At the tone, the time is " + new Date()); if (beep) Toolkit.getDefaultToolkit().beep(); } } }
实验结果:
实验程序2:
l 编辑、调试运行教材254页程序6-8,结合程序运行结果理解程序;
了解匿名内部类的用法。
package anonymousInnerClass;
import java.awt.*;
import java.awt.event.*; import java.util.*; import javax.swing.*; import javax.swing.Timer; /** * This program demonstrates anonymous inner classes. * @version 1.11 2015-05-12 * @author Cay Horstmann */ public class AnonymousInnerClassTest { public static void main(String[] args) { TalkingClock clock = new TalkingClock();//TalkingClock类声明为私有的 clock.start(1000, true); // keep program running until 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) { ActionListener listener = new ActionListener() { public void actionPerformed(ActionEvent event) { System.out.println("At the tone, the time is " + new Date()); if (beep) Toolkit.getDefaultToolkit().beep(); //外围类引用. } }; Timer t = new Timer(interval, listener); t.start(); } }
实验结果:
实验程序3:
l 在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) { double[] d = new double[20]; for (int i = 0; i < d.length; i++) d[i] = 100 * Math.random();//算法 ArrayAlg.Pair p = ArrayAlg.minmax(d); 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); } }
实验结果:
总结:本章我们学习了接口定义方法,了解和熟悉了接口的使用方法,Lambda表达式语法,Comparator接口用法,还能够区分浅拷贝和深拷贝的异同之处,最后基本了解了内部类的定义和使用。这周也主要是以案例练习为主。但在这些知识上仍然还有很多不太理解的地方,还需要在之后的学习中慢慢融会贯通。比如只会用接口编写一些简单的程序。这周的学习也让我感觉到了学习java的难度,在之后的学习中我会更加认真努力的学习。