20175316盛茂淞 2018-2019-2 《Java程序设计》第6周学习总结

最新推荐文章于 2024-09-10 10:21:38 发布

weixin_30678821

最新推荐文章于 2024-09-10 10:21:38 发布

阅读量95

点赞数

文章标签： java 开发工具操作系统

原文链接：http://www.cnblogs.com/sms369/p/10667222.html

版权

20175316盛茂淞 2018-2019-2 《Java程序设计》第6周学习总结

教材学习内容总结

第7章内部类与异常类

1.使用 try、catch

Java中所有信息都会被打包为对象，如果愿意，可以尝试（try）捕捉（catch）代表错误的对象后做一些处理

try{
    ...(需要尝试捕捉的程序代码)
}
catch(... ex){
    ...(发生错误时执行的代码)
}

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

有时错误可以在捕捉处理之后，尝试恢复程序正常执行流程，例如：

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

2.异常继承架构

Throwable 定义了取得错误信息、堆栈追踪等方法，有两个子类：java.lang.Error 与 java.lang.Exception
异常处理：程序设计本身的错误，建议使用 Exception 或其子类实例来表现，所以通常称错误处理为异常处理
单就语法与继承架构上来说，如果某个方法声明会抛出 Throwable 或子类实例，只要不是属于 Error、ava.lang.RuntimeException 或其子类实例，你就必须明确使用 try、catch语法加以处理，或者用 throws 声明这个方法会抛出异常，否则会编译失败
受检异常：Exception 或其子对象，但非属于 RuntimeException 或其子对象，称为受检异常
执行期异常（非受检异常）：因为编译程序不会强迫一定得在语法上加以处理，亦称为非受检异常
规则表达式：String 的 matches() 方法中设定了 "\d*"，这是规则表示式，表示检查字符串中的字符是不是数字，若是则 matches() 返回 true
如果父类异常对象在子类异常对象前被捕捉，则 catch 子类异常对象的区块将永远不不会被执行

3.多重捕捉语法：

try{
        做一些事...
    }catch(IOException | InterruptedException | ClassCastException e){
//catch 区块会在发生 IOException、InterruptedException、ClassCastException 时执行
        e.printStackTrace();
    }

catch 括号中列出的异常不得有继承关系，否则会发生编译错误

5.catch or throw?

如果方法设计流程中发生异常，而设计时没有充足的信息知道该如何处理，那么可以抛出异常，让调用方法的客户端来处理。为了告诉编译程序这个事实，必须用 throws 声明此方法会抛出的异常类型或父类型，编译程序才会让你通过编译。例如：

public class FileUtil {
    public static String readFile(String name)
        throws FileNotFoundException{
        StringBuilder text = new StringBuilder();
        Scanner console = new Scanner(new FileInputStream(name));
        while(console.hasNext()){
            text.append(console.nextLine())
                    .apend('\n');
        }
        return text.toString();
    }
}

在catch区块进行完部分错误处理之后，可以使用throw（注意不是throws）将异常再抛出。如：
```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();
}
}```

如果抛出的是受检异常，表示你认为客户端有能力且应处理异常，此时必须在方法上使用 throws 声明；
如果抛出的异常是非受检异常，表示你认为客户端调用方法的时机出错了，抛出异常是要求客户修正这个漏洞再来调用方法，此时也就不使用 throws 声明
如果使用继承时，父类某个方法声明throws 某些异常，子类重新定义该方法时可以：

1.    不声明` throws`任何异常

2.    `throws`父类该方法中声明的某些异常

3.    `throws`父类该方法中声明异常的子类

但是不可以：
4.    `throws`父类方法中未声明的其他异常

5.    `throws`父类方法中声明异常的父类

自定义异常
自定义异常类别时，可以继承Throw、Error 或 Exception或其子类，如果不是继承自Error或 RuntimeException，那么就会是受检异常
自定义受检异常：

public class CustomizedException extends Exception{
    ...
}

错误发生时：

*    无足够信息处理异常：就现有信息处理完异常后，重新抛出异常

*    已针对错误做了某些处理：考虑自定义异常，用以更精确地表示出未处理的错误

*    客户端有能力处理未处理的错误：自定义受检异常、填入适当错误信息并重新抛出，并在方法上使用 `throws`加以声明

*    客户端没有准备好就调了方法造成未处理错误：自定义受检异常、填入适当错误信息并重新抛出

6.异常堆栈

