JAVA实验报告 接口 泛型 枚举 内部类与异常

实验报告课程名称： Java程序设计成绩评定：实验项目名称：接口、泛型、枚举、内部类与异常指导教师：学生姓名：学号：专业班级：实验项目类型：基础实验地点：实验时间：一、实验目的与要求：1、理解接口的定义与实现；2、知道泛型、枚举型与内部类的基本应用；3、掌握常用异常的抛出与捕获及处理.二、实验环境：（硬件环境、软件环境）1.硬件环境：奔ⅣPC。

2.软件环境：Windows XP 操作系统，JDK6.0。

三、实验内容：（原理、操作步骤、程序代码等）任务：1、按照要求完成下述接口及实现类的程序1)定义名称为PCI（）的接口，包括启动的方法start和关闭的方法stop；2)定义名称为NetworkCard 的类表示网卡，实现PCI接口，并且其在实现start方法时输出“sending data……”，在实现stop方法时输出“network stop.”3)定义名称为SoundCard 的类表示声卡，实现PCI接口；并且其在实现start方法时输出“dudu……”，在实现stop方法时输出“sound stop.”4)定义名称为MainBoard 的类表示主板，包含方法public void usePCICard(PCIp)，在方法体内通过p来启动和关闭组件；5)定义一个包含main方法的Test类，在main方法内创建一个MainBoard 对象用mb来引用，创建一个NetworkCard对象用nc来引用，创建一个SoundCard对象用sc来引用，分别通过mb来使用usePCICard(PCI p)启动声卡和网卡。

2、泛型类程序的调试调试教材P165的程序8-2，写出程序运行结果，理解泛型类的工作机理及应用。

3、调试运行内部类程序：在类内部再定义另外一个类，这个另外定义的类就叫内部类。

调试教材P171-172程序8-3，写出程序运行结果，理解内部类的定义方法与应用。

4、异常抛出与捕获编程与调试先调试教材P182、183中的程序9-2和9-3，写出调试结果。

计算科学与工程（院、系）网络工程专业班组Java语言程序设计课学号姓名dong ge 实验日期教师评定实验四：异常类一、实验目的1、认识程序的逻辑运行错误，学习Java语言的异常处理机制。

2、加深异常处理机制的理解，认识Java语言中的常见异常类。

3、学习Java语言中多异常处理。

4、学习在方法中抛出异常，捕获并处理由方法抛出的异常。

5、学习自己定义异常类。

二、实验要求1、以上图为长方体类的继承关系，Rectangle为矩形类，为矩形类定义两个构造方法，分别带有两个参数和一个参数，其中带有两个参数的构造方法调用带有一个参数，toString()成员方法的功能显示矩形的长和宽以及面积；Cuboid为长方体类，为长方体类定义两个构造方法，分别带有三个参数和和没有参数，其中带有两个参数的构造方法调用父类带有两个参数的构造方法，长方体不需要计算周长返回0，toString()成员方法的功能显示长方体的长和宽、高以及体积；在主方法中定义对象测试所定义的类。

2、编写一个程序，抛出一个ArrayIndexOutOfBoundsException异常，并捕获处理。

3、自定义一个异常类，异常类中有一个带字符串参数的构造方法，将此参数赋值给异常类中惟一的字符串数据成员。

类中还定义一个成员方法，打印字符串数据成员。

在主方法中测试这个异常类。

