201771010118马昕璐《面向对象程序设计java》第八周学习总结
第一部分：理论知识学习部分
1.接口
在Java程序设计语言中，接口不是类，而是对类的一组需求描述，由常量和一组抽象方法组成。Java为了克服单继承的缺点，Java使用了接口，一个类可以实现一个或多个接口
声明方式：
public interface 接口名
{ …… }
接口体中包含常量定义和方法定义，接口中只进行方法的声明，不提供方法的实现。
接口中不包括变量和有具体实现的方法。
只要类实现了接口，则该类要遵从接口描述的统一格式进行定义，并且可以在任何需要该接口的地方使用这个类的对象。
类似建立类的继承关系，接口也可以扩展。
扩展方法：
public interface 接口1 extends 接口2
{ …… }；
接口中的所有常量必须是public static final，方法必须是public abstract，这是 系统默认的 在类声明时用implements关键字声明使用一个或多个接口
class Employee implements Printable
{ …}
接口不能构造接口对象，但可以声明接口变量以指向一个实现了该接口的类对象
2. 接口与回调
回调(callback)：一种程序设计模式，在这种模式中，可指出某个特定事件发生时程序应该采取的动作
在java.swing包中有一个Timer类，可以使用它在到达给定的时间间隔时触发一个事件。
– Timer(int interval, ActionListener listener)
– void start()
– void s
3. Comparator接口
所在包： java.util.*
Comparator接口定义
Public interface Comparator<T>{
Int compare(T o1,To2);
}
用途：处理字符串按长度进行排序的操作
4. 对象克隆
当拷贝一个对象变量时，原始变量与拷贝变量引用同一个对象。这样，改变一个变量所引用的对象会对另一个变量产生影响。
如果要创建一个对象新的copy，它的最初状态与original一样，但以后可以各自改变状态，就需要使用Object类的clone方法
Employee copy = original.clone();
浅层拷贝：被拷贝对象的所有常量成员和基本类型属性都有与原来对象相同的拷贝值，而若成员域是一个对象，则被拷贝对象该对象域的对象域用仍然指向有原来的对象。
深层拷贝：被拷贝对象的所有成员域都含有与原来对象相同的值,且对象域将指向被复制过的新象，而不是原有对象被引用的对象。换言之，深层拷贝将拷贝对象内引用的对象也拷贝一遍。
Lambda的主要用途是提供一个函数化的语法来简化编码。
Lambda 表达式的语法基本结构
(arguments) -> body
有如下几种情况：
参数类型可推导时，不需要指定类型，如(a) -> System.out.println(a)
只有一个参数且类型可推导时，不强制写 (), 如a -> System.out.println(a)
参数指定类型时，必须有括号，如 (int a) -> System.out.println(a)
参数可以为空，如 () -> System.out.println(“hello”)
body 需要用 {} 包含语句，当只有一条语句时 {} 可省略
内部类(inner class)是定义在一个类内部的类
内部类方法可以访问外围类的数据，包括私有的数据.
内部类可以对同一个包种的其他类隐藏起来.
使用anonymous内部类定义回调函数类.
第二部分：实验学习部分
1、实验目的与要求
(1) 掌握接口定义方法；
(2) 掌握实现接口类的定义要求；
(3) 掌握实现了接口类的使用要求；
(4) 掌握程序回调设计模式；
(5) 掌握Comparator接口用法；
(6) 掌握对象浅层拷贝与深层拷贝方法；
(7) 掌握Lambda表达式语法；
(8) 了解内部类的用途及语法要求。
2、实验内容和步骤
实验1： 导入第6章示例程序，测试程序并进行代码注释。
测试程序1：
l 编辑、编译、调试运行阅读教材214页-215页程序6-1、6-2，理解程序并分析程序运行结果；
l 在程序中相关代码处添加新知识的注释。
l 掌握接口的实现用法；
l 掌握内置接口Compareable的用法。
package interfaces;
public class Employee implements Comparable<Employee>
{
//声明属性；
private String name;
private double salary;
//构造方法；
public Employee(String name, double salary)
{
this.name = name;
this.salary = salary;
}
//Name属性访问器；
public String getName()
{
return name;
}
//Salary属性访问器；
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);//包装器 调用compare方法；
}
}
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);//静态方法
// print out information about all Employee objects
for (Employee e : staff)
System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
}
}
程序测试结果：
测试程序2：
l 编辑、编译、调试以下程序，结合程序运行结果理解程序；
|
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); } } |
interface A//定义一个接口，接口名为A
{
double g=9.8;//定义一个g=9.8
void show( );//调用一个void方法，但这个方法为空
}
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：
l 在elipse IDE中调试运行教材223页6-3，结合程序运行结果理解程序；
l 26行、36行代码参阅224页，详细内容涉及教材12章。
l 在程序中相关代码处添加新知识的注释。
l 掌握回调程序设计模式；
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;
// 解决与java.util.Timer的矛盾
public class TimerTest
{
public static void main(String[] args)
{
ActionListener listener = new TimePrinter();
//构造一个调用侦听器的计时器；
//每十秒一次；
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 掌握对象克隆实现技术；
掌握浅拷贝和深拷贝的差别。
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
{
Employee cloned = (Employee) super.clone();//返回Object对象后强制类型转换；
// 克隆可变部分；
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 + "]";
}
}
程序测试结果：
实验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类数组；
String[] 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);
System.out.println(Arrays.toString(planets));//按字母顺序排序输出；
System.out.println("Sorted by length:");
//按单词长度排序后，使用lambda表达式；
Arrays.sort(planets, (first, second) -> first.length() - second.length());
System.out.println(Arrays.toString(planets));//
//方法引用；lambda表达式；
Timer t = new Timer(1000, event ->
System.out.println("The time is " + new Date()));//每隔一秒输出当前时间；
t.start();
// 继续运行程序，知道用户选择OK；
JOptionPane.showMessageDialog(null, "Quit program?");
System.exit(0);
}
}
程序测试结果：
实验3: 编程练习
l 编制一个程序，将身份证号.txt 中的信息读入到内存中；
l 按姓名字典序输出人员信息；
l 查询最大年龄的人员信息；
l 查询最小年龄人员信息；
l 输入你的年龄，查询身份证号.txt中年龄与你最近人的姓名、身份证号、年龄、性别和出生地；
查询人员中是否有你的同乡。
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.Scanner;
public class Search{
private static ArrayList<Person> Personlist1;
public static void main(String[] args) {
Personlist1 = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
File file = new File("E:\\面向对象程序设计Java\\实验\\实验六\\身份证号.txt");
try {
FileInputStream F = new FileInputStream(file);
BufferedReader in = new BufferedReader(new InputStreamReader(F));
String temp = null;
while ((temp = in.readLine()) != null) {
Scanner linescanner = new Scanner(temp);
linescanner.useDelimiter(" ");
String name = linescanner.next();
String id = linescanner.next();
String sex = linescanner.next();
String age = linescanner.next();
String place =linescanner.nextLine();
Person Person = new Person();
Person.setname(name);
Person.setid(id);
Person.setsex(sex);
int a = Integer.parseInt(age);
Person.setage(a);
Person.setbirthplace(place);
Personlist1.add(Person);
}
} catch (FileNotFoundException e) {
System.out.println("查找不到信息");
e.printStackTrace();
} catch (IOException e) {
System.out.println("信息读取有误");
e.printStackTrace();
}
boolean isTrue = true;
while (isTrue) {
System.out.println("******************************************");
System.out.println("1:按姓名字典顺序输出信息；");
System.out.println("2:查询最大年龄与最小年龄人员信息；");
System.out.println("3：按省份找你的同乡；");
System.out.println("4:输入你的年龄,查询年龄与你最近人的信息；");
System.out.println("5：退出");
System.out.println("******************************************");
int type = scanner.nextInt();
switch (type) {
case 1:
Collections.sort(Personlist1);
System.out.println(Personlist1.toString());
break;
case 2:
int max=0,min=100;int j,k1 = 0,k2=0;
for(int i=1;i<Personlist1.size();i++)
{
j=Personlist1.get(i).getage();
if(j>max)
{
max=j;
k1=i;
}
if(j<min)
{
min=j;
k2=i;
}
}
System.out.println("年龄最大："+Personlist1.get(k1));
System.out.println("年龄最小："+Personlist1.get(k2));
break;
case 3:
System.out.println("place?");
String find = scanner.next();
String place=find.substring(0,3);
String place2=find.substring(0,3);
for (int i = 0; i <Personlist1.size(); i++)
{
if(Personlist1.get(i).getbirthplace().substring(1,4).equals(place))
{
System.out.println("你的同乡："+Personlist1.get(i));
}
}
break;
case 4:
System.out.println("年龄：");
int yourage = scanner.nextInt();
int close=ageclose(yourage);
int d_value=yourage-Personlist1.get(close).getage();
System.out.println(""+Personlist1.get(close));
break;
case 5:
isTrue = false;
System.out.println("再见!");
break;
default:
System.out.println("输入有误");
}
}
}
public static int ageclose(int age) {
int m=0;
int max=53;
int d_value=0;
int k=0;
for (int i = 0; i < Personlist1.size(); i++)
{
d_value=Personlist1.get(i).getage()-age;
if(d_value<0) d_value=-d_value;
if (d_value<max)
{
max=d_value;
k=i;
}
} return k;
}
}
//jiekouwenjiaan
public class Person implements Comparable<Person> {
private String name;
private String id;
private int age;
private String sex;
private String birthplace;
public String getname() {
return name;
}
public void setname(String name) {
this.name = name;
}
public String getid() {
return id;
}
public void setid(String id) {
this.id= id;
}
public int getage() {
return age;
}
public void setage(int age) {
// int a = Integer.parseInt(age);
this.age= age;
}
public String getsex() {
return sex;
}
public void setsex(String sex) {
this.sex= sex;
}
public String getbirthplace() {
return birthplace;
}
public void setbirthplace(String birthplace) {
this.birthplace= birthplace;
}
public int compareTo(Person o) {
return this.name.compareTo(o.getname());
}
public String toString() {
return name+"\t"+sex+"\t"+age+"\t"+id+"\t";
}
}
程序测试结果：
实验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);
clock.start();
// 保持程序运行知道用户选择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
{
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，结合程序运行结果理解程序；
l 了解匿名内部类的用法。
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();
clock.start(1000, true);
// 保持程序运行知道用户选择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，结合程序运行结果理解程序；
l 了解静态内部类的用法。
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表达式的学习。但在接口方面我深刻感受到了自己的不足，也有很多跟不上的地方，需要再多研究一二。
201771010118马昕璐《面向对象程序设计java》第八周学习总结的更多相关文章
- 201871010115——马北《面向对象程序设计JAVA》第二周学习总结
项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p ...
- 201771010134杨其菊《面向对象程序设计java》第九周学习总结
第九周学习总结 第一部分:理论知识 异常.断言和调试.日志 1.捕获 ...
- 201871010132-张潇潇《面向对象程序设计(java)》第一周学习总结
面向对象程序设计(Java) 博文正文开头 项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cn ...
- 扎西平措 201571030332《面向对象程序设计 Java 》第一周学习总结
<面向对象程序设计(java)>第一周学习总结 正文开头: 项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 ...
- 杨其菊201771010134《面向对象程序设计Java》第二周学习总结
第三章 Java基本程序设计结构 第一部分:(理论知识部分) 本章主要学习:基本内容:数据类型:变量:运算符:类型转换,字符串,输入输出,控制流程,大数值以及数组. 1.基本概念: 1)标识符:由字母 ...
- 201871010124 王生涛《面向对象程序设计JAVA》第一周学习总结
项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://edu.cnblogs.com/campus/xbsf/ ...
- 201777010217-金云馨《面向对象程序设计(Java)》第二周学习总结
项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p ...
- 201871010132——张潇潇《面向对象程序设计JAVA》第二周学习总结
项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p ...
- 201771010123汪慧和《面向对象程序设计Java》第二周学习总结
一.理论知识部分 1.标识符由字母.下划线.美元符号和数字组成, 且第一个符号不能为数字.标识符可用作: 类名.变量名.方法名.数组名.文件名等.第二部分:理论知识学习部分 2.关键字就是Java语言 ...
- 20155321 2016-2017-2 《Java程序设计》第八周学习总结
20155321 2016-2017-2 <Java程序设计>第八周学习总结 教材学习内容总结 创建Logger对象 static Logger getLogger(String name ...
随机推荐
- Decision tree(决策树)算法初探
0. 算法概述 决策树(decision tree)是一种基本的分类与回归方法.决策树模型呈树形结构(二分类思想的算法模型往往都是树形结构) 0x1:决策树模型的不同角度理解 在分类问题中,表示基于特 ...
- Kubernetes之RBAC
API Server的授权管理 API Server 内部通过用户认证后,然后进入授权流程.对合法用户进行授权并且随后在用户访问时进行鉴权,是权限管理的重要环节.API Server 目前支持一下几种 ...
- 面试：atoi() 与 itoa()函数的内部实现（转）
原 面试:atoi() 与 itoa()函数的内部实现 2013年04月19日 12:05:56 王世晖 阅读数:918 #include <stdio.h> #include < ...
- windows下使用curl命令 && 常用curl命令
什么是curl命令? curl是利用URL语法在命令行方式下工作的开源文件传输工具.它被广泛应用在Unix.多种Linux发行版中,并且有DOS和Win32.Win64下的移植版本. 如何在windo ...
- [再寄小读者之数学篇](2014-06-22 求极限 [中国科学技术大学2011年高等数学B考研试题])
设数列 $\sed{x_n}$ 满足 $0<x_1<\pi$, $x_{n+1}=\sin x_n\ (n=1,2,\cdots)$. (1) 证明 $\dps{\vlm{n}x_n}$ ...
- 学习python笔记 协程
下面将一个经典的消费者和生产者的案例进行分析: import time def consumer(): r = '' while True: n = yield r if not n: return ...
- RabbitMQ环境搭建
消息 RabbitMQ 1.安装erlang环境 2.安装rabbitmq 3.参考资料 AMQP协议,可以跨语言通信 Advance Message Queuing Protocol Rabbit ...
- 在visual studio 2013中编译Lua5.3.1
注:以下是基于 别人的教程或笔记来操作并按照自己的操作记录的纯文字版编译和hello lua过程. 原图文版链接: 原文链接 1.创建空的解决方案: 文件->新建->项目->其他项目 ...
- activiti的springboot模块
目标: springboot 下 使用activiti,搭建微服务,并且使用自己的用户与组 版本 activiti version 5.22.0spring boot version 1.5.1 主要 ...
- iOS 新建xib文件时，最外层view的约束问题
今天用在利用xib实例化view 时, 生成的view的自动布局总是用问题.具体来说,宽和高都不能和父view正确变化.仔细检查,发现下图: 注意这里右上角的Autoresizing部分,并没有设置正 ...