201871010114-李岩松《面向对象程序设计(java)》第十周学习总结

项目

内容

这个作业属于哪个课程

https://www.cnblogs.com/nwnu-daizh/

这个作业的要求在哪里

https://www.cnblogs.com/nwnu-daizh/p/11435127.html

作业学习目标

1.掌握java异常处理技术;

2.了解断言的用法;

3.了解日志的用途;

4.掌握程序基础调试技巧。

 

第一部分:总结第七章关于异常处理相关理论知识

 

 

 

 

1.1 异常概念

异常,就是不正常的意思。在生活中:医生说,你的身体某个部位有异常,该部位和正常相比有点不同,该部位的功能将受影响.在程序中的意思就是:

  异常 :指的是程序在执行过程中,出现的非正常的情况,最终会导致JVM的非正常停止

在Java等面向对象的编程语言中,异常本身是一个类,产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行.

1.2 异常体系

异常机制其实是帮助我们找到程序中的问题,异常的根类是 java.lang.Throwable ,其下有两个子类:java.lang.Error 与 java.lang.Exception ,平常所说的异常指 java.lang.Exception 。

 

 

 

Throwable体系:

  Error:严重错误Error,无法通过处理的错误,只能事先避免,好比绝症。

  Exception:表示异常,异常产生后程序员可以通过代码的方式纠正,使程序继续运行,是必须要处理的。好比感冒、阑尾炎。

Throwable中的常用方法:

public void printStackTrace() :打印异常的详细信息。

包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace

public String getMessage() :获取发生异常的原因。

提示给用户的时候,就提示错误原因。

public String toString() :获取异常的类型和异常描述信息(不用)。

 出现异常,不要紧张,把异常的简单类名,拷贝到API中去查。

 

 

 

1.3 异常分类

 我们平常说的异常就是指Exception,因为这类异常一旦出现,我们就要对代码进行更正,修复程序。

异常(Exception)的分类:根据在编译时期还是运行时期去检查异常?

  编译时期异常:checked异常。在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常)

  运行时期异常:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。(如数学异常)

 

1.4         异常的产生过程解析

 先运行下面的程序,程序会产生一个数组索引越界异常ArrayIndexOfBoundsException。我们通过图解来解析下异常产生的过程。

 

public class ArrayTools {

//    对给定的数组通过给定的角标获取元素。

public static int getElement(int[] arr, int index) { int element = arr[index];

return element;

}

}

工具类

ublic class ExceptionDemo {

public static void main(String[] args) {

int[] arr = { 34, 12, 67 };

intnum = ArrayTools.getElement(arr, 4)

System.out.println("num=" + num);

System.out.println("over");

}

}

上述程序执行过程图解:

 

 

 第二章 异常的处理

 

Java异常处理的五个关键字:trycatchfinallythrowthrows

 

2.1 抛出异常throw

 

在编写程序时,我们必须要考虑程序出现问题的情况。比如,在定义方法时,方法需要接受参数。那么,当调用方法使用接受到的参数时,首先需要先对参数数据进行合法的判断,数据若不合法,就应该告诉调用者,传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。

 java中,提供了一个throw关键字,它用来抛出一个指定的异常对象。那么,抛出一个异常具体如何操作呢?

 1.创建一个异常对象。封装一些提示信息(信息可以自己编写)

 2.需要将这个异常对象告知给调用者。怎么告知呢?怎么将这个异常对象传递到调用者处呢?通过关键字throw就可以完成。throw 异常对象。throw用在方法内,用来抛出一个异常对象,将这个异常对象传递到调用者处,

并结束当前方法的执行。

 使用格式:

throw new 异常类名(参数);

例如:

throw new NullPointerException("要访问的arr数组不存在");

throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在,已超出范围");

我们通过下面程序演示下throw的使用。

