张季跃 201771010139《面向对象程序设计（java）》第九周学习总结
张季跃 201771010139《面向对象程序设计（java）》第九周学习总结
第一部分：理论知识学习部分
- 异常的概念：
（1）异常:在程序的执行过程中所发生的异常事件，它 中断指令的正常执行。
（2）Java的异常处理机制可以控制程序从错误产生的 位置转移到能够进行错误处理的位置。
（3）程序中出现的常见的错误和问题有:用户输入错误 ，设备错误， 物理限制 ，代码错误。
- 异常分类：
（1）Java把程序运行时可能遇到的错误分为两类：
- 非致命异常:通过某种修正后程序还能继续执行。 这类错误叫作异常。如：文件不存在、无效的数组 下标、空引用、网络断开、打印机脱机、磁盘满等。 Java中提供了一种独特的处理异常的机制，通过异 常来处理程序设计中出现的错误。
- 致命异常：程序遇到了非常严重的不正常状态，不 能简单恢复执行，是致命性错误。
（2）Java中所有的异常类都直接或间接地继承于 Throwable类。除内置异常类外，程序员可自定义异常类，Java中的异常类可分为两大类：
- Error Error类层次结构描述了Java运行时系统的内部错误 和资源耗尽错误。应用程序不应该捕获这类异常，也不会抛出这种异常。
- Exception Exception类：重点掌握的异常类。Exception层次结 构又分解为两个分支：一个分支派生于 RuntimeException；另一个分支包含其他异常。
- 抛出异常：
（1）声明抛出异常：如果一个方法可能会生成一些异 常，但是该方法并不确切知道如何对这些异常事 件进行处理，此时，这个方法就需声明抛出这些异常。
（2）声明抛出异常在方法声明中用throws子句中来指明，l以下4种情况需要方法用throws子句声明抛出异常：
–方法调用了一个抛出已检查异常的方法。
–程序运行过程中可能会发生错误，并且利用throw语句 抛出一个已检查异常对象。
–程序出现错误。例如，a[-1]= 0；
–Java虚拟机和运行时库出现的内部异常。
（3）当Java应用程序出现错误时，会根据错误类型产 生一个异常对象，这个对象包含了异常的类型和 错误出现时程序所处的状态信息。把异常对象递交给Java编译器的过程称为抛出。
（4）如何抛出异常
- 首先决定抛出异常类型。
- 对于已存在的异常类，抛出该类的异常对象非常容易，步骤是： –找到一个合适的异常类；
–创建这个类的一个对象；
–将该对象抛出。
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，我还是有好多不懂的地方，即使请教了很多同学也有失误，左后还是和同学一起参考网上的示例程序才完成的。此外，这一周我们还初步对断句进行了学习。
