20172329 2017-2018-2 《程序设计与数据结构》第九周学习总结
20172329 2017-2018-2 《程序设计与数据结构》第九周学习总结
教材学习内容总结
第十一章：异常
-
1、一些引起异常抛出的问题：
-
（1）试图做除以0的操作；
-
（2）数组索引越界；
-
（3）找不到指定的文件；
-
（4）不能正常完成被请求的I/O操作；
-
（5）使用了空引用；
-
（6）执行的操作违反了某种安全规则。
-
2、try-cash语句
-
（1）执行try语句时，将执行try语句块中的语句。如果没有异常抛出，将继续执行try语句后的语句（所有catch子句后的语句）；
-
3、finally语句
-
（1）一条try-catch语句可以有一个可选的finally子句，用于定义一段无论是否有异常发生的都会执行的代码；
-
（2）try语句块可以没有catch子句。没有catch语句时，如果需要仍然可以使用finally子句；
-
4、自定义异常
-
（1）可由Exception类或它的后代类派生一个新类来定义一个新的异常；
-
5、可检测异常与不可检测异常
-
对于可检测异常，如果发生异常的方法不捕获和处理这个异常，则必须在该方法定义的声明头中包含throws子句；
-
6、I/O异常
-
（1）流是一个有序的字节序列，它可以用做输入源或作为输出目标；
-
（2）
System.out.in：标准输入流； -
System.out.out：标准输出流； -
System.out.err：标准错误流（输出错误信息）；
第十二章：递归
- 1、递归思想：递归是一种方法能够调用自己的编程技术，掌握递归编程的关键是能以递归的思想考虑问题；
- （1）无穷递归：任何一个递归定义中必须有称为基本情况的非递归定义部分，才能使递归最终结束；
- （2）数学中的递归运算：数学函数和数学公式常以递归的形式表示；
- 2、递归编程
- （1）每一次对方法的递归调用，都会创建新的局部变量与参数；
- （2）对于某些问题，递归是最精炼和适当的方法，但对于其他的问题，递归则不如迭代解法直观；
- 3、递归的应用
- （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解决方案：其实这个算是老师在课上留给我们的一个自主的课下任务，我比较感兴趣也就查了一下：
1、out：“标准”输出流。此流已打开并准备接受输出数据。通常，此流对应于显示器输出或者由主机环境或用户指定的另一个输出目标。
2、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之间的数字；
于是我就想着能不能把它们先分开，再将一个个整体写入数组里，就开始写：
1、首先我用了这个语句String[] sourceStrArray = a.split(" ");将其以空格作为分界，把一个个分开以后存进数组；
2、后来就发现，一个是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的错误检查机制。
结对及互评
- 本周结对学习情况
- 博客中值得学习的或问题：
- 内容详略得当；
- 代码调试环节比较详细；
- 基于评分标准，我给本博客打分：5分。得分情况如下：
-
正确使用Markdown语法（加1分）：
-
模板中的要素齐全（加1分）
-
教材学习中的问题和解决过程, 一个问题加1分
-
代码调试中的问题和解决过程, 一个问题加1分
- 博客中值得学习的或问题：
- 内容详略得当；
- 代码调试环节比较详细；
- 基于评分标准，我给本博客打分：9分。得分情况如下：
- 正确使用Markdown语法（加1分）：
- 模板中的要素齐全（加1分）
- 教材学习中的问题和解决过程, 一个问题加1分
- 代码调试中的问题和解决过程, 一个问题加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的区别
