201521123007《Java程序设计》第5周学习总结

1. 本周学习总结

1.1 尝试使用思维导图总结有关多态与接口的知识点。

---

2. 书面作业

作业参考文件下载

1. 代码阅读：Child压缩包内源代码

1.1 com.parent包中Child.java文件能否编译通过?哪句会出现错误？试改正该错误。并分析输出结果。

Child.java文件不能编译通过，上图中提示第13行i出错，"Thread [main] (Suspended (The field Parent.i is not visible))"，说明i在Parent类中是不可见的；会有以下方式修改该错误：

按照以往我们的习惯会选第二种方法，"create getter and setter for 'i'",这样文件就可以编译通过了。i在Parent类中无修饰，但默认是私有"private"，外部类是无法访问的，get()和ger()方法可以对数据进行设置和获取。

我们可以尝试第一种方法，"change visibility of 'i' to 'protected'"，文件同样可以通过。protected对于子女、朋友，也就是同包下的所有类和不同包的子类来说，就是public的，可以*使用，没有任何限制，而对于其他的外部class，protected就变成private。所以Parent类中i用"protected"修饰后，对Child类来说i就是可见的，因为Child类继承Parent类。

输出结果是7个数字“1 2 2 1 1 2 1”，以下代码后的注释是该行代码的输出结果

        c.getParenti();//1
        c.getParentj();//2,2,1,1
        Other.showParentj(p);//2,1

同时补上Other类的代码：

1.2 另外一个包中的OutOfParentPackage.java，能否编译通过?提示什么错误？分析原因。

不能编译通过，

提示"The type Parent is not visible","The field Parent.j is not visible"，"The method geti() from the type Parent is not visible",也就是说Parent类对OutOfParentPackage.java文件是不可见的，还有j和geti()是protected修饰的，也不对OutOfParentPackage开放。protected权限问题在上题中已解答。
以下是各种修饰符的权限比较：

1.3 回答：如果为了访问到protected修饰的属性或方法应该怎么办？

最直接也是有点麻烦的方法就是把protected修饰改成public修饰，但是会破坏原属性和方法的封装性。

2. abstract进阶：阅读GuessGame抽象类的设计与使用源代码

2.1 Guess改造前代码很简单，而改造后的代码使用了抽象类、抽象方法看起来很复杂，那这样的改造到底有什么好处呢？

改造前，未使用抽象类，只能控制台输出

改造后，使用抽象类，可以在控制台，也可以使用对话框图形界面等输入

2.2 如果想将该游戏改造成图形界面，应该进行一些什么操作？

那就要设计一个图形界面猜数字的类去继承上文提到的抽象类，然后用图形界面支持的输入输出语句来重写抽象类当中的抽象方法。

2.3 结合该例子，你觉得什么时候应该使用abstract?

声明方法的存在而不去实现它的类被叫做抽象类(abstract class)，它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。

该例创建了一个公有抽象类GuessGame，并声明了公共抽象方法print(),println(),nextInt()，供非抽象子类ConsoleGame类实现，子类ConsoleGame覆盖了父类抽象类GuessGame中的print(),println(),nextInt()方法。

2.4 重要:在这个例子中，变化的是什么，不变的是什么？尝试结合abstract、继承等概念进行说明。

在这个例子中，变化的是对抽象类GuessGame中声明的方法的实现方式，不变的是声明的方法。先声明方法，后继承重写，主要是为了定义一个标准、规范。

3. Comparable与Comparator

3.1 描述Comparable接口的用途。为什么某个类实现了Comparable接口就可以直接使用Arrays.sort对其进行排序？

让类实现Comparable接口，并覆盖compareTo方法就可以实现对象的自动排序。Arrays有一方法public static void sort()根据元素的自然顺序对指定对象数组按升序进行排序，数组中的所有元素都必须实现 Comparable 接口.所以某个类实现了Comparable接口就可以直接使用Arrays.sort对其进行排序。

3.2 有了Comparable接口为什么还需要Comparator接口呢？

Comparator 是比较器接口。
我们若需要控制某个类的次序，而该类本身不支持排序(即没有实现Comparable接口)；那么，我们可以建立一个“该类的比较器”来进行排序。这个“比较器”只需要实现>Comparator接口即可。
也就是说，我们可以通过“实现Comparator类来新建一个比较器”，然后通过该比较器对类进行排序。
Comparator 接口仅仅只包括两个个函数，它的定义如下：

    public interface Comparator<T> {

        int compare(T o1, T o2);

        boolean equals(Object obj);
    }

