实验名称：java编程基础

实验地点：10-306

所使用的工具软件及环境：

JDK1.7或1.8与Eclipse

一、实验目的：

1. 掌握包、接口、异常处理的设计方法。
2. 掌握输入输出流类。

二、实验内容：

一．了解异常处理机制，使用try…catch 语句处理异常

1．异常类型匹配的处理方式

（1）程序功能： 首先说明" 这是一个异常处理的例子", 然后在程序中主动产生一个

ArithmeticException 类型被0 除的异常， 并用catch 语句捕获这个异常。最后通过

ArithmeticException 类的对象e 的方法getMessage 给出异常的具体类型并显示出来。

（2）编写使用 try…catch 语句处理异常的程序文件LX3_1.java，源代码如下。

（3）编译并运行程序，分析说明运行结果。

注意：如果在catch 语句中声明的异常类是Exception，catch 语句也能正确地捕获，这是因为Exception 是ArithmeticException 的父类。如果不能确定会发生哪种情况的异常，那么最好指定catch的参数为Exception，即说明异常的类型为Exception。

三、源代码

//LX3_1.java

public class LX3_1 {

    public static void main(String args[]) {

        System.out.println("这是一个异常处理的例子");

        try {

            int a=2;

            int b=0;

            int c;

            c=a/b;

        }

        catch(ArithmeticException e) {

            System.out.println("异常为："+e.getMessage());

        }

    }

}

四、实验结果测试、收获与体会：

    能够运行此程序，通过简单的try…catch可以初步了解到程序的异常和系统对于异常的自动抛出，对于catch 语句中要写声明的异常类或者是异常类的父类，catch才能正确捕获。

实验名称：java编程基础

实验地点：10-306

所使用的工具软件及环境：

JDK1.7或1.8与Eclipse

一、实验目的：

1. 掌握包、接口、异常处理的设计方法。
2. 掌握输入输出流类。

二、实验内容：

2．异常类型不匹配的程序

（1）在上题的基础上修改异常类型，编写一个catch 语句中声明的异常类型不匹配的程序LX3_2.java

（2）编译并运行程序，分析说明运行结果。

三、源代码

//LX3_2.java

public class LX3_2 {

    public static void main(String args[]) {

        System.out.println("这是一个异常处理的例子");

        try {

            int a=2;

            int b=0;

            int c;

            c=a/b;

        }

        catch(IndexOutOfBoundsException e) {

            System.out.println("异常为："+e.getMessage());

        }

    }

}

四、实验结果测试、收获与体会：

在该程序中try语句抛出一个异常类ArithmeticException的异常，但是在该程序中只有异常类IndexOutOfBoundsException的异常，所以，程序可以通过编译但在运行时系统会给出没有被捕获的异常的报告。此程序明白了系统抛出的异常不是随便的catch语句就能捕获，需要与之匹配的异常类或者是异常类的父类，catch才能正确捕获。

实验名称：java编程基础

实验地点：10-306

所使用的工具软件及环境：

JDK1.7或1.8与Eclipse

一、实验目的：

1. 掌握包、接口、异常处理的设计方法。
2. 掌握输入输出流类。

二、实验内容：

3．包含多个catch 子句的异常处理程序

（1）程序功能：在try 子句中设计两个可能出现的异常，当a 为0 时会发生异常。另外一个是肯定的异常，因为数组c 的长度为1，定义c[42]是非法的。通过两个catch 子句分别来捕获异常。

（2）编写包含多个catch 子句的LX3_3.java 程序，补充完整源代码。

public class LX3_3{

public static void main(String[] args) {

try {

int a=args.length;

System.out.println("\na = "+a);

int b=42/a;

int c[]={1};

c[42]=99;

}

catch (               ) {

System.out.println("发生了被 0 除："+e);

}

catch (                  ) {

System.out.println("数组下标越界："+e);

}

}

}

（3）实验下面两种情况：

1） 在程序运行时不输入参数，则args.length 的值为0，分析运行结果。

    2） 在运行程序时，输入22，分析运行结果。  

