张季跃 201771010139《面向对象程序设计（java）》第九周学习总结

• Z时代
• 2024-01-10
• 分类：综合

张季跃 201771010139《面向对象程序设计（java）》第九周学习总结

第一部分：理论知识学习部分

1. 异常的概念：

（1）异常:在程序的执行过程中所发生的异常事件，它 中断指令的正常执行。

（2）Java的异常处理机制可以控制程序从错误产生的 位置转移到能够进行错误处理的位置。

（3）程序中出现的常见的错误和问题有:用户输入错误 ，设备错误， 物理限制 ，代码错误。

1. 异常分类：

（1）Java把程序运行时可能遇到的错误分为两类：

1. 非致命异常:通过某种修正后程序还能继续执行。 这类错误叫作异常。如：文件不存在、无效的数组 下标、空引用、网络断开、打印机脱机、磁盘满等。 Java中提供了一种独特的处理异常的机制，通过异 常来处理程序设计中出现的错误。

2. 致命异常：程序遇到了非常严重的不正常状态，不 能简单恢复执行，是致命性错误。

（2）Java中所有的异常类都直接或间接地继承于 Throwable类。除内置异常类外，程序员可自定义异常类，Java中的异常类可分为两大类：

1. Error Error类层次结构描述了Java运行时系统的内部错误 和资源耗尽错误。应用程序不应该捕获这类异常，也不会抛出这种异常。
2. Exception Exception类：重点掌握的异常类。Exception层次结 构又分解为两个分支：一个分支派生于 RuntimeException；另一个分支包含其他异常。
3. 抛出异常：

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

（2）声明抛出异常在方法声明中用throws子句中来指明，l以下4种情况需要方法用throws子句声明抛出异常：

–方法调用了一个抛出已检查异常的方法。

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

–程序出现错误。例如，a[-1]= 0；

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

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

（4）如何抛出异常

1. 首先决定抛出异常类型。

2. 对于已存在的异常类，抛出该类的异常对象非常容易，步骤是： –找到一个合适的异常类；

–创建这个类的一个对象；

–将该对象抛出。

C.一个方法抛出了异常后，它就不能返回调用者了。

4.断句：

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

（2）断言（assert）语法如下：

1、assert  条件

或者

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

第二部分：实验部分

1、实验目的与要求

(1) 掌握java异常处理技术；

(2) 了解断言的用法；

(3) 了解日志的用途；

(4) 掌握程序基础调试技巧；

2、实验内容和步骤

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

修改程序：

ExceptionDemo1：

package 实验1;

public class ExceptionDemo1 {

public static void main(String args[]) {

int a = 0;

System.out.println(5 / a);

}

}

ExceptionDemo2 ：

package 实验1;

import java.io.*;

public class ExceptionDemo2 {

public static void main(String args[])

