博文正文开头格式:(2分)

项目

内容

这个作业属于哪个课程

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

这个作业的要求在哪里

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

作业学习目标

(1) 掌握接口定义方法;

(2) 掌握实现接口类的定义要求;

(3) 掌握实现了接口类的使用要求;

(4) 掌握程序回调设计模式;

(5) 掌握Comparator接口用法;

(6) 掌握对象浅层拷贝与深层拷贝方法;

(7) 掌握Lambda表达式语法;

(8) 了解内部类的用途及语法要求。

随笔博文正文内容包括:

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

7.1 处理错误

如果由于出现错误而是的某些操作没有完成,程序应该;
返回到一张安全状态,并能够让用户执行一些其他的命令
允许用户保存所有操作的结果,并以妥善的方式终止程序
异常处理的任务就是将控制权从错误产生的地方转移给能够处理的错误处理器
在java中,如果某个方法不能够采用正常的途径完整它的任务,就可以通过另外一个途径退出方法。在这种情况下,方法并不能够返回任何值,而是抛出一个封装了错误信息的对象
在Java程序设计语言中,异常对象都是派生于Trowable类得到一个示例,如果java中内置的异常类不能够满足需求,用户可以创建自己的异常类
所有异常都是由trowable类继承而来,但在下一层立即分解为两个分支:Error和Exception
Error类层次结构描述了java运行时系统的内部错误和资源耗尽错误。应用程序不应该抛出这种类型的对象。如果出现类这样的内部错误,除了报告给用户,并尽力使程序安全的终止外,再也无能无力类,这种情况很少遇见。
在设计Java程序时,需要关注Exception层次结构,这个层次结构又分解为两个分支:一个分支派生于RuntimeException;另一个包含其他异常。划分两个分支的规则是:由程序错误导致的异常属于RuntionException;而程序本身没有问题,但像I/O错误这类问题导致的异常属于其他异常
派生于RuntimeException的异常包含下面几种情况:
错误的类型转换
数组访问越界
访问null指针
不是派生与RuntimeException的异常包括:
试图在文件尾部苟免读取数据
试图打开一个不存在的文件
试图根据给定的字符串查找Class对象,而这个字符串表示的类并不存在
“如果出现RuntimeEeception异常,就一定是你的问题”
Java语言规范将派生于Error类或RuntimeException类的所有异常成为非受查异常,所有其他的异常成为受查异常。这是两个很有用的术语。
方法应该在首部声明所有可能抛出的异常。这样可以从首部反映出这个方法可能抛出哪类受查异常。(thows)
如果一个方法可能抛出多个受查异常类型,那么就必须在方法的首部李处所有的异常类。每个异常类之间用逗号隔开。但是,不需要声明Java的内部错误,即从Error继承的异常。任何程序都具有抛出哪些异常的潜能,而我们对其没有任何控制能力。
我们必须catch的是受查异常(IOException),像数组越界等非受查异常,不需要捕获。总之,一个方法必须声明所有可能抛出的受查异常。如果方法没有申明所有kennel发生的受查异常,编译器就回发出一个错误信息。
子类方法中可以抛出更特定的异常,或则根本不抛出任何异常。如果超类没有抛出任何异常,子类也不能抛出任何受查异常。
关键词:
throws:列出这个方法可能抛出的异常
throw:已经产生类异常,需要抛出。一般用于自定义异常
try——catch:如果有,捕获异常
在Java中,只能抛出Trowable子类的对象
7.2 捕获异常

如果某个异常发生的时候没有在任何地方捕获,程序就回终止,并在控制台打印出异常信息。要想捕获一个异常,必须设置try/catch语句块
如果调用了一个抛出受查异常的方法,就必须对它进行处理或者继续传递
不允许在子类的throws说明符中出现超过超类方法说列出的异常范围
7.3 只用异常机制的技巧

异常处理不能代替简单的测试
不要过分的细化异常
利用异常层次结构
不要压制异常
在检测错误时,“苟刻”要比放任更好
不要羞于传递异常
7.4 断言

断言是一种测试和调试阶段所使用的工具,断言机制允许在测试期间向代码中插入一些检查语句,当代码发布的时候这些插入的检测语句将会被自动移走

断言的语法规则如下,这两种方式都会对条件进行检测,如果为false就抛出一个AssertionError异常,在第二种形式中,表达式就作为一条字符串传入AssertionError构造器,转换成消息字符串

assert 条件;

assert 条件:表达式; —— 这里表达式就可以理解成字符串

运行程序时可以使用-enableassertions或-ea参数启用断言

7.5日志

全局日志记录(global logger)

Logger.getGlobal().info("test");

Logger.getGlobal().serLevel(Level.OFF);

可以使用getLogger方法创建或获取记录器,未被任何变量引用的日志记录器可能会被垃圾回收,所以可以使用静态变量存储日志记录器的一个引用