三、源代码

//LX3_3.java

public class LX3_3{

    public static void main(String[] args) {

        try {

                int a=args.length;

                System.out.println("\na = "+a);

                int b=42/a;

                int c[]={1};

                c[42]=99;

        }

        catch (ArithmeticException e) {

            System.out.println("发生了被 0 除："+e);

        }

        catch (ArrayIndexOutOfBoundsException e) {

            System.out.println("数组下标越界："+e);

        }

    }

}

四、实验结果测试、收获与体会：

程序运行时不输入参数，此时args.length的值为0，系统会抛出一个被0除的异常，会被catch中异常类ArithmeticException的对象所捕获。程序运行时输入22，不会引起被0除的异常，但系统会抛出数组过界的异常，所以会被catch中异常类ArrayIndexOutOfBoundsException的对象所捕获。此程序了解到系统抛出异常时会自动匹配与之对于的catch语句，对try…catch更加深入学习。

实验名称：java编程基础

实验地点：10-306

所使用的工具软件及环境：

JDK1.7或1.8与Eclipse

一、实验目的：

1. 掌握包、接口、异常处理的设计方法。
2. 掌握输入输出流类。

二、实验内容：

二．使用throw 语句抛出异常

1． throw 语句的作用

在上面的实验中，可以发现，异常对象是Java 运行时由系统抛出的。抛出异常也可以通过使用throw 语句实现。throw 是Java 语言的关键字，用来告知编译器此处要发生一个异常。throw 后面要跟一个新创建的异常类对象，用于指出异常的名称和类型。

throw 语句格式为：<throw> <new> <异常对象名()>;

程序会在throw 语句处立即终止，转向try…catch 寻找异常处理方法，不再执行throw 后面的语句。

2． throw 语句的使用

（1）编写带有throw 语句的程序，源代码如下。

public class LX3_4 {

static void throwProcess() {

try {

throw new NullPointerException("空指针异常");

}

catch (NullPointerException e) {

System.out.println("\n 在 throwProcess 方法中捕获一个"+e.getMessage());

throw e;

}

}

public static void main(String args[]) {

try {

throwProcess();

}

catch (NullPointerException e) {

System.out.println("再次捕获："+e);

}

}

}

（2）编译并运行程序，分析程序运行流程。

三、源代码

//LX3_4.java

public class LX3_4 {

    static void throwProcess() {

        try {

            throw new NullPointerException("空指针异常");

        }

        catch (NullPointerException e) {

            System.out.println("\n 在 throwProcess 方法中捕获一个"+e.getMessage());

            throw e;

        }

    }

    public static void main(String args[]) {

        try {

            throwProcess();

        }

        catch (NullPointerException e) {

            System.out.println("再次捕获："+e);

        }

    }

}

四、实验结果测试、收获与体会：

调用throwProcess方法，抛出了一个NullPointerException异常，名为“空指针异常”。

然后程序在throwProcess中将寻找与NullPointerException匹配的catch语句进行捕获，输出信息。throwProcess 方法的catch子句又抛出了一个同样的异常e。然后结束

throwProcess方法的调用，执行main方法中的catch子句，再次捕获这个异常，输出信息。此程序可以深刻理解throw语句的抛出和catch的捕获，对于异常处理更明白。

实验名称：java编程基础

实验地点：10-306

所使用的工具软件及环境：

JDK1.7或1.8与Eclipse

一、实验目的：

1. 掌握包、接口、异常处理的设计方法。
2. 掌握输入输出流类。

二、实验内容：

三．使用throws 子句

1．throws 子句的作用

throws 子句一般用来表明在使用该方法时可能抛出异常但不捕获的异常。异常由系统来处理。

throws 子句也可以指出抛出异常是RuntimeException 或自定义异常类，即异常的类型，以便准备调用其它方法捕获它，这种情况一般需要两个方法来分别处理抛出异常和处理异常。

2．只是在方法中抛出异常的程序

