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

教材学习内容总结

本周学习了课本第六、七章内容，即继承与多态、接口与多态。

第六章继承与多态

6.1 何谓继承
6.1.1 继承共同行为

继承就是避免多个类间重复定义共同行为。
想要要避免在程序设计上出现重复，可以用子类继承父类，把相同的程序代码提升为父类。
使用 extends 关键字继承。
eg.代码如下：

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.printf("剑士:(%s,%d,%d)%n",swordsMan.getName(),
    swordsMan.getLevel(),swordsMan.getBlood());
}

static void demoMagician(){
    Magician magician = new Magician();
    magician.setName("Moinca");
    magician.setLevel(1);
    magician.setBlood(100);
    System.out.printf("魔法师 :(%s,%d,%d)%n",magician.getName(),
        magician.getLevel(),magician.getBlood());
}
}

运行结果：

6.1.2 多态与is-a

在java中，子类只能继承一个父类，子类父类间会有is-a关系。
检查语法逻辑是否正确的方法是从=右边往左读，右边类是不是左边类的子类。
eg.代码示例：

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

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

    showBlood(swordsMan);
    showBlood(magician);
}

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

运行结果：

多态：使用单一接口操作多种类型的对象。

6.1.3 重新定义行为

在继承父类之后，定义与父类中相同的方法部署，但执行内容不同，这称为重新定义。
在重新定义父类中某个方法时，子类必须撰写与父类方法中相同的签署。
如果要重新定义某方法，加上@Override，就不用担心错字问题了。
eg：代码如下：

public class RPG3{
    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);
        
        drawFight(swordsMan);
        drawFight(magician);
    }
   
    static void drawFight(Role role)
    {
        System.out.print(role.getName());
        role.fight();
    }
}

运行结果：

6.1.4 抽象方法、抽象类

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

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

抽象类：内含抽象方法的类，一定要在class前标示abstract，表示这是一个定义不完整的类，不能实例化抽象类。
子类继承抽象类，对于抽象方法有两种做法：1.继续标示该方法为abstract。2.操作抽象方法。

6.2 继承语法细节

6.2.1 protected成员

被声明为protected的成员，相同包中的类可以直接存取，不同包中的类可以在继承后的子类直接存取。
java中三个权限关键字：private、protected与public，若不知使用哪个，就先使用private。权限关键字与权限范围关系如下图：

eg.
Role.java

public abstract class Role{
    protected String name;
    protected int level;
    protected int blood;
...
}

SwordsMan.java

public class SwordsMan extends Role{
    ...
    public String toString(){
        return String.format("剑士（&s, %d, %d）", this.name, this.level, this.blood);
    }
}

Magician.java

public class Magician extends Role{
   ...
    public String toString(){
        return String.format("魔法师（&s, %d, %d）", this.name, this.level, this.blood);
    }
}

6.2.2 重新定义的细节

如果想取得父类中的方法定义，可以在调用方法前，加上super关键字，但不能定义为private（因为这就限定只能在类内使用）。
重新定义方法要注意，对于父类中的方法权限，只能扩大但不能缩小。若原来成员public，子类中重新定义时不可为private或protected。

代码如下
Role类中原本就定义了toString（）方法：

public abstract class Role
{
    public String toString()
    {
        ...
        return String.format("(%s, %d, %d)", this.name, this.level, this.blood);
    }
}

6.2.3 再看构造函数

如果类有继承关系时，会先进行父类定义的初始流程，再进行子类定义的初始流程。
构造函数可以重载，父类中可以重载多个构造函数，如果子类构造函数中没有制定执行父类中哪个构造函数，默认会调用父类中无参数构造函数。
注意this()和super()只能择一调用，并且要写在构造函数第一行执行。

6.2.4 再看final关键字

如果class前使用了final关键字定义，那么表示这个类是最后一个了，不会再有子类即不能被继承。

6.2.5 java.lang.Object

