20172329 2017-2018-2 《程序设计与数据结构》第九周学习总结

20172329 2017-2018-2 《程序设计与数据结构》第九周学习总结

教材学习内容总结

第十一章：异常

• 一、一些引发异常抛出的问题：
• （1）试图作除以0的操做；
• （2）数组索引越界；
• （3）找不到指定的文件；
• （4）不能正常完成被请求的I/O操做；
• （5）使用了空引用；
• （6）执行的操做违反了某种安全规则。
• 二、try-cash语句
• （1）执行try语句时，将执行try语句块中的语句。若是没有异常抛出，将继续执行try语句后的语句（全部catch子句后的语句）；
• 三、finally语句
• （1）一条try-catch语句能够有一个可选的finally子句，用于定义一段不管是否有异常发生的都会执行的代码；
• （2）try语句块能够没有catch子句。没有catch语句时，若是须要仍然可使用finally子句；
• 四、自定义异常
• （1）可由Exception类或它的后代类派生一个新类来定义一个新的异常；
• 五、可检测异常与不可检测异常

• 对于可检测异常，若是发生异常的方法不捕获和处理这个异常，则必须在该方法定义的声明头中包含throws子句；

• 六、I/O异常
• （1）流是一个有序的字节序列，它能够用作输入源或做为输出目标；
• （2）System.out.in：标准输入流；
• System.out.out：标准输出流；

• System.out.err：标准错误流（输出错误信息）；

第十二章：递归

• 一、递归思想：递归是一种方法可以调用本身的编程技术，掌握递归编程的关键是能以递归的思想考虑问题；
• （1）无穷递归：任何一个递归定义中必须有称为基本状况的非递归定义部分，才能使递归最终结束；
• （2）数学中的递归运算：数学函数和数学公式常以递归的形式表示；
• 二、递归编程
• （1）每一次对方法的递归调用，都会建立新的局部变量与参数；
• （2）对于某些问题，递归是最精炼和适当的方法，但对于其余的问题，递归则不如迭代解法直观；
• 三、递归的应用
• （1）迷宫旅行；
• （2）汉诺塔问题；

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

第十一章：

• 问题1：
  假如错误和异常都是对象的话，它是否能够调用方法或者它在哪儿声明呢？
• 问题1解决方案：
  （1）首先先用做业里的一道题举个例子，假如咱们先创建一个异常类，而且用一个test测试类来声明一个异常对象，
  好比：

public class test {
    public static void main(String[] args) {
        StringTooLongException a = new StringTooLongException("");
        System.out.println(a);
    }
}

在这里就能够看见不少异常的方法，因此就能够说明是一个对象，包含一个对象所具备一些性质；

（2）由于咱们是到其实类都是object类的子类，因此在书里有这样一句话：

Java预约义了一组程序执行中可能发生的异常和错误；

因此咱们应当明白，其实也就能够理解为它是一个对象所拥有的一个性质。

• 问题2：错误和异常属于对象，那所抛出的问题属于一个程序中的哪一部份？

• 问题2解决方案：既然是程序里的一部分，因此我在想，假如程序运行，他会被抛出，会不会是程序就是输出的一部分，或者就是一部分语句块，想了不少中状况，由于在后面讲的捕捉异常，我感受它应该是是一个输出的结果，或者就是一个检测程序错误的部分。

• 问题3：一直都在讲错误和异常，他俩的区别是什么呢？

• 问题3解决方案：
  书里是这样解释的：

一个异常是一个定义非正常状况或错误的对象；

错误相似异常，不一样之处是错误表明不可恢复的问题而且必须捕获处理。

感受这个概念书里讲的挺模糊的，就上网查了查：

• 问题4：在捕获问题的时候如何具体到语句？这个问题的提出是由于看到了例11.2，里面的输出语句后面都带有一个“+code”，因此，像这样的须要咱们输进去语句，检查咱们输进去语句是否存在异常，想要知道那句错了是简单的，可是假如当咱们编了一个程序，忽然冒出来一堆错误，在哪里也不知道怎么办？这道题假如用idea的时候，其实找错误只须要点一下抛出异常的后面那个显示蓝色的线，其实就能够知道哪里错了，可是学了这一章之后，假如我要捕捉这个错误，再如何去找错误呢？（这个有一个前提，就是不能提早已知错误的语句）

