zoukankan      html  css  js  c++  java
  • 20145201 《Java程序设计》第五周学习总结

    20145201 《Java程序设计》第五周学习总结

    教材学习内容总结

    本周学习了课本第八、九章内容,即异常处理、Collection与Map。

    第八章 异常处理

    8.1 语法与集成架构

    8.1.1 使用try、catch

    • Java中所有错误都会被打包为对象,可以尝试(try)捕捉(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.println("必须输入整数");
           }
        }
    }
    
    • JVM 会尝试执行 try 区块中的程序代码。如果发生错误,执行流程会跳离错误发生点,然后比较 catch 括号中声明的类型,是否符合被抛出的错误对象类型,如果是的话,就执行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);
        }
    }
    

    8.1.2 异常继承架构

    • 错误会被包装成对象,这些对象都是可抛出的(throw),因此设计错误对象都继承自java.lang.Throwable类,Throwable定义了取得错误信息、堆栈追踪等方法,它有两个子类java.long.Error与java.lang.Exception。

    • Error与其子类实例代表严重系统错误(硬件层面错误,JVM错误或内存不足等),不建议用try、catch来处理Error对象。

    • 程序设计本身的错误,建议使用Exception或其子类实例可以表现,通常称错误处理为“异常处理”

    • 如果某个方法声明会抛出Throwable或子类实例。只要不是属于Error、java.lang.RuntimeException或其子类实例,就必须使用try、catch语法处理,或用throws声明这个方法会抛出异常,否则会编译失败。

    • 受检异常:Exception或其子对象,但不属于RuntimeException或其子对象

    • 非受检异常:属于RuntimeException衍生出的类实例,API客户端应该在调用方法前做好检查,以避免引发叙错误,因为编译程序不会强迫一定在语法上加以处理,亦称为非受检异常。

    代码如下:

    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);
        }
    }
    
    • 实际上在异常发生时,可使用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('
    ');
                }
            }catch(FileNotFoundException ex){
                ex.printStackTrace();
                throw ex;
            }
            return text.toString();
        }
    }
    
    • 在catch区块进行完部分错误处理之后,可以使用throw(注意不是throws)将异常再抛出。

    • 如果抛出的是受检异常,表示你认为客户端有能力且应该处理异常,此时必须在方法上使用throws声明;如果抛出的异常是非受检异常,表示你认为客户端调用方法的时机错了,抛出异常是要求客户端修正这个漏洞再来调用方法,此时也就不用throws声明。

    • 如果使用继承时,父类某个方法声明throws某些异常,子类重新定义该方法时可以:

    不声明throws任何异常。

    throws父类该方法中声明的某些异常。

    throws父类该方法中声明异常的子类。

    但是不可以:

    throws父类方法中未声明的其他异常。

    throws父类方法中声明异常的父类。

    8.1.3
    Java是唯一采用受检异常的语言,这有两个目的:一是文件化;二是提供编译程序信息。

    8.1.5

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

    要善用堆栈追踪,前提是程序代码中不可有私吞异常的行为、对异常做了不适当的处理,或显示了不正确的信息。

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

    如果想让异常堆栈起点为重抛异常的地方,可以使用fillStackTrack()方法,它会重新装填异常堆栈,将起点设为重抛异常的地方,并返回Throwable对象。
    代码如下:

    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异常与资源管理

    8.2.1

    try、catch语法还可以搭配finally使用,无论try区块中有无发生异常,若撰写有finally区块,则finally区块一定会被执行。
    代码如下:

    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('
    ');
                }
            }finally{
                if(console!=null) {
                    console.close();
                }   
                }
            return text.toString();
        }
    }
    

    如果程序撰写的流程中先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;
    }
    

    8.2.2
    在JDK7之后,新增了尝试关闭资源语法。想要尝试自动关闭资源的对象,是撰写在try之后的括号中,如果无须catch处理任何异常,可以不用撰写,也不用撰写finally自行尝试关闭资源。
    代码如下:

    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('
    ');
                }
            }
            return text.toString();
        }
    }
    

    8.2.3
    JDK7的尝试关闭资源语法可套用的对象,必须操作java.lang.AutoCloseable接口,这是JDK7新增的接口。尝试关闭资源语法也可以同时关闭两个以上的对象资源,只要中间以分号分隔。在try的括号中,越后面撰写的对象资源会越早被关闭。
    代码如下:

    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("资源被关闭");
        }
    }
    

    尝试关闭资源语法也可以同时关闭两个以上的对象资源,只要中间以分号分隔。在try的括号中,越后面撰写的对象资源会越早被关闭。

    第九章 Collection与Map

    9.1 使用Collection收集对象

    9.1.1

    • 收集对象的行为,像是新增对象的add()方法、移除对象的remove()方法等,都是定义在java.util.Collection中,既然可以收集对象,也要能逐一取得对象,这就是java.lang.Iterable定义的行为,它定义了iterator()方法返回java.util.Iterator操作对象,可以让你逐一取得收集的对象。

    9.1.2

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

    代码如下:

    import java.util.*;
    import static java.lang.System.out;
    public class Guest {
        public static void main(String[] args) {
            List names = new 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会有比较好的效率。

    9.1.3

    • 同样是收集对象,在收集过程中若有相同对象,则不再重复收集,若有这类需求,可以使用Set接口的操作对象。
      eg.若有一个字符串,当中有许多英文单词,想要知道不重复的单词有几个
      代码如下:
    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));
        }
    }
    

    9.1.4

    • 如果对象有操作Queue,并打算以队列方式使用,且队列长度受限,通常建议使用offer()、poll()、与peek()等方法。想对队列的前端与尾端进行操作,在前端加入对象与取出对象,在尾端加入对象与取出对象,Queue的子接口Deque就定义了这类行为。
      代码如下:
    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 rquest = (Request) request.poll();
                request.execute();
            }
        }
    }
    
    • 想对队列的前端与尾端进行操作,在前端加入对象与取出对象,在尾端加入对象与取出对象,Queue的子接口Deque就定义了这类行为。

    9.1.5

    • 泛型语法:类名称旁有角括号,这表示此类支持泛型。实际加入ArrayList的对象会是客户端声明的E类型。
      泛型语法代码如下:
    import java.util.Arrays;
    
    public class ArrayList<E>
    {
         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;
       }
    }
    

    9.1.6
    在JDK8中 Lambda表达式:Request request = ()-> out.ptinf("处理数据%f%n",Math.random() )

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

    简化代码

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

    }

    简化后
    IntegerFunction doubleFunction = (Integer i) -> i * 2;

    9.1.7

    • 在JDK5之后有了增强式for循环,它可运用在操作Iterable接口的对象上。

    9.1.8

    • 在收集对象之后,对对象进行排序是常用的动作,你不用亲自操作排序算法,java.util.Collections提供有sort()方法。由于必须有索引才能进行排序,因此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);
            System.out.println(numbers);
        }
    }
    

    9.2 键值对应的Map

    9.2.1
    若要根据某个键来取得对应的值,可以事先利用java.util.Map接口的操作对象来建立键值对应数据,之后若要取得值,只要用对应的键就可以迅速取得。

    • 常用的Map操作类为java.util.HashMap与java.util.TreeMap,其继承自抽象类java.util.AbstractMap。

    9.2.2访问Map键值
    如果想取得Map中所有的键,可以调用Map的keySet()返回Set对象。

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

    有代码运行时本来输入的是小写字母,输出结果时就自动变成大写。

    本周代码托管截图





    其他(感悟、思考等,可选)

    本周学习了课本八九章内容,感触最多的是各种接口越来越多,比较容易遗忘,要多敲代码才可以加以熟悉巩固。这次没有将全部代码一一列在博客上,挑选了一些自己认为比较基础、重要的写在博客里,下面自己的练习代码托管至网上了。

    学习进度条

    代码行数(新增/累积) 博客量(新增/累积) 学习时间(新增/累积) 重要成长
    目标 4500行 30篇 400小时
    第一周 200/200 2/2 20/20
    第二周 300/500 1/3 18/38
    第三周 400/900 1/4 22/60
    第四周 1000/1900 1/5 35/95
    第五周 800/2700 1/6 30/125

    参考资料

  • 相关阅读:
    2017上半年技术文章集合【Android】—184篇文章分类汇总
    一个高仿闲鱼键自定义数字键盘特效
    Android智能下拉刷新加载框架—看这些就够了
    深入了解Android蓝牙Bluetooth——《进阶篇》
    with和爬虫基础
    数据类型
    变量及注释
    计算机基础知识
    Markdown使用
    3732: Network
  • 原文地址:https://www.cnblogs.com/20145201lzx/p/5350081.html
Copyright © 2011-2022 走看看