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

java

张季跃 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,结合程序运行结果理解程序,掌握未检查异常和已检查异常的区别。

//异常示例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();

      }

}

修改程序:

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 掌握两种异常处理技术的特点。

//积极处理方式  

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");

     }

}

修改程序:

消极处理:

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:

//断言程序示例

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);

    }

}

 

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

回到顶部