20145127《java程序设计》第四周学习总结

教材学习内容总结

第六章 继承与多态

6.1 何为继承

0.面向对象中，子类继承父类，避免城府的行为定义。正确判断使用继承的时机，以及继承之后如何活用多态，才是学习继承时的重点。

1.继承：避免多个类间重复定义共同行为。

继承的好处：将name、level、blood改为其它名称，只要修改Role.java就可以了，只要继承Role的子类都无需修改。

public class RPG {

public static void main(String[] args)

{

demoSwordsMan();

demoMagician();

}

static void demoSwordsMan()
{
    SwordsMan swordsMan = new SwordsMan();
    swordsMan.setName("Justin");
    swordsMan.setLevel(1);
    swordsMan.setBlood(200);
    System.out.pringtf(“剑士：(%s, %d, %d)%n”, swordsMan.getName(), swordMan.getLevel(), swordsMan.getBlood());
}

static void demoMagician()
{
    Magician magician = new Magician();
    magician.setName("Monica");
    magician.getLevel(1);
    magician.getBlood(100);
    System.out.printf（“魔法师：(&s, &d, &d)%n”, magician.getName(), magician.getLevel(), magician.getBlood()）;
}

}

执行结果：

剑士：（Justin，1，200）

魔法师：（Monica，1，100）

2.多态与is-a

在java中，子类只能继承一个父类。

is-a：继承除了可避免类间重复的行为定义类外，还有一种重要的关系——is-a，中文称为“是一种”的关系。

多态：抽象的说，就是使用单一接口操作多种类型的对象。

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.getLevel(1);
    magician.getBlood(100);

    showBlood(swordsMan);
    showBlood(magician);
}

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

}

执行结果：

Justin 血量 200

Magica 血量 100

3.重新定义行为

再重新定义父类中的某个方法时，子类必须编写与父类方法中相同的签署。

再重新定义某种方法时，加上@override，就不用担心打错字的问题了。

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.getLevel(1);
    magician.getBlood(100);

    drawFight(swordsMan);
    drawFight(magician);
}

static void showBlood(Role role)
{
    System.out.printf(role.getName());
    role.fight();
}

}

执行结果：

Justin挥剑攻击

Monica魔法攻击

4.抽象方法、抽象类

java中规定内涵抽象方法的类，一定要在class前标示abstract，表示一个定义不完整的抽象类。（如果尝试用抽象类创建实例，就会引发编译错误）

子类若继承抽象类，对于抽象方法有两种做法：

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

·操作抽象方法。

(两种抽象方法都没有实施，就会引发编译错误)

6.2 继承语法继承

1.protected成员

被声明为protected成员，相同包中的类可以直接存取，不同包中的类可以自己城中的子类直接存取。

java中的权限关键字：public、protected、private。（实际上有4个权限范围，因为没有定义权限关键字，默认就是是包范围）

2.重新定义的细节

对于父类中的方法权限，只能扩大不能缩小。

在JDK5之前，重新定义方法时除了可以定义权限较大的关键字外，其他部分必须与父类中方法签署完全一致。

在JDK5之后，重新定义方法类时，如果返回类型是父类中方法返回类型的子类，也是可以通过编译的。

3.java.lang.Object

如果定义类时没有使用extends关键字指定继承任何类，那一定是继承java.lang.Object。

因此在java中，任何类追溯至最上层一定就是java.lang.Object，也就是说，在java中所有对象，一定“是一种”Object。

任何类型的对象，都可以使用Object申明的名称来参考。

import java.util.Scanner;

import static java.lang.System.out;

public class Guess

{

public static void main(String[] args)

{

ArrayList names = new ArrayList();

collectNameTo(names);

out.printIn(“访客名单：”);

printUpperCase(names);

}

static void collectNameTo(ArrayList names)

{

Scanner console = new Scanner(System.in);

while(true)

{

out.print(“访客名称：”);

String names = console.nextLine();

if(name.equals("quit"))

{

break;

}

names.add(name);

}

}

static void printUpperCase(ArrayList names)
{
    for(int i = 0; i < names.size(); i++)
    {
        String name = (String) names.get(i);
        out.printIn(name.toUpperCase());
    }
}

}

