20145232 韩文浩《Java程序设计》第4周学习总结

教材学习内容总结

· Chapter 继承与多态

继承：避免多个类间重复定义共同行为。继承可以理解为一个对象从另一个对象获取属性的过程。
所有Java的类均是由java.lang.Object类继承而来的，所以Object是所有类的祖先类，而除了Object外，所有类必须有一个父类。
将相同的代码提升为父类，继承消除重复代码。

public class Role{
    private String name;
    private int leval;
    private int blood;
    public int getBlood(){
        return blood;
    }
    public void setBlood(int blood){
        this.blood=blood;
    }
    public int getLevel(){
        return level;
    }
    public void setLevel(int level){
        this.level=level;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
}

使用estends关键字进行继承，扩充Role的行为。

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

public class Magician extends Role{
    public void fight(){
        System.out.println("魔法攻击");
    }
    public void cure(){
        System.out.println("魔法治疗");
    }
}

从以下的程序结果可以看出继承。

public class RPG{
    public static void main(String[] args){
        demoSwordMan();
        demoMagician();
    }

    static void demoSwordsMan(){
        SwordsMan swordsMan = new SwordsMan();
        swordsMan.setname("Justin");
        swordsMan.setlevel(1);
        swordsMan.setblood(200);
        System.out.printf("剑士：(%s,%d,%d)%n",swordsMan.getName(),swordsMan.getLevel(),swordsMan.getBlood());

    }
    static coid demoMagician(){
        Magician magician =new Magician();
        magician.setname("Monica");
        magician.setLevel(1);
        magician.setBlood(100);
        System.out.printf("魔法师：(%s,%d,%d)%n",magician.getName(),magician.getLevel(),magician.getBlood())；
    }
}

结果如图

教材中通过设计一款RPG游戏的部分代码向我们展示了“重复”程序代码的弊端，SwordsMan与Magician没有定义getName()等方法，但从Role得到继承，可以直接使用。

private成员也会被继承，只不过子类无法直接存取，必须通过父类提供的方法来存取
子类只能继承一个父类（单一继承）
类与类之间要有所属is-a “是一种”关系

Role role1= new SwordsMan();
SwordsMan swordsMan= role1;
SwordsMan swordsMan= （SwordsMan）role1;

//SwordsMan是一种Role
//role1为Role声明的名称，Role不一定是一种SwordsMan，编译失败
//别啰嗦！通过编译，后果自负

多态：使用单一接口操作多种类型的对象。具有更高的可维护性。用父类声明对象引用，用子类生成对象就有了多态。
既可以通过Role类型操作SwordsMan对象，也可以通过Role类型操作Magician对象，这就是多态。

作用：多态的存在提高了程序的扩展性和后期可维护性
前提：需要存在继承或者实现关系要有覆盖操作

Override：在继承父类之后，定义与父类中相同的方法部署，但执行内容不同，称为重新定义（Overeide）在子类中某个方法前标注@Override，表示要求编译程序检查，该方法是不是真的重新定义了父类中某个方法。在重新定义父类中某个方法的时候，子类必须撰写与父类方法中相同的签署，加上@Override可用来检查该方法是否真的重新定义了父类中的某个方法，防止打错字，否则就会发生错误。

书中关于@Override描述不是很清晰，看了视频就可以得到一些补充。

Override也称函数覆盖，重写，复写
父类中的私有方法不可以被覆盖
在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取
覆盖时，子类方法权限一定不能小于父类方法权限
当子类需要父类的功能，而功能主题子类有自己特有内容时，可以override父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

abstract：如果某方法区块中真的没有任何程序代码操作，可以使用abstruct标示该方法为抽象方法，该方法不用撰写{}区块，直接“；”结束即可。内含抽象方法的类，一定要在class前标示abstract。

public abstract class Role{
......略
public abstract void fight();
}

protected成员：相同包中的类可以直接存取，不同包中的类可以再继承后的子类直接存取。
权限大小： private<无关键字<protected<public

Super：如果想取得父类中的方法定义，可以在调用方法前，加上super关键字。不能定义为private（这就限定只能在类中使用）。重新定义方法要注意对于父类中的方法权限只能扩大不能缩小。

