杨玲 201771010133《面向对象程序设计(java)》第八周学习总结

Posted yanglinga

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了杨玲 201771010133《面向对象程序设计(java)》第八周学习总结相关的知识,希望对你有一定的参考价值。

《面向对象程序设计(java)》第八周学习总结

第一部分:理论知识学习部分

1. 接口:用interface声明,是抽象方法和常量值定义的集 合。从本质上讲,接口是一种特殊的抽象类。

(1)在Java程序设计语言中,接口不是类,而是对类 的一组需求描述,由常量和一组抽象方法组成。 ? 接口中不包括变量和有具体实现的方法。

(2)接口体中包含常量定义和方法定义,接口中只进 行方法的声明,不提供方法的实现。

(3)通常接口的名字以able或ible结尾;

(4)接口中的所有常量必须是public static final,方法必须是public abstract,这是 系统默认的,不管你在定义接口时,写不写 修饰符都是一样的.

(5)接口的实现:一个类使用了某个接口,那么这个类必须实现该 接口的所有方法,即为这些方法提供方法体。一个类可以实现多个接口,接口间应该用逗号分 隔开。

(6)接口的使用:接口不能构造接口对象,但可以声明接口变量以指向一个实现了该接口的类对象。

(7)可以用instanceof检查对象是否实现了某个接口。

(8)抽象类:用abstract来声明,没有具体实例对象的类,不 能用new来创建对象。

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

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 需要用 {} 包含语句,当只有一条语句时 {} 可省略

4. 内部类:是定义在一个类内部的类。

(1)使用内部类的原因有以下三个: –内部类方法可以访问该类定义所在的作用域中 的数据,包括私有数据。

–内部类能够隐藏起来,不为同一包中的其他类 所见。

–想要定义一个回调函数且不想编写大量代码时, 使用匿名内部类比较便捷。

(2)内部类可以直接访问外部类的成员,包括 private成员,但是内部类的成员却不能被外部 类直接访问。

(3)内部类并非只能在类内定义,也可以在程序块内 定义局部内部类。

(4)如果构造参数的闭圆括号跟一个开花括号,表明正 在定义的就是匿名内部类。

5. 代理(Proxy)

 第二部分:实验部分

1、实验名称:实验六 接口的定义与使用

2、实验目的与要求

(1) 掌握接口定义方法;

(2) 掌握实现接口类的定义要求;

(3) 掌握实现了接口类的使用要求;

(4) 掌握程序回调设计模式;

(5) 掌握Comparator接口用法;

(6) 掌握对象浅层拷贝与深层拷贝方法;

(7) 掌握Lambda表达式语法;

(8) 了解内部类的用途及语法要求。

2、实验内容和步骤

实验1: 导入第6章示例程序,测试程序并进行代码注释。

测试程序1:

  编辑、编译、调试运行阅读教材214页-215页程序6-1、6-2,理解程序并分析程序运行结果;

  在程序中相关代码处添加新知识的注释。

  掌握接口的实现用法;

  掌握内置接口Compareable的用法。

 1 package interfaces;
 2 
 3 public class Employee implements Comparable<Employee>
 4 {
 5 private String name;
 6 private double salary;
 7 
 8 public Employee(String name, double salary)//构造方法
 9 {
10 this.name = name;
11 this.salary = salary;
12 }
13 
14 public String getName()//Name属性的访问器
15 {
16 return name;
17 }
18 
19 public double getSalary()//Salary属性的访问器
20 {
21 return salary;
22 }
23 
24 public void raiseSalary(double byPercent)//改写工资数据的方法
25 {
26 double raise = salary * byPercent / 100;
27 salary += raise;
28 }
29 
30 /**
31 * Compares employees by salary
32 * @param other another Employee object
33 * @return a negative value if this employee has a lower salary than
34 * otherObject, 0 if the salaries are the same, a positive value otherwise
35 */
36 public int compareTo(Employee other)
37 {
38 return Double.compare(salary, other.salary);//调用pouble包装器类的compare方法
39 }
40 }
 1 package interfaces;
 2 
 3 import java.util.*;
 4 
 5 /**
 6  * This program demonstrates the use of the Comparable interface.
 7  * @version 1.30 2004-02-27
 8  * @author Cay Horstmann
 9  */
