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

最新推荐文章于 2024-07-23 21:37:49 发布

weixin_30535565

最新推荐文章于 2024-07-23 21:37:49 发布

阅读量77

点赞数

文章标签： java

原文链接：http://www.cnblogs.com/vicheng/p/6596803.html

版权

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。

转载于:https://www.cnblogs.com/vicheng/p/6596803.html

weixin_30535565

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
201521123064 《Java程序设计》第5周学习总结

1. 本章学习总结1.1 尝试使用思维导图总结有关多态与接口的知识点。1.2 可选：使用常规方法总结其他上课内容。对匿名内部类的印象很深（内部类类部类内部内……）。总结一下，匿名内部类也就是没有名字的内部类。正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。2. 书面作业作业参考文件下载Q1：代码...
复制链接

扫一扫