public class ThrowDemo {

public static void main(String[] args) {

//创建一个数组

int[] arr = {2,4,52,2};

//根据索引找对应的元素

int index = 4;

int element = getElement(arr, index);

System.out.println(element);

System.out.println("over");

}

/*

*    根据 索引找到数组中对应的元素

*/

public static int getElement(int[] arr,int index){

//判断    索引是否越界

if(index<0 || index>arr.length‐1){

/*

判断条件如果满足,当执行完throw抛出异常对象后,方法已经无法继续运算。

这时就会结束当前方法的执行,并将异常告知给调用者。这时就需要通过异常来解决。

*/

throw new ArrayIndexOutOfBoundsException("哥们,角标越界了~~~");

}

int element = arr[index];

return element;

}

}

2.3 声明异常throws

声明异常:将问题标识出来,报告给调用者。如果方法内通过throw抛出了编译时异常,而没有捕获处理(稍后讲解该方式),那么必须通过throws进行声明,让调用者去处理。

 关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).

 声明异常格式:

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{    }

声明异常的代码演示:

public class ThrowsDemo {

public static void main(String[] args) throws FileNotFoundException { read("a.txt");

}

//    如果定义功能时有问题发生需要报告给调用者。可以通过在方法上使用throws关键字进行声明 public static void read(String path) throws FileNotFoundException {

if (!path.equals("a.txt")) {//如果不是 a.txt这个文件

//    我假设 如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常 throw

throw new FileNotFoundException("文件不存在");

}

}

}

throws用于进行异常类的声明,若该方法可能有多种异常情况产生,那么在throws后面可以写多个异常类,用逗号隔开。

public class ThrowsDemo2 {

public static void main(String[] args) throws IOException { read("a.txt");

}

public static void read(String path)throws FileNotFoundException, IOException { if (!path.equals("a.txt")) {//如果不是 a.txt这个文件

//    我假设 如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常 throw throw new FileNotFoundException("文件不存在");

}

if (!path.equals("b.txt")) {

throw new IOException();

}

}

}

2.4 捕获异常try…catch

 

如果异常出现的话,会立刻终止程序,所以我们得处理异常:

1. 该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)

2. 在方法中使用try-catch的语句块来处理异常。

try-catch的方式就是捕获异常。

 捕获异常:Java中对异常有针对性的语句进行捕获,可以对出现的异常进行指定方式的处理。

 

捕获异常语法如下:

try{

编写可能会出现异常的代码

}catch(异常类型    e){

处理异常的代码

//记录日志/打印异常信息/继续抛出异常

}

try:该代码块中编写可能产生异常的代码。

 

catch:用来进行某种异常的捕获,实现对捕获到的异常进行处理。

 

注意:trycatch都不能单独使用,必须连用。

 

 

演示如下:

public class TryCatchDemo {

public static void main(String[] args) {

try {// 当产生异常时,必须有处理方式。要么捕获,要么声明。

read("b.txt");

} catch (FileNotFoundException e) {// 括号中需要定义什么呢?

//try中抛出的是什么异常,在括号中就定义什么异常类型

System.out.println(e);

}

System.out.println("over");

}

/*

*

*    我们 当前的这个方法中 有异常 有编译期异常

*/

public static void read(String path) throws FileNotFoundException { if (!path.equals("a.txt")) {//如果不是 a.txt这个文件

//    我假设 如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常 throw throw new FileNotFoundException("文件不存在");

}
}

}

 

1、实验目的与要求

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

(2) 了解断言的用法;

(3) 了解日志的用途;

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

2、实验内容和步骤

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

package week11.test;

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

运行结果:

 

 

 

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:

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

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

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

package week11.test;

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)
   {
//调用Throwable类的getStackTrace方法访问栈堆轨迹的文本描述信息

System.out.println("factorial("+n+"):");

Throwable t=new Throwable();
       StackTraceElement[] frames=t.getStackTrace();
       for(StackTraceElement f:frames)//遍历fames数组
           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中编辑、调试运行源程序ExceptionTest.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");

     }

}

 
 

//积极处理
import java.io.*;
class ExceptionDemo1 {
public static void main (String args[])
{
File fis=new File("身份证号.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();
}

}

 

//消极处理方式

import java.io.*;
class ExceptionDemo1 {
    public static void main (String args[]) throws  IOException
       {
        File fis=new File("身份证号.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);
       }
}

 

运行结果:

积极处理方式:

 

