20155326 2006-2007-2 《Java程序设计》第4周学习总结

20155326 2006-2007-2 《Java程序设计》第4周学习总结

教材学习内容总结

• 继承共同行为

  （1）继承基本上就是避免多个类间重复定义共同行为，关键词为extends。
  
  （2）继承的三个好处：减少代码冗余；维护变得简单；扩展变得容易。
  
  （3）构造方法不能被继承。
  

• 代码及运行结果如下

class Role {
    private String name;
    private int level;
    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;
    }

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

    }
    class Magician extends Role{
    //private  String fight;

    public void fight(){
        System.out.println("魔法攻击");
    }
    public void cure(){
        System.out.println("魔法治疗");
    }
    }
    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.getBlood(),swordsMan.getLevel());
        swordsMan.fight();
    }
    static void demoMagician(){
        Magician magician=new Magician();
        magician.setName("Monica");
        magician.setLevel(1);
        magician.setBlood(100);
        System.out.printf("魔法师：（%s,%d,%d)%n",magician.getName(),magician.getBlood(),magician.getLevel());
        magician.fight();
        magician.cure();
    }
    }

• 多态与is-a：

  （1）is-a代表的是类之间的继承关系。中文称为“是一种”关系。
  
  （2）使用是一种原则，就可以判断何时编译成功，何时编译失败。编译程序会检查父子类间的“是一种”关系.
  
  （3）子类只能继承一个父类。
  
  （4）检查语法的逻辑是否正确时，方式是从=号右边往左读，判断右边是不是左边的子类，若是，则语法正确，若不是，则不正确。
  
  （5）定义继承需要注意：类与类之间要有是一种（is-a）关系，比如SwordsMan继承了Role，所以SwordsMan is a Role。加上Cast语法，可强制使右边成为左边的子类，但有风险。
  

• 代码及运行结果如下

    class Role {
    private String name;
    private int level;
    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;
    }

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

    }
    class Magician extends Role{
    //private  String fight;

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

    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",rol     e.getName(),role.getBlood());
    }
    }

• 重新定义行为

  （1）重新定义是指在继承父类之后，定义与父类中相同的方法部署，但实行内容不同。
  
  （2）在继承父类之后，定义与父类中相同的方法部署，但执行内容不同，这称为重新定义。
  
  （3）防止因打错字而使程序无法运行，可在重新定义某方法时，加上@Override。
  
  （4）对于父类中的方法权限，只能扩大但不能缩小。若原来成员public，子类中重新定义时不可为private或protected。
  

• 代码及运行结果如下

     class Role {
     private String name;
     private int level;
     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;
        }
     public void fight(){}
        }
     class SwordsMan extends Role{
    public void fight(){
        System.out.println("挥剑攻击");
    }

     }
     class Magician extends Role{
    //private  String fight;

    public void fight(){
        System.out.println("魔法攻击");
    }
    public void cure(){
        System.out.println("魔法治疗");
    }
     }
     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.println(role.getName());
        role.fight();
    }
     }

• 抽象方法、抽象类：

  （1）如果某方法区块中实际上没有撰写任何程序代码，可以使用abstract标示该方法为抽象方法，该方法不用撰写{}区块，直接“；”结束即可。
  
  （2）类中若有方法没有操作，并且标示为abstract,表示这个类定义不完整，定义不完整的类不能生成实例。Java中规定内含抽象方法的类，一定要在class前标示abstract,表示这是一个不完整的抽象类。
  
  （3）子类如果继承抽象类，对于抽象方法有两种做法：一是做法是继续标示该方法为abstract，该子类也是个抽象类，必须在class前标示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 String toString(){
        return
    String.format("(%s,%d,%d)%n",this.name,this.blood,this.level);
    }
    }
    class SwordsMan extends Role{
    public void fight(){
        System.out.println("挥剑攻击");
    }
    public String toString(){
        return "剑士"+super.toString();
    }
    }
    class Magician extends Role{
    private  String fight;
    public void fight(){
        System.out.println("魔法攻击");
    }
    public void cure(){
        System.out.println("魔法治疗");
    }
    public String toString()
    { return "魔法师"+super.toString();
    }

    }

    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);
        System.out.println(magician.toString()     );
        System.out.println(swordsMan.toString(     ));
    }
    }

• protected的成员

   （1）被声明为protected的成员，相同包中的类可以直接存取，不同包中的类可以在继承后的子类直接存取。
  
   （2）权限关键字与范围
  
    关键字       类内部     相同包类     不同包类
  
    public      可存取     可存取       可存取
  
    protected   可存取     可存取       子类可存取
  
    private     可存取     不可存取     不可存取
  
   （3）依权限小至大来区分，就是private、无关键字、protected与public，设计时要使用哪个权限，是依经验或团队讨论而定，如果一开始不知道使用哪个权限就先使用private，以后视需求再开放权限。
  

• 重新定义的细节

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

• 再看构造函数

  （1）如果类有继承关系，在创建子类实例后，会先进行父类定义的初始流程，再进行子类中的初始流程，也就是创建子类实例后，会先执行父类构造函数定义的流程，再执行子类构造函数定义的流程。
  （2）构造函数可以重载，父类中可重载多个构造函数，如果子类构造函数中没有指定执行父类中哪个构造函数，默认会调用父类中无参数构造函数。
   (3) this()与super()只能择一调用，而且一定要在构造函数第一行执行。
  

• 再看final关键字

（1）如果在指定变量值之后，就不想再改变变量值，可以在声明变量时加上final限定。

（2）如果对象数据成员被声明为final，但没有明确使用=指定值，那表示延迟对象成员值的指定，在构造函数执行流程中，一定要有对该数据成员指定值的动作，否则编译错误。

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