在Java中，子类只能继承一个父类，如果定义类时没有使用extends关键字指定继承任何类，那一定是继承java.lang.Object。任何类追溯至最上层父类，一定就是java.lang.Object。

代码如下：

定义ArrayList类，可以不限长度地收集对象。

import java.util.Arrays;

public class ArrayList {
    private Object[] list;
    private int next;

    public ArrayList(int capacity){
        list = new Object[capacity];
    }

    public ArrayList() 
    {
        this(16);
    }

    public void add(Object o) 
    {
        if(next == list.length) 
        {
            list = Arrays.copyOf(list, list.length*2);
        }
        list[next++]=o;
    }
    public Object get(int index) 
    {
        return list[index];
    }

    public int size() 
    {
        return next;
    }
}

使用ArrayList类，可收集访客名称，并将名单转为大写后显示。

import java.util.Scanner;
import static java.lang.System.out;

public class Guest {
    public static void main(String[] args) 
    {
        ArrayList names=new ArrayList();
        collectNameTo(names);
        out.ptintln("访客名单：");
        printUpperCase(names);
    }

static void collectNameTo(ArrayList names)
 {
    Scanner console=new Scanner(System.in);
    while(true) {
        out.print("访客名称：");
        String name=console.nextLine();
        if(name.equals("quit")) {
            breaks;
        }
        names.add(name);
    }
}

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

6.2.5 关于垃圾收集

创建对象会占据内存，如果程序执行流程中已无法再使用某个对象，该对象就只是耗内存的垃圾。
JVM有垃圾收集机制，收集到的垃圾对象所占据的内存空间，会被垃圾收集器释放。
执行流程中，无法通过变量参考的对象，会被JVM认定为垃圾对象。

第七章接口与多态

7.1何谓接口

7.1.1接口定义行为

类要操作接口，必须使用implements关键字。
操作接口时，对接口中定义的方法有两种处理方式：1.操作接口中定义的方法2.再度将该方法标示为abstract。
继承会有“是一种”关系，操作接口表示“拥有行为”，但不是“是一种”的关系。

代码如下：

在java中可以使用interface关键字定义:

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

Fish拥有Swimmer行为：

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();
}

Humman要能游泳

public class Human implements Swimmer {
private String name;
public Human(String name){
this.name=name;
}
public String getName()
{
return name;
}

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

Submarine也有Swimming的行为

public class Submarine implements Swimmer{
private String name;
public Submarine(String name){
        this.name=name;
    }
public String getName(){
    return name;
    }

@Override
public void swim();{
    System.out.printf("潜水艇 %s 潜行%n",name);
    }
}

7.1.2行为的多态
判断方式是“右边是不是拥有左边的行为”，或者“右边对象是不是操作了左边接口”。
代码如下：

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

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

运行结果：

7.1.3解决需求变化
如果增加新的需求，可使原有的程序无需修改，只针对新需求撰写程序，那就是有弹性、具可维护性的程序。

使用interface定义Flyer接口：

public interface Flyer{
    public abstract void fly();
}

Airplane.java

public class Seaplane implements Swimmer,Flyer{
private String name;

public Seaplane(String name){
this.name=name;
}
    
@Override
public void fly(){
System.out.printf("海上飞机 %s 在飞%n",name);
}
    
@Override
public void swim(){
 System.out.printf("海上飞机 %s 航行海面%n",name);
}
}

FlyingFish.java


public class FlyingFish extends Fish implements Flyer{
   public FlyingFish(String name){
            super(name);
     }
    
@Override
public void swim(){
     System.out.println("飞鱼游泳");
}
    
@Override
public void fly(){
System.out.println("飞鱼会飞");
}}

Ocean.java

public class Ocean{
   public static void main(String[] args){    
     doSwim(new Airplane("空军零号"));
     doSwim(new FlyingFish("甚平"));
}
    
static void doSwim(Swimmer swimmer){
swimmer.swim();
}
}

7.2 接口语法细节

7.2.1 接口的默认
在java中，可使用interface来定义抽象的行为与外观，如接口中的方法可声明为public abstract。
代码如下：

在interface中，可以定义常数。

public interface Action{
public static final int STOP=0;
public static final int RIGHT=1;
public static final int LEFT=2;
public static final int UP=3;
public static final int DOWN=4;
}

枚举常数

import static java.lang.System.out;
public class Game{
    public static void main(String[] args){
        play(Action.RIGHT);
        play(Action.UP);
    }
    public static void play(int action){
        switch(action){
            case Action.STOP:
            out.println("播放停止动画");
            break;
            case Action.RIGHT:
            out.println("播放向右动画");
            break;
            case Action.LEFT:
            out.println("播放向左动画");
            break;
            case Action.UP:
            out.println("播放向上动画");
            break;
            case Action.DOWN:
            out.println("播放向下动画");
            break;
            default:
            out.println("不支持此动作");
        }
    }
}

运行结果：

7.2.2匿名内部类
在撰写java程序时，如果需要临时继承某个类或操作某个接口并建立实例，而这类子类或接口操作类只使用一次，不需要为这些类定义名称时，可以使用匿名内部类。

代码如下：

假设打算开发多人联机程序，对每个联机客户端，都会建立Client对象封装相关信息

public class Client{
public final String ip;
public final String name;
public Client(String ip,String name){
    this.ip=ip;
    this.name=name;
}
}

将Client加入或移除的信息包装为ClientEvent。

public class ClientEvent{
    private Client client;
    public ClientEvent(Client client){
        this.client=client;
    }
    