• 问题4解决方案：
  我目前尚未找到答案，感受这个问题本身太较真了，或者再后面仍是能够利用自定义异常来编写，因此感受问的这个问题价值不是很高，可是由于这个问题我仍是进行了思考的，因此仍是记录下来。

• 问题5：语句System.err和System.out的具体用法？
• 问题5解决方案：其实这个算是老师在课上留给咱们的一个自主的课下任务，我比较感兴趣也就查了一下：
  一、out：“标准”输出流。此流已打开并准备接受输出数据。一般，此流对应于显示器输出或者由主机环境或用户指定的另外一个输出目标。
  二、err：“标准”错误输出流。此流已打开并准备接受输出数据。一般，此流对应于显示器输出或者由主机环境或用户指定的另外一个输出目标。按照惯例，此输出流用于显示错误消息，或者显示那些即便用户输出流（变量 out 的值）已经重定向到一般不被连续监视的某一文件或其余目标，也应该马上引发用户注意的其余信息。
  out和err的一个区别是，out每每是带缓存的，而err没有缓存（默认设置，能够改）。因此若是你用标准出错打印出来的东西能够立刻显示在屏幕，而标准输出打印出来的东西可能要再积累几个字符才能一块儿打印出来。若是你在应用中混用标准输出和标准出错就可能看到这个问题。
  测试代码：

public class Test2 {
  static{
    System.out.println("1");
  }
  public static void main(String[] args) {
    System.err.println("2");
    new Test2();
  }
  public Test2() {
    System.out.println("3");
  }
 }

实验结果：
1,3的位置相对不变,2的位置随机出现

• 问题6：写入和读取文件的几种方式？
• 问题6解决方法：

import java.io.*;
public class FileTest {
    public static void main(String[] args) throws IOException {
        //（1）文件建立（文件类实例化）
        File file = new File("C:\\Users\\besti\\Desktop\\FileTest","HelloWorld.txt");
        if (!file.exists()){
            file.createNewFile();
        }
        //（2）文件读写
        //第一种：字节流读写，先写后读
        OutputStream outputStream1 = new FileOutputStream(file);
        byte[] hello = {'H','e','l','l','o',',','W','o','r','l','d','!'};
        outputStream1.write(hello);

        InputStream inputStream1 = new FileInputStream(file);
        while (inputStream1.available()> 0){
            System.out.print((char) inputStream1.read()+"  ");
        }
        inputStream1.close();
        //============================BufferedInputStream====================================
        byte[] buffer = new byte[1024];
        String content = "";
        int flag = 0;
        InputStream inputStream2 = new FileInputStream(file);
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream2);

        while ((flag =bufferedInputStream.read(buffer))!=-1){
            content += new String(buffer,0,flag);
        }
        System.out.println(content);
        bufferedInputStream.close();
//====================================BufferedOutputstream================================================
        OutputStream outputStream2 = new FileOutputStream(file);
        BufferedOutputStream bufferedOutputStream2 = new BufferedOutputStream(outputStream2);
        String content2 = "写入文件的缓冲区内容";
        bufferedOutputStream2.write(content2.getBytes(),0,content2.getBytes().length);
        bufferedOutputStream2.flush();
        bufferedOutputStream2.close();
        //第二种：字符流读写，先写后读(两种读)
        Writer writer2 = new FileWriter(file);
        writer2.write("Hello, I/O Operataion!");
        writer2.flush();
        writer2.append("Hello,World");
        writer2.flush();

        BufferedWriter bufferedWriter = new BufferedWriter(writer2);
        String content3 = "使用bufferedWriter写入";
        bufferedWriter.write(content3,0,content3.length());
        bufferedWriter.flush();
        bufferedWriter.close();

