20145317彭垚《Java程序設計》第5周學習總結

時間 2019-11-09

標籤 Java程序設計 5周學習總結欄目 Java 简体版

原文原文鏈接

20145317彭垚《Java程序設計》第5周學習總結

教材學習內容總結

第八章
8.1 語法與繼承架構

package CH5; /** * Created by Administrator on 2016/3/29. */ import java.util.Scanner; public class Average { public static void main(String[] args) { 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); } }

Java 中全部錯誤都會被打包成對象，若是願意，能夠嘗試捕捉表明錯誤的對象後作一些處理

package CH5; /** * Created by Administrator on 2016/3/29. */ 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("必須輸入整數"); } } }

有時錯誤能夠在捕捉處理以後，嘗試恢復程序正常執行流程：

package CH5; /** * Created by Administrator on 2016/3/29. */ 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); } }

錯誤會被包裝爲對象，這些對象都是可拋出的，所以設計錯誤對象都繼承自java.lang.Throwable類，Throwable定義了取得錯誤信息、堆棧追蹤等方法，它有兩個子類：java.lang.Error與java.lang.Exception.
Error與其子類實例表明嚴重系統錯誤，發生嚴重系統錯誤時，Java應用程序自己是無力回覆的，Error對象拋出時，基本上不用處理，任其傳播至JVM爲止，或者是最多留下日誌信息。

package CH5;

/**
 * Created by Administrator on 2016/3/29.
 */
import java.util.Scanner;
public class Average4 {
    public static void main(String[] args) {
        double sum = 0;
        int count = 0;
        while(true){
            int number = 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);
    }
}

若是父類異常對象在子類異常對象前被捕捉，則catch子類異常對象的區塊將永遠不會被執行，編譯程序會檢查出這個錯誤。
Java的設計上認爲，非受檢異常是程序設計不當引起的漏洞，異常應自動往外傳播，不該使用try、catch來嘗試處理，而應改善程序邏輯來避免引起錯誤。html

package CH5;

/**
 * Created by Administrator on 2016/3/29.
 */
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是惟一採用受檢異常的語言，這有兩個目的：一是文件化；二是提供編譯程序信息。
查看堆棧追蹤最簡單的方法，就是直接調用異常對象的printStackTrace().前端

package CH5;

/**
 * Created by Administrator on 2016/3/29.
 */
public class StackTraceDemo {
    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();
    }
}

要善用堆棧追蹤，前提是程序代碼中不可有私吞異常的行爲、對異常作了不適當的處理，或顯示了不正確的信息。java

package CH5;

/**
 * Created by Administrator on 2016/3/29.
 */
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();
    }
}

package CH5;

/**
 * Created by Administrator on 2016/3/29.
 */
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();
    }
}

8.2 異常與資源管理
不管try區塊中有無發生異常，若撰寫有finally區塊，則finally區塊必定會被執行。若是程序撰寫的流程中先return了，並且也有finally區塊，finally區塊會先執行完後，再將值返回。數組

package CH5;

/**
 * Created by Administrator on 2016/3/29.
 */
import java.io.*;
import java.util.Scanner;
public class TryCatchFinally {
    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();
    }
}

package CH5;

/**
 * Created by Administrator on 2016/3/29.
 */
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;
}

在JDK以後，新增了嘗試關閉資源語法，想要嘗試自動關閉資源的對象，是撰寫在try以後的括號中。架構

package CH5;

/**
 * Created by Administrator on 2016/3/29.
 */
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();
    }
}

JDK的嘗試關閉資源語法可套用的對象，必須操做java.lang.AutoCloseable接口，這是JDK7新增的接口。嘗試關閉資源語法也能夠同時關閉兩個以上的對象資源，只要中間以分號分隔。在try的括號中，越後面撰寫的對象資源會越早被關閉。app

package CH5;

/**
 * Created by Administrator on 2016/3/29.
 */
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("資源被關閉");
    }
}

第九章

9.1
·JavaSE中提供了知足各類需求的API，收集對象的行爲，都定義在java.collection中，既能收集對象也能驅逐對象。
·若是手機是具備索引順序，可使用數組。
·List是一種Collection，做用是收集對象，並以索引的方式保留手機的對象順序dom

import java.util.Arrays;

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

·ArrayListArrayList特性：數組在內存中會是連續的線性空間，根據索引隨機存取時速度快，若是操做上有這類需求時，像是排序，就可以使用ArrayList，可獲得較好的速度表現。
·LinkedList在操做List接口時，採用了連接（Link）結構。
·在收集過程當中如有相同對象，則再也不重複收集，若是有這類需求，可使用Set接口的操做對象。
·HashSet的操做概念是，在內存中開設空間，每一個空間會有個哈希編碼。;Queue繼承自Collection，因此也具備Collection的add()、remove()、element()等方法，然而Queue定義了本身的offer()、poll()與peek()等方法，最主要的差異之一在於：add()、remove()、element()等方法操做失敗時會拋出異常，而offer()、poll()與peek()等方法操做失敗時會返回特定值。
·若是對象有操做Queue，並打算以隊列方式使用，且隊列長度受限，一般建議使用offer()、poll()與peek()等方法。LinkedList不只操做了List接口，與操做了Queue的行爲，因此能夠將LinkedList看成隊列來使用。ide

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 request = (Request) requests.poll();
            request.execute();
        }
    }
}

