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

教材学习内容总结

第八章

java中所有错误都会被包装为对象，可以尝试（try）执行程序并捕捉（catch）代表错误的对象后做一些处理。使用try、catch语法，JVM会尝试执行try区块中的程序代码，如果发生错误，执行流程会跳离错误发生点，然后对比catch括号中声明的类型，是否符合被抛出的错误对象类型，如果是的话，就执行catch区块中的程序代码。
错误会被包装为对象，这些对象都是可抛出的，因此设计错误对象都继承自

java.lang.Throwable类，Throwable定义了取得错误信息、堆栈追踪等方法，他有两个子类：java.lang.Error与java.lang.Exception。
Error与其子类实例代表严重系统错误，例如硬件层面错误，JVM错误或内存不足等问题。虽然也可以用try、catch来处理Error对象。但并不建议，发生严重系统错误时，java应用程序本身是无力处理的。
如果抛出了Throwable对象，而程序中没有任何catch捕捉到错误对象，最后由JVM捕捉到的话，JVM基本处理就是显示错误对象包装的信息并中断程序。
程序设计本身的错误，建议使用Expection或其子类实例来表现，所以通常称错误处理为异常处理。
单就语法与继承框架上来说，如果某个方法声明会抛出Throwable或子类实例，只要不是属于Error或java.lang.RuntimeException或其子类实例，就必须明确使用try、catch语法加以处理，或者在方法中用throws声明这个方法会抛出异常，否则会编译失败。
Exception或其子对象，但非属于RuntimeException或其子对象，称为受检异常。受检异常存在的目的在于API设计者实现某方法时，某些条件成立时会引发错误，而且认为调用方法的客户端有能力处理错误，要求编译程序提醒客户端必须明确处理错误，不然不可通过编译，API客户端无权选择要不要处理。
属于RuntimeException衍生出来的类实例，代表API设计者实现某方法时，某些条件成立时会引发错误，而且认为API客户端应该在调用方法前做好检查，以避免引发错误。
如果父类异常对象在子类异常对象前被捕捉，则catch子类异常对象的区块将永远不会被执行，编译程序会检查出这个错误。
在catch区块进行完部分错误处理之后，可以使用throw将异常抛出。
可以利用异常对象自动收集的堆栈追踪来得知异常发生的根源，以及多重方法调用下异常的堆栈传播，例如调用异常对象的printStackTrace()、getStackTrace()等方法。要善用堆栈追踪，前提是程序代码中不可有私吞异常的行为，对异常做了不适当的处理，或显示了不正确的信息。
在使用throw重抛异常时，异常的追踪堆栈起点，仍是异常的发生根源，而不是重抛异常的地方。如果想要让异常堆栈起点为重抛异常的地方，可以使用fillInStackTrace（），这个方法会重新装填异常堆栈，将起点设为重抛异常的地方，并返回Throeable对象。无论try区块中有无发生异常，若撰写有finally区块，则finally区块一定会被执行。如果程序撰写的流程中先return了，也有finally区块，finally区块会先执行完后，再将值返回。

部分程序代码：

运用try、catch在错误被捕捉处理后、尝试恢复程序正常的执行流程。

import java.util.*;

    public class Average3{

        public static void main(String[] args)

        {

            Scanner console=new Scanner(System.in);

            double sum=0;

            int count=0;

            while(true)

            {

                try

                {

                    int number=console.nextInt();

                    if(number==0)

                    {

                        break;

                    }

                    sum+=number;

                    count++;

                }

                catch (InputMismatchException ex)

                {

                    System.out.printf("略过非整数输入:%s%n",console.next());

                }

            }

            System.out.printf("平均 %.2f%n",sum/count);

        }

    }

取得用户的字符串输入之后，检查时候位数字格式，若是在转换为int整数，若格式不对就提醒用户做正确格式输入。

import java.util.Scanner;

public class Average4{

    public static void main(String[] args){

        double sum=0;

        int count=0;

        while(true){

            int number=console.nextInt();

            if(number==0){

                break;

            }

            sum+=number;

            count++;

        }

        System.out.printf("平均 %.2f%n",sum/count);

    }

    static Scanner console=new Scanner(System.in);

    static int nextInt(){

        String input=console.next();

        while(!input.matches("\\d*")){

            System.out.println("请输入数字");

            input=console.next();

        }

        return Integer.parseInt(input);

    }

}

在异常发生时，可以使用try、catch处理当时环境可进行的异常处理，无法决定如何处理的部分，可以抛出由调用方法的客户端处理，如果想处理部分事项再抛出的做法。

import java.io.*;

import java.util.Scanner;

public class FileUtil{

    public static String readFile(String name)throws FileNotFoundException{

        StringBuilder text=new StringBuilder();

        try{

            Scanner console=new Scanner(new FileInputStream(name));

            while(console.hasNext()){

                text.append(console.nextLine())

                .append('\n');

            }

        }catch(FileNotFoundException ex){

            ex.printStackTrace();

            throw ex;

        }

        return text.toString();

    }

}

使用fillInStrackTrace（）方法，让异常堆栈起点为重抛异常的地方。

