时间戳

首页 > 技术文章 > 20145333 《Java程序设计》第5周学习总结

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

rx719523850 2016-04-03 20:37 原文

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

教材学习内容总结

语法与继承架构

  • 使用try、catch

Java中所有错误都会被包装成对象，可以尝试(try)执行程序并捕捉(catch)代表错误的对象后做一些处理。使用了try、catch语法，JVM会尝试执行try区块中的程序代码，如果发生错误，执行程序会跳离错误发生点，然后比对catch括号中声明的类型，是否符合被抛出的错误对象类型，如果是就执行catch中的程序代码。

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

}
  • 异常继承架构

错误会被包装为对象，这些对象是可抛出的，因此设计错误对象都继承自java.lang.Throwable类。
Throwable定义了取得错误信息堆栈追踪等方法，它有两个子类：java.lang.Error与java.lang.Exception。
Error与其子类实例代表严重系统错误，如硬件层面错误、JVM错误或内存不足等问题。虽可以使用try、catch处理，但并不建议，发生严重错误时，Java应用程序本身是无力回复的。
程序设计本身的错误，建议使用Exception或其子类实例来表现，所以通常称错误处理为异常处理。
单就语法与继承构架上来说，如果某个方法声明会抛出Throwable或子类实例，只要不是属于Error、java.lang.RuntimeException或其子类实例，就必须明确使用try、catch语法处理，或者使用throws声明这个方法会抛出异常，否则编译失败。
IOException是Exception的直接子类，所以编译程序要求明确使用语法加以处理。
受检异常：Exception或其子对象，但非属于RuntimeException或其子对象。
非受检异常：属于RuntimeException衍生出来的类实例，代表API设计者实现某方法时，某些条件成立时引发错误，而且认为API客户端应该在调用方法前做好检查，避免引发错误，编译程序不会强迫一定得在语法上加以处理。
catch括号中列出的异常不能有异常关系，否则会发生编译错误。

package cc.openhome;
public class StackTrace {
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();
}
}
  • 要抓还是要抛

编译时被检测异常 ：该异常在编译时，如果没有处理（没有抛也没有try）,编译失败。该异常被表示，代表可以被处理。
运行时异常（编译时不检测）：在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止，需要对代码进行修正。

在异常发生时，可以使用try、catch处理当时环境可进行的异常处理，无法决定如何处理的部分，可以抛出由调用方法的客户端处理，如果想处理部分事项再抛出的做法。

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是唯一采用受检异常的语言，这有两个目的：一、文件化，受检异常声明会是API操作接口的一部分，客户端只需要查阅文件就可以知道方法可能引发哪些异常，并事先加以处理；二、提供编译程序信息，让编译程序能够在编译时期就检查出API客户端没有处理的异常。
自定义异常类别时，可以继承Throwable、Error、Exception的相关子类，通常建议继承自Exception或其子类，如果不是继承自Error或RuntimeException，那么就会是受检异常。

  • 认识堆栈追踪

若想得知异常发生的根源，以及多重方法调用下异常的堆栈传播，可以利用一场对象自动收集的对堆栈追踪来获取相关信息。
查看堆栈追踪最简单的方法是直接调用异常对象的printStackTrace()。
在使用`throw重抛异常时，异常的追踪堆栈起点，仍是异常的发生根源，而不是重抛异常的地方。

异常与资源管理

  • 使用finally

try、catch语法可以搭配finally，无论try区块中有无发生异常，若撰写有finally区块，则finally区块一定会被执行。
如果程序撰写的流程中先return了，而且也有finally区块，那finally区块会先执行完后，再将值返回。

程序撰写的流程中先return了，而且也有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收集对象 **

  • 认识Collection

收集对象的共同行为定义在Collection中。既然可以收集对象，也要能逐一取得对象，这就是java.lang.Iterable定义行为，它定义了iterator()方法返回java.util.Iterator操作对象，可以逐一取得对象。

  • 具有索引的List

List是一种Collection ,作用是收集对象，并以索引方式保留收集的对象顺序，其操作类之一是java.util.ArrayList。
List定义了许多索引操作的方法。
ArrayList特性： 有个可指定容量的构造函数，在大致知道将收集的对象范围，可事先建立足够长度的内部数组。
LinkedList特性： LinkedList在操作List接口时，采用了链接结构。若收集对象经常会有变动索引的情况，考虑链接方式操作的List比较好，像是随时会有客户登录或注销的客户端List，使用LinkedList会有比较的好的效率。

  • 内容不重复的Set

同样是收集对象，在收集过程中若有相同对象，则不再重复收集，此时可以使用Set接口的操作对象。
判断对象是否重复时，都会调用hashCode()与equals()方法，建议两个方法同时使用。

  • 支持队列操作的Queue

使用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 ifFull()
{
    return elems.size() + 1 > capacity;
}

public Object pop()
{
    return elems.pollLast();
}

public Object peek()
{
    return elems.size();
}

public static  void main (String[] agrs)
{
    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());
}
}
  • 使用泛型

在设计API时可以指定类或方法支持泛型，使用API的客户端在语法上会更为简洁，并得到编译时期检查。
使用定义类型，在需要编译程序检查类型的地方，都可以使用E像是add()方法必须检查传入的对象类型是E，get()方法必须转换为E类型。
声明与建立对象时，可使用角括号告知编译程序，这个对象收集的都会是String,而取回之后也会是String，不用再使用括号转换类型。
泛类型可以定义在方法上，最常见的是在静态方法上定义泛型。

  • 简介Lambda表达式

    IntegerFunction doubleFunction = new IntegerFunction()
    {
    public Integer apply(Integer i)
    {
    return i*2;
    }

    }

键值对应的Map

  • 常用Map操作类

常用的Map操作类为java.util.HashMap与java.util.TreeMap，其继承自抽象类java.util.AbstractMap。
使用HashMap：在HashMap中建立键值对应之后，键是无序的。
使用TreeMap：如果使用TreeMap建立键值对应，则键的部分将会排序，条件是作为键的对象必须操作Comparable接口，或者是创建TreeMap时指定操作Comparator接口的对象。
使用Properties：Properties类继承自HashTable，HashTable操作了Map接口，Properties自然也有Map行为。Properties的=左边设定属性名称，右边设定属性值。可以使用Properties的load()方法指定InputStream实例。load()方法结束后会自动关闭InputStream实例。

  • 访问Map键值

若想取得Map中所有的键，可以调用Map的keySet()返回Set对象。
若想同时取得Map的键与值，可以使用entrySet()方法，这会返回一个Set对象，每个元素都是Map.Entry实例，可以调用getKey()取得键，调用getValue()取得值。
Map没有继承Iterable，有个forEach（）方法是定义在Map接口上，可使用这个方法结合Lambda表达式，在迭代键与值时获得不错的可读性。

本周代码托管截图

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

这一周学习的两章内容很多，又接触到了很多新知识。上周的测试反映除了我学习中的一些问题，就是只看书敲代码，遇到选择题判断题还会一些，但是一遇到写代码这种题就完全不会做了。这说明学的还不扎实，没有对知识完全的理解透彻，也许是自己花的时间的确还不够多，以后要在Java上投入更多的时间来学习。

学习进度条

代码行数（新增/累积） 博客量（新增/累积） 学习时间（新增/累积） 重要成长
目标 3500行 15篇 400小时
第一周 100/100 2/2 20/20
第二周 150/250 1/3 18/38
第三周 100/350 1/4 22/60
第四周 300/650 1/5 30/90
第五周 100/750 1/6 20/110

推荐阅读