20155219 2016-2017-2 《Java程序设计》第4周学习总结

20155219 2016-2017-2 《Java程序设计》第4周学习总结

教材学习内容总结

• 抽象方法与抽象类
  如果某方法区块中没有任何程序代码操作，可以使用abstract在class之前，表示该方法为抽象方法，不用撰写{}，直接；结束即可。表示这个类定义不完整，因此不能用来生成实例。

public abstract class i {
   public abstract void fight();
   i aa=new i();
}

上述代码会出现如下错误
如果子类要继承抽象父类，那么它必须继续标示该方法为abstract,或者是操作抽象方法。

• protect成员：对于private语句，如果你只想让子类可以直接存取，可以使用protect语句。被声明为protect的成员，相同包中的类可以直接存取，不同包中的类可以在继承后的子类中存取。

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

（如果方法中没有同名函数，this可以省略）
如上代码段，（其中String.format语句：String类的format()方法用于创建格式化的字符串以及连接多个字符串对象。详见如下链接).在父类中定义如下函数，即可引用子类的函数。

  public static void  drawFight(d role)
    {
        System.out.println(role.toString());
    }

至此，已经学习了java中关于权限的三个关键字，分为四个权限范围，如下表

关键字	类内部	相同包内	不同包类
public	可存取	可存取	可存取
private	可存取	不可存取	不可存取
protected	可存取	可存取	不可存取但子类可存取
无	可存取	可存取	不可存取

• super（）关键字的使用
  如果想去的父类中定义的方法，可以在调用方法前加上super关键字。注意：可以使用super关键字调用的父类方法不能定义为private。重新定义方法是要注意，对于父类的方法权限，只能扩大但不能缩小。（关于子类的static成员：如果子类中定义了相同签署的static成员，该成语属于子类所有而非重新定义，static方法也没有多态。）
• 构造函数：创建子类实例后，会先执行父类中构造函数定义的流程，在执行子类中构造函数定义的流程。父类中可以重裁多个构造函数，如果子类构造函数中没有指明使用父类中哪个构造函数，默认会调用父类中无参数构造函数。
  如下代码

public class i{
    public static void main(String[] args) {
        other ss=new other();
        ss.toString();
    }
        static class a{
            a()
            {
                System.out.println("some()被调用");
            }
            a(int i)
            {
                System.out.println("some(int i)被调用");
            }
        }
        static class other extends a
        {
            other()
            {
                super();
                System.out.println("other()被调用");
            }
        }
    }

结果如图在new other（）时，先调用了other版本的构造函数，super（10）表示调用父类some（int i）版本的构造函数，故有上述输出。如果子类在构造函数中没有指定执行父类中的那个构造函数，默认会调用父类中无参数构造函数。如下代码段会显示编译出错

static class a{
            a(int i)
            {
                System.out.println("some(int i)被调用");
            }
        }
        static class other extends a
        {
            other()
            {
                System.out.println("other()被调用");
            }

如下因为父类中定义了a（int i）构造函数，不会自动加入任何构造函数，而子类默认调用父类中无参数的构造函数，因此编译失败。（如果定义了有参数的构造函数，也可以加入无参数构造函数为日后使用上的弹性）。

• final类不能被继承在构造函数执行流程中，一定要有对该数据成员指定值的动作，否则编译出错。
• java中，子类只能继承一个父类，如果定义时没有使用关键字extends，那就一定是继承了java.lang.object。因此如下撰写程序是合法的

Object o1="taylor swif";
Object o2=new Data() ;

• 重新定义tostring（）
  许多方法传入对象，默认都会调用toString（），如下代码

System.out.println(swords.toString());
System.out.println(swords);

是相同的。

• 对于instanceof运算符，它可以用来判断对象是否由某个类创建。左操作数是对象，右操作数是类。在执行时，只要左操作数是右操作数类型的子类型，返回值也是true。
• 接口定义行为
  如下代码

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

package src.week3;
public class human implements swimmer{
    public static void main(String[] args) {
        human a=new human("hjasdh");
        a.swim();
    }
    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);
    }
}

human操作了swimmer，所以都拥有Swimer定义的行为，但他们没有继承Fish。类要操作接口，必须使用implement关键字，操作某接口时，对接口中定义的方法有两种处理方式，一是操作接口中定义的方法，二是再度将该方法表示为abstract。注意：java中子类只能继承一个父类。

• 行为的多态
  只要是操作Swimmer接口的对象，都可以使用范例中doswim（）方法，代码如下：