三、实验程序和结果1、程序代码：interface Area {public double area();}interface Volume {public double volume();}class Rect implements Area{double Length;double Width;double area;Rect(){}Rect(double Length){this.Length=Length;System.out.println("没有参数的构造方法被调用"); }Rect(double Length, double Width){this(Length);this.Width=Width;System.out.println("一个参数的构造方法被调用"); }public double area(){return Length*Width;}public double perimeter(){return 2*(Length+Width);}public String toString(){return Length+" "+Width+" "+area();}}class Cuboid extends Rect implements Volume{double Height;Cuboid( ){System.out.println("没有参数的构造方法被调用"); }Cuboid(double Height,double Width,double Length){super(Length,Width);this.Height=Height;System.out.println("两个参数的构造方法被调用");}public double perimeter(){return 0;}public double volume (){return Height*Width*Length;}public String toString(){return Length+" "+Width+" "+Height+" "+volume();}}public class R{public static void main(String[] args){Rect n=new Rect(2.0,5.0);System.out.println ("长,"+"宽,"+"面积"+"分别为"+n.toString());Cuboid c=new Cuboid(5.0,6.0,8.0);System.out.println("长,"+"宽,"+"高,"+"体积"+"分别为"+c.toString());}}输出结果为：没有参数的构造方法被调用一个参数的构造方法被调用长,宽,面积分别为2.0 5.0 10.0没有参数的构造方法被调用一个参数的构造方法被调用两个参数的构造方法被调用长,宽,高,体积分别为8.0 6.0 5.0 240.02、：编写一个程序，抛出一个ArrayIndexOutOfBoundsException异常，并捕获处理。

java异常处理实验报告Java异常处理实验报告一、实验目的本次实验旨在通过编写Java程序，学习和掌握异常处理的相关知识和技巧，提高代码的健壮性和可靠性。

二、实验环境本次实验使用的开发环境为Eclipse，使用Java语言进行编程。

三、实验内容1. 异常的概念异常是指程序在运行过程中出现的意外情况，例如除零错误、数组越界等。

Java中的异常是以类的形式存在的，所有异常类都是Throwable类的子类。

2. 异常处理的方法Java提供了try-catch-finally语句用于处理异常。

在try块中编写可能会抛出异常的代码，如果发生异常，则会跳转到对应的catch块进行处理。

finally块中的代码无论是否发生异常都会被执行。

3. 异常的分类Java中的异常分为两种类型：受检异常（Checked Exception）和非受检异常（Unchecked Exception）。

受检异常需要在代码中显式地进行处理，否则编译器会报错；而非受检异常不需要强制处理。

4. 自定义异常除了使用Java提供的异常类，我们还可以根据需要自定义异常类。

自定义异常类需要继承Exception类或RuntimeException类，并重写相应的方法。

5. 异常处理的最佳实践在实际的软件开发中，异常处理是非常重要的一部分。

以下是一些异常处理的最佳实践：- 尽早捕获异常：在代码中尽量早地捕获异常，以避免异常的传播和影响其他部分的代码。

- 适当处理异常：根据具体情况，选择合适的处理方式，可以是打印日志、返回默认值、抛出新的异常等。

- 避免捕获过宽的异常：捕获异常时要尽量精确，避免捕获过宽的异常类型，以免屏蔽了真正的问题。

四、实验步骤1. 创建一个Java项目，并新建一个类用于实现异常处理的实验。

2. 编写代码，在try块中编写可能会抛出异常的代码。

3. 使用catch块捕获异常，并进行相应的处理，例如打印异常信息。

4. 在finally块中编写必要的代码，例如资源的释放。

java异常处理实验报告Java异常处理实验报告引言：异常处理是Java编程中非常重要的一部分，它能够帮助我们优雅地处理程序中可能出现的错误情况，提高程序的健壮性和稳定性。

本实验旨在通过编写一段简单的Java代码，来探索异常处理的机制和应用。

实验过程：在实验中，我们编写了一个简单的Java程序，用于模拟一个学生信息管理系统。

该程序包含了以下几个功能：添加学生信息、查询学生信息、删除学生信息和修改学生信息。

在每个功能中，我们故意引入了一些可能导致异常的情况，以便验证异常处理的效果。

首先，我们创建了一个名为"Student"的类，用于表示学生的信息。

该类包含了学生的姓名、年龄和成绩等属性，并提供了相应的getter和setter方法。

接着，我们创建了一个名为"StudentManagementSystem"的类，用于实现学生信息的管理功能。

在添加学生信息的功能中，我们通过捕获可能抛出的"NullPointerException"异常来处理可能出现的空指针异常。

