201871010117-石欣钰 《面向对象程序设计（Java）》第十周学习总结

项目	内容
这个作业属于哪个课程	https://www.cnblogs.com/nwnu-daizh/
这个作业要求在哪里	https://www.cnblogs.com/nwnu-daizh/p/11778090.html
作业的学习目标	1.掌握java异常处理技术； 2.了解断言的用法； 3.了解日志的用途； 4.掌握程序基础调试技巧。

第一部分：第七章理论知识

一、异常

(1)   异常：在程序的执行过程中所发生的异常事件，它中断指令的正常执行。

（2）异常处理的任务就是将控制权从错误产生的地方转移给能够处理这种情况的错误处理器。

（3）程序中可能出现的错误和问题：a.用户输入错误。b.设备错误。c.物理限制。d.代码错误。

（4）Java中把程序运行时可能出现的错误分为两类：

A:非致命异常：通过某种修正后程序还能继续执行。如：文件不存在，网络断开，无效的数组下标，磁盘满等。Java中提供了一种独特的异常处理机制处理这类             错误。

B:致命异常：程序用到了非常严重的不正常的状态，不能简单执行恢复，是致命性错误。如：内存耗尽，系统内部错误。这种错误程序本身无法解决。

（5）Java中所有异常类都直接或间接地继承于Throwable类。除內置异常类外，程序员可自定义异常类。

(6)  Java的异常类可分为两大类：

A：Error类：描述了java运行时系统的内部错误和资源耗尽错误。应用程序不应该捕获这类异常，也不会抛出这种异常。（很难恢复的严重错误，一般不由程序处理）

B：Exception类：分为两分支，一个分支派生于Runtime Exception；另一个分支包含其他异常。（程序设计或者实现上的问题，如数组越界等）。其他异常：通常是由环境引起的，并且可以被处理。

（7）Java异常层次结构简化示意图如下：

（8）声明抛出异常:如果一个方法可能会生成一些异常，但是该方法并不确切知道如何对这些异常进行处理，此时，这个方法就声明抛出异常。

A:声明抛出异常在方法声明中用throws子句中来声明，throws子句可以同时指多个异常，说明该方法将不对这些异常进行处理，而是声明抛出它们。

B:以下四种情况用throws子句声明抛出异常：

—方法调用了一个抛出已检查异常的方法；

—程序运行过程中可能发生错误，并且利用throw语句抛出一个已检查异常对象

—程序出现错误

—Java虚拟机和运行时库出现的内部异常。

C:一个方法必须声明该方法所有可能抛出的已检查异常，而未检查异常要么不可控制(Error),要么应该避免发生(RuntimeException).

D:如果方法没有声明所有可能发生的已检查异常，编译器会给出一个错误消息。

(9) 当Java应用程序出现错误时，会根据错误类型产生一个异常对象，这个对象包含了异常的类型和错误出现时程序所处的状态信息。把异常对象递交给Java编译器的过程称为抛出。

(10)抛出异常要生成异常对象，异常对象可由某些类的实例生成，也可以由JVM生成。

(11)抛出异常对象通过throw语句来实现。

(12)创建异常类

A:自定义异常类：定义一个派生于Exception的直接或者间接子类。自定义的异常类应该包括两个构造器：a:默认构造器b:带有详细描述信息的构造器。

二：捕获异常

（1)捕获：程序运行期间，异常发生时，Java运行系统从异常生成的代码块开始，寻找相应的异常处理代码，并将异常交给该方法处理。

（2)某个异常发生时，若程序没有在任何地方进行该异常的捕获，则程序就会终止执行，并在控制台上输出异常信息。

（3)若要捕获一个异常，需要在程序中设置一个 try/catch/ finally块：

–try语句括住可能抛出异常的代码段。

–catch语句指明要捕获的异常及相应的处理代码。

–finally语句指明必须执行的程序块。

（4)try子句：捕获异常的第一步是用try{….}子句选定捕获异常的代码范围，由try所限定的代码块中的语句，在执行过程中可能会自动生成异常对象并抛出。

（5)catch子句:

a)catch块是对异常对象进行处理的代码；

