20145219 《Java程序设计》第05周学习总结

20145219 《Java程序设计》第05周学习总结

教材学习内容总结

• try、catch

  1.求平均数程序示例

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

当用户正确输入每个整数时可以求出平均数，但是，当用户输入整数有错时会显示如下错误：

表明用户输入不符合`Scanner`对象预期。

2.使用`try、catch`语法，JVM会先尝试执行`try`区块中的代码，如果发生错误就会调理错误发生点，然后比较`catch`括号中声明类型是否符合被抛出的错误对象类型，如果是就执行`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.printf("必须输入整数");
	        }

	    }
	}

• 异常架构

  1.错误会被包装为对象，这些对象都是可抛出的。设计错误对象都继承自java.lang.Throwable类，Throwable定义了取得错误信息、堆栈追踪等方法，它有两个子类：java.lang.Error与java.lang.Exception。如果某个声明方法会抛出Throeable或子类实例，只要不属于Error或java.lang.RuntimeException或其子类实例，就必须明确使用try、catch语句加以处理，或用throws声明这个方法会抛出异常。

  2.Error与其子类实例代表严重系统错误，Java应用程序本身无力回复。

  3.Exception与其子类实例代表程序设计本身的错误，通常称错误处理为异常处理。受检异常要求明确使用语法加以处理，非受检异常也叫执行时期异常，编译程序不会强迫必须在语法上加以处理。

  4.如果父类异常对象在子类异常对象前被捕捉，则catch子类异常对象的区块永远不会被执行。

  5.catch括号中列出的异常不得有继承关系。

  6."\\d*"是规则表达式，会检测字符串中的字符是否为数字

    static int nextInt(){
            String input=console.next();
            while(!input.matches("\\d*")){
                System.out.println("请输入数字");
                input=console.next();
            }
            return Integer.parseInt(input);
        }
  

• catch、throw

  1.FileInputStream可以指定档名来开启与读取文档内容，但是在创建时会抛出FileNotFoundException错误。

  2.抛出受检异常表示客户端有能力且应处理异常，必须在方法上使用throws声明。

  3.抛出非受检异常表示客户端调用方法的时机错误，要求客户端修正漏洞后再调用方法，不用throws声明。

  4.catch区块进行完部分错误处理后可以使用throw将异常再抛出。

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

• 自定义异常：让异常更能表现应用程序特有的错误信息，用以更精确地表示出未处理的错误。自定义异常类别时，可以继承Throwable、Erroe或Exception，通常建议继承自Exception或其子类。

• 异常堆栈：得知异常发生的根源以及多重方法调用下异常的堆栈传播。

• printStackTrace 和fillInStackTrace

  1.直接调用一场对象的printStackTrace()是查看堆栈追踪最简单的方法。堆栈追踪信息会显示异常类型，最顶层是异常的根源。

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

2.使用`getStackTrace()`可以取得个别的堆栈追踪元素进行处理，会返回`StackTraceElement`数组，数组中索引0为异常根源的相关信息。

3.`fillInStackTrace()`方法会让异常堆栈起点为重抛异常的地方，并返回Throwable对象。

	public class StackTraceDemo3{
	    ...
	    static void c(){
	        try{
	            b();
	        }catch(NullPointerException ex){
	            ex.printStackTrace();
	            Throwable t=ex.fillInStackTrace();
	            throw (NullPointerException) t;
	        }
	    }
	    ...
	}

• assert：断言动能，使用assert作为关键字，默认执行时不启动，若要启动，可以在执行java指令时指定-enableassertions或是-ea自变量。

• finally

  1.无论try区块中有无发生异常，若有撰写finally区块，则finally区块一定会被执行。

  2.如果撰写的流程中先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 with resources：尝试关闭资源语法。尝试自动关闭资源的对象撰写在try之后的括号中，如果无须catch处理任何异常可以不用撰写，也不用撰写finally自行尝试关闭资源。

    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.util.Scanner;
    public class FileUtil3{
        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：尝试关闭资源语法可套用的对象必须操作java.lang.AutoCloseable接口，同时关闭两个以上的对象资源时中间以分号间隔，越后面的越早被关闭。

• collection架构

  1.目前为止已学过的收集对象的方式是使用object数组。收集对象的行为，如新增对象的add()方法、移除对象的remove()方法等，都是定义在java.util.Collection中。既然能收集对象，也能逐一取得对象，是java.lang.Iterable定义的行为。

  2.收集时记录每个对象的索引顺序，并可依索引取回对象，此行为定义在java.util.List接口中；收集的对象不重复，具有集合的行为，则由java.util.Set定义；收集对象时以队列方式排列，收集的对象加入至尾端，取得对象时从前端，用java.util.Queue；对Queue的两端进行加入、移除等动作，用java.util.Deque。

• List

  1.ArrayList特性：ArrayList搜集对象时使用数组，由于数组在内存中是连续线性空间，根据索引随机存取时速度快，所以适合排序的时候用，可得到较好的速度表现。

  2.LinkedList特性：LinkedList采用了链接结构，每次新增对象后会形成链状结构，链接的每个元素会参考至下一个元素，有利于调整索引顺序。

• Set：判断对象是否重复时会调用hashCode()和equals()方法，且必须同时操作。

• Queue：
  
  1.Queue具有Collection的add（）、remove（）、element（）等方法，也定义了自己的offer（）、poll（）与peek（）等方法。最主要的差别在于，前者操作失败时会抛出异常，而后者操作失败时会返回特定值。

  2.Queue的子接口Deque在队列前端加入对象与取出对象，在队列尾端加入对象与取出对象。其中定义的addFirst（）、removeFirst（）、getFirst（）、addLast（）、removeLast（）、getLast（）等方法，操作失败时会抛出异常，而offerFirst（）、pollFirst（）、peekFirst（）、offerLast（）、pollLast（）、peekLast（）等方法，操作失败时会返回特定值。

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

3.堆栈结构先进后出。

• 泛型与继承：设计API时可以指定类或方法支持泛型，会使客户端在语法上更为简洁，并得到编译时期检查。声明与建立对象时使用角括号告知编译程序，只要声明参考时有指定类型，创建对象时就不用再写了。

• Lambda表达式：Request request=()->out.printf("处理数据 %f",Math.random());，Lambda表达式的语法省略了接口类型和方法名称。—>左边是参数列，右边是方法本体，编译程序可以由Request request的声明中得知语法上被省略的信息。可以使用区块{}符号包括演算流程，使用区块时如果方法必须返回值，在区块中就必须使用return。

    import java.util.*;
  
    interface Request2
    {
        void execute();
    }
  
    public class RequestQueue2
    {
        public static void main (String[] args)
        {
            Queue<Request2>requests = new LinkedList<>();
            offerRequestTo(requests);
            process(requests);
        }
        static void offerRequestTo(Queue<Request2>requests)
        {
            for (int i = 1; i < 6;i++)
            {
                requests.offer
                        (() -> System.out.printf("处理数据%f%n",Math.random()));
            }
        }
  
        static void process(Queue<Request2>requests)
        {
            while(requests.peek() != null)
            {
                Request2 request = requests.poll();
                request.execute();
            }
        }
    }
  

• Iterable与Iterator

  1.iterator（）方法定义在Collection接口中，会返回java.util.Iterator接口的操作对象，这个对象包括了Collection收集的所有对象。可以使用Iterator的hasNext（）看看有无下一个对象，若有的话，再使用next（）取得下一个对象，因此无论List、Set、Queue还是任何Collection，都可以使用forEach（）来显示所收集的对象。

  2.增强式for循环还可以运用在操作Iterable接口的对象上，JDK8演进了interface语法，允许接口定义默认方法。

    import java.util.*;
  
    public class ForEach
    {
        public static void main(String[] args)
        {
            List names = Arrays.asList("Justin","Monica","Irene");
            forEach(names);
            forEach(new HashSet(names));
            forEach(new ArrayDeque(names));
        }
  
        static void forEach(Iterable iterable)
        {
            for(Object o :iterable)
            {
                System.out.println(o);
            }
        }
    }
  

• Comparable与Comparator

  1.Collection的sort（）方法要求被排序的对象必须操作java.lang.Comparable接口。Collection的sort（）方法在取得a对象与b对象进行比较时，会先将a对象扮演为Comparable，然后调用a.compareTo（b），如果a对象顺序上小于b对象则返回小于0的值，若顺序上相等则返回0，若顺序上a大于b则返回大于0的值。

  2.Collections的sort（）方法有另一个重载版本，可接受java.util.Comparator接口的操作对象，如果使用这个版本，排序方式将根据Comparator的compare（）定义来决定。

    import java.util.*;
    import static java.util.Comparator.*;
  
    public class Sort6 {
        public static void main(String[] args){
            List words=Arrays.asList("B","X","A","M",null,"F","W","O",null);
            words.sort(nullsFirst(reverseOrder()));
            System.out.println(words);
        }
    }
  

• 常用的Map类

  1.常用的Map操作类为java.util.HashMap与java.util.TreeMap，其继承自抽象类java.util.AbstractMap。Map支持泛型语法，建立Map操作对象时，可以使用泛型语法指定键与值的类型。

  2.在hashMap中建立键值对应后，键是无序的。

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

    import java.util.*;
  
    public class Messages3 {
        public static void main(String[] args){
            Map<String,String> messages=new TreeMap<>((s1,s2) -> -s1.compareTo(s2));
  
            messages.put("Justin","Hello!Justin的信息！");
            messages.put("Monica","给Monica的悄悄话！");
            messages.put("Irene","Irene的可爱猫喵喵叫！");
            System.out.println(messages);
        }
    }
  

4.一般常用Properties的setProperty（）指定字符串类型的键值，getProperty指定字符串类型的键，取回字符串类型的值，通常称为属性名称和属性值。.properties的=左边设定属性名称，右边设定属性值。可以使用Properties的load（）方法指定InputStream的实例。

• 访问Map键值

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

  2.键是不重复的。

  3.如果想取得Map中所有的值，则可以使用values（）返回Collection对象。

  4.如果想同时取得Map的键与值，可以使用entrySet（）方法，会返回一个Set对象，每个元素都是Map.Entry实例，可以调用getKey（）取得键，调用getValue（）取得值。

    import java.util.*;
  
    public class MapKeyValue3 {
        public static void main(String[] args) {
            Map map = new TreeMap<>();
            map.put("one","一");
            map.put("two","二");
            map.put("three","三");
            map.forEach((key,value) -> System.out.printf("(键 %s,值 %s)%n",key,value));
  
        }
    }
  

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

问题1：书上p266SimpleLinkedList按照书上在IDEA中输入后显示有错误Cannot resolve symbol 'elem'，不知道如何解决。

解决方法：待解决。

问题2：书上p269Students按照书上在IDEA中输入后显示有错误Cannot resolve symbol 'set'。

解决方法：书上印刷有错误，将最后一句中的set改为students即可运行成功。

问题3：书上p270Students2按照书上在IDEA中输入后显示有错误，不知道如何解决。

解决方法：待解决。

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

问题：在调试书上p253、p254上的AutoCloseableDemo和AutoCloseableDemo2时一直显示如下错误。

解决方法：多次对比后我又仔细阅读书上的文字部分，终于发现，原来错将AutoCloseable打成了AutoClosable，少了一个e，结果大不同啊~

本周代码托管截图

本周代码行数

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

第八章主要是介绍在变成过程中我们可能遇到的异常情况，以及解决方法。第九章主要是用实例介绍一些具体的API接口，例如收集对象所用的List、Set、Queue、泛型语法、Lambda表达式等和搜索对象所用的Map架构等。学习就是不断积累、不断丰富的过程，通过前期的学习，我已经了解了Java的基本结构、语法规则、对象、封装、继承、多态、接口等，接下来就是要细化这些知识，真正能够在编程中用到。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	150/150	1/2	15/15	学会搭建Java环境，学会写Hello World小程序
第二周	350/500	1/3	20/35	掌握IDE的使用方法，学会Java的基本语法规则
第三周	400/900	1/4	35/70	学会代码托管，学习了类类型、面向对象、函数等知识
第四周	990/1890	1/5	40/110	学会使用wc统计代码行数，学会将多个class文件放在一个包内
第五周	992/2882	1/6	30/140	了解Java的异常处理，学习Collection和Map架构

参考资料

• Java学习笔记(第8版)
• 《Java学习笔记(第8版)》学习指导
• ...