在多重方法调用下，异常发生点可能是在某个方法之中，若想得知异常发生的根源，以及多重方法调用下的堆栈传播，可以利用异常对象自动收集的堆栈追踪来取得相关信息
查看堆栈追踪最简单的方法，就是直接调用异常对象的printStackTrace()，例如：

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

如果并不知道调用的顺序，当异常发生而被捕捉后，可以调用 printStackTrace()在控制台显示堆栈追踪
如果想要取得个别的堆栈元素进行处理，则可以使用getStackTrace()，这会返回 StackTraceElement 数组，数组中索引0为异常根源的相关信息，之后为各方法调用中的信息，可以使用StrackTraceElement的 getClassName()、getFileName()、getLineNumber()、getMethodName() 等方法取得对应的信息
要善用堆栈追踪，前提是程序代码中不可有私吞异常的行为

第10章输入、输出流

输入流

Java语言定义了许多类专门负责各种方式的输入或者输出，这些类都被放在java.io包中。其中，

所有输入流类都是抽象类InputStream(字节输入流)，或者抽象类Reader(字符输入流)的子类；

而所有输出流都是抽象类OutputStream(字节输出流)或者Writer(字符输出流)的子类。

InputStream类是字节输入流的抽象类，是所有字节输入流的父类，InputStream类具有层次结构如下图所示；
java中的字符是Unicode编码的，是双字节的。InputStream是用来处理字节的，在处理字符文本时很不方便。Java为字符文本的输入提供了专门的一套类Reader。Reader类是字符输入流的抽象类，所有字符输入流的实现都是它的子类。
输出流OutputStream类是字节输入流的抽象类，此抽象类表示输出字节流的所有类的超类。
Writer类是字符输出流的抽象类，所有字符输出类的实现都是它的子类。
File类是IO包中唯一代表磁盘文件本身的对象。通过File来创建，删除，重命名文件。File类对象的主要作用就是用来获取文本本身的一些信息。如文本的所在的目录，文件的长度，读写权限等等。（有的需要记忆，比如isFile(),isDirectory(),exits();有的了解即可。使用的时候查看API）

详细如下
File类(File类的概述和构造方法)

A:File类的概述
　　File更应该叫做一个路径
　　文件路径或者文件夹路径
　　路径分为绝对路径和相对路径
　　　　** 绝对路径是一个固定的路径,从盘符开始
　　　　相对路径相对于某个位置,在eclipse下是指当前项目下,在dos下 **
　　查看API指的是当前路径
　　文件和目录路径名的抽象表示形式
B:构造方法
　　File(String pathname)：根据一个路径得到File对象
　　File(String parent, String child):根据一个目录和一个子文件/目录得到File对象
　　File(File parent, String child):根据一个父File对象和一个子文件/目录得到File对象

File类(File类的创建功能)

A:创建功能
　　public boolean createNewFile():创建文件 如果存在这样的文件，就不创建了
　　public boolean mkdir():创建文件夹 如果存在这样的文件夹，就不创建了　　　　public boolean mkdirs():创建文件夹,如果父文件夹不存在，会帮你创建出来
    （使用createNewFile()文件创建的时候不加.txt或者其他后缀也是文件，不是文件夹；使用mkdir()创建文件夹的时候，如果起的名字是比如aaa.txt也是文件夹不是文件；）
** 注意事项：如果你创建文件或者文件夹忘了写盘符路径，那么，默认在项目路径下。 **

File类(File类的重命名和删除功能)

　　A:重命名和删除功能
　　　　public boolean renameTo(File dest):把文件重命名为指定的文件路径
　　　　public boolean delete():删除文件或者文件夹
　　B:重命名注意事项
　　　　如果路径名相同，就是改名。
　　　　如果路径名不同，就是改名并剪切。
　　C:删除注意事项：
　　　　Java中的删除不走回收站。
　　　　要删除一个文件夹，请注意该文件夹内不能包含文件或者文件夹

File类(File类的判断功能)

　　A:判断功能
　　　　public boolean isDirectory():判断是否是目录
　　　　public boolean isFile():判断是否是文件
　　　　public boolean exists():判断是否存在
　　　　public boolean canRead():判断是否可读
　　　　public boolean canWrite():判断是否可写
　　　　public boolean isHidden():判断是否隐藏

File类(File类的获取功能)

　　A:获取功能
　　　　public String getAbsolutePath()：获取绝对路径
　　　　public String getPath():获取路径
　　　　public String getName():获取名称
　　　　public long length():获取长度。字节数
　　　　public long lastModified():获取最后一次的修改时间，毫秒值
　　　　public String[] list():获取指定目录下的所有文件或者文件夹的名称数组
　　　　public File[] listFiles():获取指定目录下的所有文件或者文件夹的File数组

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