b)每个try代码块可以伴随一个或多个catch语句，用于处理try代码块中所生成的格类异常事件；

c)catch语句只需要一个形式参数指明它所能捕获的异常类对象，这个异常类必须是Throwable的子类，运行时系统通过参数值把被抛出的异常传递给catch块；

d)catch块可以通过异常对象调用类Throwable所提供的方法。

---getMessage()用来得到有关异常事件的信息；

---printStackTrace()用来跟踪异常事件发生时执行堆栈的内容。

e)可以在一个try块中捕获多个异常类型，每个异常类型需要一个单独的catch子句。

（6)finally 子句：

A:捕获异常的最后一步是通过finally语句为异常处理提供一个统一出口，使得控制流程在转到程序其他部分以前，能够对程序的状态做统一的管理；

B:不管异常是否被捕获，finally子句中的代码都会被执行。

（7)异常处理中分析堆栈跟踪元素：

A:堆栈跟踪(staack trace)是程序执行中一个方法调用过程的列表，它包含了程序执行过程中的特定位置；

B:可用Throwable类的printStack Trace方法访问堆栈跟踪的文本描述信息。

三：使用异常机制的建议：

（1）积极处理方法：确切知道如何处理的异常应该捕获

（2）消极处理方法：不知道如何去处理的异常声明抛出。

四：异常处理的原则

(1)异常处理不能代替简单的条件检测，只在异常情况下使用异常机制。例如:上百万次地对一个空栈进行退栈操作。

(2)程序代码不要过分细化异常，尽量将有可能产生异常的语句放在--个try语句块中。

(3)抛出的异常类型尽可能明确。

(4)不要压制异常，对于很少发生的异常，应该将其关闭。

(5) 早抛出，晚捕获，尽量让高层次的方法通告用户发生了错误。

五：断言

1.断言:是程序的开发和测试阶段用于插入一些代码错误检测语句的工具。

2.断言(assert) 语法如下:
1）assert 条件

或者
2）assert 条件:表达式
这两个形式都会对布尔“条件”进行判断，如果判断结果为假(false)，说明程序已经处于不正确的状态下，系统则抛出AssertionError,给出警告并且退出。在第二种形式中，“ 表达式”会传入AssertionError的构造函数中并转成一个消息字符串。

第二部分：实验部分

实验1：用命令行与IDE两种环境下编辑调试运行源程序ExceptionDemo1、ExceptionDemo2，结合程序运行结果理解程序，掌握未检查异常和已检查异常的区别。

//异常示例1
public class ExceptionDemo1 {
    public static void main(String args[]) {
        int a = 0;
        System.out.println(5 / a);
    }
}

运行结果如下

//异常示例2
import java.io.*;

public class ExceptionDemo2 {
    public static void main(String args[])
     {
          FileInputStream fis=new FileInputStream("text.txt");//JVM自动生成异常对象
          int b;
          while((b=fis.read())!=-1)
          {
              System.out.print(b);
          }
          fis.close();
      }
}

运行结果如下：

实验2： 导入以下示例程序，测试程序并进行代码注释。

测试程序1：

1）在elipse IDE中编辑、编译、调试运行教材281页7-1，结合程序运行结果理解程序；

2）在程序中相关代码处添加新知识的注释；

3）掌握Throwable类的堆栈跟踪方法；

代码如下：

package stackTrace;

  import java.util.*;

  /**
   * A program that displays a trace feature of a recursive method call.
   * @version 1.10 2017-12-14
   * @author Cay Horstmann
   */
 public class StackTraceTest
 {
    /**
    * Computes the factorial of a number
    * @param n a non-negative integer
     * @return n! = 1 * 2 * . . . * n
     */
    public static int factorial(int n)    //求阶乘
   {
      System.out.println("factorial(" + n + "):");
       var walker = StackWalker.getInstance(); //创建对象时调用堆栈的跟踪
       walker.forEach(System.out::println);    //调用对象walker的foreach循环
      int r;
      if (n <= 1) r = 1;
      else r = n * factorial(n - 1);     //计算n的阶乘需要去调用n-1的阶乘
      System.out.println("return " + r);
      return r;
   }

    public static void main(String[] args)
    {
       try (var in = new Scanner(System.in)) //try语句块
       {
          System.out.print("Enter n: ");
          int n = in.nextInt();
          factorial(n);
       }
   }
 }