对于程序中无法处理的异常，可以使用throws 子句在方法中抛出异常交由系统处理。

（1）程序功能：在程序中打开文件a3.txt，因为该文件可能不存在或路径不对，所以存在IOException 类型异常的可能，因此这里使用throws 来抛出异常。

（2）编写只是抛出异常的程序文件LX3_5.java，源代码如下。

import java.io.*;

public class LX3_5

{

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

{

FileInputStream fis = new FileInputStream("a3.txt");

}

}

（3）编译并运行程序，如果该文件在当前目录中不存在，将由系统自动给出异常报告。

三、源代码

//LX3_5.java

import java.io.*;

public class LX3_5{

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

    {

        FileInputStream fis = new FileInputStream("a3.txt");

    }

}

四、实验结果测试、收获与体会：

此程序中打开文件时，该目录下没有该文件，所以系统会抛出一个“系统找不到指定的文件”的异常。此程序明白了，对于文件找不到，系统会自动给出异常报告。

实验名称：java编程基础

实验地点：10-306

所使用的工具软件及环境：

JDK1.7或1.8与Eclipse

一、实验目的：

1. 掌握包、接口、异常处理的设计方法。
2. 掌握输入输出流类。

二、实验内容：

3．带有捕获处理的throws 子句

（1）程序功能：在这个程序中的mathod 方法中使用throws 子句抛出异常，在main 方法中捕获处理异常。

（2）TC6.java，源代码如下。

import java.io.*;

public class LX3_6{

static void mathod() throws IllegalAccessException {

System.out.println("\n 在 mathod 中抛出一个异常");

throw new IllegalAccessException();

}

public static void main(String args[]) {

try {

mathod();

}catch (IllegalAccessException e) {

System.out.println("在 main 中捕获异常："+e);}

}

}

（3）编译并运行程序。

三、源代码

//LX3_6.java

import java.io.*;

public class LX3_6{

    static void mathod() throws IllegalAccessException {

        System.out.println("\n 在 mathod 中抛出一个异常");

        throw new IllegalAccessException();

    }

    public static void main(String args[]) {

        try {

            mathod();

        }catch (IllegalAccessException e) {

            System.out.println("在 main 中捕获异常："+e);}

    }

}

四、实验结果测试、收获与体会：

在main中进入mathod方法，在mathod中抛出一个异常，并在main中的catch语句中进行捕获，然后输出信息。此程序明白了在函数方法中抛出异常，若没有与之匹配的catch语句，会进入main中寻找，找到与之匹配的catch语句。

实验名称：java编程基础

实验地点：10-306

所使用的工具软件及环境：

JDK1.7或1.8与Eclipse

一、实验目的：

1. 掌握包、接口、异常处理的设计方法。
2. 掌握输入输出流类。

二、实验内容：

四．使用输入输出流类

1. 使用标准数据流的应用程序

标准数据流指在字符方式下（如DOS 提示符）程序与系统进行输入输出的方式，键盘和显示器屏幕是标准输入输出设备，数据输入的起点为键盘，数据输出的终点是屏幕，输出的数据可以在屏幕上显示出来。

（1）程序功能：将键盘上输入的字符在屏幕上显示出来。

（2）编写LX3_7.java 程序文件，源代码如下。

class LX3_7{

public static void main(String[] args) throws java.io.IOException {

byte buffer[]=new byte[10];

System.out.println("从键盘输入不超过10 个字符，按回车键结束输入：");

int count =System.in.read(buffer);//读取输入的字符并存放在缓冲区buffer 中

System.out.println("保存在缓冲区buffer 中元素的个数为："+count);

System.out.println("buffer 中各元素的值为：");

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

System.out.print(" "+ buffer[i]);//在屏幕上显示buffer 元素的值

}

System.out.println();

System.out.println("输出buffer 字符元素：");

System.out.write(buffer, 0, buffer.length);

}

}

(3)编译LX3_7.java 文件。在命令提示符窗口运行LX3_7.class 文件，并输入1234，分析结果。

三、源代码

//LX3_7.java

