20145303刘俊谦 《Java程序设计》第4周学习总结

20145303刘俊谦 《Java程序设计》第4周学习总结

教材学习内容总结

1、继承：继承是面向对象的第二大特征，避免多个类间重复定义共同行为。把单独抽取出来的那个类称为父类，其他的多个类称为子类。继承减少了代码冗余，并使维护变得简单，扩展变得容易。使用关键字extend命令实现继承。

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

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

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

    public void cure()
    {
        System.out.println("魔法治疗");
    }
}

剑士：(Justi,1,200)
魔法师：（Moinca,1,100）

2、多态：从字面上的解释就是某一类事物的多种存在形态，以抽象讲法解释，就是使用单一借口操作多种类型的对象。

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.setLevel(1);
    magician.setBlood(100);

    showBlood(swordsMan);
    showBlood(magician);

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

Justi 血量 200
Moinca 血量 100

3、

重新定义：在继承父类之后，定义与父类中相同的方法部署，但实行内容不同。

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

    drawFight(swordsMan);
    drawFight(magician);

}
static void drawFight(Role role)
{
    System.out.print(role.getName());
    role.fight();
}
}

Justi挥剑攻击
Moinca魔法攻击

4、

protected成员：被声明为protected的成员，想通报中的类可以直接存取，不同包中的类可以在继承后的子类直接存取。依权限小至大来区分，就是private、无关键字、protected与public，若不知使用哪个，就先使用private。

public abstract class Role
{
protected String name;
protected int level;
protected 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;
}
}
public class Magician extends Role
{
public void fight()
{
    System.out.println("魔法攻击");
}
public void cure()
{
    System.out.println("魔法治疗");
}
public String toString()
{
    return String.format("魔法师 (%s, %d, %d)", this.name, this.level, this.blood);
}

}
public class SwordsMan extends Role
{
public void fight()
{
    System.out.println("挥剑");
}
public String toString()
{
    return String.format("剑士 (%s, %d %d)", this.name, this.level, this.blood);
    }

  }

5、

重新定义的细节：如果想取得父类中的方法定义，可以在调用方法前，加上super关键字，但不能定义为private。

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

6、再看构造函数：如果类有继承关系，在创建子类实例后，会先进行父类定义的初始流程，再进行子类中的初始流程，也就是创建子类实例后，会先执行父类构造函数定义的流程，再执行子类构造函数定义的流程。

7、java.lang.Object：子类只能继承一个父类，如果定义类时没有使用extends关键字指定继承任何类，那就是继承java.lang.Object。

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;
    }
}
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.println("访客名单：");
        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")) {
                break;
            }
            names.add(name);
        }
    }

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

8、接口

对于“定义行为”，可以使用interface关键字定义，例如public、 interface、 Swimmer，操作某接口时，对接口中定义的方法有两种处理方式，一是操作接口中定义的方法，二是再度将该方法标示为abstract，以java的语意来说，接口则表示“拥有行为”关系，对于接口多态语法的判断，方式是“右边是不是拥有左边的行为”，或者“右边对象是不是操作了左边接口”。

public interface Swimmer
{
    public abstract void swim();

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

9、行为的多态

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

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

10：接口的默认

在java中，用interface来定义抽象的行为外观，方法声明为public abstract，也可以省略，编译程序会自动协助补齐。

类可以操作两个以上的接口，如果有两个接口都定义了某方法，操作两个接口并不会有错误。接口可以继承别的接口，也可以同时继承两个以上的接口，同样也是使用extends，代表了继承父接口的行为。

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("不支持此动作");
        }
    }
}

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

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

12、enum可以用于定义枚举常数。enum定义了特殊的类，继承自java.lang.Enum。

import static java.lang.System.out;
public class Game2{
    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;
        }
    }
}

本周代码托管截图

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

学习任务越来越重，但心态还是要放平稳的，一步一个脚印总归没错。也发现了时间的安排有多么重要，每一点的时间利用起来是可以做很多事的。这周的学习主要是看书，视频一半都没看完，课后题也没来得及写，希望自己以后还是提高效率吧。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第四周	250/750	2/8	25/98