# 20145210 《Java程序设计》第04周学习总结

教材学习内容总结

第六章

继承

•继承：继承基本上就是避免多个类间重复定义共同行为。

我理解的就是：在编写程序的过程中可能会出现部分代码重复的现象，把重复的部分单独定义为一类（父类），在其他代码中（子类）直接继承，这样子类可直接使用父类的方法，子类的对象也可以使用父类的方法，同时避免了大段代码的重复出现的问题。

•扩充：关键字 extend

public class SwordsMan extends Role{
        //SwordsMan会继承Role的行为，并对Role的行为进行扩充，仅在SwardsMan中使用新定义的行为
        public void fight(){
            System.out.println("挥剑攻击");
        }
    }

•在Java中，子类只能继承一个父类

•is-a：因为子类继承了父类，所以子类是一种父类

•运用“is-a”关系判断语法的正确性：方式：判断等号右边是否为等号左边的子类，以下两例均无法通过编译：

 SwordsMan swordsMan = new Role();
    Magician magician = new Rile();
    //Role 为 SwordsMan 和 Magician 的父类，右边类不是左边类的子类，所以编译不通过

 Role role1 = new SwordsMan();
    //SwordsMan 是一种 Role ，这条语句可以通过编译
    SwordsMan swordsMan = role1;
    //role1 为 Role 声明的名称，编译程序认为 Role 不一定是一种 SwordsMan，编译失败

•住嘴语法：在等号右边加括号声明即可通过编译，但执行不一定能通过，例如：

Role role2 = new Magician();
    SwordsMan swordsMan = (SwordsMan) role2;
    //在 role1 前加括号声明关系，编译能通过,但执行时不一定能通过，要根据参考的对象实际类型判断，本例让魔法师扮演剑士，执行时会出现错误

•多态：使用单一接口操作多种类型的对象。我的理解是：就子类和父类来讲，一个父类可以有很多子类，在程序中就可以通过一个父类操作很多它的子类，这样比较方便，同时使程序具有更高的可维护性

•封装是继承的基础，继承是多态的基础

•重新定义：在继承父类之后，定义与父类中相同的方法部署，但各子类中执行的内容不同。父类定义了方法，但是没有内容，子类可以重新定义父类中的实际行为。因父类定义了方

法，所以可以运用多态，传入子类中定义的方法，实现一些功能操作。

•注意：在重新定义父类中某个方法时，子类必须撰写与父类方法中相同的签署，就是定义的方法的名字要完全一样

•注意：重新定义方法时，对于父类中的方法权限，只能扩大但不能缩小，若原来成员 public 子类中重新定义时不可为 private 或 protected

•标注：@Override 如果在子类中某个方法前标注@Override，表示要求编译程序检查，该方法是不是真的重新定义了父类中的某个方法，如果不是的话，就会引发编译错误

•抽象方法、抽象类：

•抽象方法：如果某方法区块中真的没有任何程序代码操作，可以使用 abstract 标示该方法为抽象方法，该方法不用撰写{}区块，直接“;”结束即可，例如：

public abstract void fight();

•抽象类：Java中规定内含抽象方法的类，一定要在 class 前标示 abstract ，表示一个定义不完整的抽象类

•类中若有方法没有操作，且标示为 abstract，表示这个类定义不完整，定义不完整的类不能用来生成实例，就好像设计图不完整就不能拿来生产成品

•如果尝试用抽象类创建实例，会引发编译错误

•子类如果想继承抽象类，对于抽象方法有两种做法：（如果两种做法都没有实施，就会引发编译错误）

1）继续标示该方法为 abstract（该子类因此也是个抽象类，必须在class前标示 abstract）

2）操作抽象方法

继承语法细节

•protected：被声明为 protected 的成员，相同包中的类可以直接存取，不同包中的类可以在继承后的子类中直接存取，存取时可用“this”，具体的权限关键字与范围如下：

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

•super：在Java中，如果想取得父类中的方法定义，可以在调用方法前加上“super”关键字，例如：

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

•注意：可以使用 super 关键字调用的父类方法，不能定义为 private（因为这就限定只能在类内使用）

•构造函数

•创建子类实例后，会先执行父类构造函数定义的流程，再执行子类构造函数定义的流程

•构造函数可重载

•如果子类构造函数中没有指定执行父类中哪个构造函数，默认会调用父类中无参数的构造函数，例如：

 class Some {
        Some() {
        System.out.println("调用Some（)");
    }
  }
    class Other extends Some{
        Other(){
            //子类构造函数中没有指定执行父类中哪个构造函数，则调用父类中无参数的构造函数
            System.out.println("调用Other（）");
        }
    }
    //先执行Some中的流程，再执行Other中的流程，最后的结果是：先显示“调用Some()”,再显示“调用Other()”

运行结果截图：

•若父类中自行定义了构造函数，在父类中就不会加入任何构造函数了，此时若子类没有指定调用父类哪个函数，就会编译失败

•final

