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

1. 本周学习总结

---

2. 书面作业

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

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

1.2 另外一个包中的OutOfParentPackage.java，能否编译通过?提示什么错误？分析原因。如何更改才能使之正常编译？

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

(1.1)代码如下：

package com.parent;
class Parent{
    private int i=1;
    protected int j=2;
    protected int geti(){
        return i;
    }
    public void getj(){
        System.out.println(j);
    }
}
//Other.java
class Other{
    public static void showParentj(Parent p){
        System.out.println(p.j);
        System.out.println(p.geti());
    }

}
//Child.java
public class Child extends Parent{
    public static void main(String[] args){
        Parent p = new Parent();
        Child c = new Child();
        c.getParenti();
        c.getParentj();
        Other.showParentj(p);

    }
    public void getParenti(){
        System.out.println(i);//出错
    }
    public void getParentj(){
        System.out.println(super.j);
        System.out.println(j);
        System.out.println(geti());
        System.out.println(super.geti());
    }
}

答：

(1)不能通过编译；

(2)在Child类中public void getParenti()语句显示The field Parent.i is not visible；

(3)可以将Parent类中的i属性的修饰符private改为protected，因为i属性原先是private，只能在自己的类中使用，不能在其他类中调用；

(4)输出结果：

1 2 2 1 1 2 1

---

(1.2)

public class OutOfParentPackage{
    public static void showParentj(Parent p){
        System.out.println(p.j);
        System.out.println(p.geti());
        p.getj();
    }
}

答：不能通过编译，显示错误The type Parent is not visible，因为Parent前未加任务修饰符，修饰符为默认，而showParentj只能在本类或是在本包中才能调用，所以或出错，所以可以加大权限，在Parent前加public

---

(1.3)

答：protected的访问范围是本类，同一个包或是子类，所以要访问protected修饰的属性或方法可以在同一个类中调用protected修饰的属性或方法，火灾同一个包中或是子类中调用protected修饰的属性或方法

---

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

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

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

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

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

(2.1) 答：使用了抽象类、抽象方法后，代码显得更有弹性，添加的java.util.Scanner类，用于扫描输入文本的实用程序。改造后抽象类、抽象方法可以自己进行编写，输出与输入就不局限于扫描输入输出文本。

（2.2）答：设计一个图形界面猜数字的类去继承 GuessGame这个抽象类，然后用图形界面支持的输入输出语句来覆盖抽象类当中的抽象方法。

（2.3）答：首先使用abstract类需要被继承，因为abstract的设计就是为了继承，如果不继承就没什么意义。这是区分为什么不用接口的一个关键。

然后结合该例子，在这个例子中我们知道了需要运用继承，而abstract可以定义abstract方法也就是只有声明没有具体实现的方法，也就是说如果当实现还无法确定下来的时候，可以暂且用abstract将一些已有的方法声明确定下来。后面具体的实现由子类来写。

－

（2.4）答：在这个例子中，变化的是代码所处的环境，不变的是代码实现的功能即完成猜数游戏这个整体架构。abstract为抽象，抽象类或抽象方法增强了代码的弹性，方便以后根据代码的外界环境进行编写。未被继承的抽象类是没有意义的，只有实现了抽象类并应用，抽象类才有存在的意义。

---

3.Comparable与Comparator

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

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

3.3 可选：使用匿名内部类、Lambda表达式实现PTA编程5-2。

Comparable接口里有抽象方法compareTo,用来比较对象的大小。

（3.1）答： 此接口强行对实现它的每个类的对象进行整体排序；在类中实现Comparable接口后，调用Arrays.sort()时，传入的是对象，根据指定比较器产生的顺序对指定对象进行排序

if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0)
{
    System.arraycopy(src, low, dest, destLow, length);
    return;
 }
for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
        if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
            dest[i] = src[p++];
        else
            dest[i] = src[q++];
    }

(3.2)答：查看Arrays.sort源代码，sort将传入的参数强制转换为Comparable类，且调用Comparable接口的compareTo方法对数组进行排序。

Comparable接口是内比较器，采用的一般是自然比较法，方法传入的参数只有一个；Comparator接口有compare方法是外比较器，方法传入的参数有两个。

1.实现类实现了Comparable接口，但是对compareTo方法内的比较算法不满意可选实现Comparator接口

2.需要对传入的两个对象进行比较时可选实现Comparator接口

3.实现Comparator的类是在外部进行比较的，不需要对实现类有任何修改，而实现Comparable类需要在实现类中做修改

4.可以在实现Comparator的类进行各种排序，多种排序方式可创建多种实现Comparator类来实现

具体选用哪种接口进行比较需要根据实际情况进行选择。

---

4.面向接口案例分析

阅读Case-StudentDao.zip案例

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

4.2 StudenDaoListImpl与StudentDaoArrayImpl有何区别？

(4.1)

(4.2)

public class StudentDaoArrayImpl implements StudentDao {

    private Student[] students;
    private int size=80;//默认数组大小

    public StudentDaoArrayImpl(int size) {
        this.size = size;
        students = new Student[size];
    }

    @Override
    public Student readStudent(String name) {
        Student temp = null;
        for(int i=0; i<students.length;i++){
            if(students[i]!= null){
                if (students[i].getName().equals(name)){
                    temp = students[i];
                    break;
                }
            }
        }
        return temp;

    }

    @Override
    public boolean writeStudent(Student student) {
        boolean success = false;
        for(int i=0; i<students.length;i++){
            if(students[i]==null){
                students[i] = student;
                success = true;
                break;
            }
        }
        return success;
    }

    @Override
    public void diplayAllStudent(){
        for(Student e:students){
            if (e != null)
                System.out.println(e);
        }
    }

}

//StudenDaoListImpl
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;

public class StudenDaoListImpl implements StudentDao {

    private List<Student> students = new ArrayList<Student>();

    @Override
    public Student readStudent(String name) {
        Student temp = null;
        for(Student e:students){
            if(e.getName().equals(name)){
                temp = e;
            }
        }
        return temp;
    }

    @Override
    public boolean writeStudent(Student student) {
        students.add(student);
        return true;

    }

    @Override
    public void diplayAllStudent(){
        for(Student e:students){
            if (e != null)
                System.out.println(e);
        }
    }

}

答:ac

学生信息存储的形式不同。StudenDaoListImpl是用列表实现存储学生信息，支持存取不定长度的对象数组；StudentDaoArrayImpl是用数组存储学生信息，需要已知数组的大小。

---

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

结合题目3与4中的Test.java的代码讨论分析。不要百度原封不动照搬！

答:面向接口的编程使得，定义和实现分开，这样再设计一个系统时如果需要更改实现只要更改实现类就好不会使得模块的改动引起其他模块的大规模调整。比如第四题中用了两个实现类，而不是把一堆代码放到Student类中，这样如果想用数组来实现或者ArrayList只要改变一下Text中的几行代码，而不用大规模的改变Stdent中的代码。

---

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

3.1. 码云代码提交记录

3.2. PTA实验

5-1：comparable接口强行对实现它的每个类的对象进行整体排序。类的 compareTo 方法是它的比较方法 。实现此接口的对象（和数组）可以通过Arrays.sort 进行自动排序。

5-2：利用Comparator接口对某些对象进行整体排序。

我们需要在compare(T o1, T o2)方法中自定义排序算法。