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

合集下载

java(枚举、泛型)

java(枚举、泛型)

第4章枚举和泛型---6.1 枚举---6.2 泛型1 知识点1.1 上次内容1.Java异常处理1.2 习题讲解1.求int型数组元素的平均值。

(提示:存在空对象异常和除数为0等潜在错误,要求使用异常进行处理。

(参考教材128页)1.3 本次内容〖知识点〗1.枚举2.泛型〖了解〗1.枚举扩展【重点】1.泛型2.枚举〖难点〗1.泛型2.枚举2 具体内容6.1 枚举在实际编程中,往往存在着这样的“数据集”,它们的数值在程序中是稳定的,而且“数据集”中的元素是有限的。

例如:星期一到星期日七个数据元素组成了一周的“数据集”,春夏秋冬四个数据元素组成了四季的“数据集”。

在java中如何更好的使用这些“数据集”呢?因此枚举便派上了用场。

6.1.1 枚举简介在JDK 1.5之前,JA V A可以有两种方式定义新类型:类和接口。

对于大部分面向对象编程来说,这两种方法看起来似乎足够了。

但是在一些特殊情况下,这些方法就不适合。

例如,想定义一个Color类,它只能有Red、Green、Blue三种值,其他的任何值都是非法的,那么JDK 1.5之前虽然可以构造这样的代码,但是要做很多的工作,也有可能带来各种不安全的问题。

而JDK 1.5之后引入的枚举类型(Enum)就能避免这些问题。

枚举就是规定好了指定的取值范围,所有的内容只能从指定的范围中取得,也就是一个类只能产生固定的几个对象。

范例:使用定义类实现枚举操作。

范例:使用接口表示一组范围6.1.2 定义一个枚举类型在JDK 1.5之后,引入了一个新的关键字类型—— enum,可以直接定义枚举类型,格式如下:范例:定义一个Color的枚举类型。

范例:枚举操作。

6.1.3 Enum使用enum关键字可以定义一个枚举。

实际上此关键字表示的是ng.Enum类型,即:使用enum 声明的枚举类型,就相当于定义一个类,而此类默认继承ng.Enum类。

ng.Enum类的定义如下:枚举类的主要操作方法:6.1.4 取得枚举的信息枚举类的构造方法:protected Enum(String name,int ordinal);在枚举类建立完成之后,实际上都会为其调用枚举类中的构造方法,为其赋值,在Enum类的构造方法中的第一个参数name就是定义的枚举的名称,第二个参数ordinal则会从0开始依次进行编号。

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

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,写出调试结果。

java10-泛型与枚举

java10-泛型与枚举

java10-泛型与枚举java10泛型与枚举泛型和枚举都是JDK1.5版本之后加⼊的新特性,泛型将程序代码的类型检查提前到了编译期间进⾏,枚举类型增强了程序代码的健壮性。

1.泛型类class VariableType<T> { // 此处可以随便写标识符号,T是type的简称private T var; // var的类型由T指定,即:由外部指定public T getVar() { // 返回值的类型由外部决定,泛型⽅法return var;}public void setVar(T var) { // 设置的类型也由外部决定this.var = var;}};public static void main(String args[]) {VariableType <String> p = new VariableType <String>(); // ⾥⾯的var类型为String类型p.setVar("it"); // 设置字符串System.out.println(p.getVar().length()); // 取得字符串的长度}2.泛型⽅法// T 为参数类型public static void main(String[] args) {variableType(1);variableType(1.0);}public static <T> void variableType(T a) {System.out.println(a.getClass());}3.泛型接⼝的定义和使⽤package com.rimi.Test;import java.util.Date;interface Show<T,U>{void show(T t,U u);}class ShowTest implements Show<String,Date>{@Overridepublic void show(String str,Date date) {System.out.println(str);System.out.println(date);}}public class TestDemo {public static void main(String[] args) {ShowTest showTest=new ShowTest();showTest.show("Hello",new Date());}}4.⽐较任意类型的两个数的⼤⼩public static void main(String[] args) {System.out.println(get(1,2));}public static <T extends Comparable> T get(T t1, T t2) { // 添加类型限定if (pareTo(t2) >= 0){return t2;}return t1;}5.枚举// 枚举定义public enum Color {RED, GREEN, BLANK, YELLOW}// 枚举使⽤public static void main(String[] args) {System.out.println( isRed( Color.BLANK ) ) ; //结果: falseSystem.out.println( isRed( Color.RED ) ) ; //结果: true}// 枚举值的使⽤static boolean isRed( Color color ){if ( Color.RED.equals( color )) {return true ;}return false ;}public enum Color {RED, GREEN, BLANK, YELLOW}public static void main(String[] args) {showColor(Color.RED);}static void showColor(Color color) {switch (color) {case BLANK:System.out.println(color);break;case RED:System.out.println(color);break;default:System.out.println(color);break;}}//⾃定义函数public enum Color {RED("红⾊", 1), GREEN("绿⾊", 2), BLANK("⽩⾊", 3), YELLO("黄⾊", 4);private String name;private int index;private Color(String name, int index) { = name;this.index = index;}public String getName() {return name;}public void setName(String name) { = name;}public int getIndex() {return index;}public void setIndex(int index) {this.index = index;}}public static void main(String[] args) {// 输出某⼀枚举的值System.out.println(Color.RED.getName());System.out.println(Color.RED.getIndex());// 遍历所有的枚举for (Color color : Color.values()) {System.out.println(color + " name: " + color.getName() + " index: " + color.getIndex()); }}。

java接口实验报告

java接口实验报告

java接口实验报告实验报告:Java接口实验一、实验目的通过本次实验,我们希望达到以下目的:1. 深入理解Java接口的概念、特点和用途。

2. 掌握如何定义、实现和使用接口。

3. 理解接口在多态性中的作用。

4. 掌握如何使用接口来设计可扩展的代码。

二、实验内容1. 定义一个接口,并实现该接口。

2. 使用接口实现多态性。

3. 通过接口设计可扩展的代码。

三、实验步骤及结果步骤1:定义一个接口首先,我们定义一个名为"Shape"的接口,该接口包含一个计算面积的方法。

```javapublic interface Shape {double getArea();}```步骤2:实现接口接下来,我们创建两个类(Circle和Rectangle),分别实现Shape接口。

每个类都提供了一个计算面积的方法。

Circle类:```javapublic class Circle implements Shape {private double radius;private static final double PI = ;public Circle(double radius) {= radius;}Overridepublic double getArea() {return PI radius radius;}}```Rectangle类:```javapublic class Rectangle implements Shape {private double width;private double height;public Rectangle(double width, double height) {= width;= height;}Overridepublic double getArea() {return width height;}}```步骤3:使用接口实现多态性现在,我们创建一个名为"ShapeDisplay"的类,该类接受一个Shape对象,并使用该对象的getArea方法来计算面积。

java异常处理实验报告

java异常处理实验报告

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程序设计方法。

人员编号基数为 0A00,每创建一个人员实例对象,其编号属性的值顺序加 1。

月薪计算方法:经理拿固定月薪 5000 元;兼职技术人员按每小时 60 元领取月薪;兼职推销人员的月薪按当月的销售额的 4%提成。

要求:根据题意,自己确定需要定义的类及各类的属性、构造方法和其他方法,程序实现功能:存储若干个职工信息,然后分行显示所有职工的姓名、编号、月工资等相关信息,另外计算所有职工的月薪总和并显示出来。

要求定义:(1)抽象类 Staff 作为父类,并定义通用的域变量 name,num,income,添加构造方法 Staff(String name,int num,double income){……} 添加抽象方法 abstract double getPay(); abstract void print(); (2)分别定义 Staff 的子类 Manager,Engineer,Salesman,让它们继承父类的属性并分别将抽象的构造方法根据各自特点将抽象方法具体化。

(3)上述类放在同一个包中实现。

3. 编写一个Java程序,计算S=N!,其中N的值由键盘输入,要求用try catch finally 语句能够处理多种不同的异常处理。

四、实验结果(包括程序或图表、结论陈述、数据记录及分析等,可附页)1.实验一2.实验二3.实验三五、实验总结(包括心得体会、问题回答及实验改进意见,可附页)真的难六、教师评语1、完成了所有规定的实验内容,实验步骤正确,结果正确;2、完成了绝大部分规定的实验内容,实验步骤正确,结果正确;3、完成了大部分规定的实验内容,实验步骤正确,结果正确;4、基本完成了规定的实验内容,实验步骤基本正确,结果基本正确;5、未能很好地完成规定的实验内容或实验步骤不正确或结果不正确;。

java实验报告——异常、集合类和泛型

java实验报告——异常、集合类和泛型
Stu[12]=new XueShengXinXi(" 电 信 ", " 电 信 10-2", " 李 雨 ", " 女 ", "6314", "43ghffvvdfnhjbh");
for(int x=13;x<Stu.length;x++) {
Stu[x]-generated method stub //XueShengXinXi[] Stu=ChuShiHua(); //初始化系统数据 XueShengXinXi[] Stu=new XueShengXinXi[100]; Stu[0]=new XueShengXinXi("专业", "班级", "姓名", "性别", "电话", "家庭住址 "); Stu[1]=new XueShengXinXi(" 自 动 化 ", " 自 动 化 10-1", " 张 三 ", " 男 ", "63256", "fnhjfdhsdbh"); Stu[2]=new XueShengXinXi("自动化", "自动化10-2", "李四", "女", "653256", "nfhggdfddhsdbh"); Stu[3]=new XueShengXinXi(" 电 子 ", " 电 子 10-1", " 王 五 ", " 男 ", "6156", "fnhvjbh");

JAVA实验报告

JAVA实验报告

学生实验报告课程名称:面向对象程序语言(Java)年级:专业:学号:姓名:指导教师:实验地点:学年至学年度第学期1.目录实验一初识Java——“一个简单的应用程序”实验二基本数据类型与数组——“输出希腊字母表”实验三分支与循环语句——“猜数字游戏”实验四类与对象——“机动车”实验五类与对象——“家中的电视”实验六类与对象——“共饮同井水”实验七类与对象——“求方程的根”实验八子类与继承——“中国人、北京人和美国人”实验九子类与继承——“银行计算利息”实验十子类与继承——“公司支出的总薪水”实验十一接口与实现——“评价成绩”实验十二内部类与异常类——“检查危险品”实验十三常用实用类——“检索简历”实验十四组件及时间处理——“计算三角形的面积”实验十五实验十六实验(一)初识Java——“一个简单的应用程序”实验时间:2017年02月21日实验目的本实验的目的是让学生掌握开发Java应用程序的三个步骤:编写源文件、编译源文件和运行应用程序实验要求编写一个简单的Java应用程序,该程序在命令行窗口输出两行文字:“你好,欢迎学习Java”和“We are students”。

实验内容public class Hello {public static void main (String args[ ]) {System.out.println("你好,很高兴学习Java"); //命令行窗口输出"你好,很高兴学习Java"A a=new A();a.fA();}}class A {void fA() {System.out.println("We are students"); //命令行窗口输出"We are students"}}实验结果分析通过本次实验,在老师的指导下我学会了基本的JAVA编译原理,能够自行改变环境变量,能够成功编译出一个简单的应用程序,而且通过实验后的练习知道了一些基础的错误在JAVA中出现时编译器的提示信息是怎样的。

实验泛型异常处理实验研究报告

实验泛型异常处理实验研究报告

实验二泛型异常处理实验报告一、实验目地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异常处理实验报告

java异常处理实验报告

java异常处理实验报告Java异常处理实验报告实验目的:通过实验,掌握Java中异常处理的基本原理和方法,能够编写能够处理各种异常情况的程序。

实验环境:使用Java编程语言,Eclipse集成开发环境。

实验内容:1. 异常的基本概念异常是指在程序执行过程中出现的错误情况,包括编译时异常和运行时异常。

编译时异常是在编译阶段就会被检测出来的异常,如IOException、SQLException等;而运行时异常是在程序运行过程中才会出现的异常,如NullPointerException、ArrayIndexOutOfBoundsException等。

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

2. 异常处理的方法在Java中,异常处理的方法主要有try-catch语句和throws关键字。

try-catch 语句用于捕获和处理异常,可以将可能发生异常的代码放在try块中,然后在catch块中处理异常;throws关键字用于声明方法可能抛出的异常,让调用该方法的代码处理异常。

3. 编写能够处理异常的程序通过实验,我们编写了一段能够处理异常的程序。

在程序中,我们使用了try-catch语句来捕获可能发生的异常,并且在catch块中输出异常信息,以便程序的调用者能够得到相应的反馈。

实验结果:经过实验,我们成功掌握了Java中异常处理的基本原理和方法,能够编写能够处理各种异常情况的程序。

实验总结:异常处理是Java编程中非常重要的一部分,能够有效地提高程序的健壮性和可靠性。

通过本次实验,我们深入理解了异常处理的原理和方法,为今后的Java编程打下了坚实的基础。

希望通过不断的实践和学习,能够更加熟练地运用异常处理的技巧,编写出高质量的Java程序。

java泛型枚举和异常实验报告

java泛型枚举和异常实验报告
String s = (String) strobj.getobj();
System.out.println("value= " + s);
}
}
2.阅读程序并分析其输出结果:
public class Exceptiontest
{
public static void mb_createException()
{
this.obj = o1;
}
public Object getobj()
{
return obj;
}
public void setobj(o one)
{
this.obj = one;
}
public void showTyep() {
System.out.println("T的实际类型是: " + obj.getClass().getName());
}
}
public class GenericityDemo
{
public static void main(String[] args)
{
//定义类Genericity的一个Integer版本
Genericity<Integer> intobj = new Genericity<Integer>(new Integer(88));
}
}
class Calculate
{
public void Calcuat(double a,double b)
{
System.out.println("结果为:"+a/b);
}
}

Java泛型总结报告精选

Java泛型总结报告精选

Java泛型总结报告Java泛型总结报告精选篇一:Java泛型总结1. 什么是泛型?泛型(Generic type 或者 generics)是对 Java 语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的类。

可以把类型参数看作是使用参数化类型时指定的类型的一个占位符,就像方法的形式参数是运行时传递的值的占位符一样。

可以在集合框架(Collection framework)中看到泛型的动机。

例如,Map 类允许您向一个Map 添加任意类的对象,即使最常见的情况是在给定映射(map)中保存某个特定类型(比如String)的对象。

因为Map.get() 被定义为返回Object,所以一般必须将Map.get() 的结果强制类型转换为期望的类型,如下面的代码所示:Map m = new HashMap();m.put("key", "blarg");String s = (String) m.get("key");要让程序通过编译,必须将 get() 的结果强制类型转换为 String,并且希望结果真的是一个String。

但是有可能某人已经在该映射中保存了不是String 的东西,这样的话,上面的代码将会抛出ClassCastException。

理想情况下,您可能会得出这样一个观点,即m 是一个Map,它将 String 键映射到 String 值。

这可以让您消除代码中的强制类型转换,同时获得一个附加的类型检查层,该检查层可以防止有人将错误类型的键或值保存在集合中。

这就是泛型所做的工作。

2. 泛型的好处Java 语言中引入泛型是一个较大的功能增强。

不仅语言、类型系统和编译器有了较大的变化,以支持泛型,而且类库也进行了大翻修,所以许多重要的类,比如集合框架,都已经成为泛型化的了。

这带来了很多好处:类型安全。

泛型的主要目标是提高 Java 程序的类型安全。

接口、内部类、异常

接口、内部类、异常
局部位置:在局部位置定义的类,被称为局部内部类。
❖ 方法内部类,也称为局部内部类 ❖ 匿名内部类
成员内部类
❖ 刚才我们讲解过了,成员内部类的使用,但是一般 来说,在实际开发中是不会这样使用的。因为一般 内部类就是不让外界直接访问的。
举例讲解这个问题:Body和Heart,电脑和CPU。
❖ 成员内部的常见修饰符
为常量添加“public static final”修饰符。与此类似,在接口中定义抽象方 法时,也可以省略“public abstract”修饰符,定义default默认方法和 static静态方法时,可以省略“public”修饰符,这些修饰符系统都会默认 进行添加。
接口
接口——语法定义说明
接口中可以包含三类方法,抽象方法、默认方法、静态方法。 静态方法可以通过“接口名.方法名”的形式来调用。 抽象方法和默认方法只能通过接口实现类的实例对象来调用。 接口的实现类,必须实现接口中的所有抽象方法。
建内部类对象的具体语法格式如下:
外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
内部类分类
❖ 按照内部类在类中定义的位置不同,可以分为如下 两种格式:
成员位置:在成员位置定义的类,被称为成员内部类。
❖ 非静态成员内部类,简称为成员内部类 ❖ 静态成员内部类,简称为静态内部类
❖ 抽象类不能被实例化,必须被继承,抽象方法必须 被重写。
❖ 抽象方法只需声明,无需实现; ❖ 抽象类不一定要包含抽象方法,若类中包含了抽象
方法,则该类必须被定义为抽象类
接口概述
❖ 接口概述
继续回到我们的猫狗案例,我们想想狗一般就是看门, 猫一般就是作为宠物了,对不。但是,现在有很多的驯 养员或者是驯兽师,可以训练出:猫钻火圈,狗跳高, 狗做计算等。而这些额外的动作,并不是所有猫或者狗 一开始就具备的,这应该属于经过特殊的培训训练出来 的,对不。所以,这些额外的动作定义到动物类中就不 合适,也不适合直接定义到猫或者狗中,因为只有部分 猫狗具备这些功能。所以,为了体现事物功能的扩展性 ,Java中就提供了接口来定义这些额外功能,并不给出 具体实现,将来哪些猫狗需要被培训,只需要这部分猫 狗把这些额外功能实现即可。

实验三(01)泛型、枚举和内部类-必做

实验三(01)泛型、枚举和内部类-必做

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

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

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

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

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

(比较一下题目1和题目3异同)
评语:
教师签字:日期:年月日。

【兔年惊喜】Java语言程序设计 实验五 第五、六章 泛型、异常、单体类

【兔年惊喜】Java语言程序设计 实验五 第五、六章 泛型、异常、单体类

实验报告课程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));}结果:回答问题:泛型类比较适用于数据的类型转换复杂,代码运行效率低,程序代码复用性低的场合。

