20145239杜文超 《Java程序设计》第4周学习总结

20145239 《Java程序设计》第4周学习总结

教材学习内容总结

第六章：

继承：避免多个类间重复定义共同行为。即当多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承单独的那个类即可。我们也把单独抽取出来的那个类称为父类，其他的多个类称为子类。

继承的关键字：extends

比如书上的例子：Role就是一个父类，是SwordsMan和Magician都具有的基础属性，这里要注意，我们说的继承是一种is-a的关系，SwordsMan继承了Role，所以说SwordsMan is a Role。

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

}

　　剑士继承了Role的所有属性并拥有自己独特的属性：

public class SwordsMan extends Role
{
    public void fight()
    {
        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.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());

    }
}

　　*tip：java中还支持多层继承：

class A{}
class B extends A{}
class C extends B{}

　　就好比子-父-爷的关系。

多态：多态从字面上的解释就是某一类事物的多种存在形态，以抽象讲法解释就是使用单一接口操作多种类型的对象。 如果角色的数量较多，只要他们继承的都是同一个类（Role）就可以用多态的方法来代替重载的方式，提高了程序的可维护性。

public class RPG2
{
    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("Moinca");
        magician.setLevel(1);
        magician.setBlood(100);

        showBlood(swordsMan);   //SwordsMan是一种Role
        showBlood(magician);
    }
    static void showBlood(Role role)   //声明为Role类型
    {
        System.out.printf("%s 血量 %d%n",role.getName(), role.getBlood());
    }
}

　　

抽象方法：如果某方法区块中没有任何程序代码操作，可以使用abstract标示该方法。

抽象类：类中若有方法没有操作，并且标示为abstract，表示这个类定义不完整，因此也就不能用来生成实例。Java中规定内含抽象方法的类，一定要在class前标示abstract，表示这是一个定义不完整的抽象类。

 public abstract class GuessGame {
        public void go() {
            int number=(int)(Math.random()*10);
            int guess;
            do {
                print("输入数字：");
                guess=nextInt();
            }while(guess!=number);
            println("猜中了");
        }

        public void println(String text) {
            print(text+"\n");
        }

        public abstract void print(String text);
        public abstract int nextInt();
    }

　　

import java.util.Scanner;

    public class ConsoleGame extends GuessGame {
        private Scanner scanner=new Scanner(System.in);

        @Override
        public void print(String text) {
            System.out.print(text);
        }

        @Override
        public void println(String text) {
            System.out.println(text);
        }

        @Override
        public int nextInt() {
            return scanner.nextInt();
        }
    }

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

　　

继承语法细节：被声明为protected的成员，相同包中的类可以直接存取，不同包中的类可以在继承后的子类直接存取。

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

垃圾对象：执行流程中，无法通过变量参考的对象。

第七章：

接口：要重点理解和继承的区别，Java的接口支持多重继承，操作接口表示“拥有行为”，但不是“是一种”的关系。

接口中定义的方法的两种处理方式：1.操作接口中定义的方法。2.再度将该方法标示为abstract。

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

接口关键字：implements

运行实例：

接口语法细节：

• 使用interface来定义抽象的行为外观，方法要声明为public abstract，无须且不能有操作。为了方便，也可以省略public abstract，编译程序会协助补齐。可以使用接口枚举常数，只能定义为public static final。为了方便，也可以省略public static final。
• 接口可以继承别的接口，也可以同时继承两个以上的接口，也是使用extends关键字。
• enum语法可用于定义枚举常数，enum实际上定义了类，而enum中列举的常数实际上是public static final，无法撰写程序直接实例化枚举类型，因为构造函数权限设定为private，只有类中才可以实例化。

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

在阅读教材的时候，我发现了一个不懂的关键字：@Override。在敲代码的时候出现了如下错误：

我随后在博客园中的一个帖子里找到了答案：

“@Override是Java5的元数据，自动加上去的一个标志，告诉你说下面这个方法是从父类/接口 继承过来的，需要你重写一次，这样就可以方便你阅读，也不怕会忘记。

使用该标记是为了增强程序在编译时候的检查，如果该方法并不是一个覆盖父类的方法，在编译时编译器就会报告错误。”

具体可以点击这篇帖子。http://www.cnblogs.com/hnrainll/archive/2011/10/17/2215138.html

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

第七章教材里的许多代码只是单纯的类，并不能执行。我在IDEA里敲完代码以后发现无法run，还以为代码有问题，其实仔细一看才发现这些代码都是没有main函数的，所以不能运行。

本周代码托管截图

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

讲真java学习的难度越来越大了，我感觉非常吃力。可能是上周四五章的内容还不够扎实，下周的学习任务就来了，其实看视频加上看书加上敲代码加上写博客任务量还是非常繁重的。可能是我还没有完全适应这种自主学习的模式。本周的内容我印象最深刻的就是继承和接口的区别，书上的例子很生动，鱼会游泳，鲨鱼是鱼、小丑鱼是鱼，所以它们是继承关系，但人也会游泳，但人和鱼就没有继承关系，但人和鱼之间的这种联系就可以用接口表示。虽然理解了这一点，但我还不能联想到区别这两种定义方法在具体程序中究竟能有多大的利处。总之，要继续学习的或者说要补的知识还很多，希望我可以坚持下去，不要最后无奈沦为混完课程的人。人间正道是沧桑啊！

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	100/100	1/2	12/15
第二周	200/300	1/2	15/15
第三周	300/300	1/2	20/20
第四周	500/500	1/2	25/25

参考资料

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