20145221 《Java程序设计》第四周学习总结

20145221 《Java程序设计》第四周学习总结

教材学习内容总结

第六章部分 - 继承与多态

何谓继承

  • 继承
    继承是Java程序设计语言面向对象的又一重要体现，允许子类继承父类，避免重复的行为定义。一般来说，如果类A是类B的父类，类B是类C的父类，那么也称类A是类C的父类，且同一个子类只允许拥有一个父类，而同一个父类则可以拥有多个子类。继承的出现提高了代码的复用性，也让类与类之间产生了关系，提供了多态的前提。

  • extends
    在Java中，使用关键字extends来表示类与类之间的继承关系：

    public class SwordsMan extends Role {
        public void fight() {
            System.out.println("挥剑攻击");
        }
    }

上述代码表示，类SwordsMan继承了类Role，类SwordsMan扩充了类Role的行为，也就是类Role中有定义的程序代码，类SwordsMan因为继承而都拥有了。

  • IS-A

    • IS-A译为“是一种”，子类与父类就是一种“IS-A”的关系。例如上述代码，SwordsMan是一种Role（即SwordsMan is a Role）。
    • 注意建立对象时候的顺序，应该遵守从右往左读的原则（这样才符合IS-A原则）：
    Role role1 = new SwordsMan();
Role role2 = new Magician();
    • 赋值时：如果用父类建立了一个对象实例，那么要将这个对象赋给它的子类时，需要进行强制转eg:
    Role role1 = new SwordsMan();
SowrdsMan swordsMan = (SwordsMan) role1;
    • 我们还可以使用instanceof来判断IS-A关系：
    System.out.println(SwordsMan instanceof Role);     \\输出true
System.out.println(Role instanceof SwordsMan);     \\输出false

  • 多态
    按照字面的意思上说，就是多种状态。指的是使用一个接口，操作多种类型的数据。例如以下代码中，既可以通过Role操作SwordsMan对象，也可以通过Role操作Magician对象。

    public class RPG {
        public static void main(String[] args) {
            SwordsMan swordsMan = new SwordsMan();
            swordsMan.setName("Justin");
            swordsMan.setLevel(1);
            swordsMan.setBlood(200);

            Magician magician = new Magician();
            magician.setName("Monica");
            magician.setLevel(1);
            magician.setBlood(100);

            showBlood(swordsMan);   //SwordsMan是一种Role
            showBlood(magician);    //Magician是一种Role
        }

	//声明为Role类型
        static void showBlood(Role role) {
           System.out.printf("%s 血量 %d%n", role.getName(), role.getBlood());
        }
    }

  • 覆盖（Override）

    • 一般来说，当子类和父类具有一模一样的方法时，会出现覆盖操作，也就是重新定义行为。因为子类一般来说都有其独特的功能，父类一般的函数定义不能满足每个不同角色的需要。
    • 虽然都是角色，都有攻击这一个动作。但是战士施展的是物理攻击，法师施展的是魔法攻击，所以要对子类进行重新定义，使其具有相应的功能。
    • 函数的覆盖也更好的体现了面向对象的多态性。
    • 要将覆盖（Override）与重载（Overload）区分开：覆盖除了保留了原有的相同方法部署，但执行内同不同，方法是一样的；而重载指的是函数名相同，但调用变量的类型个数都不同，是不同的函数，并不存在某个函数把某个函数覆盖的情况。
    • 注意：
    1. 在重新定义父类中的某个方法时，除了可以定义权限较大的关键字外，子类必须撰写与父类方法中相同的签 署。如果函数名打错了，那就不是重新定义了，而是子类新定义了一个方法函数。
      2. 通常，我们会在子类中重新定义行为前加上\@Override，用以判断该方法是否真的重新定义了父类中的一个方法。
      3. 重新定义方法时，对于父类中的方法权限，只能扩大不能缩小。
      4. static方法属于类拥有，如果子类中定义了相同签署的static成员，那么该成员属于子类拥有，而非重新定义，所以static方法没有多态，因为对象不会个别拥有static成员。

  • 抽象方法、抽象类

    • abstract：对于一个类的方法区块中实际上没有撰写任何程序代码，为了避免不被漏掉，可以使用abstract标示该方法为抽象方法。该方法不用撰写{}区块，直接“;”结束即可。
    • 注意：
    1. Java中有抽象方法的类一定是抽象类，但抽象类中的方法不一定都是抽象方法。
    2. 象类，但抽象类中的方法不一定都是抽象方法

  • Square（正方形）类继承Rectangle（矩形）类合适吗？
    应该是可以的，因为正方形是一种（IS-A）矩形，它拥有矩形的一般特点。