    public String getName(){
        return client.name;
    }

     public String getIp(){
        return client.ip;
    }
}

ClientListener.java

public interface ClientListener{
    void clientAdded(ClientEvent event);
    void clientRemoved(ClientEvent event);
}

ClientQueue.java

import java.util.ArrayList;
public class ClientQueue{
    private ArrayList clients=new ArrayList();
    private ArrayList listeners=new ArrayList();
   
    public void addClientListener(ClientListener listener){
        listeners.add(listener);
    }
    public void add(Client client){
        clients.add(client);
        ClientEvent event=new ClientEvent(client);
        for(int i=0;i<listeners.size();i++){
            ClientListener listener=(ClientListener) listener.get(i);
            listener.client.Added(event);
        }
    }

     public void remove(Client client){
        client.remove(client);
        ClientEvent event=new ClientEvent(client);
        for(int i=0;i<listeners.size();i++){
            ClientListener listener=(ClientListener) listener.get(i);
            listener.client.Removed(event);
        }
    }
}

MultiChat.java

public class Multichat{
    public static void main(String[] args){
    Client c1=new Client("127.0.0.1","Caterpillar");
    Client c1=new Client("192.168.0.2","Justin");
    
    ClientQueue queue=new ClientQueue();
    queue.addClientListener(new ClientListener(){
        @Override
        public void clientAdded(ClientEvent event){
            System.out.printf("%s cong %s lianji%n",
            event.getGame(),event.getIp());
        }
        @Override
        public void clientRemoved(ClientEvent event){
            System.out.printf("%s cong %s tuoji%n",
            event.getGame(),event.getIp());
        }
    });
    
    queue.add(c1);
    queue.add(c2);
    queue.remove(c1);
    queue.remove(c1);
}
}

运行结果：

7.2.3 使用enum枚举常数
enum可以用于定义枚举常数。
enum定义了特殊的类，继承自java.lang.Enum，直接撰写程序继承Enum类会被编译程序拒绝。

代码如下：

定义枚举常数

public enum Action{
    STOP,RIGHT,LEFT,UP,DOWN
}

利用Action声明类型

import static java.lang.System.out;

public class Game{
    public static void main(String[] args){
        play(Action.RIGHT);
        play(Action.UP);
    }
    
    public static void play(Action action){
        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;
        }
    }
}

运行结果：