20155208徐子涵 2016-2017-2 《Java程序设计》第5周学习总结

Posted 2020-09-06

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了20155208徐子涵 2016-2017-2 《Java程序设计》第5周学习总结相关的知识，希望对你有一定的参考价值。

20155208徐子涵 2016-2017-2 《Java程序设计》第5周学习总结

教材学习内容总结

第八章异常处理

8.1 语法与继承结构

Java中所有错误都会被打包为对象，运用try、catch，可以在错误发生时显示友好的错误信息。如：

import java.util.*;

public class Average2
{
    public static void main(String[] args)
    {
       try
       {
           Scanner console = new Scanner(System.in);
           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);
       }
       catch (InputMismatchException ex)
       {
           System.out.println("必须输入整数");
       }
    }
}

运用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);
    }
}

如果父类异常对象在子类异常前被捕捉，则catch子类异常对象的区块将永远不会被执行。
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();
    }
}

如果抛出的是受检异常，表示你认为客户端有能力且应该处理异常，此时必须在方法上使用throws声明；如果抛出的异常是非受检异常，表示你认为客户端调用方法的时机错了，抛出异常是要求客户端修正这个漏洞再来调用方法，此时也就不用throws声明。
如果使用继承时，父类某个方法声明throws某些异常，子类重新定义该方法时可以：

不声明throws任何异常。

throws父类该方法中声明的某些异常。

throws父类该方法中声明异常的子类。但是不可以：

throws父类方法中未声明的其他异常。

throws父类方法中声明异常的父类。

在多重方法调用下，异常发生点可能是在某个方法之中，若想得知异常发生的根源，以及多重方法调用下的堆栈传播，可以利用异常对象自动收集的堆栈追踪来取得相关信息，例如调用异常对象的printStackTrace()。如：

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

要善用堆栈追踪，前提是程序代码中不可有私吞异常的行为。
在使用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();
    }
}

程序执行的某个时间点或某个情况下，必然处于或不处于何种状态，这是一种断言。
何时该使用断言？

断言客户端调用方法前，已经准备好某些前置条件（通常在private方法之中）

断言客户端调用方法后，具有方法承诺的结果。

断言对象某个时间点下的状态。

使用断言取代批注。

断言程序流程中绝对不会执行到的程序代码部分。断言是判定程序中的某个执行点必然是或不是某个状态，所以不能当作像if之类的判断式来使用，assert不应当作程序执行流程的一部分。
若想最后一定要执行关闭资源的动作，try、catch语法可以搭配finally，无论try区块中有无发生异常，若撰写有finally区块，则finally区块一定会被执行。如：

import java.io.*;
import java.util.Scanner;

public class FileUtil
{
    public static String readFile(String name) throws FileNotFoundException
    {
        StringBuilder text = new StringBuilder();
        Scanner console = null;
        try
        {
            console = new Scanner(new FileInputStream(name));
            while (console.hasNext()) 
            {
                text.append(console.nextLine())
                .append(‘\\n‘);
            }
        } 
        finally 
        {
            if(console != null)
            {
                console.close();
            }
        } 
        return text.toString();
    }
}

如果程序撰写的流程中先return了，而且也有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;
    }
}

尝试关闭资源语法：想要尝试自动关闭资源的对象，是撰写在try之后的括号中，如果无须catch处理任何异常，可以不用撰写，也不用撰写finally自行尝试关闭资源。如：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class FileUtil2
{
    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‘);
            }
        } 
        return text.toString();
    }
}

尝试关闭资源语法可套用的对象，必须操作java.lang.AutoCloseable接口。如：

public class AutoClosableDemo
{
    public static void main(String[] args)
    {
        try(Resource res = new Resource())
        {
            res.doSome();
        } 
        catch(Exception ex)
        {
            ex.printStackTrace();
        }
    }
}

class Resource implements AutoCloseable
{
    void doSome()
    {
        System.out.println("作一些事");
    }
    @Override
    public void close() throws Exception
    {
        System.out.println("資源被關閉");
    }
}