public class StackTraceDemo3{

    public static void main(String[] args){

        try{

            c();

        }catch(NullPointerException ex){

            ex.printStackTrace();

        }

    }

    static void c(){

        try{

            b();

        }catch(NullPointerException ex){

            ex.printStackTrace();

            Throwable t=ex.fillInStackTrace();

            throw (NullPointerException) t;

        }

    }

    static void b(){

        a();

    }

    static String a(){

        String text=null;

        return text.toUpperCase();

    }

}

在try括号中，越后面撰写的对象资源会越早被关闭。

import static java.lang.System.out;

public class AutoClosableDemo2{

    public static void main(String[] args){

        try(ResourceSome some=new ResourceSome();

        ResourceOther other=new ResourceOther()){

            some.doSome();

            other.doOther();

        }catch(Exception ex){

            ex.printStackTrace();

        }

    }

}

class ResourceSome implements AutoClosable{

    void doSome(){

        out.println("做一些事");

    }

    @Override

    public void close() throws Exception{

        out.println("资源Some被关闭");

    }

}

class ResourceOther implements AutoClosable{

    void doOther(){

        out.println("做其他事");

    }

    @Override

    public void close() throws Exception{

        out.println("资源Other被关闭");

    }

}

第九章

收集对象的行为，像是新增对象的add（）方法、移除对象的remove（）方法等，都是定义在java.util.Collection中。java.lang.Iterable定义的行为可以收集对象，也能逐一取得对象，它定义了iterator（）方法返回java.util.Iterator操作对象，可以让你逐一取得收集的对象。
如果希望收集时记录每个对象的索引顺序，并可依索引取回对象，这样的行为定义在java.util.List接口中。如果希望收集的对象不重复，具有集合的行为，则由java.util.Set定义。如果希望收集对象时以队列方式，收集的对象加入至尾端，取得对象时从前端，则可以使用java.util.Queue。如果希望对Queu的两端进行加入、移除等操作，则可以使用java.util.Deque.
ArrayList有个可指定容量的构造函数，如果大致知道将收集的对象范围，事先建立足够长度的内部数组，可以节省时间与内存的成本。
LinkedList在操作List接口时，采用了链接结构，不会事先耗费内存，想要指定索引随机存取对象，会比较没有效率，链接的每个元素会参考下一个元素，这有利于调整索引顺序。
判断对象是否重复时，都会调用hashCode（）与equals（）方法。
如果对象有操作Queue，并打算以队列方式使用，且队列长度受限，通常建议使用offer（），poll（）与peek（）等方法。想对队列的前端与尾端进行操作，在前端加入对象与取出对象，在尾端加入对象与取出对象，Queue的子接口Deque就定义了这类行为。
一般常用Properties的setProperty（）指定字符串类型的键值，getProperty（）指定字符串类型的键，取回字符串类型的值，通常称为属性名称与属性值。

部分程序代码：

操作了hashcode（）与equal（）方法，重复的student不会被收集。

import java.util.*;

class Student2 {

    private String name;

    private String number;

    Student2(String name, String number) {

        this.name = name;

        this.number = number;

    }

    @Override

    public int hashCode()

    {

        int hash = 7;

        hash = 47 * hash + Objects.hashCode(this.name);

        hash = 47 * hash + Objects.hashCode(this.number);

        return hash;

    }

    @Override

    public boolean equals(Objects obj) {

        if (obj == null) {

            return false;

        }

        if (getClass() != obj.getClass()) {

            return false;

        }

        final Student2 other = (Student2) obj;

        if (!Objects.equals(this.name, other.name)) {

            return false;

        }

        if (!Objects.equals(this.number, other.number)) {

            return false;

        }

        return true;

    }

    @Override

    public String toString()

    {

        return String.format("(%s,%s)", name, number);

    }

}

public class Students2

{

    public static void main(String[] args)

    {

        Set students = new HashSet();

        students.add(new Student2("Justin","B835031"));

        students.add(new Student2("Monica","B835032"));

        students.add(new Student2("Justin","B835031"));

        System.out.println(students);

    }

}

使用ArrayDeque来操作容量有限的堆栈。

import java.util.*;

import static java.lang.System.out;

public class Stack

{

    private Deque elems = new ArrayDeque();

    private int capacity ;

    public Stack(int capacity)

    {

        this.capacity = capacity;

    }

    public boolean push(Object elem)

    {

        if(isFull())

        {

            return false;

        }

        return elems.offerLast(elem);

    }

    private boolean ifFull()

    {

        return elems.size() + 1 > capacity;

    }

    public Object pop()

    {

        return elems.pollLast();

    }

    public Object peek()

    {

        return elems.size();

    }

    public static  void main (String[] agrs)

    {

        Stack stack = new Stack(5);

        stack.push("Justin");

        stack.push("Monica");

        stack.push("Irene");

        out.println(stack.pop());

        out.println(stack.pop());

        out.println(stack.pop());

    }

}

ArrayList为例，加入泛型语法。

import java.util.Arrays;

import java.util.Objects;

public class ArrayList<E>