4. 面向接口案例分析

阅读Case-StudentDao.zip案例

4.1 画出类关系图，描述每个类与接口的作用。

StudentDaoArrayImpl类和StudenDaoListImpl类实现了StudentDao接口，覆盖了StudentDao接口中的writeStudent();readStudent();diplayAllStudent();方法，让其在本类中有各自的实现。

4.2 StudenDaoListImpl与StudentDaoArrayImpl有何区别？

StudenDaoListImpl建立的是List<Student>列表，而StudentDaoArrayImpl建立的是Student[]数组，都是实现StudenDao接口，但各自的实现方法不同。

5. 什么是面向接口编程？面向接口编程的好处是什么？

结合题目3与4中的Test.java的代码讨论分析。

面向接口编程的意思是指在面向对象的系统中所有的类或者模块之间的交互是由接口完成的。

概念很抽象，现在我们针对Test.java代码进行分析：

01 package chpt06;
02 
03 public class Test {
04
05     /**
06      * @param args
07      */
08     public static void main(String[] args) {
09         Student[] students = new Student[3];
10         students[0] = new Student("Tom");
11         students[1]= new Student("Jerry");
12         students[2] = new Student("Sophia");
13 
14      
15         StudentDao sdm = new StudentDaoArrayImpl(50);//使用数组实现
16         //StudentDao sdm = new StudenDaoListImpl();//使用列表实现
17      
18         //往后台写数据，无需考虑后台是什么(到底是数据库、文件、数组、List)
19         //因为这里是面向StudentDao接口
20         System.out.println("===========写入学生========");
21         for(Student e:students){
22             if (!sdm.writeStudent(e)){
23                 System.out.println("添加学生失败");
24             }else{
25                 System.out.println("插入成功！！");
26             }
27         }
28         System.out.println("===========显示所有学生========");
29         sdm.diplayAllStudent();
30         System.out.println("===========查询学生========");
31         Student temp = sdm.readStudent("Tom") ;
32         if(temp == null){
33             System.out.println("查无此人");
34         }else{
35             System.out.println(temp);
36         }
37
38     }
39
40 }

第15行代码StudentDao sdm = new StudentDaoArrayImpl(50);中，指向数组的变量sdm实现了StudentDao接口，可以调用接口中所有方法：
第22行代码if (!sdm.writeStudent(e)){}，调用了StudentDao接口的writeStudent()方法，
第29行代码sdm.diplayAllStudent();，调用了StudentDao接口的diplayAllStudent()方法，
第31行代码Student temp = sdm.readStudent("Tom") ;，调用了StudentDao接口的readStudent()方法。

若是把15行代码注释掉，而编译第16行代码StudentDao sdm = new StudenDaoListImpl();，则是指向列表的变量sdm实现了StudentDao接口，同样可以调用接口中所有方法。

6. 结对编程：面向对象设计(大作业2-非常重要)

内容：使用Java代码完成上周做的面向对象设计大作业，需要有初步界面。实现的功能尽量简单，少而精，只包含必要的功能，不要追求高大全。
写出：类图(尽量精简，不用太多子类，两个即可)、系统常用功能描述、关键代码与界面
形式： 两人依托码云合作完成。请在这里贴出你们的学号、姓名与任务分工。
注意： 再过几次课要讲Java图形界面编程，到时候要将该系统升级为图形界面。系统的业务逻辑部分应该变化不大，变化大的是输入与输出部分。所以编码的时候，输入(Scanner)与输出(System.out)的代码，请不要将其与某个业务处理函数绑死。
选做加分： 给出两人在码云上同一项目的提交记录截图，额外加分。注：两个人在码云上新建一个项目。
参考资料:
结对编程参考资料
可以使用Processon画图

• 6.1

学生A	学生B	项目地址
谭燕	null	null

• 6.2常用功能描述框架图

• 6.3

package Shopping;

public class Login {
    private String name="customer";
    private String secret="123456";
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSecret() {
        return secret;
    }
    public void setSecret(String secret) {
        this.secret = secret;
    }
    public Login(String name, String secret) {
        super();
        this.name = name;
        this.secret = secret;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Login other = (Login) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (secret == null) {
            if (other.secret != null)
                return false;
        } else if (!secret.equals(other.secret))
            return false;
        return true;
    }

}