当用户输入的学生信息为空时，程序将抛出该异常并给出相应的提示信息，避免程序崩溃。

在查询学生信息的功能中，我们通过捕获可能抛出的"IndexOutOfBoundsException"异常来处理可能出现的数组越界异常。

当用户输入的学生索引超出了学生信息数组的范围时，程序将抛出该异常并给出相应的提示信息，避免程序崩溃。

在删除学生信息的功能中，我们通过捕获可能抛出的"NumberFormatException"异常来处理可能出现的数字格式异常。

当用户输入的学生索引不是一个合法的数字时，程序将抛出该异常并给出相应的提示信息，避免程序崩溃。

在修改学生信息的功能中，我们通过捕获可能抛出的"InputMismatchException"异常来处理可能出现的输入不匹配异常。

java异常处理实验结论-回复【java异常处理实验结论】在开发过程中，异常处理是一个至关重要的问题。

异常处理允许开发者在程序运行过程中，捕获并处理潜在的错误情况，以避免程序的崩溃或异常行为。

本文将通过实验探讨Java中异常处理的相关原理和方法，并总结实验结论。

首先，我们需要了解异常是什么。

在Java中，异常是指在程序运行过程中可能发生的错误或异常情况。

这些错误或异常情况可能是由于外部因素（如网络连接问题）、程序逻辑错误或用户输入不合法等原因引起的。

异常通过抛出和捕获机制来处理。

Java提供了一套完整的异常处理机制，以帮助开发人员捕获和处理异常。

异常处理的主要目标是提供一种对错误情况进行处理的方法，从而避免程序的崩溃或异常行为。

异常处理的主要思想是，在程序中进行适当的异常捕获，然后根据具体情况给予合适的处理和反馈。

为了更好地理解Java异常处理机制，我们进行了一系列的实验。

在实验中，我们模拟了几种常见的异常情况，并使用Java异常处理机制进行了处理。

实验的目的是验证Java异常处理机制的可行性和有效性。

实验一：ArithmeticException异常处理在该实验中，我们模拟了一个除零异常的情况。

在Java中，当一个数字尝试除以0时，会抛出ArithmeticException异常。

为了处理这种异常，我们使用了try-catch块来捕获该异常，并对异常进行了相应的处理。

实验结果表明，通过使用try-catch块来捕获ArithmeticException异常，我们能够有效地处理该异常，并避免程序的崩溃。

实验表明，Java 异常处理机制的确具有良好的可行性和有效性。

实验二：ArrayIndexOutOfBoundsException异常处理在该实验中，我们模拟了一个数组越界的异常情况。

在Java中，当我们尝试访问数组中不存在的索引时，会抛出ArrayIndexOutOfBoundsException异常。

java异常处理实验总结
在这个实验中，我们学习了Java中的异常处理机制。

异常是在程序执行过程中发生的错误或异常情况，例如除以零、数组越界等。

在Java中，异常被分为两种类型：受检异常和非受检异常。

受检异常是在代码中显式声明并处理的异常，需要在方法签名中声明并在方法体中捕获或抛出。

这样做是为了确保开发人员在编写代码时考虑到了可能发生的异常情况，并处理它们。

受检异常的处理方式包括捕获和处理异常、向调用方法抛出异常或者使用try-catch-finally语句块处理异常。

非受检异常是指那些不需要在代码中显式声明和捕获的异常，通常是由程序错误导致的异常，如空指针异常、数组越界异常等。

对于非受检异常，我们可以使用try-catch语句块来捕获并处理异常，或者在方法签名中使用throws关键字声明可能抛出的异常。

在实验中，我们通过编写代码来模拟各种异常情况，并使用try-catch语句块来捕获和处理异常。

我们还学习了如何创建自定义异常类，并在需要的时候抛出这些异常。

通过这个实验，我学到了异常处理的重要性以及如何正确地处理异常。

异常处理可以提高程序的健壮性和容错性，避免程序崩溃或出现未知的错误。

同时，异常处理也可以帮助我们定位和调试代码中的问题，提高代码的可维护性和可读性。