程序运行结果如下：

测试程序2：

1） Java语言的异常处理有积极处理方法和消极处理两种方式；

2）下列两个简单程序范例给出了两种异常处理的代码格式。在elipse IDE中编辑、调试运行源程序ExceptionTest.java，将程序中的text文件更换为身份证号.txt，要求将文件内容读入内容，并在控制台显示；

3）掌握两种异常处理技术的特点。

//积极处理方式　　

import java.io.*;

class ExceptionTest {

public static void main (string args[])

{

try{

FileInputStream fis=new FileInputStream("text.txt");

}

catch（FileNotFoundExcption e）

{   ……  }

……

}

}

//消极处理方式

import java.io.*;

class ExceptionTest {

public static void main (string args[]) throws  FileNotFoundExcption

{

FileInputStream fis=new FileInputStream("text.txt");

}

}

程序运行结果如下：

实验3: 编程练习

1）编写一个计算器类，可以完成加、减、乘、除的操作；

2）利用计算机类，设计一个小学生100以内数的四则运算练习程序，由计算机随机产生10道加减乘除练习题，学生输入答案，由程序检查答案是否正确，每道题正确计10分，错误不计分，10道题测试结束后给出测试总分；

3）将程序中测试练习题及学生答题结果输出到文件，文件名为test.txt；

4）在以上程序适当位置加入异常捕获代码。

代码如下：

package JavaTest;
//import java.text.DecimalFormat;
//import java.lang.*;
import java.util.Scanner;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
//import java.io.FileOutputStream;

//import java.io.IOException;
public class Test {

public static void main(String[] args) throws IOException {
int i,j,ss=0;
//int[] arr= new int[10];
//int[] arr1= new int[10];
//int[] arr2= new int[10];
double[] arr= new double[10];
double[] arr1= new double[10];
double[] arr2= new double[10];
FileWriter fileWriter=new FileWriter("D:\\text.txt");
for(i=0;i<10;i++)
{
double a=114.145;
double b=114.145;
a=(Math.random()*100+1);
b=(Math.random()*100+1);
a= (double) Math.round(a * 100) / 100;
b = (double) Math.round(b * 100) / 100;
double c=Math.random()*4+1;
jsq s = new jsq(a,b,(int)c);
System.out.println((i+1)+"."+"\t"+a+" "+s.getc()+" "+b+"\t"+"=");
arr[i]=s.get();
fileWriter.write((i+1)+"."+"\t"+a+" "+s.getc()+" "+b+"\t"+"="+"\n");
}

for(j=0;j<10;j++)
{
System.out.println(arr[j]);

}

System.out.println("请输入答案：");
@SuppressWarnings("resource")
Scanner in =new Scanner(System.in);
for(j=0;j<10;j++){
arr1[j]=in.nextDouble();
}

for(j=0;j<10;j++)
{
System.out.println(arr1[j]);

}

fileWriter.write("你的答案为:"+"\n");
for(j=0;j<10;j++)
{
fileWriter.write(arr1[j]+" ");

}
for(j=0;j<10;j++)
{
if(arr1[j]==arr[j]) {ss=ss+10;
arr2[j]=0;
}
if(arr1[j]!=arr[j]) {
arr2[j]=1;
}

fileWriter.write("\n");
}
for(j=0;j<10;j++)
{
if(arr2[j]==1){
System.out.println("第"+(j+1)+"题错误！");
fileWriter.write("第"+(j+1)+"题错误！"+"\n");
}

}
if(ss==100)
{
System.out.printf("全对！");
}
System.out.printf("总分为：%d",ss);
fileWriter.write("总分为："+ss);

fileWriter.flush();
fileWriter.close();
}

}

