20145127《java程序设计》第五周学习总结

教材学习内容总结

第八章 异常处理

1.try catch

java中所有错误会被打包成对象，可以进行尝试捕捉代表错误的对象进行处理。

Import java.until.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”, sun / count);
}

}

执行结果：

（输入正确）

10 20 30 40 0

平均 25.00

（输入错误）

10 20 3O 40 0

Exception in thread “main”

java.until.InputMismatchException

at java.until.Scanner.throwFor(Scanner.java:909)

at java.until.Scanner.next(Scanner.java:1530)

at java.until.Scanner.nextInt(Scanner.java:2160)

at java.until.Scanner.nextInt(Scanner.java:2119)

at cc.openhome.Average.main(Average.java:11)

Java Result: 1

在错误可以捕捉处理后，尝试恢复程序正常执行流程。

Import java.until.*;

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”, sun / count);
    }catch (InputMismatchException ex) {
        System.out.printIn(“必须输入整数”);
    }
}

}

执行结果：

（输入正确）

10 20 30 40 0

平均：25.00

（输入错误）

10 20 3o 40 0

逆序输入整数

Import java.until.*;

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”, sun / count);
}

}

执行结果：

（输入错误）

10 20 3o 40 0

略过非整数输入：3o

平均：23.33

2.异常继承构架

解决错误信息的方法：使用try、catch打包System.in.read()，是在main（）方法旁边声明throws java.io.IOException。

3.认识堆栈追踪

利用异常对象自动收集的堆栈追踪得知异常发生的根源。

查看堆栈追踪的最简单方法就是直接调用对象的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();
}

}

执行结果：

java.lang.NullPointerException

java.lang.NullPointerException

at cc.openhome.StackTraceDemo2.a(StackTraceDemo2.java:28)

at cc.openhome.StackTraceDemo2.b(StackTraceDemo2.java:23)

at cc.openhome.StackTraceDemo2.c(StackTraceDemo2.java:14)

at cc.openhome.StackTraceDemo2.main(StackTraceDemo2.java:6)

java.lang.NullPointerException

at cc.openhome.StackTraceDemo2.a(StackTraceDemo2.java:28)

at cc.openhome.StackTraceDemo2.b(StackTraceDemo2.java:23)

at cc.openhome.StackTraceDemo2.c(StackTraceDemo2.java:14)

at cc.openhome.StackTraceDemo2.main(StackTraceDemo2.java:6)

如果要异常堆栈起点为重抛异常的地方，可使用fillInStackTrace()方法。

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

}

执行结果：

java.lang.NullPointerException

at cc.openhome.StackTraceDemo3.a(StackTraceDemo3.java:28)

at cc.openhome.StackTraceDemo3.b(StackTraceDemo3.java:23)

at cc.openhome.StackTraceDemo3.c(StackTraceDemo3.java:14)

at cc.openhome.StackTraceDemo3.main(StackTraceDemo3.java:6)

java.lang.NullPointerException

at cc.openhome.StackTraceDemo3.c(StackTraceDemo3.java:17)

at cc.openhome.StackTraceDemo3.main(StackTraceDemo3.java:6)

4.java.lang.AutoCloseable接口

操作java.lang.AutoCloseable接口，在JDK7尝试关闭资源语法客套用的对象。

public class AutoClosableDemo {

public static void main(String[] args) {

    try(Reource res = new Reource()) {
      res.doSome()
    }catch(Excepion ex) {
        ex.pintSackTrace();
    }
}

}

class Resource implements AutoCloseable {

void doSome() {
    System.out.printIn(“做一些事”);
}

@Override
public void close() throws Exception {
System.out.prinIn(“资源被关闭”);
}

}

执行结果：

做一些事

资源被关闭

尝试关闭资源语法也可以同时关闭两个以上的对象资源。

import static java.lang.System.out;

public class AutoClosableDemo {

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.printIn(“做一些事”);
}

@Override
public void close() throws Exception {
    out.prinIn(“资源Some被关闭”);
}

}

