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	初步了解了继承与接口

参考资料