总的来说，这个实验对我来说是一次很好的学习和实践机会，让我更深入地理解了Java中的异常处理机制，并掌握了如何正确地处理异常。

我相信这些知识和技能对我在日后的编程工作中会非常有帮助。

序抽象类的特点：1，抽象方法一定在抽象类中。

2，抽象方法和抽象类都必须被abstract关键字修饰。

3，抽象类不可以用new创建对象。

因为调用抽象方法没意义。

4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。

如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

抽象类和一般类没有太大的不同。

抽象类比一般类多个了抽象函数。

就是在类中可以定义抽象方法。

抽象类不可以实例化。

特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

abstract 关键字，和哪些关键字不能共存。

final：被final修饰的类不能有子类。

而被abstract修饰的类一定是一个父类。

private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。

而抽象方法出现的就是需要被复写。

static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。

可是抽象方法运行没意义。

抽象类中有构造函数,因为抽象类是一个父类，要给子类提供实例的初始化。

继承：1，提高了代码的复用性。

2，让类与类之间产生了关系。

有了这个关系，才有了多态的特性。

注：不要为了获取其他类的功能，简化代码而继承。

必须是类与类之间有所属关系才可以继承。

所属关系 is a。

Java语言中：java只支持单继承，不支持多继承。

因为多继承容易带来安全隐患:当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个。

但是java保留这种机制。

并用另一种体现形式来完成表示。

多实现。

java支持多层继承。

也就是一个继承体系子父类中的函数。

当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容。

如同父类的函数被覆盖一样。

这种情况是函数的另一个特性：重写(覆盖)当子类继承父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致，这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。

贵州大学实验报告学院：计信学院专业：网络工程班级：101 姓名学号实验组实验时间05.27 指导教师肖源源成绩实验项目名称Java异常处理实验目的1）掌握Java异常的概念及工作机制2）掌握异常的分类3）掌握抛出异常语句的使用(throw)4）掌握抛出捕获处理异常语句的使用(try…catch…finally) 5）掌握上抛异常语句的使用(throws)6）掌握创建自定义异常实验要求1．安装并设置Java SDK 软件包。

2．按要求编写程序完成实验指导所需实验要求。

3．调试并成功运行。

实验内容1、编写一个应用程序，要求从键盘输入一个double型的圆的半径，计算并输出其面积。

测试当输入的数据不是double型数据（如字符串“abc”）会产生什么结果，怎样处理。

（根据上课讲课内容来做）。

实验代码import java.io.*;public class Circle {public static void main (String[] args)throws IOException{System.out.println("请输入圆的半径：");BufferedReader str=new BufferedReader(new InputStreamReader(System.in));try{ System.out.println("圆的面积为："+computerArea(Double.parseDouble(str.readLine())));}catch(NumberFormatException e){System.out.println("输入异常");}}public static double computerArea (double r) { return Math.PI*r*r;}}实验数据使用ecplise运行，正常输入，则给出计算结果输入非double数值，则显示异常。

班级：姓名：学号：成绩
泛型、枚举和内部类
实验目的：
1.理解泛型的作用，掌握泛型类的声明及实例化的方法
2.掌握枚举类的定义和使用
3.掌握内部类的定义和使用方法
4.掌握匿名类的使用方法
实验要求和过程
1.修改书上程序7-4，要求利用具有泛型机制的Comparable<T>实现。

2.模仿程序8-5，利用匿名内部类实现对Account数组进行按照属性id的
大小进行排序。

3.在java.util包中有一接口Comparator<T>，提供了比较器的功能。

请根据
此接口定义的比较方法，针对类Account中的余额字段，完成比较器类
的定义（声明成普通外部类）。

修改书上程序7-4，验证你的设计是否正
确。

（比较一下题目1和题目3异同）
评语：
教师签字：日期：年月日。

实验六内部类和异常类1.实验目的1、掌握内部类的常用方法2、掌握匿名类的常用方法3、掌握接异常类的常用方法2.实验内容1、根据附录里的源代码，按照注释要求，完成代码填空，使程序能够运行得出结果。

