20155232 2016-2017-3 《Java程序设计》第6周学习总结

时间  2019-12-18
标签 Java程序设计 6周 学习 总结 栏目 Java 繁體版
原文   原文链接

20155232 2016-2017-3 《Java程序设计》第6周学习总结

教材学习内容总结

  • 第十章 异常处理

1.从应用程序来看，若是要将数据从源取出，可使用输入串流。html

2.若是要将数据写入目的地，可使用输出串流。java

3.输入串流表明对象为java.io.inputStream实例，输出串流对象为java.io.oututStram实例。
==注意==在不使用inputstream与outputstream时，必须使用close()关闭串流，也可以使用JDK7尝试自动关闭资源语法。git

4.FileInputStream与InputStream的子类，能够指定文件名建立实例，一旦建立文档就开启，接着可用来写数据==不使用时都要使用close（）关闭文档==数组

5.InputStream、outputstream提供串流基本操做，若是想要为输入输出的数据作加工处理，可使用打包器类。安全

6.经常使用的打包器具备缓冲区做用的BufferedInputStream、Bufferedoutputstream。多线程

7.具有数据转换处理做用的DataInputStream、DataOutputStream。架构

8.具有对象串行化能力的ObjectInputStream、ObjectOutputStream等。dom

9.对字符数据的读取，提供了java.io.Reader类。ide

10.对字符串的写入提供了java.io.writer类。函数

11.FileReader、FileWriter能够对文档作读取与写入，读取或写入时默认使用操做系统默认编码作字符转换。
==提示==再启动JVM时，能够指定-Dfile.encoding来指定所使用的编码。

12.Reader,Writer有一些装饰器类能够用，若是串流处理数据的字节数据，实际上表明某些字符的编码数据，而想要字节数据装换为对应的编码字符，可以使用InputStreamReader,OutputSteamWriter对串流数据打包。

13.BufferedReader,BufferedWriter可对Reader,Writer提供缓冲区做用。对效率有所帮助。

14.PrintWriter与PrintStream使用上极为类似，除了对Outputstream打包以外，printwriter还能够对writer进行打包。

15.父类中的方法，核心类：
image
image

16.标准输入输出：

标准输入输出

System.in：标准输入，默认关联到键盘(终端输入)

System.out：标准输出，默认关联到显示器(终端输出)

System.err：标准错误，默认关联到显示器(终端输出)

输入输出重定向：setIn，setOut，setErr

  • 第十一章

1.使用java.lang.Thread的静态sleep()方法，让目前流程暂停指定时间==注意==指定的单位是毫秒。

2.线程的生命周期
image

3.撰写类操做java.lang.runnable接口，达到main之外独立设置流程。

4.建立Thread实例来执行Runnable实例定义的run()方法，使从main开始的流程由主线程执行。

5.要启动线程执行指定流程，调用Thread实例的start()方法。

6.除了将流程定义在Runnable的run()方法以外，另外一个撰写多线程程序的的方式，就是继承Thread类，从新定义run()方法。

7.操做Runnable接口的好处就是较有弹性，类还能够继承其余类。

8.若是主线程中启动了额外线程，默认会等待被启动的全部线程都执行完，run()方法才终止JVM。

9.若Thread被标示为Daemon线程，在全部的非DAaemon线程都结束时，JVM就会自动终止。

11.在调用Thread实例start()方法后，基本状态为可执行，被阻断，执行中。

12.线程有优先权，可以使用Thread的setpriority()方法设定优先权，设定值为1到10，默认为5。==超出设定值会抛出IllegalArgumentException==

13.数字越大，优先权越高，排班器越优先排入CPU==注意==若是优先权相同，则输流执行。

14.当某线程进入Blocked时，将另外一线程排入cpu执行，避免cpu空闲下来，是改进效能的方式之一。

15.线程因输入输出进入Blocked状态后，在阻断状况结束后，会回到Runnable状态，等待排班器排入执行。一个进入Blocked状态的线程，能够由另外一个线程调用该线程的Interrupt()方法，使离开Blocked状态。

16.若是A线程正在运行，流程中容许B线程加入，等到B线程执行完毕后再继续A线程流程，则可使用join()方法完成这个需求。