     {

          FileInputStream fis = null;

try {

fis = new FileInputStream("C:\\Users\\张季跃\\Desktop\\text.txt");

} catch (FileNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}//JVM自动生成异常对象

          int b;

          try {

while((b=fis.read())!=-1)

  {

      System.out.print(b);

  }

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

          try {

fis.close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

      }

}

实验结果：

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

测试程序1：

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

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

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

程序代码：

package stackTrace;

import java.util.*;

/**

 * A program that displays a trace feature of a recursive method call.

 * @version 1.01 2004-05-10

 * @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 + "):");

      Throwable t = new Throwable();

      StackTraceElement[] frames = t.getStackTrace();

      for (StackTraceElement f : frames)

         System.out.println(f);

      int r;

      if (n <= 1) r = 1;

      else r = n * factorial(n - 1);

      System.out.println("return " + r);

      return r;

   }

   public static void main(String[] args)

   {

      Scanner in = new Scanner(System.in);

      System.out.print("Enter n: ");

      int n = in.nextInt();

      factorial(n);

   }

}

实验结果：

测试程序2：

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

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

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

修改程序：

消极处理：

package 实验2-2;

//消极处理方式

import java.io.*;

class ExceptionTest1 {

    public static void main (String args[]) throws  IOException

       {

        File fis=new File("C:\\Users\\张季跃\\Desktop\\身份证号.txt");

        FileReader fr = new FileReader(fis);

        BufferedReader br = new BufferedReader(fr);

        String s, s2 = new String();

            while ((s = br.readLine()) != null) {

                s2 += s + "\n ";

            }

            br.close();

            System.out.println(s2);

       }

}

积极处理：

package 实验2-2;

//积极处理方式　　

import java.io.*;

import java.io.BufferedReader;

import java.io.FileReader;

class ExceptionTest {

    public static void main (String args[])

 {

        File fis=new File("C:\\Users\\张季跃\\Desktop\\身份证号.txt");

     try{

         FileReader fr = new FileReader(fis);

         BufferedReader br = new BufferedReader(fr);

         try {

             String s, s2 = new String();

             while ((s = br.readLine()) != null) {

                 s2 += s + "\n ";

             }

             br.close();

             System.out.println(s2);

         } catch (IOException e) {

             // TODO Auto-generated catch block

             e.printStackTrace();

         }

     } catch (FileNotFoundException e) {

         // TODO Auto-generated catch block

         e.printStackTrace();

     }

  }

}

实验结果：

实验3: 编程练习

练习1：

l 编制一个程序，将身份证号.txt 中的信息读入到内存中；

l 按姓名字典序输出人员信息；

l 查询最大年龄的人员信息；

l 查询最小年龄人员信息；

l 输入你的年龄，查询身份证号.txt中年龄与你最近人的姓名、身份证号、年龄、性别和出生地；

l 查询人员中是否有你的同乡；

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

实验程序：

            System.out.println(s2);

       }

}

package 实验3;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.Scanner;

import java.util.Collections;

public class 实验 {

    public static People findPeopleByname(String name) {

        People flag = null;

        for (People people : peoplelist) {

            if(people.getName().equals(name)) {

                flag = people;

            }

        }

        return flag;

    }

    public static People findPeopleByid(String id) {

        People flag = null;

        for (People people : peoplelist) {

            if(people.getnumber().equals(id)) {

                flag = people;

            }

        }

        return flag;

    }

    private static ArrayList<People> agenear(int yourage) {

        // TODO Auto-generated method stub

        int j=0,min=53,d_value=0,k = 0;

        ArrayList<People> plist = new ArrayList<People>();

        for (int i = 0; i < peoplelist.size(); i++) {

            d_value = peoplelist.get(i).getage() > yourage ?

                    peoplelist.get(i).getage() - yourage : yourage - peoplelist.get(i).getage() ;

            k = d_value < min ? i : k;

            min = d_value < min ? d_value : min;

        }

        for(People people : peoplelist) {

            if(people.getage() == peoplelist.get(k).getage()) {

                plist.add(people);

            }

        }

        return plist;

    }

    private static ArrayList<People> peoplelist;

    public static void main(String[] args) {

        peoplelist = new ArrayList<People>();

        Scanner scanner = new Scanner(System.in);

        File file = new File("C:\\Users\\张季跃\\Desktop\\身份证号.txt");

        try {

            FileInputStream files = new FileInputStream(file);

            BufferedReader in = new BufferedReader(new InputStreamReader(files));

            String temp = null;

            while ((temp = in.readLine()) != null) {

                String[] information = temp.split("[ ]+");

                People people = new People();

                people.setName(information[0]);

                people.setnumber(information[1]);

                int A = Integer.parseInt(information[3]);

                people.setage(A);

                people.setsex(information[2]);

                for(int j = 4; j<information.length;j++) {

                    people.setplace(information[j]);

                }

                peoplelist.add(people);

            }

        } catch (FileNotFoundException e) {

            System.out.println("文件未找到");

            e.printStackTrace();

        } catch (IOException e) {

            System.out.println("文件读取错误");

            e.printStackTrace();

        }

        boolean isTrue = true;

        while (isTrue) {

            System.out.println("******************************************");

            System.out.println("   1.按顺序输出人员信息");

            System.out.println("   2.查询年龄最大人员的信息");

            System.out.println("   3.查询年龄最小人员的信息");

            System.out.println("   4.查询身份证号.txt中年龄与输入年龄最近的人");

            System.out.println("   5.查询人员中是否有输入地址的同乡");

            System.out.println("   6.退出");

            System.out.println("******************************************");

            int nextInt = scanner.nextInt();

            switch (nextInt) {

            case 1:

                Collections.sort(peoplelist);

                System.out.println(peoplelist.toString());

                break;

            case 2:

                int max=0;

                int j,k1 = 0;

                for(int i=1;i<peoplelist.size();i++)

                {

                    j = peoplelist.get(i).getage();

                   if(j>max)

                   {

                       max = j;

                       k1 = i;

                   }

                }  

                System.out.println("年龄最大："+peoplelist.get(k1));

                break;

            case 3:

                int min = 100;

                int j1,k2 = 0;

                for(int i=1;i<peoplelist.size();i++)

                {

                    j1 = peoplelist.get(i).getage();

                    if(j1<min)

                    {

                        min = j1;

                        k2 = i;

                    }

                 }

                System.out.println("年龄最小："+peoplelist.get(k2));

                break;

            case 4:

                System.out.println("年龄：");

                int input_age = scanner.nextInt();

                ArrayList<People> plist = new ArrayList<People>();

                plist = agenear(input_age);

                for(People people : plist) {

                    System.out.println(people.toString());

                }

                break;

            case 5:

                System.out.println("请输入省份");

                String find = scanner.next();        

                for (int i = 0; i <peoplelist.size(); i++)

                {

                    String [] place = peoplelist.get(i).getplace().split("\t");

                    for(String temp : place) {

                        if(find.equals(temp)) {

                            System.out.println("    "+peoplelist.get(i));

                            break;

                        }

                    }

                }

                break;

            case 6:

                isTrue = false;

                System.out.println("再见!");

                break;

            default:

                System.out.println("输入有误");

            }

        }

    }

}

package 实验3;

public class People implements Comparable<People> {

    private    String name = null;

    private    String number = null;

    private    int age = 0;

    private    String sex = null;

    private    String place = null;

    public String getName()

    {

        return name;

    }

    public void setName(String name)

    {

        this.name = name;

    }

    public String getnumber()

    {

        return number;

    }

    public void setnumber(String number)

    {

        this.number = number;

    }

    public int getage()

    {

        return age;

    }

    public void setage(int age )

    {

        this.age = age;

    }

    public String getsex()

    {

        return sex;

    }

    public void setsex(String sex )

    {

        this.sex = sex;

    }

    public String getplace()

    {

        return place;

    }

    public void setplace(String place)

    {

        if(this.place == null) {

            this.place = place;

        }else {

            this.place = this.place+ "\t" +place;

        }

    }

    public int compareTo(People o)

    {

        return this.name.compareTo(o.getName());

    }

    public String toString()

    {

return  name+"\t"+sex+"\t"+age+"\t"+number+"\t"+place+"\n";

    }

}

实验结果：

练习2：

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

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

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

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

实验程序：        

package 实验3-2;

import java.util.Random;

import java.util.Scanner;

public class 实验3{

int sum;

public static void main(String[] args) {

实验3 t=new 实验3();

System.out.println("考试开始");

t.sum=0;

Random r=new Random();

for(int i=0;i<10;i++) {

t.core();

}

System.out.println("考试结束");

System.out.println("你的总分为"+t.sum);

}

private void core() {

Random r=new Random();

int m,n;

m=r.nextInt(11);

n=m%4;

switch(n) {

case 0:

int a ,b,c;

a=r.nextInt(101);

b=r.nextInt(101);

System.out.println(a+"+"+"("+b+")"+"=");

Scanner x=new Scanner(System.in);

c=x.nextInt();

if(c!=a+b)

System.out.println("计算失误");

else {

System.out.println("计算正确");

sum=sum+10;

}

break;

case 1:

int h,g,f;

h=r.nextInt(101);

g=r.nextInt(101);

System.out.println(h+"-"+"("+g+")"+"= ");

Scanner u=new Scanner(System.in);

f=u.nextInt();

if(f!=h-g)

System.out.println("计算失误");

else {

System.out.println("计算正确");

sum=sum+10;

}

break;

case 2:

int q,w,e;

q=r.nextInt(101);

w=r.nextInt(101);

System.out.println(q+"*"+"("+w+")"+"= ");

  Scanner y=new Scanner(System.in);

e=y.nextInt();

if(e!=q*w)

System.out.println("计算失误");

else {

System.out.println("计算正确");

sum=sum+10;

}

break;

case 3:

double j,k,l;

j=r.nextInt(101);

k=r.nextInt(101);

if(k==0)

k++;

System.out.println(j+"/"+"("+k+")"+"= ");

Scanner z=new Scanner(System.in);

l=z.nextDouble();

if(l!=(j/k)/1.00)

System.out.println("计算失误");

else {

System.out.println("计算正确");

sum=sum+10;

}

break;

}

}

}  

实验结果：

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

实验程序1：

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

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

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

实验结果：

实验程序2：

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

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

实验程序：

package logging;

import java.awt.*;

import java.awt.event.*;

import java.io.*;

import java.util.logging.*;

import javax.swing.*;

/**

 * A modification of the image viewer program that logs various events.

 * @version 1.03 2015-08-20

 * @author Cay Horstmann

 */

public class LoggingImageViewer

{

   public static void main(String[] args)

   {

      if (System.getProperty("java.util.logging.config.class") == null

            && System.getProperty("java.util.logging.config.file") == null)

      {

         try

         {

            Logger.getLogger("com.horstmann.corejava").setLevel(Level.ALL);

            final int LOG_ROTATION_COUNT = 10;

            Handler handler = new FileHandler("%h/LoggingImageViewer.log", 0, LOG_ROTATION_COUNT);

            Logger.getLogger("com.horstmann.corejava").addHandler(handler);

         }

         catch (IOException e)

         {

            Logger.getLogger("com.horstmann.corejava").log(Level.SEVERE,

                  "Can't create log file handler", e);

         }

      }

      EventQueue.invokeLater(() ->

            {

               Handler windowHandler = new WindowHandler();

               windowHandler.setLevel(Level.ALL);

               Logger.getLogger("com.horstmann.corejava").addHandler(windowHandler);

               JFrame frame = new ImageViewerFrame();

               frame.setTitle("LoggingImageViewer");

               frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

               Logger.getLogger("com.horstmann.corejava").fine("Showing frame");

               frame.setVisible(true);

            });

   }

}

/**

 * The frame that shows the image.

 */

class ImageViewerFrame extends JFrame

{

   private static final int DEFAULT_WIDTH = 300;

   private static final int DEFAULT_HEIGHT = 400;   

   private JLabel label;

   private static Logger logger = Logger.getLogger("com.horstmann.corejava");

   public ImageViewerFrame()

   {

      logger.entering("ImageViewerFrame", "<init>");      

      setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);

      // set up menu bar

      JMenuBar menuBar = new JMenuBar();

      setJMenuBar(menuBar);

      JMenu menu = new JMenu("File");

      menuBar.add(menu);

      JMenuItem openItem = new JMenuItem("Open");

      menu.add(openItem);

      openItem.addActionListener(new FileOpenListener());

      JMenuItem exitItem = new JMenuItem("Exit");

      menu.add(exitItem);

      exitItem.addActionListener(new ActionListener()

         {

            public void actionPerformed(ActionEvent event)

            {

               logger.fine("Exiting.");

               System.exit(0);

            }

         });

      // use a label to display the images

      label = new JLabel();

      add(label);

      logger.exiting("ImageViewerFrame", "<init>");

   }

   private class FileOpenListener implements ActionListener

   {

      public void actionPerformed(ActionEvent event)

      {

         logger.entering("ImageViewerFrame.FileOpenListener", "actionPerformed", event);

         // set up file chooser

         JFileChooser chooser = new JFileChooser();

         chooser.setCurrentDirectory(new File("."));

         // accept all files ending with .gif

         chooser.setFileFilter(new javax.swing.filechooser.FileFilter()

            {

               public boolean accept(File f)

               {

                  return f.getName().toLowerCase().endsWith(".gif") || f.isDirectory();

               }

               public String getDescription()

               {

                  return "GIF Images";

               }

            });

         // show file chooser dialog

         int r = chooser.showOpenDialog(ImageViewerFrame.this);

         // if image file accepted, set it as icon of the label

         if (r == JFileChooser.APPROVE_OPTION)

         {

            String name = chooser.getSelectedFile().getPath();

            logger.log(Level.FINE, "Reading file {0}", name);

            label.setIcon(new ImageIcon(name));

         }

         else logger.fine("File open dialog canceled.");

         logger.exiting("ImageViewerFrame.FileOpenListener", "actionPerformed");

      }

   }

}

/**

 * A handler for displaying log records in a window.

 */

class WindowHandler extends StreamHandler

{