class ResourceOther implements AutoCloseable {

void doOther () {
    out.printIn(“做其他事”);
}

@Override
public void close() throws Exception {
    out.prinIn(“资源Other被关闭”);
}

}

执行结果：

做一些事

做其他事

资源Some被关闭

资源Other被关闭

第九章 Collection与Map

1.认识Collection构架

针对手机对象的需求，Java提供了Collection API。

2.具有索引的List

ArrayList特性：排序

LinkedList特性：链式结构

3.Set

使用Set接口操作对象，可以在收集过程中的相同对象不再重复收集。

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() {
    return 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.printIn(set);
}

}

执行结果：

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

重复的student不被收集

import java.util.*;

class Student {

private String name;
private String number;
Student(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(Object obj) {
    if (obj == null) {
        return false;
    }
    if (grtClass() != obj.getClass()) {
        return false;
    }
    final Student other = (student) 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 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.printIn(set);
}

}

执行结果：

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

4.Queue

Queue与Deque等义方法

Queue方法 Deque方法

add() addLast()

Offer() offerLast()

remove() removeFirst()

poll() pollFirst()

element() getFirst()

peek() peekFirst()

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

import java.util.*;

import static java.lang.System.out;

public class Stack {

private Deque elems = new ArrayDeque();
prive 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.printIn(stack.pop());
    out.printIn(stack.pop());
    out.printIn(stack.pop());
}

}

执行结果：

Irene

Monica

Justin

5.Comparable与Comparator

必须有索引才能进行排序。

使用Collections的sort（）方法接受List的操作。

import java.util.*;

public class Sort {

public static void main(String[] args) {
    List numbers = Arrays.asList(10, 2, 3, 1, 9, 15, 4);
    Collections.sort(numbers);
    Sysem.out.printIn(numbers);
}

}

执行结果：

[1， 2， 3， 4， 9， 10， 15]

操作Comparable

import java.util.*;

class Account implements Comparable {

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

@Override
public int compareTo(Account other) {
    return this.balance – other.balance;
}

}

public class Sort {

public static void main(String[] args) {
    List account = Arrays.asList(
        new Account(“Justin”,”X1234”,1000),
        new Account(“Monica”,”X5678”,500),
        new Account(“Irene”,”X2468”,200)
    };
    Collections.sort(accounts);
    System.out.printIn(accounts);
}

}

执行结果：

[Account(Irene, X2468, 200), Account(Monica, X5678, 500), Account(Justin, X1234, 1000)]

操作Comparator

import java.util.*;

public class Sort {

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

}

执行结果：

[A, B, F, M, O, W, X]

另一方法：排序方式根据Comparator的compare（）定义来决定

import java.util.*;

class StringComparator implements Comparator {

@Override
public int compare(String s1, String s2) {
    return –s1.compareTo(s2);
}

}

public class Sort {

public static void main(String[] args) {
    List words = Arrays.asList(“B”,”X”,”A”,”M”,”F”,”W”,”O”);
    Collections.sort(words, new StringComparator());
    System.out.printIn(words);
}

}

执行结果：

[X, W, O, M, F, B, A]

6.常用Map操作类

HashMap Map也支持泛型语法

TreeMap 如果使用TreeMap建立键值对应，则键的部分将会排序，条件式作为键的对象必须操作Compatable接口。

使用Properties Properties可以从文档中读取属性。

7.访问Map键值

如果想取得Map中所有键值，可以调用Map的keySet（）返回Set对象。

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

本周的学习内容说实话有点多，光是看书并不能都看懂弄会，许多地方都询问了同学。总的来说我还需要多多练习。

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

还是没有搞懂使用comparable到底是如何索引排序的，还有如何使用TreeMap建立键值对应我也不是太理解。

其他（感悟、思考等）

连续几周，需要学习的内容比较多，感觉有点吃紧还有一部分知识点掌握的不好，看来需要再接再厉了。

参考资料

Java学习笔记（第8版）

《Java学习笔记（第8版）》学习指导