{

    private Object[] elems;

    private int next;

    public ArrayList(int capacity)

    {

        elems = new Object [capacity];

    }

    public ArrayList()

    {

        this(16);

    }

    public void add(E e)

    {

        if(next == elems.length)

        {

            elems = Arrays.copyOf(elems,elems.length * 2);

        }

        elems[next++] = e;

    }

    public E get (int index)

    {

        return (E) elems[index];

    }

    public int size()

    {

        return next;

    }

}

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

问题1：

操作对象的过程中如果抛出受检异常，但目前环境信息不足以处理异常，所以无法用try、catch处理时，该怎么办？
解决方案1：

这时候应该由方法的客户端依据当时调用的环境信息进行处理。为了告诉编译程序这个事实，必须使用throws声明此方法会抛出的异常类型或父类型，编译程序才会让你通过编译。
问题2：

如果想取得Map中的所有键，可以调用Map的keySet（）返回Set对象，如果想取得Map中所有值，可以使用values返回Collection对象。那如果同时想取得Map键与值该怎么办？
解决方案2：

可以使用entrySet（）方法，这会返回一个Set对象，每个元素都是Map.Entry实例，可以调用getKey（）取得键，调用getValue（）取得值。

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

问题1：

课本P269页代码：

import java.util.*;

class Student {

private String name;

private String number;

Student(String name, String number) {

    this.name = name;

    this.number = number;

}

@Override

public String toString()  {

    eturn String.format("(%s, %s)", name, number);

}

}

public class Students {

public static void main(String[] args) {

    Set students = new HashSet();

    students.add(new Student("Justin", "B835031"));

    students.add(new Student("Monica", "B835032"));

    students.add(new Student("Justin", "B835031"));

    System.out.println(set);

}

}

解决方案1：

IDEA报错了，IDEA的提醒是不能识别“set”。结合课本，不难发现这里应该想要输出的是Set类的实例students。果然改成students后，代码顺利执行，显示结果：

[(Monica, B835032), (Justin, B835031), (Justin, B835031)]

上周考试错题总结

错题1:填空：使用JDB进行调试时单步执行命令有step和next,我们优先使用（next）。
错题2:使用JDB进行调试时查看源代码的命令是（list）。
错题3:填空：”Hello”.substring( 0,2 )的值是“He”。
错题4：面向对象中，设计经验可以用（设计模式）表达。

结对及互评

评分标准(满分10分)

从0分加到10分为止
正确使用Markdown语法（加1分）：
- 不使用Markdown不加分
- 有语法错误的不加分（链接打不开，表格不对，列表不正确...）
- 排版混乱的不加分
模板中的要素齐全（加1分）
- 缺少“教材学习中的问题和解决过程”的不加分
- 缺少“代码调试中的问题和解决过程”的不加分
- 代码托管不能打开的不加分
- 缺少“结对及互评”的不能打开的不加分
- 缺少“上周考试错题总结”的不能加分
- 缺少“进度条”的不能加分
- 缺少“参考资料”的不能加分
教材学习中的问题和解决过程, 一个问题加1分
代码调试中的问题和解决过程, 一个问题加1分
本周有效代码超过300分行的（加2分）
- 一周提交次数少于20次的不加分

6 其他加分：

- 周五前发博客的加1分

- 感想，体会不假大空的加1分

- 排版精美的加一分

- 进度条中记录学习时间与改进情况的加1分

- 有动手写新代码的加1分

- 课后选择题有验证的加1分

- 代码Commit Message规范的加1分

- 错题学习深入的加1分

7 扣分：

- 有抄袭的扣至0分

- 代码作弊的扣至0分

点评模板：

基于评分标准，我给本博客打分：（0-10）。得分情况如下：xxx
参考示例

点评过的同学博客和代码

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

之前感觉java每周的学习太过紧张，因为是将任务全都堆到周末去做，所以在周末的两天里要看大量的视频，写大量的文字。但是其实只要每天都拿出时间来学java，就可以减轻一点周末写博客时的压力写博客也不只是抄书，而要进行自己的思考与感悟，虽然现在让我们自己写代码仍是有一定难度，毕竟练习的还是少，实话说我现在根本写不出，只能依葫芦画瓢去打书上的代码，稍微改动一点就会蒙掉，但是我相信经过之后的学习与努力，我最终可以写出自己的代码。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）
目标	5000行	30篇	400小时
第一周	5/5	1/4	20/20
第二周	140/145	1/5	18/38
第三周	330/451	1/6	16/54
第四周	578/1038	1/7	18/72
第五周	774/1472	1/8	18/90

尝试一下记录「计划学习时间」和「实际学习时间」，到期末看看能不能改进自己的计划能力。这个工作学习中很重要，也很有用。

耗时估计的公式

：Y=X+X/N ，Y=X-X/N，训练次数多了，X、Y就接近了。

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

计划学习时间:25小时
实际学习时间:18小时
改进情况：这周有其他学习任务，在java方面没有花很多时间改进，以后会注意的。
有空多看看现代软件工程课件软件工程师能力自我评价表

参考资料