17.线程完成Run()方法后就会进入Dead,不能够再调用start()方法，不然抛出

IllegalThreadStateException

18.Thread类上定义有stop()方法，不过被标示为Deprecated,表示过去确实定义过，后来由于某些问题，这些API没有直接剔除。

19.若要中止线程，最好自行操做，不要使用stop（）方法（包括暂停，重启）

20.线程一旦进入某个群组，就没法更换群组。

21.线程存取同一对象相同资源时，可能引起竞速状况，这样的类是不安全的。

22.每一个对象都会有个内部锁定。被标示为synchronized的区块将被监控。

23.若在方法上标示synchronized，则执行方法必须取得该实例的锁定。

24.执行synchronized范围的程序代码期间，若调用锁定对象的wait()方法，线程会释放对象锁定，并进入对象等待集合，处于阻断状态。

25.放在等待的线程不会参与cpu排班，wait()能够指定等待时间，时间到以后线程会再次加入排班。
==注意==若是指定时间为0或不指定，则线程会持续等待，直到被中断或告知。

26.被竞争锁定的对象用notify()时，会从对象等待集合中随机通知一个线程加入。若是调用notifyAll()，全部等待集合中的线程都会被通知参与排班，这些会与其余线程共同竞争对象锁定。

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

  • 问题一

课本p305页代码中

while ((length = input.read(data)) != -1)

这里代码中的-1有什么用?

  • 解决方案一：

在上网查找了一下获得以下结果：虽然代码不同，可是知道了-1表明了读取完毕。
image
image
image

  • 问题二

课本p325页代码：

boolean isHareSleep = flags[((int) (Math.random() * 10)) % 2];
            if(isHareSleep) {
                out.println("兔子睡著了zzzz");
            } else {
                hareStep += 2;    
                out.printf("兔子跑了 %d 步...%n", hareStep);

在这里，flags数组有什么做用？

  • 解决方案：

个人理解是flag数组中随机函数产生的随机数非0的数字，数组就为非空，即boolean的值为True,反之，数组为空，即为False。能够用来判断兔子是否随机睡觉。

  • 问题三

线程退出后，进程就退出了，主线程建立的线程没有执行完就退出了。怎么解决

  • 解决方案

两个方式：
一、主线程等待子线程，用join；
二、子线程设置本身为守护线程。

  • 问题四

进程中线程之间的关系？

  • 解决问题

线程不像进程，一个进程中的线程之间是没有父子之分的，都是平级关系。即线程都是同样的, 退出了一个不会影响另一个。

可是所谓的"主线程"main,其入口代码是相似这样的方式调用main的：exit(main(...))。

main执行完以后, 会调用exit()。

exit() 会让整个进程over终止，那全部线程天然都会退出。

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

  • 问题一：p309页运行时出现错误
    image
    image

  • 解决方案：
    上网搜索出现这个错误的缘由，结果以下：image
    image
    image总结了一下，就是由于没有对args[]传值，没有加入参数，因此致使越界错误声明。

  • 问题二：
    课本p339页

package Thread;

public class ArrayListDemo {

    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        Thread thread1 = new Thread(() -> {
            while (true) {
                list.add(1);
            }
        });

        Thread thread2 = new Thread(() -> {
            while (true) {
                list.add(2);
            }
        });

        thread1.start();
        thread2.start();
    }
}

按照书上的代码打上去，运行结果应该是发生ArrayIndexOutOfBoundException异常，可是在我编译的时候出现了以下错误：
image
image

  • 解决方案：

在仔细看书后，检查到了缘由，是由于这个是用了课本6.2.5节中的方法，可是由于没有把这些程序放到同一个包中，因此找不到符号，不是代码自己的问题，由于在这个包中就没有定义这个方法。而书上全部代码都在同一个包中，因此编译能够经过。

  • 问题三：
    课本p350-p353 producer,consumer,代码编译都出现相似问题，显示找不到符号，可是此次代码都在同一个包中，因此出现了问题。
    image
  • 解决方案：
    image
    如上图，在编译时应注意先编译producer,和consumer，最后在编译含有main的主类，三个编译才能经过，最后在云心时必定要在同一个包中才能运行。

