下载文档原格式
一、实验目的1. 理解内部类的概念及其在Java编程中的应用。
2. 掌握内部类的定义、使用方法和特点。
3. 通过实例分析，加深对内部类的理解。
二、实验环境1. 操作系统：Windows 102. 开发工具：Eclipse IDE3. 编程语言：Java三、实验内容1. 内部类的定义及特点2. 成员内部类3. 静态内部类4. 局部内部类5. 匿名内部类四、实验步骤1. 创建一个名为“OuterClass”的类，作为外部类。
2. 在“OuterClass”中定义一个成员内部类“InnerClass”。
3. 在“OuterClass”中定义一个静态内部类“StaticInnerClass”。
4. 在“OuterClass”中定义一个局部内部类“LocalInnerClass”。
5. 创建一个匿名内部类的实例，并演示其使用。
五、实验代码```java// 1. 创建外部类OuterClasspublic class OuterClass {// 2. 成员内部类InnerClasspublic class InnerClass {public void display() {System.out.println("这是成员内部类InnerClass的方法");}}// 3. 静态内部类StaticInnerClasspublic static class StaticInnerClass {public void display() {System.out.println("这是静态内部类StaticInnerClass的方法");}}// 4. 局部内部类LocalInnerClasspublic void outerMethod() {class LocalInnerClass {public void display() {System.out.println("这是局部内部类LocalInnerClass的方法");}}LocalInnerClass localInner = new LocalInnerClass();localInner.display();}// 5. 匿名内部类public void anonymousInnerClass() {Runnable runnable = new Runnable() {@Overridepublic void run() {System.out.println("这是匿名内部类的方法");}};new Thread(runnable).start();}public static void main(String[] args) {OuterClass outer = new OuterClass();OuterClass.InnerClass inner = outer.new InnerClass(); InnerClass.display();StaticInnerClass staticInner = new StaticInnerClass(); staticInner.display();outer.outerMethod();outer.anonymousInnerClass();}}```六、实验结果与分析1. 成员内部类：通过定义在类中的内部类，可以访问外部类的成员变量和方法。
实验报告课程名称： 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语言概述【实验目的】1．掌握开发Java应用程序的三个步骤：编写源文件、编译源文件和运行应用程序。
2．熟悉Java应用程序的基本结构，并能联合编译应用程序所需要的类。
文件保存要求：在D:盘新建文件夹“学号”，在“D:\ 学号”下新建文件夹“timu1”。
题目1的文件保存在“timu1”中，以下依次类推。
【题目1】1、实验要求：编写一个简单的Java应用程序，该程序在命令行窗口输出两行文字：“你好，很高兴学习Java”和“We are students”。
2、程序模板：请按模板要求，将【代码】替换为Java程序代码。
3、实验后的练习a.编译器怎样提示丢失大括号的错误。
b.编译器怎样提示语句丢失分号的错误。
c.编译器怎样提示将System写成system这一错误。
d.编译器怎样提示将String写成string这一错误。
【题目2】1、实验要求：编写3个源文件：、、，每个源文件只有一个类。
含有应用程序的主类（含有main方法），并使用了Teacher和Student类。
将3个源文件保存到同一目录，D:\timu2，然后编译。
2、程序模板：请按模板要求，将【代码】替换为Java程序代码。
3、实验后的练习a.将编译通过后，不断地修改源文件中的【代码2】。
比如，在命令行窗口输出“我是语文老师”或“我是数学老师”。
要求每次修改源文件后，单独编译，然后直接运行应用程序（不要再编译）。
b.如果需要编译某个目录下的全部Java源文件，如D:\1001目录，可以使用如下命令：D:\1001>javac *.java请练习上述命令。
【题目3】1、实验要求：课本第15页习题2、实验后的练习习题8.(4)实验四类与对象【实验目的】1．掌握使用类来封装对象的属性和行为。
2．掌握对象的组合以及参数传递。
3．掌握类变量与实例变量，以及类方法与实例方法的区别。
文件保存要求：在D:盘新建文件夹“shiyan04”，在“D:\ 20120shiyan04”下新建文件夹“timu1”。
java实验报告：实验六一、实验目的本次实验的主要目的是深入理解和掌握 Java 中的一些关键概念和技术，包括面向对象编程的特性、异常处理机制以及文件操作等。
通过实际的编程实践，提高我们运用 Java 解决实际问题的能力。
二、实验环境本次实验使用的开发工具是 IntelliJ IDEA，操作系统为 Windows 10。
三、实验内容（一）面向对象编程实践1、定义一个名为“Student”的类，包含学生的姓名、学号和成绩等属性，并实现相应的 getter 和 setter 方法。
2、在主函数中创建“Student”类的对象，并对其属性进行赋值和输出。
（二）异常处理1、编写一个方法，实现两数相除的运算。
如果除数为 0，抛出“ArithmeticException”异常。
2、在主函数中调用该方法，并使用trycatch 语句捕获并处理异常。
（三）文件操作1、创建一个文本文件，并向其中写入一些数据。
2、读取该文件中的数据，并将其输出到控制台。
四、实验步骤（一）面向对象编程实践1、首先，在 IntelliJ IDEA 中创建一个新的 Java 项目。
2、然后，创建“Student”类，代码如下：｀｀｀javapublic class Student ｛private String name;private int studentId;private double score;public String getName(）｛return name;｝public void setName(String name) ｛thisname ＝ name;｝public int getStudentId(）｛return studentId;｝public void setStudentId(int studentId) ｛thisstudentId ＝ studentId;｝public double getScore(）｛return score;｝public void setScore(double score) ｛thisscore ＝ score;｝｝｀｀｀3、在主函数中创建“Student”类的对象，并对其属性进行赋值和输出，代码如下：｀｀｀javapublic class Main ｛public static void main(String args) ｛Student student ＝ new Student(）；studentsetName(＂张三"）；studentsetStudentId(1001)；studentsetScore(905)；Systemoutprintln(＂学生姓名：＂＋ studentgetName(））；Systemoutprintln(＂学生学号：＂＋ studentgetStudentId(））；Systemoutprintln(＂学生成绩：＂＋ studentgetScore(））；｝｝｀｀｀（二）异常处理1、编写一个名为“divide”的方法，实现两数相除的运算，代码如下：｀｀｀javapublic class ExceptionHandling ｛public static double divide(double num1, double num2) ｛if （num2 ＝＝ 0) ｛throw new ArithmeticException(＂除数不能为 0"）；｝return num1 ／ num2;｝public static void main(String args) ｛try ｛double result ＝ divide(10, 0)；Systemoutprintln(＂结果：＂＋ result)；｝ catch （ArithmeticException e) ｛Systemoutprintln(＂捕获到异常：＂＋ egetMessage(））；｝｝｝｀｀｀（三）文件操作1、创建一个名为“FileOperation”的类，用于实现文件的写入和读取操作，代码如下：｀｀｀javaimport javaioBufferedWriter;import javaioFileWriter;import javaioIOException;import javaioBufferedReader;import javaioFileReader;public class FileOperation ｛public static void writeToFile(String filePath, String content) ｛try （BufferedWriter writer ＝ new BufferedWriter(new FileWriter(filePath)））｛writerwrite(content)；｝ catch （IOException e) ｛eprintStackTrace(）；｝｝public static String readFromFile(String filePath) ｛StringBuilder content ＝ new StringBuilder(）；try （BufferedReader reader ＝ new BufferedReader(new FileReader(filePath)））｛String line;while （（line ＝ readerreadLine(））！＝ null) ｛contentappend(line)append(＂＼n"）；｝｝ catch （IOException e) ｛eprintStackTrace(）；｝return contenttoString(）；｝public static void main(String args) ｛String filePath ＝＂testtxt"；String data ＝＂这是写入文件的内容"；writeToFile(filePath, data)；String readData ＝ readFromFile(filePath)；Systemoutprintln(＂读取到的文件内容：＼n" ＋ readData)；｝｝｀｀｀五、实验结果（一）面向对象编程实践成功创建了“Student”类的对象，并正确地对其属性进行了赋值和输出。
第8章高级特性:内部类和异常一、本章知识点●知识点1：内部类成员内部类、静态内部类、匿名内部类、局部内部类外部类又叫Top class顶级类，通常必须是public的内部类的分类：成员内部类、静态内部类、匿名内部类、局部内部类包含在外部类中的不带static的内部类，叫成员内部类(跟随外部类实例对象)包含在外部类中static修饰的内部类，叫静态内部类(类似顶级类，仅仅是可见性有区别) 内部类的特点：内部类可以很好的实现隐藏，可以使用protected修饰、private修饰符；内部类可以直接访问外部类的所有成员，包括私有的成员；外部类不能直接访问内部类的成员，必须首先要建立内部类的对象才可访问。
重点:怎样在成员内部类(实例)方法中访问外部类(实例)对象？Outter.this.属性(方法)怎样在测试类中创建内部成员类对象?Inner inner = outer.new Inner();//需要导包，内部类在外部不可见匿名内部类: 当某个方法的参数是抽象类或者接口时，在调用处直接new这个抽象类或接口，使用局部重写方法实现的方式，称为匿名内部类，这类语法在Java/Android 中极其常见！（形参是普通父类，直接new一个匿名内部类局部重写普通父类的某个方法这种语法也存在，但不太多见）1.1.1【案例1:演示、讲解】成员内部类/*外部类中创建成员内部类测试成员内部类的访问*/public class OuterClass {private String name;private int id;//创建外部类方法public void show(){System.out.println("外部类对象的姓名："+name+" 学号："+id);}/*** 创建成员内部类*内部类中不能声明静态的方法和属性（静态常量除外）* 1.测试创建内部类对象* 2.测试内部类如何访问外部类的属性*/public class MemberInnerClass{private String name;private int id;/*** 创建成员内部类方法*/public void Innershow(){//2 测试外部类的属性System.out.println("外部类对象的姓名："++" 学号："+OuterClass.this.id);//访问外部类的方法OuterClass.this.show();//show(); //成员内部类可以直接访问外部类的属性和方法//外部类不能直接访问内部类的属性和方法，如果调用可以先创建对象System.out.println("成员内部类对象的姓名："+name+" 学号："+id);}}}1.1.2【案例2: 练习、讲解】静态内部类//测试静态内部类和外部类在上面案例中加入静态内部类public static class StaCalss{private String name="zhangsan";private int id=10;public void staShow(){System.out.println("静态内部类对象的姓名："+name+" 学号："+id);//静态内部类不能访问外部类非静态的成员//外部类访问静态内部类非静态的成员通过对象.属性（方法）System.out.println(OuterClass.score);}}//测试类里加入OuterClass.StaCalss osc=new OuterClass.StaCalss();osc.staShow();1.1.3【案例3: 练习、讲解】局部内部类//在第一个例题中加入方法方法测试类中oc.showInner();public void showInner(){final int score1=5;System.out.println("外部类对象的姓名："+name+" 学号："+id);class PInner{private String name="zhngsi";private int id;public void showPInner(){System.out.println(name);//局部内部类只能访问其方法中声明的常量System.out.println(score1);//访问外部类的属性System.out.println("外部类对象的姓名：" + + " 学号：" + OuterClass.this.id);}}1.1.3【案例4：、讲解】匿名内部类//测试匿名内部类public abstract class Student {public abstract void sayHi();} /*** 形参是抽象父类* @param stu*/public void testStudent(Student stu){stu.sayHi();}/*** 形参是接口* @param intf*/public void testIntf(Intf intf){intf.on();intf.off();}/*** 形参是系统API某个接口* @param com*/public void testComparator(Comparator<String> com){}/**** @param args*/public static void main(String[] args) {TestAInnerType test = new TestAInnerType();test.testIntf(new Intf(){@Overridepublic void on() {System.out.println("test on");}@Overridepublic void off() {System.out.println("test off");}});new TestAInnerType().testComparator(new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {return pareTo(o1);}});TestAInnerType test1 = new TestAInnerType();test1.testStudent(new Student(){@Overridepublic void sayHi() {System.out.println("局部重写sayHello");}});String[] ary = new String[]{"abb","aab","abc"};System.out.println("默认升序");Arrays.sort(ary);for(String s: ary){System.out.println(s);}System.out.println("降序(匿名内部类实现)");Arrays. Sort(ary, new Comparator<String>() { //此处new出来的是接口的实//现类，是子类@Overridepublic int compare(String o1, String o2) {return pareTo(o1);}});for(String s: ary){System.out.println(s);} }}/*** 测试接口* @author Ava**/interface Intf{public void on();public void off();}●知识点2:自动拆箱和封箱引用类型和基本数据类型之间的转换，称为装箱拆箱常用包装类: Integer,Double,Character,Boolean,FloatLong装箱操作: int ->Interger将基本类型自动转换成相对应的包装类拆箱操作: Integer-> int将包装类转换成基本类型总结:字符串转基本数据类型:包装类.parseXXX(String str)方法基本数据类型转字符串:String.valueOf(基本数据类型)方法2.1.1【案例5：演示、讲解】自动拆箱和封箱//将引用类型转赋值给基本类型(Integer int),如何将字符串通过包装类转换成基本数据类型Integer it=new Integer(124);Int a=it; //将引用类型赋值给基本数据类型(自动拆箱)It=123; // 将基本数据类型赋值给引用类型(自动装箱)Sout(it.toString())Strings1=new String(“123”);Int i=Integer.parseInt(s1); //将String字符串转换成基本数据类型前提是字符串中//必须是基本数据类型的数据//如何将基本型转换成String字符串Inti=10;String s=”“；s=String.valueOf(i); //此方法返回int参数的字符串形式查APIs=i+””; //通过连接符将数字和字符串连接Integer is=i; //先将基本类型封装成引用类型s=is.toString(); //调用toString()方法返回字符串//从键盘获得一个小数，先转换成字符串，再转换成小数输出●知识点3:String、StringBuffer、StringBuilder//String类的两种创建方式特点String对象一旦创建就不能改变，如果需要大量的字符串操作，使用StringBuffer/StringBuilder；StringBuffer:线程安全的字符串序列；类似于String字符串缓冲区；通过调用某些方法可以改变该序列的长度和内容；每个字符串缓冲区都有一定的容量，只要字符串缓冲区所包含的字符序列的长度没有超出此容量，就无需分配新的内部缓冲区数组；如果内部缓冲区溢出，则此容量自动增大。
一、实验名称异常类的定义及处理二、实验目的1) 了解异常处理方法。
2) 熟悉并掌握常见异常的捕获方法。
3) 熟悉JDK中已经定义的若干异常类的层次结构。
4) 掌握自定义异常类的创建方法。
三、实验记录1.编写程序实现如下功能：生成并捕获到NegativeArraySizeException和IndexOutOfBoundsException类型的异常，并显示捕获到的异常信息。
然后在此基础上生成并捕获到NullPointerException类型的异常，并显示捕获到的异常信息。
步骤（1）：编写一个包含main方法的Application类TestException，然后定义一个方法void arraySize(){……}生成并捕获NegativeArraySizeException异常。
步骤（2）：添加一个方法void outofBound(){……}生成并捕获IndexOutOfBoundsException异常。
步骤（3）：添加一个方法void nullPointer(){……}生成并捕获IndexOutOfBoundsException异常。
步骤（4）：在main方法中分别调用以上三个方法。
步骤（5）：将文件保存为TestException.java，然后编译、调试应用程序。
步骤（6）：将outofBound()方法中捕获异常的语句注释掉，重新编译程序，看看会不会有什么语法错误？如果没错误，执行程序看结果有什么不同？步骤（7）：将array方法重新定义为如下形式：void arraySize() throws NegativeArraySizeException{……}然后修改arraySize方法中捕获NegativeArraySizeException异常的语句执行部分。
源程序如下：class TestException {public static void main(String[] args) {try{outofBound();arraySize();nullPointer();}catch(NegativeArraySizeException e){System.out.println(e.toString());}}static void arraySize(){try{int a[]; a=new int[-3];}catch(NegativeArraySizeException e){System.out.println("Error:Negative Array Size");} }static void outofBound(){try{int i;int a[];a=new int[5];for(i=0;i<6;i++){ a[i]=i;System.out.println("a["+i+"]="+ a[i]);}}catch(IndexOutOfBoundsException e){System.out.println("Error:Index Out Of Bounds");} }static void nullPointer(){try{String s=null;System.out.println(s.length());}catch(NullPointerException e){System.out.println("Error:Null Pointer");}}/* static void arraySize() throws NegativeArraySizeException { try{int a[];a=new int[-3];}catch(NegativeArraySizeException e){throw e;}}*/}运行结果如下：（1）（2）注释掉outofBound()方法中捕获异常的语句（3）重新定义array方法2.编写程序实现如下功能：计算两个数之和,参与求和运算的每个数的值都必须在10-20之间，当任意一个数超出范围时,抛出自己的异常。
实验六内部类和异常类1.实验目的1、掌握内部类的常用方法2、掌握匿名类的常用方法3、掌握接异常类的常用方法2.实验内容1、根据附录里的源代码，按照注释要求，完成代码填空，使程序能够运行得出结果。
1）实验1 红牛农场package four;public class RedCowForm {String formName;RedCow cow;//【代码1】//用内部类RedCow声明对象cowRedCowForm(){}RedCowForm(String s){cow=new RedCow(150,112,5000);//【代码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);}}}package four;public class MainClass {public static void main(String[] args) {RedCowForm form=new RedCowForm("红牛农场");form.showCowMess();}}2）实验2 检查危险品package four;public 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;}}package four;public class DangerException extends Exception{ String message;public DangerException(){message="危险品！";}public void toShow(){System.out.print(message+"");}}package four;public class Machine {Goods[] goods;public void checkBag(Goods goods) throws DangerException{ if(goods.isDanger){throw new DangerException();//【代码1】//用throw抛出一个DangerException的匿名类}}}package four;public 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){e.toShow();//【代码2】//e调用toShow()方法System.out.println(goods[i].getName()+"被禁止！");}}}}3）实验3 内部类的使用方法package four;public class Outer{private static int size;/** 内部类Inner的声明 */public class Inner{private int size;/** 方法doStuff() */public void doStuff(int size){size=size+3;//【代码1】 //存取局部变量size加3this.size=size+2;//【代码2】 //存取其内部类的成员变量size加2Outer.this.size=size+1;//【代码3】存取其外部类的成员变量size加1System.out.println(size+" "+this.size+" "+Outer.this.size);}}//内部类Inner结束/** 类Outer中定义的实例方法testInner()方法 */public void testInner(){Inner i=new Inner();i.doStuff(size);//调用Inner类中的doStuff方法}/** main()方法 */public static void main(String args[]){Outer o=new Outer();o.testInner();//调用Outer类中的testInner方法}}//类Outer结束4）实验4 匿名类的使用方法package four;interface Square{ double getSquare(int n);}interface Sqrt{ public double getSqrt(int x);}class A{ void p(Square square){System.out.println(square);//输出getSquare方法计算后的结果}void k(Sqrt sqrt){System.out.println(sqrt);//输出getSqrt方法计算后的结果}}public class Anonymity{ public static void main(String args[]){A a=new A();a.p(null);//实现Square接口，重写getSquare方法，返回n的平方Sqrt sqrt=new Sqrt(){public double getSqrt(int x) {return Math.sqrt(x);}};//重写getSqrt方法，返回x的开平方根，用静态Math.sqrt方法来运算 System.out.println("计算开平方:"+sqrt.getSqrt(5));}}5）实验5 异常类使用方法package four;class MyException extends Exception{String message;MyException(String str){message=str;//把参数的引用传给message成员变量}public String getMessage(){return message;//返回message成员变量}}abstract class C{abstract int f(int x,int y) throws MyException;}class B extends C{int f(int x,int y) throws MyException{if(x<100&&y<100)//判断x、y都不大于100{throw new MyException("乘数超过100");//抛出一个新建的MyException对象，MyException对象中构造方法传入的参数内容为：乘数超过100}return x*y;}}public class eClass{public static void main (String args[]){C a;a = new B();//设计a对象的B类上转型对象try{System.out.println(a.f(12,10));a.f(150,250);//使用f()方法时传入一个大于100的乘数}catch(MyException e){System.out.println("x、y都不大于100");//输出错误信息 }}}2、设计编写程序完成以下任务。
实验六内部类和异常类1.实验目的1、掌握内部类的常用方法2、掌握匿名类的常用方法3、掌握接异常类的常用方法2.实验内容1、根据附录里的源代码，按照注释要求，完成代码填空，使程序能够运行得出结果。
1）实验1 红牛农场package four;public class RedCowForm {String formName;RedCow cow;//【代码1】//用内部类RedCow声明对象cowRedCowForm(){}RedCowForm(String s){cow=new RedCow(150,112,5000);//【代码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);}}}package four;public class MainClass {public static void main(String[] args) {RedCowForm form=new RedCowForm("红牛农场");form.showCowMess();}}2）实验2 检查危险品package four;public 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;}}package four;public class DangerException extends Exception{ String message;public DangerException(){message="危险品！";}public void toShow(){System.out.print(message+"");}}package four;public class Machine {Goods[] goods;public void checkBag(Goods goods) throws DangerException{ if(goods.isDanger){throw new DangerException();//【代码1】//用throw抛出一个DangerException的匿名类}}}package four;public 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){e.toShow();//【代码2】//e调用toShow()方法System.out.println(goods[i].getName()+"被禁止！");}}}}3）实验3 内部类的使用方法package four;public class Outer{private static int size;/** 内部类Inner的声明 */public class Inner{private int size;/** 方法doStuff() */public void doStuff(int size){size=size+3;//【代码1】 //存取局部变量size加3this.size=size+2;//【代码2】 //存取其内部类的成员变量size加2Outer.this.size=size+1;//【代码3】存取其外部类的成员变量size加1System.out.println(size+" "+this.size+" "+Outer.this.size);}}//内部类Inner结束/** 类Outer中定义的实例方法testInner()方法 */public void testInner(){Inner i=new Inner();i.doStuff(size);//调用Inner类中的doStuff方法}/** main()方法 */public static void main(String args[]){Outer o=new Outer();o.testInner();//调用Outer类中的testInner方法}}//类Outer结束4）实验4 匿名类的使用方法package four;interface Square{ double getSquare(int n);}interface Sqrt{ public double getSqrt(int x);}class A{ void p(Square square){System.out.println(square);//输出getSquare方法计算后的结果}void k(Sqrt sqrt){System.out.println(sqrt);//输出getSqrt方法计算后的结果}}public class Anonymity{ public static void main(String args[]){A a=new A();a.p(null);//实现Square接口，重写getSquare方法，返回n的平方Sqrt sqrt=new Sqrt(){public double getSqrt(int x) {return Math.sqrt(x);}};//重写getSqrt方法，返回x的开平方根，用静态Math.sqrt方法来运算 System.out.println("计算开平方:"+sqrt.getSqrt(5));}}5）实验5 异常类使用方法package four;class MyException extends Exception{String message;MyException(String str){message=str;//把参数的引用传给message成员变量}public String getMessage(){return message;//返回message成员变量}}abstract class C{abstract int f(int x,int y) throws MyException;}class B extends C{int f(int x,int y) throws MyException{if(x<100&&y<100)//判断x、y都不大于100{throw new MyException("乘数超过100");//抛出一个新建的MyException对象，MyException对象中构造方法传入的参数内容为：乘数超过100}return x*y;}}public class eClass{public static void main (String args[]){C a;a = new B();//设计a对象的B类上转型对象try{System.out.println(a.f(12,10));a.f(150,250);//使用f()方法时传入一个大于100的乘数}catch(MyException e){System.out.println("x、y都不大于100");//输出错误信息 }}}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程序代码，编写好完整的程序文档，最后运行得到的相关文件，把实验所得文件一起打包上交。