·使用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 isFull() {
        return elems.size() + 1 > capacity;
    }
    
    public Object pop() {
        return elems.pollLast();
    }
    
    public Object peek() {
        return elems.peekLast();
    }
    
    public int size() {
        return elems.size();
    }
    
    public static void main(String[] args) {
        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());
    }
}

·隊列的前端與尾端進行操做，在前端加入對象與取出對象，在尾端加入對象與取出對象，Queue的子接口Deque就定義了這類行爲；java.util.ArrayDeque操做了Deque接口，可使用ArrayDeque來操做容量有限的堆棧。泛型語法：類名稱旁有角括號<>，這表示此類支持泛型。實際加入的對象是客戶端聲明的類型。ui

·匿名類語法來講，Lambda表達式的語法省略了接口類型與方法名稱，->左邊是參數列，而右邊是方法本體；在Lambda表達式中使用區塊時，若是方法必須有返回值，在區塊中就必須使用return。interator()方法提高至新的java.util.Iterable父接口。

·Collections的sort（）方法要求被排序的對象必須操做java.lang.Comparable接口，這個接口有個compareTo（）方法必須返回大於0、等於0或小於0的數；Collections的sort（）方法有另外一個重載版本，可接受java.util.Comparator接口的操做對象，若是使用這個版本，排序方式將根據Comparator的compare（）定義來決定。

解決方法
1.操做Comparable

import java.util.*;

class Account2 implements Comparable<Account2> {
    private String name;
    private String number;
    private int balance;

    Account2(String name, String number, int balance) {
        this.name = name;
        this.number = number;
        this.balance = balance;
    }

    @Override
    public String toString() {
        return String.format("Account2(%s, %s, %d)", name, number, balance);
    }

    @Override
    public int compareTo(Account2 other) {
        return this.balance - other.balance;
    }
}

public class Sort3 {
    public static void main(String[] args) {
        List accounts = Arrays.asList(
                new Account2("Justin", "X1234", 1000),
                new Account2("Monica", "X5678", 500),
                new Account2("Irene", "X2468", 200)
        );
        Collections.sort(accounts);
        System.out.println(accounts);
    }
}

2.操做Comparator

import java.util.*;

public class Sort4 {
    public static void main(String[] args) {
        List words = Arrays.asList("B", "X", "A", "M", "F", "W", "O");
        Collections.sort(words);
        System.out.println(words);
    }
}

·在java的規範中，與順序有關的行爲，一般要不對象自己是Comparable，要不就是另行指定Comparator對象告知如何排序；若要根據某個鍵來取得對應的值，能夠事先利用java.util.Map接口的操做對象來創建鍵值對應數據，以後若要取得值，只要用對應的鍵就能夠迅速取得。經常使用的Map操做類爲java.util.HashMap與java.util.TreeMap，其繼承自抽象類java.util.AbstractMap。

·Map也支持泛型語法，如使用HashMap的範例：

import java.util.*;
import static java.lang.System.out;

public class Messages 
{
    public static void main(String[] args) 
    {
        Map<String, String> messages = new HashMap<>();
        messages.put("Justin", "Hello！Justin的訊息！");
        messages.put("Monica", "給Monica的悄悄話！");
        messages.put("Irene", "Irene的可愛貓喵喵叫！");

        Scanner console = new Scanner(System.in);
       out.print("取得誰的訊息：");
        String message = messages.get(console.nextLine());
        out.println(message);
        out.println(messages);
    }
}

·若是使用TreeMap創建鍵值對應，則鍵的部分則會排序，條件是做爲鍵的對象必須操做Comparable接口，或者是在建立TreeMap時指定操做Comparator接口的對象。

Properties類繼承自Hashtable，HashTable操做了Map接口，Properties天然也有Map的行爲。雖然也可使用put（）設定鍵值對應、get（）方法指定鍵取回值，不過通常經常使用Properties的setProperty（）指定字符串類型的鍵值，getProperty（）指定字符串類型的鍵，取回字符串類型的值，一般稱爲屬性名稱與屬性值。

·若是想取得Map中全部的鍵，能夠調用Map的keySet（）返回Set對象。因爲鍵是不重複的，因此用Set操做返回是理所固然的作法，若是想取得Map中全部的值，則可使用values（）返回Collection對象。

·若是想同時取得Map的鍵與值，可使用entrySet（）方法，這會返回一個Set對象，每一個元素都是Map.Entry實例。能夠調用getKey（）取得鍵，調用getValue（）取得值。