private static final Logger myLogger = Logger.getLogger("com.mycompany.myapp");

日志记录器有7个级别

SERVER

WARNING

INFO

CONFIG

FINE

FINER

FINEST

可以使用Level.ALL开启所有级别的记录,使用Level.OFF关闭所有级别的记录

第二部分:实验部分

实验1:(5分)

用命令行与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();

}

}

运行结果如下:

总结:java中异常分为两类:checked exception(检查异常)和unchecked exception(未检查异常),对于未检查异常也叫RuntimeException(运行时异常).
对未检查的异常(unchecked exception )的几种处理方式:
1、捕获
2、继续抛出
3、不处理
对检查的异常(checked exception,除了RuntimeException,其他的异常都是checked exception )的几种处理方式:
1、继续抛出,消极的方法,一直可以抛到java虚拟机来处理
2、用try...catch捕获

实验2:测试程序1(5分)

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.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)     //求n的阶乘
   {
      System.out.println("factorial(" + n + "):");
      StackWalker walker = StackWalker.getInstance();    //创建一个表示指定执行点的堆栈跟踪元素walker,调用getInstance()方法
      walker.forEach(System.out::println);     
      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)
   {
      try (Scanner in = new Scanner(System.in))   //try子句
      {
         System.out.print("Enter n: ");
         int n = in.nextInt();
         factorial(n);
      }
   }
}
运行结果如下:

实验2:测试程序2(10分)

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

//积极处理方式  

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");
     }
}
下列两个简单程序范例给出了两种异常处理的代码格式。在elipse IDE中编辑、调试运行源程序ExceptionTest.java,将程序中的text文件更换为身份证号.txt,要求将文件内容读入内容,并在控制台显示;
掌握两种异常处理技术的特点。
实验代码如下:
//积极处理方式<br>import java.io.*;

 
class ExceptionTest {
    public static void main (String args[])
   {
         
       try{
           FileInputStream fis=new FileInputStream("D:\\身份证号.txt");
           BufferedReader in = new BufferedReader(new InputStreamReader(fis));
           String s = new String();
           while ((s = in.readLine()) != null) {
               System.out.println(s);
           }
           in.close();
           fis.close();
       }
       catch (FileNotFoundException e) {
           System.out.println("文件找不到");
           e.printStackTrace();
       catch (IOException e) {
           System.out.println("文件读取错误");
           e.printStackTrace();
       }
}
}
运行结果如下:

//消极处理方式

 
import java.io.*;
  
public class ExceptionTest {
    public static void main (String args[]) throws IOException
   {
           
       try{
           FileInputStream fis=new FileInputStream("D:\\身份证号.txt");
           BufferedReader in new BufferedReader(new InputStreamReader(fis));
           String s = new String();
           while ((s = in.readLine()) != null) {
               System.out.println(s);
           }
           in.close();
           fis.close();
       }
       finally {
             
       }
   
   }
}
运行结果如下:

实验3:编程练习(25分)

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

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

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

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

实验代码如下:

import java.util.Scanner;

import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Random;
 
public class Demo {
    public static void main(String[] args) {
 
        Scanner in new Scanner(System.in);
        Number counter = new Number();
        PrintWriter out null;
        try {
            out new PrintWriter("text.txt");
        catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            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 == counter.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 == counter.multiplication(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 == counter.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 == counter.reduce(a, b)) {
                    sum += 10;
                    System.out.println("恭喜答案正确");
                else {
                    System.out.println("抱歉,答案错误");
                }
                break;
 
            }
 
        }
        System.out.println("成绩" + sum);
        out.println("成绩:" + sum);
        out.close();
 
    }
}
 
public class Number {

    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 multiplication(int a, int b) {
        return a * b;
    }
 
    public int division(int a, int b) {
        if (b != 0)
            return a / b;
        else
            return 0;
    }
 
}
运行结果如下:

实验4:测试程序1(5分)

测试程序1

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

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

l  掌握断言的使用特点及用法。(5分)

实验代码如下:

 //断言程序示例

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);
    }
}
运行结果如下:

 

实验4:测试程序2(5分)

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

l  并掌握Java日志系统的用途及用法。(5分)

实验代码如下:

//断言程序示例

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);
    }
}
运行结果如下:

实验4:测试程序3(5分)

用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;
            FileHandler 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(() ->
            {
               WindowHandler windowHandler = new WindowHandler();
               windowHandler.setLevel(Level.ALL);
               Logger.getLogger("com.horstmann.corejava").addHandler(windowHandler);
  
               ImageViewerFrame 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();
      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();
   }
}

实验总结:(15分)