10 public class EmployeeSortTest
11 {
12    public static void main(String[] args)
13    {
14       Employee[] staff = new Employee[3];//创建普通数组对象
15 
16       staff[0] = new Employee("Harry Hacker", 35000);
17       staff[1] = new Employee("Carl Cracker", 75000);
18       staff[2] = new Employee("Tony Tester", 38000);//生成三个实例对象
19 
20       Arrays.sort(staff);//静态方法
21 
22       // print out information about all Employee objects
23       for (Employee e : staff)
24          System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
25    }
26 }

运行结果如下:

技术分享图片

 

                 

测试程序2:

编辑、编译、调试以下程序,结合程序运行结果理解程序;

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

  }

}

 1 package InterfaceTest;
 2 
 3 interface  A
 4 
 5 {
 6 
 7   double   g=9.8;
 8 
 9   void show(   );
10 
11 }
12 
13 class C implements A
14 
15 {
16 
17   public void   show( )
18 
19     {System.out.println("g="+g);}
20 
21 }
22 
23  
24 
25 class InterfaceTest
26 
27 {
28 
29   public   static void main(String[ ] args)
30 
31   {
32 
33        A a=new   C( );
34 
35        a.show(   );
36 
37        System.out.println("g="+C.g);
38 
39   }
40 
41 }

 

运行结果如下:

技术分享图片

 

测试程序3:

l  在elipse IDE中调试运行教材223页6-3,结合程序运行结果理解程序;

l  26行、36行代码参阅224页,详细内容涉及教材12章。

l  在程序中相关代码处添加新知识的注释。

l  掌握回调程序设计模式;

 1 package timer;
 2 
 3 /**
 4    @version 1.01 2015-05-12
 5    @author Cay Horstmann
 6 */
 7 
 8 import java.awt.*;//包
 9 import java.awt.event.*;
10 import java.util.*;
11 import javax.swing.*;
12 import javax.swing.Timer; 
13 // to resolve conflict with java.util.Timer
14 
15 public class TimerTest//主类
16 {  
17    public static void main(String[] args)
18    {  
19       ActionListener listener = new TimePrinter();//引用 监听
20 
21       // construct a timer that calls the listener
22       // once every 10 seconds
23       Timer t = new Timer(10000, listener);
24       t.start();
25 
26       JOptionPane.showMessageDialog(null, "Quit program?");
27       System.exit(0);
28    }
29 }
30 
31 class TimePrinter implements ActionListener//内置接口  用户自定义类
32 {  
33    public void actionPerformed(ActionEvent event)
34    {  
35       System.out.println("At the tone, the time is " + new Date());
36       Toolkit.getDefaultToolkit().beep();//静态方法
37    }
38 }

运行结果如下:

技术分享图片

 

测试程序4:

l  调试运行教材229页-231页程序6-4、6-5,结合程序运行结果理解程序;

l  在程序中相关代码处添加新知识的注释。

l  掌握对象克隆实现技术;