java实验报告——异常、集合类和泛型

java实验报告——异常、集合类和泛型
Stu[6]=new XueShengXinXi(" 网 络 ", " 网 络 10-2", " 小 芳 ", " 女 ", "62215", "nfgdmmmdfhbdsh");
Stu[7]=new XueShengXinXi(" 计 算 机 ", " 计 算 机 10-1", " 黄 龙 ", " 男 ", "65584", "bbbdddfnhjbh");
System.out.println("欢迎使用广石化电信学院通讯录系统!");
非0为退出
ZhuJieMian: for(int exit=0;exit==0;)//exit为退出主菜单的指示变量,0为不退出,
{ System.out.println(); System.out.println("************************************"); System.out.println("****************主菜单****************"); System.out.print(" 1。查询学生信息\t\t"); System.out.println("2。新增学生信息"); System.out.print(" 3。修改学生信息\t\t"); System.out.println("4。删除学生信息"); System.out.print(" 5。恢复已被删除信息\t\t"); System.out.println("6。退出"); System.out.println("************************************"); System.out.println("************************************"); System.out.print("请选择你要操作的功能序号:"); Scanner scn_input=new Scanner(System.in); String XuHao=scn_input.next(); System.out.println();

java报告

java报告

实验名称接口与包异常处理实验目的(1)掌握接口和的实现和使用方法。

了解内部类的实现原理。

理解包的概念和作用,掌握包的编写以及如何使用包中的类。

(2)理解Java异常处理机制。

熟练运用异常的抛出、捕捉和处理的实现方法。

掌握自定义异常类。

//(1)import java.util.Scanner;interface Area{public abstract double CalulateArea();}class MyCircle implements Area{protected double r;public MyCircle(double r) {this.r = r;}public double CalulateArea() {return Math.PI * this.r * this.r;}}class MyRectangle implements Area {protected double length;protected double width;public MyRectangle(double l, double w) {length = l;width = w;}public double CalulateArea() {return length * width;}}public class area_ex {public static void main(String[] args) {Scanner mo=new Scanner(System.in);System.out.print("请输入圆的半径:");double r=mo.nextDouble();System.out.println(new MyCircle(r).CalulateArea());System.out.print("请输入矩形的长和宽:");double l=mo.nextDouble();double w=mo.nextDouble();System.out.println(new MyRectangle(l, w).CalulateArea());}}//(2)import re.Rectangle;import ci.Circle;public class bag_ex{public static void main(String []args){Rectangle re=new Rectangle(10,20);re.print();Circle ci=new Circle(10);ci.print();}}package re;public class Rectangle{double length,width;public Rectangle(double length,double width){this.length = length;this.width = width;}public double area(){return length*width;}public void print(){System.out.println("矩形的面积为:"+this.area());}package ci;public class Circle{double R;public Circle(double R){this.R = R;}public double area(){return Math.PI*R*R;}public void print(){System.out.println("圆形的面积为:"+this.area());}}//(3)class Outer{String name="jie";void getInfo(){int age=10;char sex='M';System.out.println("年龄:"+age);System.out.println("性别:"+sex);}class Inner{void sayHello(){getInfo();System.out.println("姓名:"+name);}}Inner in=new Inner();}public class Inner_ex{public static void main(String []args){Outer out=new Outer();out.in.sayHello();}}//(4)public class Error1{public static void main(String []args){try{int i=1;i=i/0;}catch(ArithmeticException e){System.out.println(e.getMessage());}}}//(5)public class Error2{void product()throws MyError{double a=10;double b=-10;double c;c=a*b;if(c<0)throw new MyError("两个数的乘积小于0!"+c);}public static void main(String []args){Error2 er=new Error2();try{er.product();}catch(MyError e){System.out.println(e.toString());}}}class MyError extends Exception{public MyError(String s){super(s);}public MyError(){super("");}}。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验报告
课程名称: 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(PCI
p),在方法体内通过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,写出调试结果。

然后,自己编写一个能抛出并捕获、处理NullPointerException、NumberFormanException多异常的程序,并调试后写出运行结果。

具体操作步骤及程序代码为:
1.
interface PCI{
public void start();
public void stop();
}
class NetworkCard implements PCI{
public void start(){
System.out.println("sending data......"); }
public void stop(){
System.out.println("network stop."); }
}
class SoundCard implements PCI{
public void start(){
System.out.println("dudu......");
}
public void stop(){
System.out.println("sound stop.");
}
}
public class MainBoard{
public void usePCICard(PCI p){
p.start();
p.stop();
}
public static void main(String[] args){
NetworkCard nc=new NetworkCard();
SoundCard sc=new SoundCard();
MainBoard mb=new MainBoard();
ePCICard(nc);
ePCICard(sc);
}
}
2.public class GenericPool<T>{
private Object[] objArray;
private int headLoc;
private int tailLoc;
public GenericPool(int length){
objArray=new Object[10];
headLoc=-1;
tailLoc=-1;
}
public T get(){
Object result=null;
int idx=(headLoc+1)%objArray.length;
if(objArray[idx]!=null){
result=objArray[idx];
objArray[idx]=null;
headLoc++;
}
return (T)result;
}
public int add(T o){
int ins=(tailLoc+1)%objArray.length;
if(objArray[ins]!=null){
return -1;
}
objArray[ins]=o;
tailLoc=ins;
return ins;
}
public static void main(String[] args){
GenericPool<String>pool=new GenericPool<String>(2);
System.out.println(pool.add("1"));
String x=pool.get();
System.out.println(x);
System.out.println(pool.add("2"));
}
}
3.public class OutClass{
private String name;
private String state;
public OutClass(String name,String state){
super();
=name;
this.state=state;
}
private void say(){
System.out.println("外部"+name+"的状态是"+state);
}
public class InnerClass{
public void alarm(){
System.out.println("内部:"+name+"的状态是"+state);
say();
}
}
public static void main(String[] args){
OutClass Outer=new OutClass("冰箱","完好");
OutClass.InnerClass inner=Outer.new InnerClass();
inner.alarm();
}
}
4.p182 9-2的运行结果为:
D:\Java>java Summer2
不能给我一个null的参数!
P183 9-3 的运行结果为:
D:\Java>java Summer3
也不能给我一个不是数值型的参数!
sum=0
public class BuHuo{
public static int sum(String a,String b){
int sum=0,x=0,y=0;
try{
a.trim();
b.trim();
x=Integer.parseInt(a);
y=Integer.parseInt(b);
sum=x+y;
}catch(NullPointerException e){
System.out.println("不能给我一个null的参数!");
}catch(NumberFormatException e){
System.out.println("不能给我一个不是数值型的字符串参数!");
}
return sum;
}
public static void main(String[] args){
int result=sum("ab",null);
System.out.println("sum="+result);
}
}
四、实验体会(实验中碰到的问题及解决方法等)
1、知道了接口该如何定义和如何使用接口。

2、学会了枚举类的定义和使用,掌握了内部类的定义和使用方法。

3、能正确区分异常和错误,掌握了将可能发生异常的语句放在try{}catch(){}代码块中,来确保异常发生时能够得到捕获,并学会了自定义异常。

4、理解题目容易,自己写比较难,往往会遇到一些问题很难得到解决。

如:找不到符号是什么愿意导致,当定义一个方法为public时,有时程序会出错,而删除时程序能正常运行的原因。

5、将可能发生异常的语句放在try{}还不能很好的理解,如:对输入值的判断,不知道该把那句放在try中。

相关文档
最新文档