class LX3_7{

    public static void main(String[] args) throws java.io.IOException {

        byte buffer[]=new byte[10];

        System.out.println("从键盘输入不超过10 个字符，按回车键结束输入：");

        int count =System.in.read(buffer);//读取输入的字符并存放在缓冲区buffer 中

        System.out.println("保存在缓冲区buffer 中元素的个数为："+count);

        System.out.println("buffer 中各元素的值为：");

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

            System.out.print(" "+ buffer[i]);//在屏幕上显示buffer 元素的值

        }

        System.out.println();

        System.out.println("输出buffer 字符元素：");

        System.out.write(buffer, 0, buffer.length);

    }

}

四、实验结果测试、收获与体会：

输入的1234是字符，byte显示的是int型，49.50.51.52也就是显示的是按键的键码！6个元素中已经有4个元素，多两个是回车键的键码为13，10。此程序了解到buffer缓冲区的用法，以及byte类型的使用。

实验名称：java编程基础

实验地点：10-306

所使用的工具软件及环境：

JDK1.7或1.8与Eclipse

一、实验目的：

1. 掌握包、接口、异常处理的设计方法。
2. 掌握输入输出流类。

二、实验内容：

2. 使用文件输入输出流的应用程序

（1）程序功能：将保存在本地机当前文件夹中的LX5_1.HTML 文本文件的内容在屏幕上显示出来，然后将其另存为LX5_1.txt 文件。

（2）编写LX3_8.java 程序文件，源代码如下。

import java.io.*;

public class LX3_8 {

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

FileReader in=                             ;//建立文件输入流

BufferedReader bin=                             ;//建立缓冲输入流

FileWriter out=new FileWriter(" LX5_1.txt",true);//建立文件输出流

String str;

while ((str=bin.readLine())!=null) {

//将缓冲区内容通过循环方式逐行赋值给字符串str

                             ;//在屏幕上显示字符串str

out.write(str+"\n");//将字符串str 通过输出流写入LX5_1.txt 中

}

                  ;

                   ;

}

}

（3） 编译并运行程序。

三、源代码

//LX3_8.java

import java.io.*;

public class LX3_8 {

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

        FileReader in=new FileReader("LX5_1.HTML");//建立文件输入流

        BufferedReader bin=new BufferedReader(in);//建立缓冲输入流

        FileWriter out=new FileWriter("LX5_1.txt",true);//建立文件输出流

        String str;

        while ((str=bin.readLine())!=null) {//将缓冲区内容通过循环方式逐行赋值给字符串str

            System.out.println(str);//在屏幕上显示字符串str

            out.write(str+"\n");//将字符串str 通过输出流写入LX5_1.txt 中

        }

            in.close();

            out.close();

    }

}

四、实验结果测试、收获与体会：

建立文件输入流打开LX5_1.HTML文件并建立缓冲输入流，建立文件输出流打开LX5_1.txt文件将缓冲区内容通过循环方式逐行赋值给字符串str在屏幕上显示字符串str将字符串str 通过输出流写入LX5_1.txt文件中。此程序深刻对BufferedReader缓冲输入流的学习，并且成功学习将文件的复制和输出。

实验名称：java编程基础

实验地点：10-306

所使用的工具软件及环境：

JDK1.7或1.8与Eclipse

一、实验目的：

1. 掌握包、接口、异常处理的设计方法。
2. 掌握输入输出流类。

二、实验内容：

3. 使用随机文件类的应用程序

使用文件输入类FileReader 只能将文件内容全部读入。如果要选择读入文件的内容，可使用随机文件类RandomAccessFile。

（1） 程序功能：建立数据流，通过指针有选择的读入文件内容。

（2） 编写LX3_9.java 程序文件，源代码如下。

import java.io.*;