1）实验1 红牛农场2）实验2 检查危险品3）实验3 内部类的使用方法4）实验4 匿名类的使用方法5）实验5 异常类使用方法2、设计编写程序完成以下任务。

1）假如要从命令行获得两个整数，自定义两个异常类来描述可能发生的异常：ParameterNumberException（参数个数异常），ParameterFormateException （参数格式异常），设计一个类，在check(String args[])方法中通告这两个异常，在main方法中判断相应的情况下触发异常，然后捕获异常，对它们进行处理。

（知识点：异常处理机制）判断长度和类型不准，相应条件分支抛出对应的自定义异常即可2）编写一个异常类MyException，在编写一个类Student，该类有一个产生异常的方法public void speak(int m)throws MyException,要求参数m的值大于1000时，方法抛出一个MyException对象。

最后编写一个主类，在主类的main方法中用Student创建一个对象，让该对象调用speak方法。

3.实验步骤略4.评分标准1.A——内容功能完善，编程风格好，人机接口界面好；2.B——内容功能完善，编程风格良好，人机接口界面良好；3.C——完成必做内容；4.D——能完成必做内容；5.E——未按时完成必做内容，或者抄袭（雷同者全部为E）.参照书上实验按模版要求，将【代码】替换为Java程序代码，编写好完整的程序文档，最后运行得到的相关文件，把实验所得文件一起打包上交。

