20145330第五周《Java学习笔记》

20145330第五周《Java学习笔记》###

这一周又是紧张的一周。

语法与继承架构#

• Java中所有错误都会打包为对象可以尝试try、catch代表错误的对象后做一些处理。
  • 使用try、catch语法，JVM尝试执行try区块中的程序代码。如果发生错误，执行流程会跳离错误发生点，然后比较catch括号中声明的类型，是否符合被抛出的错误对象类型，如果是，就执行catch区块的程序代码。
  • 范例如下：

	import java.util.*;

	public class Average {
    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);
      }
	}

• 对于正确的整数输入予以加总，对于错误的则显示略过
• 异常继承架构
  • 程序设计本身的错误，建议使用Exception或其子类实例来表现，所以通常称错误处理为异常处理
  • 单就语法与继承上来说，如果某个方法声明会抛出Throwable或子类实例，只要不属于Error、java.lang.RuntimeException或其子类实例，就必须明确使用try、catch语法加以处理
  • 如果父类异常对象在子类异常对象前被捕捉，则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();
   	  }
	}

• 在catch区块进行完部分错误处理后，可以使用throw将异常再抛出。
  • 可以在任何流程中抛出异常，不一定在catch区块中
  • 在流程中抛出异常，就直接跳出原有的流程，可以抛出受检或非受检异常
  • 如果使用继承时，父类某个方法声明throws某些异常，子类重新定义该方法
• 认识堆栈追踪
  • 如果要取得个别的堆栈追踪元素进行处理，则可以使用getStackTrace()
  • 要善用堆栈追踪，前提是程序代码中不可有私吞异常的行为
• 关于assert

异常与资源管理##

• 程序中因错误而抛出异常时，原本的执行流程就会中断，抛出异常处之后的程序代码就不会执行
• 使用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(Scanner console=new Scanner(new FileInputStream(name)))
  • 使用自动尝试关闭资源语法时，并不影响你对特定异常的处理
  • 自动尝试关闭资源语法也仅协助你关闭资源，而非用于处理异常
• java.lang.AutoCloseable接口
• 举例简单示范：

	public class AutoCloseableDemo {
    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 AutoCloseableDemo2 {
    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已被关闭");
   	 }
	}

• 如果父类异常对象在子类异常对象前被捕捉，则catch子类异常对象的区块将永远不被执行，编译程序会检查出这个错误。从JDK7开始，可以使用多重捕捉语法，不过仍得注意异常的继承，catch括号中列出的异常不得有继承关系，否则会发生编译错误

• 如果是非受检异常，原本就可以自行选择是否处理异常，因此不使用try``catch处理时也不用特别在方法上使用throws声明，不处理非受检异常时，异常会自动往外传播。

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。

• List是一种Collection,作用是收集对象，并以索引方式保留收集的对象顺序，其操作类之一是java.util.ArrayList。

• 例如：

	import static java.lang.System.out;

	public class Guest
	{
    public static void main(String[] args)

    {
        List names = new java.util.ArrayList();
        collectNameTo(names);
        out.println("訪客名單：");
        printUpperCase(names);
    }

    static void collectNameTo(List names)
    {
        Scanner console = new Scanner(System.in);
        while(true)
        {
            out.print("訪客名稱：");
            String name = console.nextLine();
            if(name.equals("quit"))
            {
                break;
            }
            names.add(name);
        }
    }

    static void printUpperCase(List names)
    {
        for(int i = 0; i < names.size(); i++)
        {
           String name = (String) names.get(i);
            out.println(name.toUpperCase());
        }
      }
    }

• 数组在内存中会是连续的线性空间，根据索引随机存取时速度快，如果操作上有这类需求时，像是排序，就可使用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));
   		 }
	}

• HashSet的操作概念是，在内存中开设空间，每个空间会有个哈希编码。
• 如果对象有操作Queue，并打算以队列方式使用，且队列长度受限，通常建议使用offer()、poll()与peek()等方法
• LinkedList不仅操作了List接口，与操作了Queue的行为，所以可以将LinkedList当作队列来使用
• 想对队列的前端与尾端进行操作，在前端加入对象与取出对象，在尾端加入对象与取出对象，Queue的子接口Deque就定义了这类行为
• java.util.ArrayDeque操作了Deque接口，可以使用ArrayDeque来操作容量有限的堆栈。

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

• 相对于匿名类语法来说，Lambda表达式的语法省略了接口类型与方法名称，->左边是参数列，而右边是方法本体

• 在Lambda表达式中使用区块时，如果方法必须有返回值，在区块中就必须使用return

• interator()方法提升至新的java.util.Iterable父接口。

• 在java的规范中，与顺序有关的行为，通常要不对象本身是Comparable，要不就是另行指定Comparator对象告知如何排序

• 若要根据某个键来取得对应的值，可以事先利用java.util.Map接口的操作对象来建立键值对应数据，之后若要取得值，只要用对应的键就可以迅速取得。常用的Map操作类为java.util.HashMap与java.util.TreeMap，其继承自抽象类java.util.AbstractMap。

• 如果使用TreeMap建立键值对应，则键的部分则会排序，条件是作为键的对象必须操作Comparable接口，或者是在创建TreeMap时指定操作Comparator接口的对象。

• Properties类继承自Hashtable，HashTable操作了Map接口，Properties自然也有Map的行为。虽然也可以使用put（）设定键值对应、get（）方法指定键取回值，不过一般常用Properties的setProperty（）指定字符串类型的键值，getProperty（）指定字符串类型的键，取回字符串类型的值，通常称为属性名称与属性值。

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

	public class MapKeyValue {

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

        out.println("显示鍵");
        map.keySet().forEach(key -> out.println(key));

        out.println("显示值");
        map.values().forEach(key -> out.println(key));
    	}
	}

学习中遇到的问题###

• 问题：Exception与RuntimeException的区别：
• 解决：
  • Exception：在程序中必须使用try、catch进行处理。
  • RuntimeException：可以不使用try、catch进行处理，但是如果有异常产生，则异常将由JVM进行处理。

感悟和思考###

从每周的学习中我都能总结出一些学习Java的经验和道理，我留下的最深刻的印象就是各种类、接口、方法、行为越来越多，有些还很相似，结果经常分不清楚，看到后面的内容又忘记了前面的知识点，学习时一直前后反复翻教材，后来我就尝试做笔记，将重要的、容易混淆的知识点都记下来，发现这样在回顾知识点时很方便，也很清晰明了。希望可以灵活运用更好更熟练的掌握。

代码托管截图###

学习进度表###

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	200/200	2/2	20/20
第二周	300/500	2/4	18/38
第三周	500/1000	3/7	22/60
第四周	300/1300	2/9	30/90

参考资料###

• 《Java学习笔记》