 消极处理方式:

 

 

实验3: 编程练习

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

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

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

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

注:以下实验课后完成

package week11.test;

public class Calculation {
    private int a;
    private int b;
    
    public int add(int a,int b)
    {
        return a+b;
    }
    public int reduce(int a,int b)
    {
        return a-b;
    }
    public int mutli(int a,int b)
    {
        return a*b;
    }
    public int division(int a,int b)
    {
        if(b!=0)
        {
            return a/b;
        }
        return 0;
    }


}
package week11.test;

import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Random;
import java.util.Scanner;

public class CaclusionTest {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        Calculation  result=new Calculation();
        PrintWriter out=null;
        try {
                out=new  PrintWriter("test.txt");
        }catch(FileNotFoundException e) {
        
         e.printStackTrace();
        }        
        int sum=0;
        
        for(int i=1;i<=10;i++)
        {
            int a=(int)Math.round(Math.random()*100);
            int b=(int)Math.round(Math.random()*100);
            int m=(int)Math.round(Math.random()*3);
        
            Random n=new Random();
        
        switch(m) {
        case 0:
            System.out.println(i+":"+a+"/"+b+"=");
            while(b==0)
            {
                 b=(int)Math.round(Math.random()*100);        
            }
            int c=in.nextInt();
            out.println(a+"/"+b+"="+c);
            if(c==result.division(a,b)) {
                sum+=10;
                System.out.println("答案正确");
            }else {
                System.out.println("答案错误");
            }
            break;
        case 1:
            System.out.println(i+":"+a+"*"+b+"=");
            int c1=in.nextInt();
            out.println(a+"*"+b+"="+c1);
            if(c1==result.mutli(a,b)) {
                sum+=10;
                System.out.println("回答正确");
            }else {
                System.out.println("回答错误");
            }
            break;
        case 2:
            System.out.println(i+":"+a+"+"+b+"=");
            int c2=in.nextInt();
            out.println(a+"+"+b+"="+c2);
            if(c2==result.add(a,b)) {
                sum+=10;
                System.out.println("回答正确");
            }else {
                System.out.println("回答错误");
            }
            break;
        case 3:
            System.out.println(i+":"+a+"-"+b+"=");
            int c3=in.nextInt();
            out.println(a+"+"+b+"="+c3);
            if(c3==result.reduce(a,b)) {
                sum+=10;
                System.out.println("回答正确");
            }else {
                System.out.println("回答错误");
            }
            break;
           }
        }
        System.out.println("你的总分是:"+sum);
        out.println("成绩:"+sum);
        out.close();
        
    }
}
        

 

 

 

运行结果:

 

 

 

 

 

 

实验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  掌握断言的使用特点及用法。

public class AssertDemo {
    public static void main(String[] args) {        
        test1(-5);
        test2(-3);
    }
    
    private static void test1(int a){
        assert a > 0;//assert宏的原型定义在<assert.h>中,作用是如果它的条件返回错误,则终止程序执行
        System.out.println(a);
    }
    private static void test2(int a){
       assert a > 0 : "这里出错了,a不能小于0";
        System.out.println(a);
    }
}

注释前结果:

 注释后断言开启结果:

实验程序2:

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

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

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

/**
 * 显示图像的帧。
 */
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);

      //设置菜单栏
      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);
            }
         });

      //使用标签显示图像
      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);

         //设置文件选择器
         JFileChooser chooser = new JFileChooser();
         chooser.setCurrentDirectory(new File("."));

         //接受以.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";
               }
            });

         //显示文件选择器对话框
         int r = chooser.showOpenDialog(ImageViewerFrame.this);

         // 如果图像文件被接受,将其设置为标签的图标
         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");
      }
   }
}

/**
 * 用于在窗口中显示日志记录的处理程序。
 */
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)
            {
            } 

            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的常用调试技术。

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