l  掌握浅拷贝和深拷贝的差别。

 1 package clone;
 2 
 3 import java.util.Date;
 4 import java.util.GregorianCalendar;
 5 
 6 public class Employee implements Cloneable
 7 {
 8    private String name;
 9    private double salary;
10    private Date hireDay;
11 
12    public Employee(String name, double salary)
13    {
14       this.name = name;
15       this.salary = salary;
16       hireDay = new Date();
17    }
18 
19    public Employee clone() throws CloneNotSupportedException
20    {
21       // call Object.clone()
22       Employee cloned = (Employee) super.clone();
23 
24       // clone mutable fields
25       cloned.hireDay = (Date) hireDay.clone();
26 
27       return cloned;
28    }
29 
30    /**
31     * Set the hire day to a given date. 
32     * @param year the year of the hire day
33     * @param month the month of the hire day
34     * @param day the day of the hire day
35     */
36    public void setHireDay(int year, int month, int day)
37    {
38       Date newHireDay = new GregorianCalendar(year, month - 1, day).getTime();
39       
40       // Example of instance field mutation
41       hireDay.setTime(newHireDay.getTime());
42    }
43 
44    public void raiseSalary(double byPercent)
45    {
46       double raise = salary * byPercent / 100;
47       salary += raise;
48    }
49 
50    public String toString()
51    {
52       return "Employee[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]";
53    }
54 }
 1 import clone.Employee;
 2 
 3 /**
 4  * This program demonstrates cloning.
 5  * @version 1.10 2002-07-01
 6  * @author Cay Horstmann
 7  */
 8 public class CloneTest
 9 {
10    public static void main(String[] args)
11    {
12       try
13       {
14          Employee original = new Employee("John Q. Public", 50000);//Employee是一个自定义类
15 original.setHireDay(2000, 1, 1); 

16 Employee copy = original.clone();

17 copy.raiseSalary(10);//原有对象不会发生变化
18 copy.setHireDay(2002, 12, 31); //更改器

19 System.out.println("original=" + original); //字符串连接

20 System.out.println("copy=" + copy);

21 }

22 catch (CloneNotSupportedException e)

23 {

24 e.printStackTrace();

25 }

26 }

27 }

运行结果如下:

技术分享图片

实验2: 导入第6章示例程序6-6,学习Lambda表达式用法。

l  调试运行教材233页-234页程序6-6,结合程序运行结果理解程序;

l  在程序中相关代码处添加新知识的注释。