这周主要学习了程序产生的异常以及如何解决程序中产生的异常。异常时在程序的执行过程中所发生的非正常事件,它中断指令的正常执行。因此在编写代码时需要及时处理这些错误。对于异常处理,在理论课上听的不是很明白,但在实验课上通过学长演示程序,用抛出异常和将可能出错的语句放入try子句中两种方法,基本理解了异常的产生的原因和解决方法。但对于断言以及日志等内容,还是不明白,以后的日子里需要更努力学习。

201871010118-唐敬博《面向对象程序设计(java)》第十周学习总结的更多相关文章

  1. 201771010134杨其菊《面向对象程序设计java》第九周学习总结

                                                                      第九周学习总结 第一部分:理论知识 异常.断言和调试.日志 1.捕获 ...

  2. 201871010132-张潇潇《面向对象程序设计(java)》第一周学习总结

    面向对象程序设计(Java) 博文正文开头 项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cn ...

  3. 扎西平措 201571030332《面向对象程序设计 Java 》第一周学习总结

    <面向对象程序设计(java)>第一周学习总结 正文开头: 项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 ...

  4. 201871010124 王生涛《面向对象程序设计JAVA》第一周学习总结

    项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://edu.cnblogs.com/campus/xbsf/ ...

  5. 杨其菊201771010134《面向对象程序设计Java》第二周学习总结

    第三章 Java基本程序设计结构 第一部分:(理论知识部分) 本章主要学习:基本内容:数据类型:变量:运算符:类型转换,字符串,输入输出,控制流程,大数值以及数组. 1.基本概念: 1)标识符:由字母 ...

  6. 201871010115——马北《面向对象程序设计JAVA》第二周学习总结

    项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p ...

  7. 201777010217-金云馨《面向对象程序设计(Java)》第二周学习总结

    项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p ...

  8. 201871010132——张潇潇《面向对象程序设计JAVA》第二周学习总结

    项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p ...

  9. 201771010123汪慧和《面向对象程序设计Java》第二周学习总结

    一.理论知识部分 1.标识符由字母.下划线.美元符号和数字组成, 且第一个符号不能为数字.标识符可用作: 类名.变量名.方法名.数组名.文件名等.第二部分:理论知识学习部分 2.关键字就是Java语言 ...

  10. 20155303 2016-2017-2 《Java程序设计》第十周学习总结

    20155303 2016-2017-2 <Java程序设计>第十周学习总结 目录 学习内容总结 网络编程 数据库 教材学习中的问题和解决过程 代码调试中的问题和解决过程 代码托管 上周考 ...

随机推荐

  1. day54_9_18视图层某内部原理(fbv和cbv)与模板层

    一.render内部原理. 在render中往往需要返回三个参数,request,模板和一些键值对. 键值对中存储的是需要对模板渲染的值. 如果手动实现可以如下: from django.templa ...

  2. 【转】springboot结合swagger生成接口文档

    前后台分离的开发渐渐已成趋势.那么前后端的沟通就成了问题,包括移动端,web端.如果有一个东西在我们写完代码的时候,自动将接口的所有注释,调用文档提供出来,是不是一件很美好的事情.那就是使用swagg ...

  3. 题解:openjudge 1.11——01

    题目 思路:二分查找 来,上代码 #include<cstdio> #include<iostream> using namespace std; +]; int n,m; i ...

  4. pointcnn

    这篇论文先举例子解释了为什么卷积无法直接应用在点云数据上. 如图1, 传统的卷积是作用在2维图像数据上.图像中每个像素的顺序是固定的,也就是说数据是结构化存储的.直接使用conv2d就能从这种潜在的空 ...

  5. 设计模式-Builder模式(创建型模式)

    //以下代码来源: 设计模式精解-GoF 23种设计模式解析附C++实现源码 //Product.h #pragma once class Product { public: Product(); ~ ...

  6. 冒泡排序法(C语言)

    冒泡排序(Bubble Sort)一种计算机科学领域的较简单的排序算法.它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果顺序(如从大到小.首字母从从Z到A)错误就把他们交换过来.走访元素的工 ...

  7. Vue 变异方法splice删除评论功能

    <!doctype html> <html lang="en"> <head> <meta charset="UTF-8&quo ...

  8. CF 938G Shortest Path Queries

    又到了喜闻乐见的写博客清醒时间了233,今天做的依然是线段树分治 这题算是经典应用了吧,假的动态图(可离线)问题 首先不难想到对于询问的时间进行线段树分治,这样就可以把每一条边出现的时间区间扔进线段树 ...

  9. 如何在Console下面生成一个WIN32窗口

    一个小挑战? VS2017里面,新建一个控制台工程,输入名字(你不需要也成,有默认的),得到一个控制台工程. 好了,生成的代码,如下: // Win32InConsole.cpp : This fil ...

  10. 有关tab页的

    有关tab页的 1.静态的 2.动态的可以删除的 3.删除右侧,左侧,全部,除了自己以外的. 4.多了可以自动伸缩. 5.带shown事件.可以反向影响菜单去.