继承语法细节

  • public/package/protected/private

    关键字 内部类 相同包类 不同包类
    public 可存取 可存取 可存取
    protected 可存取 可存取 子类可存取
    无 可存取 可存取 不可存取
    private 可存取 不可存取 不可存取

  • super与this

    • this与super的意义较为相同，前者表示指代当前类，而super指的是子类的父类。
    • 注意：
    1. this()与super()只能择一调用，而且一定要在构造函数第一行执行。例如书中课后习题P192第10题选择题，答案应该选D。因为，Some类中的this(10);没有放在构造函数的第一行。
    2. 构造函数可以重载，如果子类构造函数中没有指定执行父类中哪个构造函数，默认会调用父类中无参数构造函数。
    3. 5.2.2节提到，编译程序会在你没有撰写任何构造函数时，自动加入没有参数的默认构造函数(Default Constructor)，如果自行定义了构造函数，就不会自动加入任何构造函数了。
    • 基于上述注意第2点，书中P192第9题选择题B选项，输出结果应为
    Some()
Some(int x)
Other(int y)
    • 基于上述注意第2、3点，书中P191第7题选择题应选D选项，因为父类中撰写了带参数的构造函数，而子类没有写调用何种父类的构造函数，这样就会默认调用父类不含参数的构造函数，但父类中没有，所以编译失败。

  • java.lang.Object

    • toString
    • equals
    • hashCode
    • instanceof
    1. 可以用来判断对象是否由某个类创建，左操作数为对象，又操作数为类；
    2. 可以检查左操作数类型是否是又操作数类型的继承架构中。

  • 垃圾收集（Garbage Collection,GC）
    在Java中，程序员不需要去关心内存动态分配和垃圾回收的问题，这一切都交给了JVM来处理。JVM会把无法通过变量引用的对象当作垃圾对象进行搜集。

  • 设计模式
    参考实验二 Java面向对象程序设计

第七章部分 - 接口与多态

何谓接口

  • 接口定义行为
    • 对于定义行为，Java中可以使用interface关键字定义。
    • 是一种特殊的类，里面全部是由全局常量（static final）和公共的抽象方法所组成。
    • 接口的数据成员，只允许被public, static, final修饰。
      接口的方法成员，只允许被public, abstract修饰。
    • 接口中的数据成员都为static final类型，必须进行初始化，且接口的数据成员的值不能被修改，允许省略static, final关键字。
    • 接口中的方法必须是“抽象方法”，不能有方法体，允许省略public及abstract关键字。
    • 对于接口多态语法的判断，方式是“右边是不是拥有左边的行为”，或者“右边对象是不是操作了左边接口”。
  • implements
    • 接口不能用new运算符直接产生对象，必须利用其特性设计新的类，再用新类来创建对象与抽象类一样，接口要使用也必须通过子类，子类通过implements关键字实现接口。
    • 操作某接口时，对接口中定义的方法有2种处理方式，一是操作接口中定义的方法，二是再度将该方法标示为abstract.
    • 实现格式：
        class 子类名称 implements 接口A，接口B，….{
	//子类成员声明
    }
  • 解决需求变更
    需求会不断变化，架构也有可能因此而修改。好的架构在修改时，其实也不会全部的程序代码都被牵动，这就是设计的重要性。一般来说，会确定一个程序的需求边界，然后设计好架构，接着就是不断朝着这个方向进行优化。

接口语法细节

  • 接口中的public abstract可以省略，但要注意：接口中的方法必须是“抽象方法”，不能有方法体，允许省略public及abstract关键字。
  • 接口中可以使用extends继承接口，并且可以继承多个接口
    • 接口不能继承一个抽象类，却可以通过extends同时继承于多个接口。
    • 例如：interface A extends B, C{……}
  • 匿名内部类
    • 匿名内部类也就是没有名字的内部类。正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写，但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。
    • JDK8 前在匿名内部类中访问局部变量，则该局部变量必须为final
  • enum
    • 可以用于定义常量，例如：
        public enum Color {  
  	RED, GREEN, BLANK, YELLOW  
    }
    • 可以用于switch语句，将enum定义的枚举常数用以switch判断选择。