class jsq{
double a,b,f,d,h,n;
int c;
public jsq(double a1,double b1,int c1)
{
this.a=a1;
this.b=b1;
this.c=c1;
}
public char getc()
{
if(this.c==1) return '+';
if(this.c==2) return '-';
if(this.c==3) return '*';
if(this.c==4) return '/';
return '#';

}
public double get()
{
if(c==1) {
h=a+b;
h = (double) Math.round(h * 100) / 100;
return h;}
if(c==2) {
n=a-b;
n = (double) Math.round(n * 100) / 100;
return n;}
if(c==3) {
f=a*b;
f = (double) Math.round(f * 100) / 100;
return f;}
if(c==4) {
d=a*b;
d = (double) Math.round(d * 100) / 100;
return d;}
return 0;
}

}

运行结果：

实验4：断言、日志、程序调试技巧验证实验。

实验程序1：

//断言程序示例

public class AssertDemo {

    public static void main(String[] args) {        

        test1(-5);

        test2(-3);

    }

    

    private static void test1(int a){

        assert a > 0;

        System.out.println(a);

    }

    private static void test2(int a){

       assert a > 0 : "something goes wrong here, a cannot be less than 0";

        System.out.println(a);

    }

}

1）在elipse下调试程序AssertDemo，结合程序运行结果理解程序；

2）注释语句test1(-5);后重新运行程序，结合程序运行结果理解程序；

3）掌握断言的使用特点及用法。

程序运行结果如下：

注释语句test1(-5);后代码如下：

package project;

//断言程序示例
public class AssertDemo {
  public static void main(String[] args) {
      //test1(-5);
      test2(-3);
  }

  private static void test1(int a){
      assert a > 0;
      System.out.println(a);
  }
  private static void test2(int a){
     assert a > 0 : "something goes wrong here, a cannot be less than 0";
      System.out.println(a);
  }
}
运行结果如下：

实验程序2：

2）用JDK命令调试运行教材298页-300页程序7-2，结合程序运行结果理解程序；

并掌握Java日志系统的用途及用法。

程序代码如下：

运行结果如下：

实验程序3：

1）用JDK命令调试运行教材298页-300页程序7-2，结合程序运行结果理解程序；

2） 按课件66-77内容练习并掌握Elipse的常用调试技术。

①条件断点 –在Eclipse Java 编辑区的行头双击就会得到一个断点， 代码会运行到此处时停止。

–条件断点，顾名思义就是一个有一定条件的断点，只有满足了用户设置的条件，代码才会在运行到断点处时停止。

–在断点处点击鼠标右键，选择后一个“Breakpoint Properties”.

添加断点

点击“Breakpoint Properties”之后：

②变量断点–断点不仅能打在语句上，变量也可以接受断点：

上图就是一个变量的打的断点，在变量的值初 始化，或是变量值改变时可以停止，当然变量 断点上也是可以加条件的，和上面的介绍的条 件断点的设置是一样的。

③方法断点 –方法断点就是将断点打在方法的入口处：

–方法断点的特别之处在于它可以打在JDK的源码里，由于JDK在编译时去掉了调试信息，所以普通断点是不能打到里面的，但是方法断点却可以，可以通过这种方法查看方法的调用栈。

④异常断点

–经常遇见一些异常，然后程序就退出来了，要找到异常发生的地方就比较难了，还好可以打一个异常断点。

–上图中我们增加了一个NullPointException的异常断点，当异常发生时，代码会停在异常发生处，定 位问题时应该比较有帮助。

⑤重新调试
–这种调试的回退不是万能的，只能在当前线程的栈帧中回退，也就说最多只能退回到当前线程的调用的开始处。

–回退时，请在需要回退的线程方法上点右键，选择 “Drop to Frame”。

实验总结：这周主要学习了程序产生的异常以及如何解决程序中产生的异常。抛出异常，捕获异常等异常处理的知识的相关运用。捕获异常通过利用try字句、catch字句以及finally字句。断言知识的理解及应用。Java日志系统的用途及用法和Elipse的常用调试技术。因此在编写代码时需要及时处理这些异常，但是我在上课中听的不是很懂，在编程的时候也不知道怎么运用，虽然实验题我可以把程序写出来，但是不够好，还是练习的太少，今后需要多做练习，勤敲代码。