20145310 《Java程序设计》第5周学习总结

教材学习内容总结

本周主要进行第八章和第九章的学习。

java中所有的错误都会打包为对象，可以try catch代表错误的对象后做一些处理。运用try、catch，还可以在捕捉处理错误之后，尝试恢复程序正常执行流程。

import java.util.*;

public class AVE {

    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("AVE %.2f%n",sum/count);

    }

}

程序运行结果：

如果父类异常对象在子类异常前被捕捉，则catch子类异常对象的区块将永远不会被执行。误会被包装为对象，这些对象是可抛出的，因此设计错误对象都继承自java.lang.Throwable类。

在异常发生时，可使用try 、catch处理当时可进行的异常处理，在catch区块进行完部分错误处理之后，可以使用throw（注意不是throws）将异常再抛出。

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

    }

}

只有java是采用受检异常的语言。

若收集的对象经常会有变动索引的情况，也许考虑链接方式操作的List会比较好，像是随时会有客户端登录或注销的客户端List，使用LinkedList会有比较好的效率。

在收集过程中若有相同对象，则不再重复收集，如果有这类需求，可以使用Set接口的操作对象。

public class StackTraceDemo1

{

    public static void main(String[] args)

    {

        try

        {

            c();

        }

        catch (NullPointerException ex)

        {

            ex.printStackTrace();

        }

    }

    static void c()

    {

        b();

    }

    static void b()

    {

        a();

    }

    static String a()

    {

        String text = null;

        return text.toUpperCase();

    }

}

查看堆栈追踪最简单的方法，就是直接调用异常对象的 printStackTrace()。

在使用 throw 重抛异常时，异常的追踪堆栈起点，仍是异常的发生根源，而不是重抛异常的地方，



public class StackTraceDemo2 {

    public static void main(String[] args) {

        try{

            c();

        }catch(NullPointerException ex){

            ex.printStackTrace();

        }

    }

    static void c(){

        try{

            b();

        }catch(NullPointerException ex) {

            ex.printStackTrace();

            throw ex;

        }

    }

    static void b(){

        a();

    }

    static String a(){

        String text = null;

        return text.toUpperCase();

    }

}

无论try区块中有无异常，若撰写finally区块，则finally区块一定会被执行

public class FinallyDemo {

    public static void main(String[] args) {

        System.out.println(test(true));

    }

    static int test(boolean flag){

        try{

            if(flag){

                return 1;

            }

        }finally{

            System.out.println("finally...");

        }

    }return 0;

}

收集对象的共同行为定义在Collection中。

java.util.ArrayDeque操作了Deque接口，可以使用ArrayDeque来操作容量有限的堆栈。

如果对象有操作Queue，并打算以队列方式使用，且队列长度受限，通常建议使用offer()、poll()与peek()等方法。

import java.util.*;

interface Request{

    void execute();

}

public class RequestQueue {

    public static void main(String[] args) {

        Queue requests = new LinkedList();

        offerRequestTo(requests);

        process(requests);

    }

    static void offerRequestTo(Queue requests){

        for(int i=1;i<6;i++){

            Request request = new Request(){

                public void execute(){

                    System.out.printf("处理数据%f%n",Math.random());

                }

            };

            requests.offer(request);

        }

    }

    static void process(Queue requests){

        while(requests.peek()!=null){

            Request rquest = (Request) request.poll();

            request.execute();

        }

    }

}

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

学习的东西越来越难了，光敲代码是没有用的，还是要多思考，多练习，否则会学得很不扎实，比如上周考试的操作题就不会。所以以后还需要在java上投入更多的时间练习。

代码托管截图：

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	100/100	2/2	10/10	初步认识java
第二周	150/250	1/3	12/22	掌握Java基础语法
第三周	537/787	2/4	20/42	认识对象，对象封装
第四周	500/1287	1/5	20/62	继承与多态，接口与多态
第五周	300/1587	1/6	20/82

参考资料