        Reader reader2 = new FileReader(file);
        System.out.println();
        while(reader2.ready()){
            System.out.print((char) reader2.read()+ "  ");
        }
        BufferedReader bufferedReader = new BufferedReader(reader2);
        while ((content =bufferedReader.readLine())!= null){
            System.out.println(content);
        }
    }
}

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

• 问题1：在编写一次课上做业的时候，第一次我是这样编的，当时觉得对了，在最后一秒发现，这样的编法没有用递归...
  

• 问题1解决方案：在周围同窗的忽然一点下，知道本身在后面的静态方法里没有用递归，因此赶忙作出了改变：
  

ps：红圈是第一次与第二次不一样的地方，也是错误的地方。

• 问题2：在编写另一次家庭做业就是那个I/O流的做业里，在编程中本身遇到了不少问题，在方案中一一点出，并讲说明本身当时的解决方法和思路
• 问题2解决方案：首先我第一次编好的程序是这样的：

import java.io.*;
import java.util.Arrays;
import java.util.Scanner;
public class homework1 {
    public static void main(String[] args) throws IOException{
    File file = new File("D:\\test","Test.txt");
        if (!file.exists()){
            file.createNewFile();}
        String a;
        Scanner scan = new Scanner(System.in);
        System.out.println("输入几个数字： ");
        a=scan.nextLine();
        Writer writer = new FileWriter(file);
        writer.write(a);
        writer.flush();
Reader reader = new FileReader(file);
        System.out.println();
        while (reader.ready()){
            System.out.print((char)reader.read()+ "");
        }
        String str = a.replaceAll(" ", "");
        char[] b=new char[str.length()];

       int in = 0;
        while (in<=str.length()-1)
        {
            b[in]=str.charAt(in);
            in++;
        }
        System.out.println();
        insertionSort(b);
 System.out.println("排序后：" + Arrays.toString(b));
 FileWriter fw = new FileWriter("D:\\test\\Test.txt");
        String q = "";
        for(int i=0;i<b.length;i++){
            q += b[i] + ",";
        }
        fw.write(q);
        fw.flush();
        fw.close();
}
private static void insertionSort(char[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int temp = arr[i];
            int j = i - 1;
            while (j >= 0 && temp < arr[j]) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = (char) temp;
        }

    }
}

输出结果后，是这个样子的：

就出现问题了；
- 我虽然分开输入了不一样位数的数字，可是最后程序把它们分红了一个个数字，也就是这个程序只能排列0~9之间的数字；
因而我就想着能不能把它们先分开，再将一个个总体写入数组里，就开始写：
一、首先我用了这个语句String[] sourceStrArray = a.split(" ");将其以空格做为分界，把一个个分开之后存进数组；
二、后来就发现，一个是int类型的数组，一个是String型的数组，不匹配，因此就想着用Integer.parseInt，可是有个问题，这个貌似不能用在数组里，因此用了很长时间研究，用了这样一段代码实现了转换：

int[] t = new int[b.length];
            for (int i = 0; i < b.length; i++) {
                t[i] = Integer.parseInt(b[i]);
            }

而后输出：

就ok啦！！

代码托管

上周考试错题总结

• 错题1
  Character streams manage
  A. byte-sized data
  B. binary data
  C. Unicode characters
  D. ASCII characters
  E. compressed data

  正确答案： C  个人答案： B

解析：字符流用于管理16位Unicode字符。这与字节流不一样，后者用于管理任何种类的字节大小的数据，包括ASCII字符和其余类型的二进制数据。

• 错题2
  A processing stream is a data stream that
  A. can manage both input streams and output streams at the same time
  B. performs some manipulation or process on the data
  C. can only manage input streams
  D. operates on input and output devices but not files
  E. can manage byte streams and character streams at the same time

  正确答案： B  个人答案： E

解析：数据流表示特定的源或目标流，用于输入或输出。处理流就像数据流，其中一些额外的处理被添加到输入或输出。例如，处理字节流可能会输入文件中的全部项目，并删除任何不是数字的ASCII字符，以便预期为数字的输入不会引起NumberFormatException。

