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.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父类方法中未声明的其他异常

  1. 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类具有层次结构如下图所示;
![](https://img2018.cnblogs.com/blog/1272669/201904/1272669-20190407211921456-2037482460.png)

- java中的字符是Unicode编码的,是双字节的。InputStream是用来处理字节的,在处理字符文本时很不方便。Java为字符文本的输入提供了专门的一套类Reader。Reader类是字符输入流的抽象类,所有字符输入流的实现都是它的子类。
![](https://img2018.cnblogs.com/blog/1272669/201904/1272669-20190407212116296-431728053.png)

- 输出流OutputStream类是字节输入流的抽象类,此抽象类表示输出字节流的所有类的超类。
![](https://img2018.cnblogs.com/blog/1272669/201904/1272669-20190407212134212-929690206.png)

- Writer类是字符输出流的抽象类,所有字符输出类的实现都是它的子类。
![](https://img2018.cnblogs.com/blog/1272669/201904/1272669-20190407212203148-1803924063.png)

- 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]```,但是程序无法编译了,思考了一下我觉得应该是在调用文档的时候,文档名少了""的关系,果然加上了就可以编译了
- 但是编译是可以编译了,程序抛出了问题:
![](https://img2018.cnblogs.com/blog/1272669/201904/1272669-20190407213119407-1419766927.png)
- 虽然有了问题,但是解决方案却更清晰了,既然是提醒我找不到指定文件,那我告诉系统文件在哪里就好了!于是我将代码段修改了一下:

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

- 输出结果如下:
![](https://img2018.cnblogs.com/blog/1272669/201904/1272669-20190407213619789-31828735.png)
- 在该代码段加上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 set = new TreeSet<>();
set.add("B");
set.add("A");
set.add("D");
set.add("C");
set.add("E");
set.add("F");
Iterator iter = set.iterator();
while (iter.hasNext()){
String str = iter.next();
if("A".equals(str)){
iter.remove();
}else {
System.out.println(str);
}
}
}
}

- 调试截图
![](https://img2018.cnblogs.com/blog/1272669/201904/1272669-20190407215406657-1356993414.png)

## [代码托管](码云学习项目链接)
![](https://img2018.cnblogs.com/blog/1272669/201904/1272669-20190407215530369-1092006795.png)

## 结对及互评
- 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            |       |
posted on 2019-04-07 21:59  20175316  阅读(108)  评论(0编辑  收藏  举报