   private JFrame frame;

   public WindowHandler()

   {

      frame = new JFrame();

      final JTextArea output = new JTextArea();

      output.setEditable(false);

      frame.setSize(200, 200);

      frame.add(new JScrollPane(output));

      frame.setFocusableWindowState(false);

      frame.setVisible(true);

      setOutputStream(new OutputStream()

         {

            public void write(int b)

            {

            } // not called

            public void write(byte[] b, int off, int len)

            {

               output.append(new String(b, off, len));

            }

         });

   }

   public void publish(LogRecord record)

   {

      if (!frame.isVisible()) return;

      super.publish(record);

      flush();

   }

}

实验结果：

实验程序3：

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

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

第三部分：实验总结：

     通过本周的学习，我对于Java程序运行中出现的异常与错误有了更深的理解，并初步了解了如何解决一些简单的错误与异常。但是在实验过程中，我发现我尽管能解决掉一些错误，但对于这些错误所代表的意义还是不太了解,而且对于实验3-2，我还是有好多不懂的地方，即使请教了很多同学也有失误，左后还是和同学一起参考网上的示例程序才完成的。此外，这一周我们还初步对断句进行了学习。

以上是 张季跃 201771010139《面向对象程序设计（java）》第九周学习总结 的全部内容， 来源链接： utcz.com/z/390336.html