代码托管

  • 代码提交过程截图：

image
image
image
image

结对及互评

评分标准(满分10分)

  1. 从0分加到10分为止
  2. 正确使用Markdown语法（加1分）：
    • 不使用Markdown不加分
    • 有语法错误的不加分（连接打不开，表格不对，列表不正确...）
    • 排版混乱的不加分
  3. 模板中的要素齐全（加1分）
    • 缺乏“教材学习中的问题和解决过程”的不加分
    • 缺乏“代码调试中的问题和解决过程”的不加分
    • 代码托管不能打开的不加分
    • 缺乏“结对及互评”的不能打开的不加分
    • 缺乏“上周考试错题总结”的不能加分
    • 缺乏“进度条”的不能加分
    • 缺乏“参考资料”的不能加分

  4. 教材学习中的问题和解决过程, 一个问题加1分

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

  6. 本周有效代码超过300分行的（加2分）
    • 一周提交次数少于20次的不加分

6 其余加分：

  • 周五前发博客的加1分
    • 感想，体会不假大空的加1分
    • 排版精美的加一分
    • 进度条中记录学习时间与改进状况的加1分
    • 有动手写新代码的加1分
    • 课后选择题有验证的加1分
    • 代码Commit Message规范的加1分
    • 错题学习深刻的加1分
      7 扣分：
    • 有抄袭的扣至0分
    • 代码做弊的扣至0分

点评模板：

  • 博客中值得学习的或问题：
    • xxx
    • xxx
    • ...
  • 代码中值得学习的或问题：
    • xxx
    • xxx
    • ...

  • 基于评分标准，我给本博客打分：XX分。得分状况以下：xxx

  • 参考示例

点评过的同窗博客和代码

  • 本周结对学习状况
    • 20155215
    • image
    • 结对学习内容
      • 一块儿讨论课本代码，共同解决代码编译报错问题。
      • 前几周考试留下来的部分没有解决的试题。
      • 一块儿看JAVA教学视频。
      • 讨论知识点，交换学习体会和学习难点。
  • 上周博客互评状况

## 上周考试错题总结

1. import java.util.*;
    2．
    3. Class FindStuff  {
    4.public static void main (String[]args)    {
    5，    ／／insert code here
    6．    c.put ("X", 123)；
    7．    }
    8.  }
分别插入到第5行，哪几行容许代码编译？

A .
Map c= new SortedMap();

B .
HashMap c= new HashMap();

C .
HashMap c= new Hashtable();

D .
SortedMap c= new TreeMap();

E .
ArrayList c= new ArrayList();

F .
Map c = new LinkedHashMap();

答案： B D F

3．  import java.util.*;
    4．    class ForInTest  {
    5.static List list=new ArrayList();
    6．
    7.public static void main (String  []  args)  {
    8.list. add("a")； list. add("b");list. add( "c")；
    9．    //insert code here
    10.    System.out.print (o)；
    11.    }
    12．  }
哪一行插入到第9行将致使输出“abc"？

A .
for (Iterator o : list.iterator()； o.hasNext (); )

B .
for (Iterator o : list)

C .
for (Object o : list.iterator())

D .
for (Object o ： list)

答案：D

  • 下列哪些项是泛型的优势？ （选两项）
    A .
    不用向下强制类型转换

B .
代码容易编写
C .
类型安全

D .
运行速度快

答案：AD

缘由：少选了C，看书看得仍是不够仔细，只记住了大概。

  • Which of the following methods will not compile?

A .
private void method1(String name) {
if (name.equals("star"))
throw new IllegalArgumentException(name);
}

B .
private void method2(int age) {
if (age > 30)
throw Exception();
}

C .
public double method5() throws Exception {
return 0.7;
}

D .
protected double method4() throws Exception {
throw new Throwable();
}

答案：BD

  • What is the output of the following code?
class EJava {
void method() {
try {
guru();
return;
} finally {
System.out.println("finally 1");
}
}
void guru() {
System.out.println("guru");
throw new StackOverflowError();
}
public static void main(String args[]) {
EJava var = new EJava();
var.method();
}
}