• 错题3
  Assume infield is a Buffered Reader for a textile and that the textile is empty. What is returned from the message infile.readLine ( );
  A. 0
  B. null
  C. a special character known as the End-of-file marker (EOF)
  D. none of the above, the message causes a NullPointerException to be thrown
  E. none of the above, the message causes a EndOfFileException to be thrown

  正确答案： B  个人答案： D

解析：readLine（）方法返回一个等于文件中下一个文本项的String。若是文件为空，则返回null。

• 错题4
  Print Writer is a better output stream class that Print Stream because Print Writer
  A. has both print and println methods and PrintStream only has print
  B. can output both byte and character streams and PrintStream can only output byte streams
  C. has error checking mechanisms as part of the class and PrintStream does not
  D. will not throw checked exceptions and PrintStream will
  E. all of the above

  正确答案： C  个人答案： E

解析：PrintWriter类是一个Writer类，而PrintStream类是一个Stream类。主要区别在于PrintWriter专门用于文件，所以具备不属于PrintStream的错误检查机制。

结对及互评

• 本周结对学习状况
  • 20172316赵乾宸
• 博客中值得学习的或问题：
  • 内容详略得当；
  • 代码调试环节比较详细；
• 基于评分标准，我给本博客打分：5分。得分状况以下：

1. 正确使用Markdown语法（加1分）：
2. 模板中的要素齐全（加1分）
3. 教材学习中的问题和解决过程, 一个问题加1分

4. 代码调试中的问题和解决过程, 一个问题加1分

   • 20172316唐才铭

• 博客中值得学习的或问题：
  • 内容详略得当；
  • 代码调试环节比较详细；
• 基于评分标准，我给本博客打分：9分。得分状况以下：

1. 正确使用Markdown语法（加1分）：
2. 模板中的要素齐全（加1分）
3. 教材学习中的问题和解决过程, 一个问题加1分
4. 代码调试中的问题和解决过程, 一个问题加1分

其余

• 这一周虽然说节奏依旧很快可是仍是跟上了，或许是由于上周周末比较开心再加上啦啦操即将结束的缘故，本身在给学习挤时间的争分夺秒老是让我非常为本身所感动，这一周的编程项目和学习内容我自身而言不是特别难，首先特别想说的就是，其实我发现伪代码不必定要写出来，我这一周，有几个项目都是晚上睡觉实在睡不着，就像如何让一个项目实现，想各类办法，记住，次日起来想写下来，有空余时间就赶快进行编写，其实本身的学习状态也在慢慢找回，由于以前时间的太少让我老是以为本身要跟不上了，的确，本身和班级的前列已经拉开了十分左右的距离，实际上是不小的距离了，有时候以为本身放弃，对不起这么久的努力，不放弃，总以为本身有时候学习的时间都被各类各样本身不能拒绝的活动所占据，因而就想着周末学习，可是啦啦操的疲惫，让周末的我身心疲惫，就是那一种，有心而力不足的感受，其实最近又想了想，说累，难道只有我一我的累么，不；说事情多，也并非只有我一我的事情多，因此，我不是特殊的，因此我也没有想着把累、苦挂在嘴上；我记得在高考完，本身特别指望的生活就是这种天天都忙忙碌碌，由于我以为年轻人，乘着年轻，为什么不拼一把，乘着年轻，为什么不努力一把呢，人也就这样一生，也就只能这样真正年轻过一次，抓住着有限的时间，我要为了本身的不后悔，作出更多让本身之后佩服本身的事情！！！！！

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）
目标	5000行	30篇	400小时
第一周	156/156	1/1	15/15
第二周	217/371	1/2	20/35
第三周	233/604	2/4	20/55
第四周	1382/1986	1/5	35/90
第五周	146/2196	1/6	25/115
第六周	462/2658	1/7	15/130
第七周	856/3514	1/8	20/150
第八周	1877/5391	3/11	20/170
第九周	1747/7138	1/12	20/190

参考资料

Java程序设计
蓝墨云
java基础(System.err和System.out)详解
java的异常和错误有什么区别
java中error和exception的区别