 public String toString(){
      return "剑士" + super.toString();

垃圾回收：在Java中，程序员不需要去关心内存动态分配和垃圾回收的问题，这一切都交给了JVM来处理。顾名思义，垃圾回收就是释放垃圾占用的空间，那么在Java中，什么样的对象会被认定为“垃圾”？（Java垃圾回收机制：http://www.cnblogs.com/dolphin0520/p/3783345.html）

· 接口与多态

抽象类：java可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的就是抽象类。抽象类和抽象方法必须用abstruct关键字来修饰。

interface：接口定义行为但不可定义操作。接口中的成员修饰符是固定的。类与接口是实现关系，而且类可以继承一个类的同时实现多个接口。

public interface Swimmer{
    public abstract void main swim();
}

implements：类要操作接口，使用implements关键字，操作接口时，对接口中定义的方法的两种处理方式：1.操作接口中定义的方法，2.将该方法标示为abstract

例如：

public abstract class Fish implements Swimmer {
protected String name;
public Fish(String name){
    this.name = name;
}
public String getName(){
    return name;
}
@Override
public abstract void swim();
}

类与类之间存在着继承关系，类与接口中间存在的是实现关系。继承用extends，实现用implements

在interface接口中常常可以定义枚举常数（例：public static final int），实际上，在interface接口中也只能定义public static final的枚举常数，并且一定要使用=指定值，否则就会编译错误。

抽象类与接口的区别
1：抽象类只能被继承，而且只能单继承。
接口需要被实现，而且可以多实现。
2：抽象类中可以定义非抽象方法，子类可以直接继承使用。
接口中都有抽象方法，需要子类去实现。
3：抽象类使用的是 is a 关系。
接口使用的 like a 关系。
4：抽象类的成员修饰符可以自定义。
接口中的成员修饰符是固定的。全都是public的。

enum：enum语法可用于定义枚举常数，enum实际上定义了类，而enum中列举的常数实际上是public static final，无法撰写程序直接实例化枚举类型，因为构造函数权限设定为private，只有类中才可以实例化。enum 可定义枚举常数，但实际上 enum 定义了特殊的类，继承自 java.lang.Enum，编译过后会产生 Action.class 文件，可用这个 Action 声明类型

public class Game {
    public static void main(String[] args){
        play(Action.RIGHT);
        play(Action.UP);
//只能传入 Action 实例
    }

    public static void play(Action action){
// action 参数声明为 Action 类型，所以只接受 Action 的实例，这样就不需要必须使用 default 检查，编译程序在编译时期会进行类型检查
        switch(action){
            case STOP:
                out.println("播放停止动画");
                break;
            case RIGHT:
                out.println("播放向右动画");
                break;
            case LEFT:
                out.println("播放向左动画");
                break;
            case UP:
                out.println("播放向上动画");
                break;
            case DOWN:
                out.println("播放向下动画");
                break;
        }
    }
}

教材学习中的问题和解决过程

刚开始学习继承的时候敲第一个角色游戏代码出现错误，在继承的时候，需要将完整的代码都放在同一个文件夹下，书中有时候只是展现一部分代码，但前面的角色定义还要敲上去，保证代码的完整性，这样子类才会继承父类。
教材中的一些内容讲得十分详尽，例如多态与is-a，翻来覆去讲不同的语句可能出现的编译失败的情况及原因，这部分的学习也十分重要，关系到以后写出来的东西有没有弹性、好不好维护的问题；书中也有一些表述比较少，让人看得不是很懂的地方，例如instanceof运算符，Override等，只能通过视频加以学习。现阶段还停留在敲书上代码的过程，希望自己能够在接下来提出些更有价值的问题。

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

interface Some {
    protected static final int x = 10;
}
public class Main {
    public static void main (String[] args){
        System.out.println(Some.x);
    }
}

被声明为protected的成员，相同包中的类可以直接存取，不同包中的类需要在继承后的子类中存取。代码中没有继承关系不同类，编译失败，删去protected编译通过结果为10

本周代码托管截图

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

随着编写的代码越来越长，即使是按着书上敲代码，有时候也会弹出来很多错误，有的是因为大小写没有正确书写，有的是因为代码片段不全导致编译错误，还是实践的时候缺少动脑去思考，思考为什么语句要这样写，语法遵循着怎样的格式，这都是需要多看代码，多敲代码才能形成的一种思维能力。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）
目标	4000行	16篇	400小时
第一周	200/200	2/2	20/20
第二周	300/400	1/3	25/45
第三周	500/900	1/4	40/85
第四周	800/1700	1/5	45/130

参考资料