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

1. 本章学习总结

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

1.2 可选：使用常规方法总结其他上课内容。

对匿名内部类的印象很深（内部类类部类内部内……）。总结一下，匿名内部类也就是没有名字的内部类。正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。

2. 书面作业

作业参考文件下载

• Q1：代码阅读：Child压缩包内源代码

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

   package parent;
  
   public class OutOfParentPackage{
       public static void showParentj(Parent p){
           System.out.println(p.j);
           System.out.println(p.geti());
           p.getj();
       }
   }
   class Parent{
       private int i=1;
       protected int j=2;
       protected int geti(){
           return i;
       }
       public void getj(){
           System.out.println(j);
       }
   }
   class Other{
       public static void showParentj(Parent p){
           System.out.println(p.j);
           System.out.println(p.geti());
       }
  
   }
   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());
       }
   }
  

答：① 不能编译通过

② System.out.println(i);这句会出错。

③ 因为i在父类中被private修饰，所以i在子类中是不可被调用的。如图 ↓↓↓



将父类中的i的private改为protected即可。如图 ↓↓↓

• 1.2 另外一个包中的OutOfParentPackage.java，能否编译通过?提示什么错误？分析原因。如何更改才能使之正常编译？(写不出来正确答案不要紧，但请一定写出思考过程)

答：① 不能编译通过。

② 提示错误3处错误，如下 ↓↓↓







③ 因为在Parent类在com.parent包中，对于另一个包是不可见的。Parent类中的常量j和方法geti也都被protected所修饰，同样对于另一个包是不可见的。将其均改为用public修饰，即可编译成功，如图 ↓↓↓

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

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

   package cc.openhome;
  
   import java.util.Scanner;
  
   public class Guess {
       public static void main(String[] args) {
           Scanner scanner = new Scanner(System.in);
           int number = (int) (Math.random() * 10);
           int guess;
  
           do {
               System.out.print("猜数字（0 ~ 9）:");
               guess = scanner.nextInt();
           } while(guess != number);
  
           System.out.println("猜中了...XD");
       }
   }
  

  改造后代码：

   package cc.openhome;
  
   public abstract class GuessGame {
       public void go() {
           int number = (int) (Math.random() * 10);
           int guess;
           do {
               print("输入数字：");
               guess = nextInt();
           } while(guess != number);
           println("猜中了");
       }
  
       public abstract void print(String text);
       public abstract void println(String text);
       public abstract int nextInt();
   }
  

答：改造前，未使用抽象类，只能控制台输出；改造后，使用抽象类，可以在控制台，也可以使用对话框图形界面等输入。

参考：http://bbs.csdn.net/topics/300065425

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

答：设计一个类去继承GuessGame抽象类，该类表示在图形界面中猜数字，然后在该类中重写抽象类当中的抽象方法。

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

答：abstract（抽象）修饰符，可以修饰类和方法。

① 抽象类：这个类将不能生成对象实例，但可以做为对象变量声明的类型，也就是编译时类型，抽象类就像当于一类的半成品，需要子类继承并覆盖其中的抽象方法。

② 抽象方法：也就是只有声明（定义）而没有实现，需要子类继承实现（覆盖）。

③ 结合改例子，我觉得当一个方法未被具体定义的时候，这时候它只是一个抽象的概念，没有具体的实现，这时候它需要使用abstract修饰。（感觉有点伪代码的意思）

参考：http://blog.csdn.net/aaaaatiger/article/details/5758068

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

答：① 变化的是输入输出的方式，改造前只能在控制台输出，改造后可以在控制台，也可以使用对话框图形界面等输入。

② 不变的是本身的这个抽象类，这个猜数字游戏的功能没有发生改变，我们根据需要来编写程序，以决定到底使用何种输入输出方法。

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

答：① Comparable接口强行对实现它的每个类的对象进行整体排序。

参考JDK ↓↓↓



② Comparable接口中含有compareTo方法，比较此对象与指定对象的顺序。在使用Arrays.sort对指定数组进行排序时，系统自动调用了Comparable接口中的compareTo方法。

参考：Comparable接口的实现和使用

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

答：Comparable接口将比较代码嵌入自身类中，而Comparator在一个独立的类中实现比较。Comparable接口强行对实现它的每个类的对象进行整体排序，Comparator则不强制，它可以使用不同的排序标准做准备。比如：升序、降序。

• Q4：面向接口案例分析
  
  阅读Case-StudentDao.zip案例
• 4.1 画出类关系图，描述每个类与接口的作用。

答：类关系图 ↓↓↓



① Student类：只有getter/setter方法和toString方法。

② StudenDaoListImpl类：继承Student类，接入StudentDao接口。用ArrayList来存放学生信息，具体实现三个抽象方法。

③ StudentDaoArrayImpl类：继承Student类，接入StudentDao接口。用数组来存放学生信息，具体实现三个抽象方法。

④ StudentDao接口：提供三个抽象方法，writeStudent、readStudent和diplayAllStudent。

• 4.2 StudenDaoListImpl与StudentDaoArrayImpl有何区别？