package Shopping;

public class Goods {
    private String name;
    private double price;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public Goods(String name, double price) {
        super();
        this.name = name;
        this.price = price;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Goods other = (Goods) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (Double.doubleToLongBits(price) != Double.doubleToLongBits(other.price))
            return false;
        return true;
    }
    @Override
    public String toString() {
        return name + "-" + price;
    }


}

package Shopping;


public class Shopcart {
    private Goods goods;
    private static int count=0;
    private double sum;


    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        Shopcart.count = count;
    }

    public double getSum() {
        return sum;
    }

    public void setSum(double sum) {
        this.sum = sum;
    }

    public Goods getGoods() {
        return goods;
    }

    public void setGoods(Goods goods) {
        this.goods = goods;
    }


    public Shopcart Add(Goods goods){
        Shopcart goods_=new Shopcart(goods);
        count++;
        goods_.sum=goods.getPrice()*count;
        return goods_;

    }
    public Shopcart(Goods goods) {
        super();
        this.goods = goods;
    }

    @Override
    public String toString() {
        return goods.toString() + "-" + count + "-" + sum;
    }


}

package Shopping;

import java.util.ArrayList;
import java.util.Scanner;
import Shopping.Shopcart;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        Goods[] goods = new Goods[5];
        goods[0] = new Goods("Java", 65.3);
        goods[1] = new Goods("Math", 37.2);
        goods[2] = new Goods("skirt", 80.0);
        goods[3] = new Goods("jacket", 46.8);
        goods[4] = new Goods("Ajax", 65.3);

        System.out.println("请输入帐号和密码：");
        Login account = new Login(in.next(), in.next());
        Login obj = new Login("customer", "123456");
        if (!account.equals(obj)) {
            System.out.println("帐号或密码错误！");
            return;
        }

        System.out.println("登入成功！");

        ArrayList<Shopcart> list = new ArrayList<Shopcart>();
        while (true) {
            System.out.println("请输入要搜索的商品名：");
            String name = in.next();
            int i;
            for (i = 0; i < goods.length; i++) {
                if (name.equals(goods[i].getName())) {
                    System.out.println(goods[i]);
                    break;
                }
            }
            if (i == goods.length) {
                System.out.println("找不到该商品！");
                return;
            } else {
                System.out.println("1.结算    2.添加至购物车");
                int choice = in.nextInt();
                if (choice == 1) {
                    System.out.printf("需支付 %.2f", goods[i].getPrice());
                    System.out.println();
                } else if (choice == 2) {
                    Shopcart g = new Shopcart(goods[i]);
                    // if (!list.contains(g))
                    list.add(g.Add(goods[i]));
                    // else
                    // 找出list中的同名商品，数量count增加
                    System.out.println("查看购物车：");
                    for (Shopcart s : list) {
                        System.out.println(s);
                    }
                    System.out.println("1.结算     2.添加商品     3.退出");
                    int choice1 = in.nextInt();
                    switch (choice1) {
                    case '1': {
                        int sum = 0;
                        for (Shopcart s : list) {
                            sum += s.getSum();
                        }
                        System.out.printf("总共需支付 %.2f", sum);
                        System.out.println();
                        break;
                    }
                    case '2':
                        break;

                    case '3':
                        return;
                    }
                }

            }
        }
    }

}

• 6.4输出结果如下，很多细节还没做，有些地方会出差错：

---

3. 码云上代码提交记录及PTA实验总结

题目集：jmu-Java-04-面向对象2-进阶-多态接口内部类

3.1. 码云代码提交记录

在码云的项目中，依次选择“统计-Commits历史-设置时间段”, 然后搜索并截图

3.2. PTA实验

继续完成前面未完成的实验面向对象1-基础-封装继承

函数(选做：4-1)、编程(5-1, 5-2)

• 类实现Comparable接口时，格式为implements Comparable<T>，T为对象的引用。
• Comparable接口中唯一方法compareTo()，实现接口时要覆盖该方法，自定义比较方式。
• 列表用Collections.sort(List);实现排序，数组用Arrays.sort(array);实现，前提是对象都实现了Comparable接口。
• 数值格式在java.text.DecimalFormat中，有方法format()，返回的都是string型字符串。
• 比较器Comparator也是一个接口，与Comparable类似也有不同，有方法compare（obj o1,obj o2);对不支持Comparable的类控制其次序.