l  将27-29行代码与教材223页程序对比,将27-29行代码与此程序对比,体会Lambda表达式的优点。

 1 package lambda;
 2 
 3 import java.util.*;
 4 
 5 import javax.swing.*;
 6 import javax.swing.Timer;
 7 
 8 /**
 9  * This program demonstrates the use of lambda expressions.
10  * @version 1.0 2015-05-12
11  * @author Cay Horstmann
12  */
13 public class LambdaTest
14 {
15    public static void main(String[] args)
16    {
17       String[] planets = new String[] { "Mercury", "Venus", "Earth", "Mars", 
18             "Jupiter", "Saturn", "Uranus", "Neptune" };//定义数组planets
19       System.out.println(Arrays.toString(planets));//静态方法
20       System.out.println("Sorted in dictionary order:");
21       Arrays.sort(planets);//Arrays.sort方法接收实验Lambda类的对象
22       System.out.println(Arrays.toString(planets));
23       System.out.println("Sorted by length:");
24       Arrays.sort(planets, (first, second) -> first.length() - second.length());//lambda表达式
25 System.out.println(Arrays.toString(planets)); 26 27 Timer t = new Timer(1000, event -> 28 System.out.println("The time is " + new Date()));//lambda表达式
29 t.start(); 30 31 // keep program running until user selects "Ok" 32 JOptionPane.showMessageDialog(null, "Quit program?"); 33 System.exit(0); //返回类型 34 }

 

运行结果如下:


技术分享图片

 

注:以下实验课后完成

实验3: 编程练习

l  编制一个程序,将身份证号.txt 中的信息读入到内存中;

l  按姓名字典序输出人员信息;

l  查询最大年龄的人员信息;

l  查询最小年龄人员信息;

l  输入你的年龄,查询身份证号.txt中年龄与你最近人的姓名、身份证号、年龄、性别和出生地;

l  查询人员中是否有你的同乡。

  1 import java.io.BufferedReader;
  2 import java.io.File;
  3 import java.io.FileInputStream;
  4 import java.io.FileNotFoundException;
  5 import java.io.IOException;
  6 import java.io.InputStreamReader;
  7 import java.util.ArrayList;
  8 import java.util.Arrays;
  9 import java.util.Collections;
 10 import java.util.Scanner;
 11 
 12 public class Main{
 13     private static ArrayList<Person> Personlist;
 14     public static void main(String[] args) {
 15         Personlist = new ArrayList<>();
 16         Scanner scanner = new Scanner(System.in);
 17         File file = new File("D:\\身份证号.txt");
 18         try {
 19             FileInputStream fis = new FileInputStream(file);
 20             BufferedReader in = new BufferedReader(new InputStreamReader(fis));
 21             String temp = null;
 22             while ((temp = in.readLine()) != null) {
 23                 
 24                 Scanner linescanner = new Scanner(temp);
 25                 
 26                 linescanner.useDelimiter(" ");    
 27                 String name = linescanner.next();
 28                 String ID = linescanner.next();
 29                 String sex = linescanner.next();
 30                 String age = linescanner.next();
 31                 String place =linescanner.nextLine();
 32                 Person Person = new Person();
 33                 Person.setname(name);
 34                 Person.setID(ID);
 35                 Person.setsex(sex);
 36                 int a = Integer.parseInt(age);
 37                 Person.setage(a);
 38                 Person.setbirthplace(place);
 39                 Personlist.add(Person);
 40 
 41             }
 42         } catch (FileNotFoundException e) {
 43             System.out.println("查找不到信息");
 44             e.printStackTrace();
 45         } catch (IOException e) {
 46             System.out.println("信息读取有误");
 47             e.printStackTrace();
 48         }
 49         boolean isTrue = true;
 50         while (isTrue) {
 51             System.out.println("————————————————————————————————————————");
 52             System.out.println("1:按姓名字典序输出人员信息");
 53             System.out.println("2:查询最大年龄与最小年龄人员信息");
 54             System.out.println("3:按省份找同乡");
 55             System.out.println("4:输入你的年龄,查询年龄与你最近人的信息");
 56             System.out.println("5:exit");
 57             int nextInt = scanner.nextInt();
 58             switch (nextInt) {
 59             case 1:
 60                 Collections.sort(Personlist);
 61                 System.out.println(Personlist.toString());
 62                 break;
 63             case 2:
 64                 
 65                 int max=0,min=100;int j,k1 = 0,k2=0;
 66                 for(int i=1;i<Personlist.size();i++)
 67                 {
 68                     j=Personlist.get(i).getage();
 69                    if(j>max)
 70                    {
 71                        max=j; 
 72                        k1=i;
 73                    }
 74                    if(j<min)
 75                    {
 76                        min=j; 
 77                        k2=i;
 78                    }
 79 
 80                 }  
 81                 System.out.println("年龄最大:"+Personlist.get(k1));
 82                 System.out.println("年龄最小:"+Personlist.get(k2));
 83                 break;
 84             case 3:
 85                 System.out.println("place?");
 86                 String find = scanner.next();        
 87                 String place=find.substring(0,3);
 88                 String place2=find.substring(0,3);
 89                 for (int i = 0; i <Personlist.size(); i++) 
 90                 {
 91                     if(Personlist.get(i).getbirthplace().substring(1,4).equals(place)) 
 92                         System.out.println("maybe is      "+Personlist.get(i));
 93 
 94                 } 
 95 
 96                 break;
 97             case 4:
 98                 System.out.println("年龄:");
 99                 int yourage = scanner.nextInt();
100                 int near=agenear(yourage);
101                 int d_value=yourage-Personlist.get(near).getage();
102                 System.out.println(""+Personlist.get(near));
103            /*     for (int i = 0; i < Personlist.size(); i++)
104                 {
105                     int p=Personlist.get(i).getage()-yourage;
106                     if(p<0) p=-p;
107                     if(p==d_value) System.out.println(Personlist.get(i));
108                 }   */
109                 break;
110             case 5:
111            isTrue = false;
112            System.out.println("退出程序!");
113                 break;
114             default:
115                 System.out.println("输入有误");
116             }
117         }
118     }
119     public static int agenear(int age) {
120      
121        int j=0,min=53,d_value=0,k=0;
122         for (int i = 0; i < Personlist.size(); i++)
123         {
124             d_value=Personlist.get(i).getage()-age;
125             if(d_value<0) d_value=-d_value; 
126             if (d_value<min) 
127             {
128                min=d_value;
129                k=i;
130             }
131 
132          }    return k;
133         
134      }
135 
136  
137 }
138 
139 Main

 

 1 public class Person implements Comparable<Person> {
 2 private String name;
 3 private String ID;
 4 private int age;
 5 private String sex;
 6 private String birthplace;
 7 
 8 public String getname() {
 9 return name;
10 }
11 public void setname(String name) {
12 this.name = name;
13 }
14 public String getID() {
15 return ID;
16 }
17 public void setID(String ID) {
18 this.ID= ID;
19 }
20 public int getage() {
21 
22 return age;
23 }
24 public void setage(int age) {
25     // int a = Integer.parseInt(age);
26 this.age= age;
27 }
28 public String getsex() {
29 return sex;
30 }
31 public void setsex(String sex) {
32 this.sex= sex;
33 }
34 public String getbirthplace() {
35 return birthplace;
36 }
37 public void setbirthplace(String birthplace) {
38 this.birthplace= birthplace;
39 }
40 
41 public int compareTo(Person o) {
42    return this.name.compareTo(o.getname());
43 
44 }
45 
46 public String toString() {
47     return  name+"	"+sex+"	"+age+"	"+ID+"	"+birthplace+"
";
48 
49 }
50 
51 
52 
53 }
54 
55  Person

 运行结果如下:

技术分享图片

技术分享图片

技术分享图片

 

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

实验程序1:

l  编辑、调试运行教材246页-247页程序6-7,结合程序运行结果理解程序;

l  了解内部类的基本用法。

 1 package innerClass;
 2 
 3 import java.awt.*;
 4 import java.awt.event.*;
 5 import java.util.*;
 6 import javax.swing.*;
 7 import javax.swing.Timer;
 8 
 9 /**
10  * This program demonstrates the use of inner classes.
11  * @version 1.11 2015-05-12
12  * @author Cay Horstmann
13  */
14 public class InnerClassTest
15 {
16    public static void main(String[] args)
17    {
18       TalkingClock clock = new TalkingClock(1000, true);
19       clock.start();
20 
21       // keep program running until user selects "Ok"
22       JOptionPane.showMessageDialog(null, "Quit program?");
23       System.exit(0);
24    }
25 }
26 
27 /**
28  * A clock that prints the time in regular intervals.
29  */
30 class TalkingClock
31 {
32    private int interval;
33    private boolean beep;
34 
35    /**
36     * Constructs a talking clock
37     * @param interval the interval between messages (in milliseconds)
38     * @param beep true if the clock should beep
39     */
40    public TalkingClock(int interval, boolean beep)
41    {
42       this.interval = interval;
43       this.beep = beep;
44    }
45 
46    /**
47     * Starts the clock.
48     */
49    public void start()
50    {
51       ActionListener listener = new TimePrinter();
52       Timer t = new Timer(interval, listener);
53       t.start();
54    }
55 
56    public class TimePrinter implements ActionListener
57    {
58       public void actionPerformed(ActionEvent event)
59       {
60          System.out.println("At the tone, the time is " + new Date());
61          if (beep) Toolkit.getDefaultToolkit().beep();
62       }
63    }
64 }

 

运行结果如下:

技术分享图片

 

实验程序2:

l  编辑、调试运行教材254页程序6-8,结合程序运行结果理解程序;

l  了解匿名内部类的用法。

 1 package anonymousInnerClass;
 2 
 3 import java.awt.*;
 4 import java.awt.event.*;
 5 import java.util.*;
 6 import javax.swing.*;
 7 import javax.swing.Timer;
 8 
 9 /**
10  * This program demonstrates anonymous inner classes.
11  * @version 1.11 2015-05-12
12  * @author Cay Horstmann
13  */
14 public class AnonymousInnerClassTest
15 {
16    public static void main(String[] args)
17    {
18       TalkingClock clock = new TalkingClock();
19       clock.start(1000, true);
20 
21       // keep program running until user selects "Ok"
22       JOptionPane.showMessageDialog(null, "Quit program?");
23       System.exit(0);
24    }
25 }
26 
27 /**
28  * A clock that prints the time in regular intervals.
29  */
30 class TalkingClock
31 {
32    /**
33     * Starts the clock.
34     * @param interval the interval between messages (in milliseconds)
35     * @param beep true if the clock should beep
36     */
37    public void start(int interval, boolean beep)
38    {
39       ActionListener listener = new ActionListener()
40          {
41             public void actionPerformed(ActionEvent event)
42             {
43                System.out.println("At the tone, the time is " + new Date());
44                if (beep) Toolkit.getDefaultToolkit().beep();
45             }
46          };
47       Timer t = new Timer(interval, listener);
48       t.start();
49    }
50 }

 运行结果如下:

技术分享图片

 实验程序3:

l  在elipse IDE中调试运行教材257页-258页程序6-9,结合程序运行结果理解程序;

l  了解静态内部类的用 1 package staticInnerClass;

 2 
 3 /**
 4  * This program demonstrates the use of static inner classes.
 5  * @version 1.02 2015-05-12
 6  * @author Cay Horstmann
 7  */
 8 public class StaticInnerClassTest
 9 {
10    public static void main(String[] args)
11    {
12       double[] d = new double[20];
13       for (int i = 0; i < d.length; i++)
14          d[i] = 100 * Math.random();
15       ArrayAlg.Pair p = ArrayAlg.minmax(d);
16       System.out.println("min = " + p.getFirst());
17       System.out.println("max = " + p.getSecond());
18    }
19 }
20 
21 class ArrayAlg
22 {
23    /**
24     * A pair of floating-point numbers
25     */
26    public static class Pair
27    {
28       private double first;
29       private double second;
30 
31       /**
32        * Constructs a pair from two floating-point numbers
33        * @param f the first number
34        * @param s the second number
35        */
36       public Pair(double f, double s)
37       {
38          first = f;
39          second = s;
40       }
41 
42       /**
43        * Returns the first number of the pair
44        * @return the first number
45        */
46       public double getFirst()
47       {
48          return first;
49       }
50 
51       /**
52        * Returns the second number of the pair
53        * @return the second number
54        */
55       public double getSecond()
56       {
57          return second;
58       }
59    }
60 
61    /**
62     * Computes both the minimum and the maximum of an array
63     * @param values an array of floating-point numbers
64     * @return a pair whose first element is the minimum and whose second element
65     * is the maximum
66     */
67    public static Pair minmax(double[] values)
68    {
69       double min = Double.POSITIVE_INFINITY;
70       double max = Double.NEGATIVE_INFINITY;
71       for (double v : values)
72       {
73          if (min > v) min = v;
74          if (max < v) max = v;
75       }
76       return new Pair(min, max);
77    }
78 

 运行结果如下:

技术分享图片

4. 实验总结:

通过本次实验我掌握了接口定义方法;掌握了实现了接口类的定义要求;掌握了实现了接口类的使用要求; 掌握了程序回调设计模式;掌握了Comparator接口用法;掌握了对象浅层拷贝与深层拷贝方法;掌握了Lambda表达式语法;了解了内部类的用途及语法要求。

























以上是关于杨玲 201771010133《面向对象程序设计(java)》第八周学习总结的主要内容,如果未能解决你的问题,请参考以下文章

杨玲 201771010133《面向对象程序设计(java)》第五周学习总结

杨玲 201771010133《面向对象程序设计(java)》第三周学习总结

杨玲 201771010133《面向对象程序设计(java)》第十三周学习总结

杨玲 201771010133《面向对象程序设计(java)》第十八周学习总结

杨玲 201771010133《面向对象程序设计(java)》第十周学习总结

杨玲 201771010133《面向对象程序设计(java)》第二周学习总结