答：StudenDaoListImpl利用ArrayList来存放学生信息，具体实现StudentDao接口的三个抽象方法，其内存空间是动态分配的。StudentDaoArrayImpl利用数组来存放学生信息，具体实现StudentDao接口的三个抽象方法，其内存空间是不可变的。

• Q5：什么是面向接口编程？面向接口编程的好处是什么？
  
  结合题目3与4中的Test.java的代码讨论分析。不要百度原封不动照搬！

答：① 面向接口编程可以使得所有实现接口的对象都拥有共同的行为，使代码与接口相关联，而不需要考虑具体的实现类。

比如T3中的Comparable接口，实现类可以通过接入该接口，重写comparaTo方法，以直接通过使用Arrays.sort对其进行排序。

比如T4中的StudentDao接口，StudenDaoListImpl类和StudentDaoArrayImpl类都接入该接口，各自重写StudentDao接口中的三个抽象方法，这也体现了多态性。

② 好处：面向接口编程可以将接口与实现相分离，从而大大提高程序的灵活性。

参考：面向接口编程详解

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

郭炜埕	无合作对象	项目地址
郭炜埕的博客链接		ShoppingCart码云地址

• 6.2 常用功能描述框架图
  
  

• 6.3 关键代码

   import java.util.Scanner;
  
   public class Main {
  
   	public static void main(String[] args) {
   		Scanner sc = new Scanner(System.in);
   		Cart cart = new Cart();
   		int choice;
   		Product flag = null;
  
   		Product[] books = new Product[7];
   		books[0] = new Product("算法导论", 128, 0);
   		books[1] = new Product("Java学习笔记", 68, 0);
   		books[2] = new Product("数字逻辑", 33.3, 0);
   		books[3] = new Product("离散数学", 38.6, 0);
   		books[4] = new Product("信号与系统", 42.5, 0);
   		books[5] = new Product("大学英语", 42.9, 0);
   		books[6] = new Product("计算机组成原理", 39, 0);
  
   		for(int j = 0; j < 10; j++){
   			choice = welcome();
   			if(choice == 0) break;
   			switch(choice){
   			case 1 :
   				menu(books);
   				System.out.print("选择：");
   				String Name = sc.next();
   				System.out.println(flag = search(Name, books));
   				System.out.println();
   				break;
   			case 2 :
   				System.out.println("所选书为： “" + flag + "”");
   				System.out.print("加入数量：");
   				int num = sc.nextInt();
   				flag.setNum(num);
   				cart.AddToCart(flag);
   				System.out.println("加入成功！");
   				System.out.println();
   				break;
   			case 3:
   				System.out.println(cart);
   				System.out.println("总价： " + cart.getTotalprice());
   				System.out.println();
   		}
  
   	}
   		}
  
   	public static int welcome(){
   		Scanner sc = new Scanner(System.in);
   		System.out.println("********欢迎光临********");
   		System.out.println("******1.查找商品*******");
   		System.out.println("******2.添加商品*******");
   		System.out.println("******3.去购物车*******");
   		System.out.println("******0.退出系统*******");
   		System.out.print("choice = ");
   		int choice = sc.nextInt();
   		return choice;
   	}
   	public static void menu(Product[] product){
   		for(Product i : product){
   			System.out.println(i);
   		}
   	}
   	public static Product search(String Name, Product[] product){
   		for(Product i : product){
   			if(i.getName().equals(Name))
   				return i;
   		}
   		return null;
   	}
  
   }
  
   // Product类
   class Product {
   	protected String name;
   	protected double price;
   	protected int num;
  
   	public Product(String name, double price, int num){
   		this.name = name;
   		this.price = price;
   		this.num = num;
   	}
  
   	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 int getNum() {
   		return num;
   	}
   	public void setNum(int num) {
   		this.num = num;
   	}
  
   	@Override
   	public String toString() {
   		return "《" + name + "》, " + price + ", " + num ;
   	}
  
       // Cart类
       class Cart {
   	ArrayList<Product> list = new ArrayList<>();
   	protected double totalprice = 0;
   	private int n = 0;
  
   	public void AddToCart(Product flag){
   		list.add(flag);
   		n++;
   	}
  
   	public double getTotalprice(){
   		for(int i = 0; i < n; i++){
   			totalprice += list.get(i).getNum() * list.get(i).getPrice();
   		}
   		return totalprice;
   	}
  
   	@Override
   	public String toString() {
   		for(int i = 0; i < n; i++){
   			System.out.println(list.get(i).toString());
   		}
   		return "";
   	}
   }
  

• 6.4 运行界面
  
  
  
  
  
  

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

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

3.1. 码云代码提交记录

① PTA实验截图



② ShoppingCart项目截图

3.2. PTA实验

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

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

一定要有实验总结

• 5-1：比较简单，创建PersonSortable类implement Comparable类，再对compareTo方法进行重写。
• 5-2：和5-1差不多，在其基础上加入了NameComparator类和AgeComparator类。注意区分Comparable和Comparator。