（4）定义方法时，也可以限定该方法为final，这表示最后一次定义方法了，也就是子类不可以重新定义final方法。

（5）子类不可以重新定义final方法，会发生编译错误。

• java.lang.Object

（1）在java中，子类只能继承一个父类，如果定义类时没有使用extends关键字指定继承任何类，那就是继承java.lang.Object。相当于public class Some Object{...}

（2）在java中，任何类型的对象，都可以使用Object声明的名称来参考。

（3）java.lang.Object是所有类的顶层父类，这代表了object上定义的方法，所有对象都继承下来了，只要不是被定义成final方法。

• 代码及运行结果如下

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

    class ArrayList{
    private Object[] list;
    private  int next;//下一个对象的索引

    public ArrayList(int
    capacity){//指定初始容量

        list =new Object[capacity];
    }
    public ArrayList(){//初始容量默认为16

        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;
    }
    }
    public class Guest {
    public static void main(String[] args) {
        ArrayList names=new ArrayList();
        collectNameTo(names);
        System.out.println("访客名单");
        printUpperCase(names);
    }
    static void collectNameTo(ArrayList names){
        Scanner console=new Scanner(System.in);
        String name;
        while(true){
            System.out.print("访客名称：");
            name =console.nextLine();
            if(name.equals("quit")){
                break;
            }
            else{
                names.add(name);
            }
        }

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

• 关于垃圾收集

（1）如果程序执行流程中无法通过变量参考的某个对象，就是徒耗内存的垃圾。

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

• 再看抽象类

• 代码及运行结果如下

    package week05;
    import java.util.Scanner;
    abstract class GuessGame{
    public void go() {
        int number = (int) (Math.random() * 10);
        int guess;
        do {
            print("输入数字");
            guess = nextInt();
        } while (number != guess);
        println("猜中了！");
    }
    public void println(String text){
        print(text+"\n");
    }
    public  abstract void  print(String text);
    public abstract int nextInt();
    }
    class ConsoleGame extends GuessGame{
    private Scanner scanner=new Scanner(System.in);
    @Override
    public void println(String text){
        System.out.println(text);
    }
    public void print(String text){
        System.out.print(text);
    }
    public int nextInt(){
        return scanner.nextInt();
    }

    }
    public class Guess {
    public static void main(String[] args) {
        GuessGame game=new ConsoleGame();
        game.go();
    }
    }

• 接口定义行为

（1）接口可以用于定义行为但不定义操作。

（2）类要操作接口，必须使用implements关键字。操作某接口时，对接口中定义的方法有两种处理方式，一是操作接口中定义的方法，二是再度将该方法标示为abstract。

（3）继承会有“是一种”关系，接口操作则表示“拥有行为”，但不会有“是一种”关系。

• 行为的多态

（1）接口多态语法的判断，方式是“右边是不是拥有左边的行为”或者“右边对象是不是操作了左边接口”。

（2）行为的多态使可维护性提高许多。

• 代码及运行结果如下

    interface Swimmer {
    public abstract void swim();
    }

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

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

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

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

• 接口语法细节：

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

（2）在interface中，可以定义常数。

（3）接口中枚举的常数，一定要使用“=”指定值，否则会编译失败。

（4）接口可以继承别的接口，也可以同时继承两个以上的接口，同样也是使用extends关键字，这代表了继承父接口的行为。

• 匿名内部类

（1）临时继承某个类或操作某个接口并建立实例，可使用匿名内部类来解决这个需求。

（2）匿名内部类语法为：new 父类()|接口(){ // 类本体操作 };

• 使用enum枚举常数

（1）enum实际上定义了类，而enum中枚举的常数，实际上是public static final，且为枚举类型实例，无法撰写程序直接实例化枚举类型，因为构造函数权限设定为private，只要类中才可以实例化。如：

    import static java.lang.System.out;

    public class EnumGame
    {
    public static void main(String[] args)
    {
        play(EnumAction.RIGHT);
        play(EnumAction.UP);
    }

    public static void play(EnumAction 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;
        }
    }
    }

（2）enum定义了特殊的类，继承自java.lang.Enum

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

课本上的代码不知道为什么不可以在cmd中运行，但可以在idea中运行。

代码托管

• 代码量截图：

上周考试错题总结

（1）java中成员方法中引用成员变量，要使用（this）关键字。

理解情况：在java中，this()代表了调用另一个构造函数，所以在成员方法中引用成员变量时，需要使用到this关键字。

（2） CH05 判断：Java中方法内可以定义类。（OK）

理解情况：方法中不能直接定义方法，但可以在方法中定义类，类里面再定义方法。

（3）可以使用java.util.Arrays的(fill())方法把数组初始化成相同的值。

理解情况：在java中，fill()方法的作用是将指定的int值赋给数组的每个元素，所以可以用java.util.Arrays的(fill())方法把数组初始化成相同的值。

（4）“30”转化为byte类型的30的语句是（Byte.parseByte(“30”);）

理解情况：在java中，java.lang.Byte.parseByte()方法的作用是将字符串参数转换为带符号的十进制数。

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

已经写到第四周的java学习总结了，这周学习了继承与多态、接口与多态这些内容，这些比起之前接触的知识可以使用户使用时更加方便，也更便于编程人员维护。但对于书上一些内容，我的理解不够透彻，还需多多看书，多多敲代码。在学习中我发现这两章书上的代码不是独立的，要几组代码组合在一起才能运行。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	15篇	400小时
第一周	20/20	1/1	20/20	安装了各种程序
第二周	126/100	1/1	25/25	掌握了托管代码
第三周	197/200	1/1	30/30	大体了解java的对象和对象封装
第四周	533/500	1/1	45/40	知道了继承接口等

• 计划学习时间:40小时

• 实际学习时间:45小时