public class Ocean {
    public static void main(String[] args) {
        doswim(new human("ads"));
        doswim(new shark("ads"));
        doswim(new submarine("ads"));
    }
    static void doswim(swimmer a)//只要对象拥有Swimer行为，就可以直接引用，无需做新的方法撰写
    {
        a.swim();
    }

在java中类可以操作两个以上的类，拥有两种以上的行为。代码如下：

public class airplane implements swimmer,flyer{}

• 接口语法细节：
  在java中，可以使用interface来定义抽象的行为与外观，接口中的方法可以声明为

public abstract void swim（）{}

• 接口中的方法没有操作时，可以省略public和abstract。需要注意的是：在之后使用这个接口时，如果要增加语句，必须在方法前加入public声明，否则默认为包权限，将public的方法权限缩小，会编译失败。如下：
• 在interface中，可以定义常数，但只能是public static final的枚举常量类型。故在接口中枚举常量，一定要使用=指定值，否则就会编译出错。
• 类可以操作两个以上的接口，如果有两个以上的接口都定义了某种方法，编译可以通过。但如果其定义的方法名称相同但要表示的是不同的操作方法，那么其名称就应该有所不同。如果表示相同方法，即可定义一个父接口，具体代码如下：

interface Action {
    void execute();
}
interface  some extends Action{
    void dosome();
}
interface  other extends Action{
    void doother();
}
public class n implements some,other{
    public static void main(String[] args) {
        n aa=new n();
        aa.dosome();
        aa.doother();
        aa.execute();
    }
    @Override
    public void execute()
    {
        System.out.println("execute");
    }
    @Override
public void dosome()
    {
        System.out.println("some");
    }
    @Override
    public void doother()
    {
        System.out.println("other");
    }
}

接口可以继承别的接口，也可以同时使用两个以上的接口，同样是使用extends关键字。

• 内部类与匿名内部类

成员内部类定义在成员位置上，局部内部类定义在局部位置与方法上。内部类的成员可以直接访问外部的成员，而外部类要访问内部类，必须建立内部类对象。当内部类定义了static成员，该内部类必须是static。局部内部类方文局部变量必须用final修饰，因为局部变量会随着方法的调用而被调用，随着方法调用完毕而消失，加上final后，这个变量就变成了常量。匿名内部类是一个继承了该类或者是实现了该接口的子类匿名对象。它必须继承一个类或者是实现了接口。格式为new 父类或者接口（）{重写方法}。可以将其理解为带内容的对象。匿名内部类中定义的方法最好不要超过三个。

• 如果子类复写了父类的方法，调用此方法的时候先找子类方法。复写即为：子类继承父类相同的方法，但有别于父类相对应得方法时就会覆盖父类的方法。（相同参数，不同实现）
• 重写方法规则：1.参数列表必须完全与被重写的方法相同，否则只能是重裁。2.返回类型必须与被重写的返回类型相同，否则是重裁。3.方法权限修饰符必须大于被重写的方法修饰符（public>protected>default>private)
• 重裁方法规则：1.必须具有不同的参数列表。2.可以有不同的返回类型。3.可以有不同的访问修饰符。

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

• xx1问题：为什么如下代码段会编译出错？

f jiansh=new d();//d类是父类，f类是子类。这行代码编译出错。

• xx1解决方案：子类是父类的继承，编译器检查语法逻辑是否正确，方式是从等号右边往左边读：右边是否是一种左边。对于上述代码d类是父类，f类是子类。f是一种d，但d不一定是一种f。故有如下代码：

public class f  extends d{
    public static void main(String[] args) {
        fight();
    }
    public static void fight(){
        System.out.println("挥剑攻击");
        d role1=new f();//
        f jianshi=(f) role1;//告诉编译程序，f是一种d。
        f jiansh=new d();//
    }
    }

其中第11行代码编译成功，因为你告诉编译程序，f是一种d。

• xx2问题：对于教材P169页，为什么编译程序后发现SwordMan没有输出“挥剑攻击”？
• xx2解决方案：教材给予说明，传入drawFiht()的是SwordMan类型，那么role参考的就是SwordMan实例，同时在重新定义父类中某个方法时，子类必须撰写与父类相同的签署，书上错例即在子类中的签署与父类因粗心写错而造成的编译错误。想避免此类错误，可以在子类中某个方法钱标注@override就会出现如上图的错误提醒。

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

• xx1问题：如下代码