尝试关闭资源语法也可以同时关闭两个以上的对象资源，只要中间以分号分隔。如：

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 AutoCloseable 
{
    void doSome() 
    {
        out.println("作一些事");
    }
    @Override
    public void close() throws Exception 
    {
        out.println("資源Some被關閉");
    }
}

class ResourceOther implements AutoCloseable 
{
    void doOther() 
    {
        out.println("作其它事");
    }
    @Override
    public void close() throws Exception 
    {
        out.println("資源Other被關閉");
    }
}

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

第九章 Collection与Map

收集对象的行为，像是新增对象的add（）方法、移除对象的remove（）方法等，都是定义在java.util.Collection中。既然可以收集对象，也要能逐一取得对象，这就是java.lang.Iterable定义的行为，它定义了iterator()方法返回java.lang.Iterable操作对象，可以让你逐一取得收集的对象。
收集对象的共同行为定义在Collection中，然而收集对象会有不同的需求。如果希望收集时记录每个对象的索引顺序，并可依索引取回对象，这样的行为定义在java.util.List接口中。如果希望收集的对象不重复，具有集合的行为，则由java.util.Set定义。如果希望收集对象时以队列方式，收集的对象加入至尾端，取得对象时从前端，则可以使用java.util.Queue。如果希望Queue的两端进行加入、移除等操作,则可以使用java.util.Deque。
数组在内存中会是连续的线性空间，根据索引随机存取时速度快，如果操作上有这类需求时，像是排序，就可使用ArrayList，可得到较好的速度表现。
若收集的对象经常会有变动索引的情况，也许考虑链接方式操作的List会比较好，像是随时会有客户端登录或注销的客户端List，使用LinkedList会有比较好的效率。在收集过程中若有相同对象，则不再重复收集，如果有这类需求，可以使用Set接口的操作对象。如：

import java.util.*;

public class WordCount
{
    public static void main(String[] args) 
    {
        Scanner console = new Scanner(System.in);

        System.out.print("請輸入英文：");
        Set words = tokenSet(console.nextLine());
        System.out.printf("不重複單字有 %d 個：%s%n", words.size(), words);
    }

    static Set tokenSet(String line)
    {
        String[] tokens = line.split(" ");
        return new HashSet(Arrays.asList(tokens));
    }
}

Queue继承自Collection，所以也具有Collection的add()、remove()、element()等方法，然而Queue定义了自己的offer()、poll()与peek()等方法，最主要的差别之一在于：add()、remove()、element()等方法操作失败时会抛出异常，而offer()、poll()与peek()等方法操作失败时会返回特定值。
如果对象有操作Queue，并打算以队列方式使用，且队列长度受限，通常建议使用offer()、poll()与peek()等方法。
java.util.ArrayDeque操作了Deque接口，可以使用ArrayDeque来操作容量有限的堆栈。相对于匿名类语法来说，Lambda表达式的语法省略了接口类型与方法名称，->左边是参数列，而右边是方法本体。
Collections的sort（）方法要求被排序的对象必须操作java.lang.Comparable接口，这个接口有个compareTo（）方法必须返回大于0、等于0或小于0的数。
若要根据某个键来取得对应的值，可以事先利用java.util.Map接口的操作对象来建立键值对应数据，之后若要取得值，只要用对应的键就可以迅速取得。常用的Map操作类为java.util.HashMap与java.util.TreeMap，其继承自抽象类java.util.AbstractMap。
如果想同时取得Map的键与值，可以使用entrySet（）方法，这会返回一个Set对象，每个元素都是Map.Entry实例。可以调用getKey（）取得键，调用getValue（）取得值。如：

import java.util.*;

public class MapKeyValue2
{
    public static void main(String[] args) 
    {
        Map<String, String> map = new TreeMap<>();
        map.put("one", "一");
        map.put("two", "二");
        map.put("three", "三");
        foreach(map.entrySet());
    }

    static void foreach(Iterable<Map.Entry<String, String>> iterable)
    {
        for(Map.Entry<String, String> entry: iterable)
        {
            System.out.printf("(鍵 %s, 值 %s)%n", 
                    entry.getKey(), entry.getValue());
        }
    }
}