A .
guru
finally 1

B .
guru
finally 1
Exception in thread "main" java.lang.StackOverflowError

C .
guru
Exception in thread "main" java.lang.StackOverflowError

D .
guru

E .
The code fails to compile.

答案：B

  • 现有：
1.   class  Parser extends  Utilis  {
   2.     public static void main (String  []  args)  {
   3 .          try  {  System. out.print (new  Parser ( ) .getlnt ("42")) ;
   4.     }  catch (NumberFormatException n) {
   5 .              System.out .println ( "NFExc" ) ;   }
   6.    }
   7.     int getlnt (String arg)  throws NumberFormatException{
   8.       return Integer.parselnt (arg) ;
   9.    }
   10. }
   11. class Utils {
   12.    int getlnt (String arg)  {  return 42;  }
   13. }

结果为 :

A .
NFExc

B .
42

C .
42NFExc

D .
编译失败

答案：B

  • 现有:
1. class Flow {
 2.   public static void main(String [] args) t
 3.    try {
 4 .              System. out .print ("before") ;
 5 .                  doRiskyThing ( )  ;
 6.          System.out.print ("after ") ;
 7.    } catch (Exception fe) {
 8.          System.out.print ("catch") ;
 9.     }
 10 .          System. out .println ( " done") ;
 11.   }
 12.  public static void doRiskyThing() throws Exception{
 13.   
          }}

可能会产生哪两项结果 ?（选两项）

A .
before catch

B .
before after done

C .
before catch done

D .
before after catch

答案：BC

  • 现有：