代码调试中的问题和解决过程

第六章书中部分代码调试：

  • 在完成课后习题时，对书中P192第9题选择题B选项有疑惑，所以将代码调试了一下。
    class Some {
        Some(){
            this(10);
            System.out.println("Some()");
        }
        Some(int x){
            System.out.println("Some(int x)");
        }
    }
    class  Other extends Some{
        Other(){
            super(10);
            System.out.println("Other()");
        }
        Other(int y){
            System.out.println("Other(int y)");
        }
    }
    public class Test{
        public static void main(String[] args) {
            Other other = new Other(10);
        }
    }

结论：编写之前，我认为B选项就是对的，但在编译之后，输出的结果和我的预想差异很大。虽然编译通过，但是不能理解为什么会这样输出。所以，我又重新地看了一下关于构造函数的知识点，更加明白了其中的含义。（相关内容已经在前文中进行了归纳总结）

第七章书中部分代码调试

  • 对于书中关于接口的讲解，仅仅看书还不能理解透彻，所以在IDEA中敲了一段代码，助于理解记忆。

//伪代码
public interface 接口名称{
private static final int var1=1; //error，必须用public修饰
public static final int var2 = 2;
public abstract void fun1();
private abstract int fun2(); //error，必须用public修饰
}
```

```java

//伪代码
public interface A{
int num; //error，没初始化
String name = “test”;
public void getName( ) {……} //error，不允许定义方法体
}
```

  • 匿名内部类（代码已托管）
    其实这一章感觉不好理解的就是匿名内部类，只知道是为了某些类的子类或接口操作类只使用一次，才定义了匿名内部类这个功能。不过通过书上代码的编译运行，大致了解了其中的机制。总之，首先要记牢匿名内部类的基本语法：
	new 父类()|接口(){
		//类基本操作
	};

其他（感悟、思考等，可选）

  • 这两章的学习其实是对第四章和第五章的一种补充。第四章介绍了对象，第五章讲了对象的封装，紧接着第六七章，就介绍了在此基础上对对象的一些应用，比如对象之间的继承、多态、接口等。这些概念描述的是Java语言中对象之间的一种关系，加强了各类对象之间的联系，使得Java语言不是孤立的程序代码，而是可以将各个代码通过“对象关系”整合起来的系统性的语言。

  • 这两章的内容，我不仅对继承和接口有了一定的了解，而且对Java语言中的设计模式以及解决需求变更有了更深刻的印象。往后学习，特别是实践应用，我们不可能用一个包、一个类、一个方法去满足我们的设计需求，往往需要我们在很多类中进行操作，而这就要求我们首先面对一个问题，要有清晰的设计思路，要有全盘的解决需求，然后制定一个范围架构，在其中通过类搭建各个不同的对象实例。

  • 总之，这两章是基于前两章的知识在介绍关于对象的新应用。就知识点来说并不是很多，只是可能有些晦涩难懂，以及可能还不知道如何去应用这些知识，这样也就不便于我们理解深刻，只是在脑海中有了一个大致的理论框架。知识虽然已经看完，博客也已经写完，但是一周的时间完全不够来消化两章的知识，所以我觉得这并不能代表我已经掌握了继承与接口，这方面知识的巩固与技术的提高有待于后期的代码实践与应用。

  • 【附1】托管截图（为了以后方便测试代码，按照书上的分类在ch06、ch07中又创建了不同的包）：

  • 【附2】用cloc.exe统计代码如下：

学习进度条

代码行数（新增/累积） 博客量（新增/累积） 学习时间（新增/累积） 重要成长
目标 5000行 30篇 400小时
第一周 200/200 1/6 20/20 学会MarkdownPad2
第二周 150/350 1/7 15/35 理解了补码机制
第三周 500/850 1/8 25/60 初步了解了对象
第四周 1058/1908 1/9 27/87 初步了解了继承与接口

参考资料

posted @ 2016-03-27 21:00  20145221高其  阅读(276)  评论(2)  编辑  收藏  举报