问题一

在学习使用Properties的时候我一开始不知道如何从文档中加载属性，代码如下：

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;
public class MapLoadProperties {
    public static void main(String[] args) throws IOException {
        Properties props = new Properties();
        props.load(new FileInputStream(args[0]));
        System.out.println(props.getProperty("CH5.username"));
        System.out.println(props.getProperty("CH5.password"));
    }
}

解决方案：
从代码中我发现，后面输出的变量是props.getProperty,所以我觉得应该从这个变量入手，也就是从代码段props.load(new FileInputStream(args[0]));来研究输出的变量，我通过API中了解FileInputStream()调用的应该就是前面说的文档，那么该如何调用呢？
一开始我尝试了直接用properties文件名替换掉args[0],但是程序无法编译了，思考了一下我觉得应该是在调用文档的时候，文档名少了""的关系，果然加上了就可以编译了
但是编译是可以编译了，程序抛出了问题：
虽然有了问题，但是解决方案却更清晰了，既然是提醒我找不到指定文件，那我告诉系统文件在哪里就好了！于是我将代码段修改了一下：

props.load(new FileInputStream("C:/Users/Cai Ye/IdeaProjects/HelloWorld/out/production/HelloWorld/CH5/Mapperson.properties"));

问题二

finally块中的代码一定会被执行吗？
想要验证finally块中的代码是不是一定会被执行，我的思路是在finally块前加一些终止类型的代码来看看能不能阻止它执行，例如return：
原代码如下：

public class TryCatchFinallyAutoClosableDemo {
    public static void main(String[] args) {
        try (Resource res = new Resource()) {
            res.doSome();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        finally {
            System.out.println("finally…");
        }
    }
}
    class Resource implements AutoCloseable {
    void doSome() {
        System.out.println("做一些事情");
    }
    @Override
    public void close() throws Exception {
        System.out.println("资源被关闭");
    }
}

输出结果如下：
在该代码段加上return：

 public static void main(String[] args) {
        try (Resource res = new Resource()) {
            res.doSome();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        finally {
            System.out.println("finally…");
        }
    }

但是结果并没有改变，这证明finally块应该是都会被执行的。
但是我在网上看到一种情况可以让finally块不执行，就是加上System.exit()，这段代码的意义是终止JVM……这太无赖了，脸JVM都被终止了，怎么可能执行别的呢，就像断电了一样……不做常规范围思考……

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

自编小程序

import java.util.Set;
import java.util.TreeSet;
import java.util.Iterator;


public class Main {
    public static void main(String[] args){
        Set<String> set = new TreeSet<>();
        set.add("B");
        set.add("A");
        set.add("D");
        set.add("C");
        set.add("E");
        set.add("F");
        Iterator<String> iter = set.iterator();
        while (iter.hasNext()){
            String str = iter.next();
            if("A".equals(str)){
                iter.remove();
            }else {
                System.out.println(str);
            }
        }
    }
}

调试截图

代码托管

结对及互评

20175329许钰玮上周很认真，结对任务我们分工合作，代码一起负责调试，我负责UML图，他负责其他，总体情况很满意。

感悟

在本周的学习中，我反而在学习的过程中觉得自己有很多不会的地方，一方面可能是因为本周的学习内容相对比较难比较生疏，另一方面，我觉得也是因为我思考的多了，对代码想要了解的更加深入一点，对于出现的错误想要尽可能的解决。所以我觉得本周我对于代码的学习反而没有上周感觉的那么顺畅。
本周的学习中，我认识到了API的作用真的很大，很多时候在代码出现问题的时候，我不了解代码的具体含义和一些引申的东西，所以在改错的时候觉得很困难，但是，如果使用API的话，改正错误代码的方向性就会比较明确，大大节约了我的时间，也让我在调试代码的时候更有条理性。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）
目标	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
第五周	300/1500	2/9	30/120
第六周	6001800	2/9	60/160

转载于:https://www.cnblogs.com/sms369/p/10667222.html

weixin_30678821

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
20175316盛茂淞 2018-2019-2 《Java程序设计》第6周学习总结

20175316盛茂淞 2018-2019-2 《Java程序设计》第6周学习总结教材学习内容总结第7章内部类与异常类1.使用 try、catchJava中所有信息都会被打包为对象，如果愿意，可以尝试（try）捕捉（catch）代表错误的对象后做一些处理try{ ...(需要尝试捕捉的程序代码)}catch(... ex){ ...(发生错误时执行的代...
复制链接

扫一扫