•类加 final：如果class前加了final，则表示这个类是最后一个了，不会再有子类 → 这个类不能被继承（例：String 在定义时就已经限定为 final 了）

•方法加 final：定义方法时也可以限定该方法为 final，表示最后一次定义方法 → 子类不可以重新定义 final 方法

•java.lang.Object

•java.lang.Object 是所有类的顶层父类，这代表了 Object 上定义的方法，所有对象都继承下来了，只要不是被定义成 final 方法，都可以重新定义

•java中所有对象，一定“是一种”Object

•如果定义类时没有使用 extends 关键字指定继承任何类，那一定是继承了 java.lang.Object，以下两段代码是等价的

public class Some{}

public class Some extends Object{}

•toString()

•toString()的作用：传入对象

•toString()是 Object 上定义的方法

•toString()调用方法：以下两段代码是等价的，调用的时候选取第二种方式调用即可

Syetem.out.println(swordsMan.toString());

System.out.println(swordsMan);

•equals()

•equlas()是 Object 类有定义的方法，程序代码如下：

public boolean equals(Object obj){
        return(this == obj);
    }

•若果没有重新定义 equals()，使用 equals() 方法时，作用等同于 ==

•要比较实质相等性，必须自行重新定义equals()

•instanceof

•用途：判断对象是否由某个类创建，左操作数是对象，右操作数是类，也就是判断 instanceof 左边的对象是否由右边的类创建

•并非只有左操作数对象为右操作数类直接的实例才能返回 true，只要左操作数类型是右操作数类型的子类型，instanceof 也返回 true

•垃圾收集

•垃圾：如果程序执行流程中已无法再使用某个对象，该对象就只是徒豪内存的垃圾

•垃圾收集机制：GC

•执行流程中，无法通过变量参考的对象，就是GC认定的垃圾对象

•GC在进行回收对象前，会调用对象的 finalize() 方法（这是 Object 上定义的方法），如果在对象被回收前有些事情想做，可以重新定义 finalize() 方法

第七章

何谓接口

•接口：书上没有明确地给出接口的定义，我理解的接口就是一段程序中可能有很多类会有共同的行为，但这些类本身并不具有任何关系，如果使用继承的话程序架构会不合理，所以使用统一的接口表示这些类具有共同的行为

•interface：可定义行为,例如：

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

•implements：类要操作接口，必须使用 implements 关键字,例如：

public abstract class Fish implements Swimmer{
}

•操作某接口时，对接口中定义的方法有两种处理方式：

1）操作接口中定义的方法

2）再度将该方法标示为 abstract

•继承与操作接口的区别：继承会有“是一种”关系，操作接口表示“拥有行为”，但不会有“是一种”的关系

•多态语法合法性判断：判断等号右边是不是拥有等号左边的行为，即等号右边的对象是不是操作了等号左边的接口，以下这个例子就可以通过编译：

Swimer swimmer = new Shark();//因为 Fish 操作了 Swimmer 接口，即 Fish 拥有了 Swimmer 行为。Shark 继承 Fish ,所以Shark 拥有 Swimmer 行为

•扮演语法：会操作 Swimmer 接口的不一定继承Fish，加上扮演语法即可通过bianyi,例如：

Swimmer swimmer = new Shark();
Fish fish = (Fish)swimmer;

以下的例子将会抛出 ClassCastException 错误：

Swimmer swimmer = new Human();//将 swimmer 参考到 Human实例
Shark shark = (Shark)swimmer;//让 swimmer 扮演鲨鱼

已经将 swimmer 参考到 Human 实例了，再让他扮演鲨鱼就会出现错误

•解决需求变更问题：我们可以定义一些拥有不同行为的接口，定义一些类作为父类，当增加新的需求的时候，可以操作接口，代表拥有接口的行为，也可以继承父类，代表这个新的类“是一种”父类，原有的程序无需修改，只针对新的需求撰写程序即可

•在java中，类可以操作两个以上的接口，也就是拥有两种以上的行为

•在java中，接口可以继承自另一个接口，也就是继承父接口行为，再在子接口中额外定义行为，例如：

public interface Diver extends Swimmer{  //接口 Diver 继承了接口 Swimmer
    public abstract void dive();
}

接口语法细节

•在java中，可使用 interface 定义抽象的 行为与外观，如接口中的方法可声明为 public abstract ,例如：

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

•接口中的方法没有操作的时候，一定要是公开抽象，可以省略 public abstract ,例如：

public interface Swimmer{
    void swim();  //此处默认是 public abstract
}
•由于默认一定是 public ，在类操作接口的时候也要撰写 public

interface Action{

void execute();

}

class Some implements Action{

void execute(){

//Some 类在操作 execute() 方法时，没有撰写 public ，因此默认为是包权限，这等于是将 Action 中的 public 方法缩小为包权限，所以编译失败

//将 Some 类的 execut() 设为public 才可通过编译

System.out.println("做一些服务");

}

}

•在 interface 中，只能定义 public static final 的枚举常数 ，例如：

public interface Action{
    public static final int STOP = 0;
}