class LX3_9 {

public static void main(String args[]) {

String str[]={"First line\n","Second line\n","Last line\n"};

try {

RandomAccessFile rf=                                     ;

System.out.println("\n 文件指针位置为："+rf.getFilePointer());

System.out.println("文件的长度为："+rf.length());

rf.seek(rf.length());

System.out.println("文件指针现在 的位置为："+rf.getFilePointer());

for (int i=0; i<3; i++)

                 ; // 字符串转为字节串添加到文件末尾

rf.seek(10);

System.out.println("\n 选择显示的文件内容：");

String s;

while ((s=rf.readLine())!=null)

System.out.println(s);

                 ;

}

catch (FileNotFoundException fnoe) {}

catch (IOException ioe) {}

}

}

（3）编译并运行程序，分析运行结果。

三、源代码

//LX3_9.java

import java.io.*;

class LX3_9 {

    public static void main(String args[]) {

        String str[]={"First line\n","Second line\n","Last line\n"};

        try {

            RandomAccessFile rf=new RandomAccessFile("LX3_9.txt","rw");

            System.out.println("\n 文件指针位置为："+rf.getFilePointer());

            System.out.println("文件的长度为："+rf.length());

            rf.seek(rf.length());//移动指针到末尾

            System.out.println("文件指针现在 的位置为："+rf.getFilePointer());

            for (int i=0; i<3; i++)

                rf.writeChars(str[i]); // 字符串转为字节串添加到文件末尾

            rf.seek(10);

            System.out.println("\n 选择显示的文件内容：");

            String s;

            while ((s=rf.readLine())!=null)

                System.out.println(s);

                 rf.close();

        }

        catch (FileNotFoundException fnoe) {}

        catch (IOException ioe) {}

    }

}

四、实验结果测试、收获与体会：

使用文件输入类FileReader 只能将文件内容全部读入。选择读入文件的内容，使用随机文件类RandomAccessFile。建立数据流，通过指针有选择的读入文件内容，通过指针将内容输入到LX3_9.txt文件中，进而输出到窗口中。从此程序学习到了随机文件类RandomAccessFile的用法，并且深刻学习到了随机文件类的使用。

实验名称：java编程基础

实验地点：10-306

所使用的工具软件及环境：

JDK1.7或1.8与Eclipse

一、实验目的：

1. 掌握包、接口、异常处理的设计方法。
2. 掌握输入输出流类。

二、实验内容：

4. 使用数据输入输出流与文件输入输出流类的应用程序

使用数据输出流DataOutputStream 和数据输入流DataInputStream 可以读取或写入任何Java 类型的数据，不用关心它们的实际长度是多少字节。一般与文件输入流FileInputStream 和输出流类FileOutputStream 一起使用。

（1） 程序功能：将整型数据和字符串对象通过数据输出流写到文件中。将文件中的整型数据和字符串对象通过数据输出流读出，并在屏幕上显示文件中的内容。

（2） 编写程序文件

（3） 编译并运行程序。

三、源代码

//LX3_10.java

import java.io.*;

import java.util.Scanner;

public class LX3_10 {

    public static void main(String args[])throws Exception {

        FileOutputStream fos=new FileOutputStream("LX3_10.txt");

        DataOutputStream dos=new DataOutputStream(fos);

        Scanner in=new Scanner(System.in);

        int a=in.nextInt();

        String s=in.next();

        dos.writeInt(a);

        dos.writeUTF(s);

        dos.close();

        FileInputStream fis=new FileInputStream("LX3_10.txt");

        DataInputStream dis=new DataInputStream(fis);

        System.out.println(dis.readInt());

        System.out.println(dis.readUTF());

        dis.close();

    }

}

四、实验结果测试、收获与体会：

将整型数据和字符串对象通过数据输出流写到LX3_10.txt文件中。将文件中的整型数据和字符串对象通过数据输入流读出，并在屏幕上显示文件中的内容。通过该程序学习到了使用数据输出流DataOutputStream 和数据输入流DataInputStream 可以读取或写入任何Java 类型的数据，不用关心它们的实际长度是多少字节。一般与文件输入流FileInputStream 和输出流类FileOutputStream 一起使用。对数据流文件有了更深刻的学习，并且学习到了更多的用法。