（压缩包的文件名为：学号后三位和名字开头字母，如109zhh．RAR|ZIP）附录：实验1 红牛农场模板代码RedCowForm.javapublic class RedCowForm {String formName;//【代码1】//用内部类RedCow声明对象cowRedCowForm(){}RedCowForm(String s){//【代码2】//创建cowformName=s;}public void showCowMess(){cow.speak();}class RedCow{String cowName="红牛";int height,weight,price;RedCow(int h,int w,int p){height=h;weight=w;price=p;}void speak(){System.out.println(cowName+"，身高："+height+"cm，体重："+weight+"kg");System.out.println("生活在"+formName);}}}MainClass.javapublic class MainClass {public static void main(String[] args) {RedCowForm form=new RedCowForm("红牛农场");form.showCowMess();}}实验2 检查危险品模板代码Goods.javapublic class Goods {boolean isDanger;String name;public boolean isDanger() {return isDanger;}public void setDanger(boolean boo) {isDanger = boo;}public String getName() {return name;}public void setName(String s) {name = s;}}DangerException.javapublic class DangerException extends Exception{String message;public DangerException(){message="危险品！";}public void toShow(){System.out.print(message+"");}}Machine.javapublic class Machine {Goods[] goods;public void checkBag(Goods goods) throws DangerException{if(goods.isDanger){//【代码1】//用throw抛出一个DangerException的匿名类}}}Check.javapublic class Check {public static void main(String[] args) {Machine machine=new Machine();String name[]={"苹果","炸药","西服","硫酸","手表","硫磺"};Goods [] goods= new Goods[name.length];//检查6件物品for(int i=0;i<name.length;i++){goods[i]=new Goods();if(i%2==0){goods[i].setDanger(false);goods[i].setName(name[i]);}else{goods[i].setDanger(true);goods[i].setName(name[i]);}}for(int i=0;i<goods.length;i++){try{machine.checkBag(goods[i]);System.out.println(goods[i].getName()+"检查通过");}catch(DangerException e){//【代码2】//e调用toShow()方法System.out.println(goods[i].getName()+"被禁止！");}}}}实验3 内部类的使用模板代码Outer.javapublic class Outer{private static int size;/** 内部类Inner的声明*/public class Inner{private int size;/** 方法doStuff() */public void doStuff(int size){【代码1】//存取局部变量size加3【代码2】//存取其内部类的成员变量size加2【代码3】//存取其外部类的成员变量size加1System.out.println(size+" "+this.size+" "+Outer.this.size);}}//内部类Inner结束/** 类Outer中定义的实例方法testInner()方法*/public void testInner(){Inner i=new Inner();【代码4】//调用Inner类中的doStuff方法}/** main()方法*/public static void main(String args[]){Outer o=new Outer();【代码5】//调用Outer类中的testInner方法}}//类Outer结束实验4 匿名类的使用方法模板代码Anonymity.javainterface Square{ double getSquare(int n);}interface Sqrt{ public double getSqrt(int x);}class A{ void p(Square square){System.out.println(【代码1】);//输出getSquare方法计算后的结果}void k(Sqrt sqrt){System.out.println(【代码2】);//输出getSqrt方法计算后的结果}}public class Anonymity{ public static void main(String args[]){A a=new A();a.p(【代码3】);//实现Square接口，重写getSquare方法，返回n的平方Sqrt sqrt=new Sqrt(){【代码4】};//重写getSqrt方法，返回x的开平方根，用静态Math.sqrt方法来运算System.out.println("计算开平方:"+sqrt.getSqrt(5));}}实验5 异常类使用方法模板代码eClass.javaclass MyException extends Exception{String message;MyException(String str){【代码1】//把参数的引用传给message成员变量}public String getMessage(){【代码2】//返回message成员变量}}abstract class A{abstract int f(int x,int y) throws MyException;}class B extends A{int f(int x,int y) throws MyException{if(【代码3】)//判断x、y都不大于100【代码4】//抛出一个新建的MyException对象，MyException对象中构造方法传入的参数内容为：乘数超过100return x*y;}}public class eClass{public static void main (String args[]){A a;【代码5】//设计a对象的B类上转型对象try{System.out.println(a.f(12,10));【代码6】//使用f()方法时传入一个大于100的乘数}catch(MyException e){【代码7】输出错误信息}}}。

JAVA语言程序设计实验报告实验三实验题目：异常处理指导老师：卢照专业班级：计算机科学与技术系1106班姓名：李锋（2011100645）2014年4月20日一、实验名称：异常处理二、实验目的：1.掌握异常处理机制的运作2.掌握处理异常的几个子句：try…catch..finally、thorws和throw3.掌握字符串类的相关操作三、实验内容：1. 编写一个类，在其main()方法中创建一个一维数组，在try字句中访问数组元素，使其产生ArrayIndexOutOfBoundsException异常。

在catch子句里捕获此异常对象，并且打印“数组越界”信息，加一个finally子句，打印一条信息以证明这里确实得到了执行。

2. 给定一个字符串，将字符串中的所有大写字母变成小写字母，数字用0来代替，其他符号用#代替。

四、实验代码1.ExceptionDemo.javaclass ExceptionDemo{public static void main(String[] args){int [] arr = new int[]{13,24,1,53,24};try{int num = arr[5];}catch (ArrayIndexOutOfBoundsException e){System.out.println("数组越界啦！！！");}finally{System.out.println("此处代码一定会执行的--finally");}}}运行结果：2.StringTest.javaclass StringTest{public static void main(String[] args){String str = "DfS分手dsA吧25J奋45斗";System.out.println("原字符串=="+str);StringBuffer sb = new StringBuffer();for(int i = 0;i<str.length();i++){char ch = str.charAt(i);if(ch>='A' && ch<='Z'){sb.append(Character.toLowerCase(ch));}else if(ch>='a' && ch<='z'){sb.append(ch);}else if(ch>=49 && ch<=58){sb.append(0);}else{sb.append("#");}}System.out.println("转换后=="+sb);}}运行结果：五、实验总结：通过本次实验，熟悉掌握了Java的异常机制，try{}catch(){}finally{}的执行过程。

实验二泛型异常处理实验报告一、实验目地1. 理解使用泛型、枚举地目地.2. 掌握异常类、异常类地结构及自定义异常类地编程方法.二、实验要求1. 应用泛型编写简单地应用程序；2. 自定义异常类地编写；3. 异常类中try, catch, throw, throws 地编写方法.三、实验内容1. 阅读以下程序，写出运行结果.同时，把程序改写为使用泛型地程序.对比两个程序并说出泛型地优点.publicclass GenericityDemo {publicstaticvoid main(String[] args) {// 定义类Genericity地一个Integer版本Genericity intobj = new Genericity(new Integer(88));intobj.showType();int i = (Integer) intobj.getobj();System.out.println("value= " + i);System.out.println("----------------------------------");// 定义类Genericity地一个String版本Genericity strobj = new Genericity("Hello Genericity!");strobj.showType();String s = (String) strobj.getobj();System.out.println("value= " + s);}}class Genericity {private Object obj; // 定义通用类型成员public Genericity(Object obj) {this.obj = obj;}public Object getobj() { return obj;}publicvoid setobj(Object obj) {this.obj = obj;}publicvoid showType() {System.out.println("T实际类型是: " +obj.getClass().getName());}}2. 阅读程序并分析其输出结果：publicclass Exceptiontest {publicstaticvoid mb_createException() {thrownew ArrayIndexOutOfBoundsException();}// 方法mb_createException结束publicstaticvoid mb_method() {try {mb_createException();System.out.print("try…\n");} catch (ArithmeticException e) {System.out.print("catch arithmeticException\n");} finally {System.out.print("execute finally\n");}// try-catch-finally结构结束System.out.print("mb_method end\n");}// 方法me_method结束publicstaticvoid main(String args[]) {try {mb_method();} catch (Exception e) {System.out.print("catch exception\n");}// try-catch结构结束System.out.print("main end\n");}// 方法main结束}3. 编程实现输入二个整数，输出它们地商(整除地结果).要求使用异常机制：当除数为0时，输出除数为0.当输入地数据出现其它字符时，重新输入数据.四、实验结果1. 实验(1)地运行结果如下：把实验(1)地程序改写为泛型程序代码如下：publicclass GenericityNew<T> {private T obj;public GenericityNew (T obj){this.obj = obj;}public T getobj() {returnthis.obj;}publicvoid setobj(T obj) {this.obj = obj;}publicvoid showType() {System.out.println("T地实际类型是: "+obj.getClass().getName());}publicstaticvoid main(String[] args) {GenericityNew<Integer> intobj =new GenericityNew<Integer>(new Integer(88));intobj.showType();int i = intobj.getobj();System.out.println("value= " + i);System.out.println("----------------------------------");GenericityNew<String> strobj =new GenericityNew<String>("Hello Genericity!");strobj.showType();String s = strobj.getobj();System.out.println("value= " + s);}}相比起原来地那个程序，泛型类对setobj方法地参数进行了限定，getobj地返回值也不需要进行强制类型转换，这样能够确保程序中不会出现ClassCastException异常.在main函数中，调用mb_method方法，mb_method方法中调用mb_createException方法，这个方法会抛出一个ArrayIndexOutOfBoundsException异常，而这个异常没有被mb_method 方法中地try…catch 语句捕获异常，但无论如何，finally中地代码始终会被执行.所以输出了execute finally，然后就把异常继续往上一层地方法，也就是main方法抛；所以mb_method 方法中地System.out.print("mb_method end\n");语句没有被执行.ArrayIndexOutOfBoundsException异常被main函数中地try…catch语句捕获，所以System.out.print("catch exception\n");语句被执行，异常已经处理完成，程序会继续往下执行，所以main end也就被输出.3. 实验(3)代码如下：import java.util.Scanner;publicclass DivideProgram {publicstaticvoid main(String[] args) {Scanner s = new Scanner(System.in);while (true) {System.out.print("请输入被除数：");String strNumberA = s.nextLine();System.out.print("请输入除数：");String strNumberB = s.nextLine();try {double numA = Double.parseDouble(strNumberA);double numB = Double.parseDouble(strNumberB);if (numB == 0) {thrownew DividedByZero();}double result = numA / numB;System.out.println(String.format("%f/%f=%f", numA, numB, result));} catch (NumberFormatException e) {System.out.println("请输入一个有效地数字！"); continue;} catch (DividedByZero e) {System.out.println("除数不能为 0！");continue;}}}}class DividedByZero extends Exception {public DividedByZero() {super("除数不能为0！");}}运行结果如下：版权申明本文部分内容，包括文字、图片、以及设计等在网上搜集整理.版权为个人所有This article includes some parts, including text, pictures, and design. Copyright is personal ownership.dvzfv。

实验报告课程Java语言程序设计实验名称第五、六章泛型、异常、单体类第页专业班级学号__ __ 姓名实验日期：2010 年10 月19 日报告退发(订正、重做)一、实验目的•掌握泛型类和接口的使用•掌握异常处理机制和两种处理方式•掌握单体类的设计和使用二、实验环境1、微型计算机一台2、DOS或WINDOWS操作系统，j2se开发包三、实验内容1、编一个程序，定义一个泛型类，并在程序中使用。

请说明泛型类比较适用于什么场合，可以举例说明。

2、对于程序中的受检异常必须进行处理，异常处理的方式有两种：try-catch-finally捕获、throws转移。

请编程演示这两种异常处理方式的使用。

3、编一个程序，定义并使用单体类，并说明单体类是如何确保全局只有一个实例对象的。

四、实验步骤和结果1.在Eclipse中新建名字为test4的工程。

2.新建Fanxing.java，CatchException.java, ThrowException.java，J_Singleton.java四个类。

3.以下分别编写各类java程序，并显示其结果。

// Fanxing.javapublic class Fanxing<T>{public String sum(T a1,T a2,T a3){return(a1.toString()+a2.toString()+a3.toString());}public static void main(String[] args){Fanxing<Integer> b=new Fanxing<Integer>();Integer a1=new Integer(7);Integer a2=new Integer(8);Integer a3=new Integer(9);System.out.println(b.sum(a1,a2,a3));}结果：回答问题：泛型类比较适用于数据的类型转换复杂，代码运行效率低，程序代码复用性低的场合。

一. 实验目的及实验环境实验目的：1.理解JA V A对异常的处理2.掌握自定义异常的定义方式实验环境：eclipse 4.4二. 实验内容1.假设Sum类中有一个addContinue(int n)方法，当n>0时，方法翻译1+2+…+n 的和；当n<0时，方法抛出一个受检查的ArgumentException异常。

ArgumentException类应该提供一个能够接受并保存n值得构造方法，以及一个能返回n值得实例方法，现定义Sum类以及ArgumentException类，并编程测试它们。

三．方案设计1.定义三个类Sum，ArgumentException，Test类2.分别在类中实现加法，异常抛出和测试四．测试数据及运行结果1．正常测试数据（3组）及运行结果；2．非正常测试数据（2组）及运行结果。

五．总结1．实验过程中遇到的问题及解决办法；①中没有明确表示需要进行异常抛出很有可能就会忘记这个题目存在的问题。

所以平常程序设计时，应该多考虑不同的情况，防止程序出现不可逆的漏洞。

②如果发生可识别的运行错误，系统应产生一个相应的异常类对象，并进一步寻找异常处理代码来处理它，确保程序能从故障中恢复，之程序能够运行下去，直到结束。

2．对设计及调试过程的心得体会。

中断，影响程序正常运行的事件称为异常。

异常处理是使程序从故障中恢复，他包括提示异常信息、不产生无效结果和释放资源三方面内容。

其中，显示异常信息和不产生无效结果可通过try和catch块来实现，释放资源可通过finally块实现。

附代码public class Add {public int addContinue(int i) throws ArgumentException{int sum=0;if( i<0){throw new ArgumentException(i);}for(int n=0;n<=i;n++){sum=sum+n;}return sum;}}public class ArgumentException extends Exception {private int n;public ArgumentException(int n) {this.n = n;}public int getN(){return n;}}public class test {public static void main(String[] args){Add s = new Add();try {System.out.println(s.addContinue(-1));} catch (ArgumentException e) {System.out.println(e.getN());}}}。