/**
 * 显示图像的帧。
 */
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);

      //设置菜单栏
      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);
            }
         });

      //使用标签显示图像
      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);

         //设置文件选择器
         JFileChooser chooser = new JFileChooser();
         chooser.setCurrentDirectory(new File("."));

         //接受以.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";
               }
            });

         //显示文件选择器对话框
         int r = chooser.showOpenDialog(ImageViewerFrame.this);

         // 如果图像文件被接受,将其设置为标签的图标
         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");
      }
   }
}

/**
 * 用于在窗口中显示日志记录的处理程序。
 */
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();
   }
}

 

1)条件断点(有一定条件的断点):在Eclipse Java 编辑区的行头双击就会得到一个断点,代码会运行到此处时停止。

在断点处点击鼠标右键,选择最后一个“Breakpoint Properties”。

2)变量断点:在变量的值初始化,或是变量值改变时可以停止。

3)方法断点:方法断点就是将断点打在方法的入口处。

4)异常断点:当异常发生时,代码会停在异常发生处。

5)重新调试:回退时,请在需要回退的线程方法上点右键,选择“Drop to Frame”。

6)单步执行程序 

7)检查变量

8)改变变量值

实验总结:在本周学习了程序产生的异常以及如何解决程序中产生的异常。异常时在程序的执行过程中所发生的非正常事件,它中断指令的正常执行。因此在编写代码时需要及时处理这些错误。基本理解了异常的产生的原因和解决方法。但对于断言以及日志等内容不太理解。因此在运行后面几个相关程序时,对程序不是很理解。以后自己也会多练习程序去了解这些知识。

获奖感想与Java阶段性学习总结

获奖感想

  • 对于期中考试后获得小黄衫倍感意外,学习java的过程刚开始是很枯燥的,但慢慢的发现其中的一些乐趣以后,就能够慢慢的去发现去探索各种java程序的应用,更是感谢助教牛百泉学长每周五坚持开直播 为我们答疑解惑,通过实践来让我们掌握学习内容,更没有想到经过自己不懈的努力,我亦有荣幸获得一件属于我的小黄衫。
  • 收获这份殊荣,喜悦之余我也感到了很大的压力。其一,小黄衫不但意味着代老师对我现阶段学习态度的肯定,也意味着更高的期望,想要不辜负这份期望与鞭策,就要继续努力做到更好。其二,小黄衫的获得者,无论是助教牛百泉学长,还是本学期的前几位同学,都是非常值得学习的人,他们的每周的博客园写的非常好,对于知识点的总结更是十分细心,以后应该更应该向他们学习,如果不更加坚实自己的脚步,最终还是会落后于别人,后面学习要更加的认真才可以。

阶段性总结

1、自主学习

从这门课程一开始,代就给我传递了自主学习的思想。它不同于我们以往接受的填鸭式教学,而是以你自己为主导去学习。这样的学习方式中,你要自己分配时间,自己查找资料,在mooc中先完成自学,在代老师的课堂上很多疑惑就会感觉到迎刃而解,同时遇到问题要自己动手解决。如同字面意思一样,在一次又一次的”doing“中,你的知识概念从模糊到清晰。起初或许会感到有些麻烦,但你会真切的感到自己能力的提高,真正的尝试思考,每一点成果都有你的思考,并且通过实践掌握的语法点更加牢固。

2、多加练习

掌握了基本的语法点以后更重要的是去不断地练习,只有不断地去写程序,我们才能感受到java语言的好处,和这个语法点在实际中不同的用途,同时遇到问题时,我们不要急于求助他人,一定要先想想自己可以怎样解决,实践中出现的问题往往可以通过新的实践来找到解决的办法。但当你遇到瓶颈,无计可施时,不妨听听别人的思路,或者上CSDN、博客园上找找答案,或许会给你的一些启发。就在这样不断的发现问题,解决问题中,我们会迭代式的得到提升。

3、贵在坚持

编程没有捷径,只有不断地坚持,才能获得更好的提升,要合理规划好自己的学习任务,在前半学期还是缺少合理规划,自主学习时间缺少坚持,后面阶段的学习要坚持练习。

猜你喜欢

转载自www.cnblogs.com/liyansong0198/p/11780113.html