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

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

参考资料

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