1.  class Guy  {  String greet()  {  return "hi";  }  j
2.  class Cowboy extends Guy  {  String greet()  {  return. "howdy";}}
3.  class  Wrangler  extends  Cowboy  {  String  greet()  {  return  "orch!"; } }
4．
5．  class Greetings2  {
6.   public  static void main (String  []  args)  {
7.     Guy g=new Wrangler();
8．    Guy g2=new Cowboy()；
9.     Wrangler w2=new Wrangler();
10.    System. out .print (g.greet()+g2.greet()+w2 .greet())；
11.    }
12.  }
结果是什么？

A .
hi hi ouch!

B .
ouch! howdy ouch!

C .
hi howdy ouch!

D .
编译失败

答案：B

1. abstract class Color  {
    2.protected abstract  String getRGB();
    3.  }
    4．
    5. public class Blue extends Color  {
    6．    ／／insert code here
    7.  }
    和四个声明：
    public String getRGB()  {  return "blue";  }
    String getRGB()  {  return  "blue";  )
    private  String getRGB()  {  return  "blue";  }
    protected String getRGB()  {  return "blue";  )
分别插入到第6行，有几个能够经过编译？

A .
0

B .
1

C .
2

D .
3

答案：C

缘由：看不太懂题目，代码也不太看得懂，我以为这种程序类的题，但愿老师能多讲解考过的试题或者课本上的代码，帮助咱们更好地理解。由于以前的考试就只有答案没有解析，有的题目仍是不太理解。

感悟心得

  • 对教材感悟
    第十章主要讲了串流与输入输出的关系，认识了InputStream outputstream继承架构，认识了reader,eriter继承架构。第十一章认识了Thread与Runnable，使用synchronized。了解了wait(),notify(),notifyAll()。

  • 对考试感悟
    此次考试，使用了蓝墨云这个APP，很是的不习惯，有点手忙脚乱，不太适应这种考试，并且以为此次题目难度加大了不少，题目篇幅也有点大，代码类的题目加多，作不太完。还得慢慢去适应这种考试方式，提升速度与熟练度。

  • 课本中代码的部分展现与思考

1.p314页代码如图：
image
运行结果：
image
范例中有三个member实例，分别存储为文档以后再读取回来。

2.p325页代码以下：
image
运行结果：
image这个是课本上最简单的，也就是只有一个流程，就是从main()开始至结束的流程。兔子可能随机睡觉，运用了random函数。

  1. 课本p326-p327页将上面这个程序作了改进。

这个是兔子的流程，从run()开始。

package Thread;

public class Hare implements Runnable {
    private boolean[] flags = {true, false};
    private int totalStep;
    private int step;

    public Hare(int totalStep) {
        this.totalStep = totalStep;
    }

    @Override
    public void run() {
        while (step < totalStep) {
            boolean isHareSleep = flags[((int) (Math.random() * 10)) % 2];
            if (isHareSleep) {
                System.out.println("兔子睡着了zzzz");
            } else {
                step += 2;
                System.out.printf("兔子跑了 %d 步...%n", step);
            }
        }
    }
}

而乌龟的流程在以下代码中：

package Thread;

public class Tortoise implements Runnable {
    private int totalStep;
    private int step;

    public Tortoise(int totalStep) {
        this.totalStep = totalStep;
    }

    @Override
    public void run() {
        while (step < totalStep) {
            step++;
            System.out.printf("乌龟跑了 %d 步...%n", step);
        }
    }
}

image
在这个程序中，主线程执行main()定义的流程，main()定义的流程中创建了tortoiseThread与hareThread两个线程。要启动线程执行指定流程，必须调用Thread()的start()方法。

3.p330代码
image
image
使用了setDaemon(true)就是当前进程变为后台线程，对java来讲，只要还有一个前台线程在运行，这个进程就不会结束。

4.课本p331代码：
image
image这个程序能够指定网页下载东西，在每次for循环，进行HTTP请求，而后进行文档写入。可是效率很是的低下。

5.课本333页代码：

image
image
Thread。sleep()会让线程进入Block状态，若此时有其余线程调用该线程的interrut()方法，会抛出异常对象，就会使线程“醒过来”。

6.p334页代码：
image
image
当线程使用join()加入另外一线程时，另外一线程会等待被加入的线程工做完毕，而后再继续他的动做。程序启动后，主线程开始，在主线程中新建threadB，并在启动后，将至加入主线程中，因此会先执行B，主线程才会继续本来的流程。

7.在课本p337页，uncaughtException()方法第一个参数可取的发生异常的线程实例，第二个参数可取得异常对象，运行结果显示了线程的名称及异常信息。
image
image

8.课本p338页中，t1,t2都属于同一个Threadgroup。t2没有设定Thread。UncaughtExceptionHandler实例。因此有默认的第三个处理方式。image
image

9.课本p344页代码以下：这个程序可能会发生死结，就是两个线程都处于不放开resource锁定的状态，在死结发生时陷入停顿状态。
image
image

10.课本p345页代码：
image
运行以下：thread1会调用Variable1.one(),thread2会调用Variable1.two()，有可能会发生thread2调用取i值后，切换至thread1不断执行，再切换至thread2取j值，有可能j远大于i。
image

11.在课本p364-p366程序中，将Pages.java和DirectExecutor.java和Download.java按这个顺序编译后，运行结果下载了
image

12.课本p371代码
image使用了newSingleThreadScheduledExecutor()返回的SchduledExecutorService。java.util.Date建立时，回去的当时系统时间，每次工做会执行2秒，然后延迟1秒，因此如图每三秒一个间隔。
image

13.课本p374页，在继承RecursiveTask以后，主要将子任务与求解过程撰写于compute（）方法中，为了不分解出过多的子任务，形成没必要要的麻烦，n< 20就直接用循环求解。
image
image

14.课本p376-p378页代码，使用了BlockingQueue的操做ArrayBlockingQueue类，这样就不用处理麻烦的wait(),notify()流程了，简化了不少。image

学习进度条

代码行数（新增/累积） 博客量（新增/累积） 学习时间（新增/累积） 重要成长
目标 5000行 30篇 400小时
第一周 15/15 1/1 23/26
第二周 208/240 2/2 35/38
第三周 376/584 3/3 32/38
第四周 823/1407 4/4 28/30
第五周 986/2393 5/5 21/26
第六周 1258/3651 6/6 26/25

尝试一下记录「计划学习时间」和「实际学习时间」，到期末看看能不能改进本身的计划能力。这个工做学习中很重要，也颇有用。
耗时估计的公式
：Y=X+X/N ，Y=X-X/N，训练次数多了，X、Y就接近了。

参考：软件工程软件的估计为何这么难，软件工程 估计方法

参考资料

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程