package src.week3;
public class RPG {
    public static void main(String[] args) {
        f qq=new f();
        qq.setName("Justin");
        qq.setLevel(1);
        qq.setBlood(200);
        showblood(qq);
        a bb=new a();
        showblood(bb);
    }
    static void showblood(d role)
    {
        System.out.printf("%s血量 %d%n",role.getName(),role.getBlood());
    }

无法从bb包内取得信息，否则编译不通过，上述代码可以得到如下结果：
同时可以借此回顾上一周学的字符串初始化为null。

• xx1解决方案：经过一番查找，我发现了问题所在。如下图
• ， 文件名上有小红叉，但依然可以运行，只是无法继承父类。经过上网百度，发现原因是不小心把一些.iml文件误删了，去回收站还原之后即可正常编译。如下：
• 
• xx2问题：关于书上代码guest.java的错误与改正。错误代码如下：

package src.week3;
import java.util.Scanner;
public class guest {
    public static void main(String[] args) {
        k name1=new k();
        collectnameto(name1);
        System.out.println("访客名单:");
        pp(name1);
    }
    public static  void collectnameto(k names)
    {
        while(!(names.equals("quit"))){
            System.out.print("访客姓名: ");
            Scanner console=new Scanner(System.in);//新建一个Scanner实例
            String name=console.nextLine();
            if(names.equals("quit"));
            break;
        }
        names.add(names);//收集name
    }
    public   static  void  pp(k name1)
    {
        for(int i=0;i<name1.size();i++)
        {
            String name=(String) name1.get(i);
            System.out.println(name.toUpperCase());
        }
    }
}

此代码只能输入一次，虽可以编译但运行出错。提示错误所在代码如下

String name=(String) name1.get(i);

所以索性直接改为

 System.out.println(name1.get(i));

但输出变成想着是呀忘了把它转换成String类型就直接输出了。于是继续修改

System.out.println((String) name1.get(i));

但还是出错，如图：根据输出判断应该和第一次代码的错误相同。估计错误不在此处，于是与书上比较是否有粗心输错的地方，果然我把

name1.add(cc);

放到了循环外侧，于是把语句拖入循环中，以为应该对了，结果直接出错如下：UNreachable statement的意思是不能到达的语句。我想是不是他的位置有问题，就把它移到了if()语句上面，可以编译和运行了，但是只能输入一个名字，如图：我想肯定是循环哪里出了毛病，于是在这个函数开头设断点开始单步调试，一开始都是正确的如下图：但在下一步就是

if(cc.equals("quit"));
            {
                break;
            }

语句处，明明不相等的两个语句，但是却break了。于是我开始着手解决if（）条件语句。尝试多次都在出错，错误都是相同的就是直接跳出循环。此处的问题还没搞清楚。于是放弃if（）语句，将代码段修改如下

public static void collectnameto(k name1)
    {int i=0;
        Scanner console=new Scanner(System.in);//新建一个Scanner实例
        while (i==0){
            System.out.printf("访客姓名: ");
            String cc=console.next();
            console.nextLine();
            name1.add(cc);
            i=ww(cc);
        }
    }
    public  static int ww(Object o)
    {
        if(o.equals("quit"))
            return 1;
        else
            return 0;
    }

显示正确。最后可以正确输入与输出如下图：最后关于

cc=console.next();
console.nextLine();

语句，我曾怀疑是这里出错，上网百度后，发现了.nextLine（）和.next（）其实没什么大的分别，但可能出现吃回车问题，于是我在cc=console.next();语句后又加入了console.nextLine();可以避免这个问题。

代码托管

• 代码提交过程截图：
  • 运行 git log --pretty=format:"%h - %an, %cd : %s" 并截图
• 代码量截图：
  • 运行 find src -name "*.java" | xargs cat | grep -v ^$ | wc -l 并截图

上周考试错题总结

• 错题及原因：
  “30”转化为byte类型的30，语句是（Byte.parseByte（“30”）；）
• 理解情况：java.lang.Byte.parseByte（）方法的作用是将字符串参数转化为带符号的十进制数。
• 错题2及原因：Linux bash中（grep）命令可以进行全文搜索？
• 理解情况：grep命令的主要功能就是进行字符串数据的对比，可以搜索文本，并将符合用户需求的字符串打印出来。
• 错题3：

public class Game {
    public static void main(String[] args) {
        System.out.println(""+52+25);
        System.out.println(52+25+"");
    }
    }

对上述代码的输出理解

• 理解情况：输出如图：
  System.out.println(""+i);等同于 System.out.println(i.tostring（）);返回对象的字符串表示，故输出为5225。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	120/120	1/1	16/16	开始了JAVA学习的第一步！
第二周	346/466	1/2	23/36	了解并学习了Java基础语法
第三周	364/830	1/3	21/57	进一步了解java设计语句
第四周	570/1300	2/5	20/77	初步学习了继承与多态，接口与多态知识。

尝试一下记录「计划学习时间」和「实际学习时间」，到期末看看能不能改进自己的计划能力。这个工作学习中很重要，也很有用。
耗时估计的公式
：Y=X+X/N ，Y=X-X/N，训练次数多了，X、Y就接近了。

参考：软件工程软件的估计为什么这么难，软件工程 估计方法

• 计划学习时间:18小时

• 实际学习时间:20小时

• 改进情况：这周学习任务量比较大，花费的时间比预期要多，但效率还不错。

• 有空多看看现代软件工程 课件 软件工程师能力自我评价表

参考资料

• Java学习笔记(第8版)

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

• ...