执行结果：

访客名称：Justin

访客名称：Monica

访客名称：Irene

访客名称：quit

访客名单：

JUSTIN

MONICA

IRENE

4.关于垃圾收集

创建对象会占据内存，如果程序执行流程中已经无法再使用某个对象，该对象只是徒耗内存的莱基。

对于不再使用的对象，JVM有垃圾收集机制（GC），收集到的垃圾对象所占据的内存，会被垃圾收集器释放。

5.再看抽象类

第七章 接口与多态

1.接口定义行为

类要操作接口，必须使用implemente关键字。

2.行为的多态

public class Ocean{

public static void main(String[] args)

{

doSwim(new Anemonefish("尼莫"));

doSwim(new Shark("兰尼"));

doSwim(new Huamn("贾斯汀"));

doSwim(new Submarine("黄色一号"));

}

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

}

执行结果：

小丑鱼 尼莫 游泳

鲨鱼 兰尼 游泳

人类 贾斯汀 游泳

潜水艇 黄色一号 潜行

7.2 接口语法细节

1.接口的默认

在java中，可使用interface来定义抽象行为与外观（如接口中的方法可声明为public abstract）。接口中的方法没有操作时，一定得是公开且抽象。可以省略public abstract，编译程序会自动帮你加上public abstract。默认一定是public。

2.匿名内部类

在编写java程序时，经常会有临时继承某个类或操作某个接口并建立实例的需求。由于这类子类或接口操作类只使用一次，不需要为这些类定义名称，这时可以使用匿名内部类（AIC）来解决这个需求。

new 父类（）|接口（）{

//类本体操作

}；

使用匿名内部类，直接建立操作ClientListener的对象：

public class MultiChat{

public static void main(String[] args){

Client c1 = new Clent("127.0.0.1","Caterpillar");

Client c2 = new Clent("192.168.0.2","Justin");

    ClientQueue queue = new ClientQueue();
    queue.addClientListener(new ClientListener(){
        @Override
        public void clientAdded(ClientEvent event){
            System.out.printf("%s 从 %s 联机%n", event.getName(), event.getIp());
        }

        @Override
        public void clientRemoved(ClientEvent event){
            System.out.printf("%s 从 %s 联机%n", event.getName(), event.getIp());
        }
    });

    queue.add(c1);
    queue.add(c2);
    queue.remove(c1);
    queue.remove(c2);
}

}

执行结果：

caterpillar 从 127.0.0.1 联机

justin 从 192.168.0.2 联机

caterpillar 从 127.0.0.1 联机

justin 从 192.168.0.2 联机

3.使用enum枚举常数

从JDK5之后新增了enum语法，可用于定义枚举常数。

例

public enum Action{

STOP, RIGHT, LEFT, UP, DOWN

}

范例中的enum定义的Action实际上是个类，而enum中例举的STOP, RIGHT, LEFT, UP, DOWN常数，实际上是public static final，且为Action实例。你无法编写程序直接实例化Action，因为构造函数权限设定为private，只有Action类中才可以实例化。

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

本周的学习内容和上周一样太多，光是看书并不能都看懂弄会，并且只是自己敲代码还是有许多的不理解，这两章的内容都有些抽象，所以许多地方都询问了同学。

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

第六章两个章节都有关于抽象方法、抽象类的内容，但是很难理解，光看书上的代码并没有搞懂。

其他（感悟、思考等）

说实话大量时间放在java上，但是感觉学习的效果并不是很理想，看来我还是得好好想想学习方法是否哪里不对。

参考资料

Java学习笔记（第8版）

《Java学习笔记（第8版）》学习指导