如下撰写程序时，编译程序会自动展开为 public static final

public interface Action{
    int STOP = 0;
}

•在接口中枚举常数，一定要使用 = 指定值，否则编译错误

•接口可以继承别的接口，可以同时继承两个以上的接口，使用 extends 关键字 ，代表了继承父接口的行为，例：

interface Action{
    void executes();
}
// 定义 Acton 为父接口
interface Some extends Action{
    void doSome();
}
interface Other extends Action{
    void doOther();
}
// Some 和 Other 接口继承 Action 接口
public class Service implements Some,Other{
// Service 继承 Some 和 Other 接口
    @Override
    public void execute(){
        System.out.println("execute()");
    }
// Service 重新定义 execute() 方法
    @Override
    public void doSome{
        System.out.println("doSome()");
    }
    @Override
    public void doOther{
        System.out.println("doOther()");
    }
// Service 重新定义 doSome 和 doOther 方法
}

•匿名内部类：某些子类或接口操作类只使用一次，不需要为这些类定义名称，这时可使用匿名内部类

•语法：

new 父类()|接口(){
//类本体操作
};

•JDK8 之前，若要在匿名内部类中存取局部变量，则该局部变量必须是 final ，否则会发生编译错误

final int[] numbers = {10,20};

•enum：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;
        }
    }
}

•enum中列举的常熟，实际上是 public static final ，且为枚举类型实例，因为构造函数权限设定为 private ,只有类中才可以实例化

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

问题一：

继承和调用函数有什么区别？

解决：

这是我刚开始看第六章的时候产生的问题，通过对第六章、第七章内容的学习，我认为继承和调用函数的区别在于以下几点：

1）在java中，子类只能继承一个父类，但是可以调用很多函数

2）子类在继承父类之后可以对父类中定义的方法进行补充，调用函数就是直接调用已经写好的函数，不会再在程序中对函数进行补充

3）继承可以是继承类，也可以是继承接口，类也可以同时继承某个类，同时操作某些接口

总体来讲觉得继承相比调用函数更为灵活，程序的弹性更大，在撰写一个很大的项目的时候使用继承可以使程序更为明确，在维护的时候也更加方便

问题二：

教材181页说“如果没有重新定义，使用 equals() 方法时，作用等同于 == ，要比较实质相等性，必须自行重新定义”但是之前使用 equals() 的时候是直接使用的，并没有进行重新定义，也能比较实质相等性，对于 equals() 的使用还是不太理解

解决：

问题已经放到答疑论坛里面了，相信老师会给出指导，同学们也会在论坛里进行交流

问题三：

教材188页的三段程序里定义了 print、println 两个方法，不是很清楚这两个方法具体要干嘛，放在这有什么具体的意义

解决：

我先把这三段代码敲到电脑里，运行成功，之后我先删掉 GuessGame 及 ConsoleGame 里面定义的 print 方法，把 GuseeGame 里面的 print 改成了

System.out.print("输入数字："); 接着，我对 println 方法及语句做了同样的改动，结果运行成功，所以我认为这两个方法就是让程序输出指定的内容，作用和

System.out.print一样，只不过教材通过这个方法给我们举例子，让我们更明白撰写程序的时候各程序之间的关系

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

问题一：

教材201页第七章的代码运行的时候出现了问题，代码及截图如下：

public class Ocean {
    public static void main(String[] args){
        doSwim(new Human("贾斯汀"));
        doSwim(new Submarine("黄色一号"));
        doSwim(new Shark("兰尼"));
        doSwim(new Anemonefish("尼莫"));

    }

    static void doSwim(Swimmer swimmer){
        swimmer.swim();
    }
}

运行结果如下：

解决：

由于之前没有对 Shark 和 Anemonefish 进行定义，所以编译的时候找不到这两类具体的内容，于是我就对这两类进行定义，代码如下：

鲨鱼游泳：

public class Shark extends Fish{
    public Shark(String name){
        super(name);
    }

    @Override
    public void swim(){
        System.out.printf("鲨鱼 %s 游泳%n",name);
    }
}

小丑鱼游泳：

public class Anemonefish extends Fish{
    public Anemonefish(String name){
        super(name);
    }

    @Override
    public void swim(){
        System.out.printf("小丑鱼 %s 游泳%n",name);
    }
}

定义之后代码运行成功，最终运行结果如下：

本周代码托管截图

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

本周的学习让我深切地体会到了动手实践的重要性，有些东西在教材上看不明白，但是通过敲代码的过程能够看到代码之间的联系，通过IDEA中给出的编译失败原因也能积累处理代码中问题的方法，多实践能有很大收获，在接下来的学习过程中我也要坚持敲代码，并继续尝试自己编写一些代码，让自己的思维活起来，不拘泥于教材上给的实例。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	200/200	2/2	20/20
第二周	300/500	1/3	18/38
第三周	500/1000	1/4	22/60
第四周	300/1300	1/5	30/90

参考资料

• Java学习笔记(第8版)
• 《Java学习笔记(第8版)》学习指导