实验六-内部类与异常类
第六章 内部类与异常类
嵌套try-catch-finally语句
Java语言的try-catch-finally语句可以嵌套,即
在try块中可以包含另外的try-catch-finally语句。
【示例程序c11_3.java】 使用嵌套的try-catch-finally语句自行处理异常。
public class c11_3 { static int a,b,c; public static void main(String args[ ]) { try { a=10; b=0; try { c=a/b; System.out.println("a/b = " + c); } catch (IndexOutOfBoundsException E) { System.out.println("捕捉超出索引异常 ..."); } finally { System.out.println("嵌套内层的 finally区块 "); } } catch(ArithmeticException E) { System.out.println("捕捉数学运算异常: b="+b); } finally { System.out.println("嵌套外层的 finally区块 "); if(b == 0) System.out.println("程序执行发生异常 !"); else System.out.println("程序正常执行完毕 !"); } } }
例子
class China { final String nationalAnthem="义勇军进行曲"; Beijing beijing; China() { beijing=new Beijing(); } String getSong() { return nationalAnthem; } class Beijing //内部类 { String name="北京"; void speak() { System.out.println("我们是"+name+" 我们的国歌是:"+getSong()); } } } public class Example4_30 { public static void main(String args[]) { China china=new China(); china.beijing.speak(); } }
第8节课 内部类和异常处理
这是外部类
private String name;
private int age;
private class 学籍{ Calendar 入学时间; String 系别;
这是内部类,它的修饰符没有static ,可以和成员变量、成员方法一样
private void 输入系别(String xb){ 系别=xb;
第八节课 内部类和异常处理
学习目标
了解内部类有哪几种类型 了解内部类和外部类的关系 能看懂有匿名内部类的程序
第八节课 内部类和异常处理
内部类
定义在类中的类就称为内部类,也称为成员类 分类
非静态成员内部类 静态成员内部类 局部内部类 匿名内部类
特点
内部类可以访问外部类的成员,包括private成员 内部类的成员只有在内部类的范围内是可知的,不能被外部类使
public interface 马戏团动物 { void 会表演(); void 动物名();
}
1、在一个包中新建一个接口,名为 马戏团动物,新建一个类,名为马戏 团 2、接口代码如上图所示 3、马戏团类代码如图所示 4、在“马戏团”类中有一个方法叫 “指派动物”,它需要“马戏团动物” 对象, 由于没有事先设计任何子类继承“马 戏团动物”类,因此在调用该方法时, 我们就用设计匿名内部类的方法临时 设计一个没名的子类
public static void main(String[] args) { int i = 1; while (i <= 5) { try { System.out.print("请输入第" + i + "个数 "); Scanner sn = new Scanner(System.in); int n = sn.nextInt(); System.out.println("你输入的是:" + n); i++; } catch (Exception e) { System.out.println("你输入的不是数字"); } }
内部类实验报告
一、实验目的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. 成员内部类:通过定义在类中的内部类,可以访问外部类的成员变量和方法。
第六章 内部类与异常类
RuntimeException类 RuntimeException子类
CheckedException类 CheckedException子类
异常类的继承结构
异常类的继承关系
Java中所有的异常类都继承自 ng.Throwable类。Throwable类有两个 直接子类:
try-catch-finally结构
无异常
try 执行catch
有异常
执行finally
try-catch-finally结构
例子
public class Example4_33 { public static void main(String args[ ]) { int n=0,m=0,t=555; try{ m=Integer.parseInt("8888"); n=Integer.parseInt(“abc789”); t=9999; } catch(NumberFormatException e) { System.out.println("发生异常:"+e.getMessage()); e.printStackTrace(); n=123; } System.out.println("n="+n+",m="+m+",t="+t); } }
嵌套try-catch-finally语句
Java语言的try-catch-finally语句可以嵌套,即
在try块中可以包含另外的try-catch-finally语句。
【示例程序c11_3.java】 使用嵌套的try-catch-finally语句自行处理异常。
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,写出调试结果。
第5章 内部类与异常类
public class Example{ public static void main(String args[]) { RedCowFarm farm = new RedCowFarm("红牛农 场"); farm.showCowMess(); farm.cow.speak(); //RedCowFarm.RedCow redCow = new RedCowFarm.RedCow(180,119,6000);//如果将内部类 定义为static,那么就可以用外部类名直接访问内部类的 构造方法。 //redCow.speak(); //如果将内部类定义为static,那 么声明的内部类的对象也可以直接访问内部类的方法。 } }
interface SpeakHello { void speak(); }
public class Example { public static void main(String args[]) { HelloMachine machine = new HelloMachine(); machine.turnOn( new SpeakHello(){ public void speak() {//实现接口中的方法 System.out.println("hello,you are welcome!"); } } ); machine.turnOn( new SpeakHello(){ public void speak() {//实现接口中的方法 System.out.println("你好,欢迎光临!"); } } ); } }
throws
• 在可能出现异常的方法上声明抛出可能出现异常的类型: – 声明的时候尽可能声明具体的异常,方便更好的处理. • 当前方法不知道如何处理这种异常,可将该异常交给上一级调用者来处理(非 RuntimeException类型的异常)。 • 方法一旦使用throws声明抛出方法内可能出现的异常类型, 该方法就可以不 再过问该异常了; • 一个方法调用另一个使用throws声明抛出的方法,自己要么try...catch , 要么也throws;
5.内部类和异常类
String s1=“Hello World!”; String s2=“Hello World!”; 此时:s1==s2
0xAb28 0xAb28
Hello World!
s2
思考:如果按照下式定义,s1 和 s2还相等吗? String s1=new String(“Hello World!”); String s2=new String(“Hello World!”);
Java技术及其应用
class 动物类{} class 骡子类{ class 马类 extends 动物类{ void 奔跑(){System.out.println("我能奔跑");} } class 驴类 extends 动物类{ void 拉磨(){System.out.println("我能拉磨");} } 马类 马; 1、接口可以实现简单的多重继承功能 驴类 驴; 骡子类(){ 2、一个外嵌类,拥有多个内部类, 马=new 马类(); 驴=new 驴类(); 可理解为多重继承的一种变通形式 } 注意:原理上没有关系 void 奔跑(){ 马.奔跑(); } void 拉磨(){ 驴.拉磨(); } } class Example{ public static void main(String args[]) { 骡子类 骡子=new 骡子类(); 骡子.奔跑(); Java技术及其应用 骡子.拉磨();
小结
内部类可直接调用外嵌类中的属性和方法; 外嵌类必须通过内部类的对象调用其属性和方法。
Java技术及其应用
字符串处理中几个问题
Java技术及其应用
关于字符串处理
Java提供String类,专门负责处理跟字符串相关 的操作。 String类在ng包内,是默认导入的。
实验题目
实验一 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面向对象程序设计第6章 内部类与异常类
内部类与异常类
主讲:王美丽
办公室:信息学院403 Email: meili_w@
主要内容
• 内部类 • 匿名类 • 异常类
• 断言
难点
• 异常类ቤተ መጻሕፍቲ ባይዱ
6.1 内部类
类的成员: 成员变量、成员方法 Java支持在一个类中声明另一个类,这样的类称作内部类, 而包含内部类的类称为内部类的外嵌类。 内部类可以访问外嵌类的成员变量、成员方法 。 外嵌类的类体中可以用内部类声明对象,作为外嵌类的成员。 内部类的类体中不可以声明类变量和类方法。 内部类能够访问外部内的一切成员变量和方法,包括私有的, 而实现接口或继承类做不到。
异常类
概念
特点
异常是指程序在执行过程中出现的意外 事件。
通常会使程序的正常流程被打断
能否很好的处理运行时刻的异常情况是一个程序 健康的标志
什么时候会发生异常?
输入数据不符合要求
除数为0
数组的下标越界
少了所需加载的类
打开不存在的文件
网络无法连接
操作数超出所要求的范围
自定义异常,要求程序处理…
和接口有关的匿名类
Java允许直接用接口名和一个类体创建一个匿名对象,
此类体被认为是实现了 Computable接口的类去掉类声 明后的类体,称作匿名类。 下列代码就是用实现了 Computable 接口的类(匿 名类)创建对象:
new Computable() { 实现接口的匿名类的类体
}
6.3
行重写
• 由于匿名类没有类名,因此不能重用这个对象
• 创建形式:
new People(){
匿名类类体 };
和类有关的匿名类
Java实验报告5 异常类、字符串、文件读取
}
void play(){ //播放wav文件
adc.play();
System.out.println("播放中...");
}
void stop(){ //停止播放wav文件
adc.stop();
System.out.println("停止播放");
}
}
public class filemusic{
System.out.println("/**************************/");
Scanner ss=new Scanner(System.in);
String s1=ss.nextLine();
if(s1.equals("play"))
audioPlay.play();
else if(s1.equals("stop"))
实验报告
【实验名称】第五章 异常类 字符串 文件读取
【实验目的】
1.学习内部类和异常类
2.学习字符串处理和文件读写
【实验原理】
1.Java程序设计基本原理
2.面向对象程序设计基本原理
【实验内容】
实验一:按要求修改一个播放器程序
import java.applet.Applet;
import java.applet.AudioClip;
输入对应的字符串后,执行播放,停止和退出程序的功能,如果输入的不是这三个指令,给出提示“无效的指令”。
注意:字符串比较不能使用“==”,应该使用equals方法。
(4)SetPlayAudioPath(String path)方法添加异常处理,当参数path的后缀名不是.wav时,给出异常消息“不支持的文件格式”。
chapter 6 内部类与异常类1
a=b=c=10; try{ d=a/(b-c); System.out.println("d="+d); }
例6.4(效果如图所示) public class Example6_4 { public static void main(String args[ ]) { int n=0,m=0,t=555; try{ m=Integer.parseInt("8888"); n=Integer.parseInt("abc789"); t=9999; } catch(NumberFormatException e) { System.out.println("发生异常:"+e.getMessage()); e.printStackTrace(); n=123; } System.out.println("n="+n+",m="+m+",t="+t); } }
6.3 异常类
所谓异常就是运行时可能出现一些错 误,程序运行出现异常时,Java运行环境 就用异常类Exception的相应子类创建一个 异常对象,并等待处理,例如,读取一个 不存在的文件时,运行环境就用异常类 IOException创建一个对象,异常对象可以 调用如下方法得到或输出有关异常的信息:
其中Error类由系统保留,而Exception类则 供应用程序使用。 Exception类又分为两种:运行时异常和非运 行时异常。
运行时异常(RuntimeException)是在Java运行 系统执行过程中出现的异常。 非运行时异常(Non- RuntimeException)是由 编译器检测到的,在程序运行过程中可能发 生而要求必须处理的异常。
java实验报告:实验六
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字符串缓冲区;通过调用某些方法可以改变该序列的长度和内容;每个字符串缓冲区都有一定的容量,只要字符串缓冲区所包含的字符序列的长度没有超出此容量,就无需分配新的内部缓冲区数组;如果内部缓冲区溢出,则此容量自动增大。
(五)异常和内部类
Some PDF Features such as printing, editing, 128 BIT encryption, etc are disabled in evaluation mode
我们说过,已检查异常是一定要处理的。 如: .... Static void method() throws Exception { ... ... throws Exception 告诉编译器,我有可能发生异 常,但它自己不处理,它交给调用它的方法去处理。 } 所以,throws XXX 异常只是一种申明,它不做任何的处理,我们叫这种方式 为: 消极的处理方式。 b) 积极的处理方式 i. Try . . . catch 1. try { //有可能出现异常的代码块; } catch (Exception e ) { //catch 后面跟得一定是个异常对像, 包括已 检查和未检查异常。 // . . . } 一旦 try 块中发生了异常,并能被 catch 后的异常所匹配,则语句会 接着 catch 后面执行,正常返回。 一个 try {} 块, 后面可以跟多个 catch() 语句。 注意:多个 catch() 语句时,子类型在前面,父类型在后面, 因为:如果父类型在前面的话,父类型一旦匹配了,则子类型就 不起作用了呀,这时 JVM 会出现编译错误,因为它不会永远不会执行 的代码存在的。 ii. Try . . . catch . . . finally 1. 最后,还可以加上 finally { . . . } 2. finally{ . . . } 中的代码块是一定会被执行的,不管有无异常发生。 3. 除非: try 或 catch 代码块中有 System.exit(0) ,提前退出 4. 所以, 根据 finally 块的这种特性,它一般用来释放资源。 5. 运行规则: 从 try 块出来后,如没有异常,进行 finally 块,如出 现异常,会先进行匹配 catch 块,然后再进入 finally. iii. Try . . . finally 1. 从 try 块出来到 finally 块,完后,会逐层抛出异常(如果有的话) 常见的 catch 语句处理方式如下: Try { ... ... } catch (XXXException e ) { e.printStackTrace(); //此方法用来打印内存的堆栈信息 System.out.println(e.getMessage()); //此方法返回在构造异常对象时所传递 的那个字符串。 } 3. 处理异常的原则 a) 什么时候 throws? 什么时候 try . . . catch ? i. 把一个异常留给真正该去处理的那个方法,通过 throws 逐层地传递到这 i.
接口、内部类、异常
❖ 方法内部类,也称为局部内部类 ❖ 匿名内部类
成员内部类
❖ 刚才我们讲解过了,成员内部类的使用,但是一般 来说,在实际开发中是不会这样使用的。因为一般 内部类就是不让外界直接访问的。
举例讲解这个问题:Body和Heart,电脑和CPU。
❖ 成员内部的常见修饰符
为常量添加“public static final”修饰符。与此类似,在接口中定义抽象方 法时,也可以省略“public abstract”修饰符,定义default默认方法和 static静态方法时,可以省略“public”修饰符,这些修饰符系统都会默认 进行添加。
接口
接口——语法定义说明
接口中可以包含三类方法,抽象方法、默认方法、静态方法。 静态方法可以通过“接口名.方法名”的形式来调用。 抽象方法和默认方法只能通过接口实现类的实例对象来调用。 接口的实现类,必须实现接口中的所有抽象方法。
建内部类对象的具体语法格式如下:
外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
内部类分类
❖ 按照内部类在类中定义的位置不同,可以分为如下 两种格式:
成员位置:在成员位置定义的类,被称为成员内部类。
❖ 非静态成员内部类,简称为成员内部类 ❖ 静态成员内部类,简称为静态内部类
❖ 抽象类不能被实例化,必须被继承,抽象方法必须 被重写。
❖ 抽象方法只需声明,无需实现; ❖ 抽象类不一定要包含抽象方法,若类中包含了抽象
方法,则该类必须被定义为抽象类
接口概述
❖ 接口概述
继续回到我们的猫狗案例,我们想想狗一般就是看门, 猫一般就是作为宠物了,对不。但是,现在有很多的驯 养员或者是驯兽师,可以训练出:猫钻火圈,狗跳高, 狗做计算等。而这些额外的动作,并不是所有猫或者狗 一开始就具备的,这应该属于经过特殊的培训训练出来 的,对不。所以,这些额外的动作定义到动物类中就不 合适,也不适合直接定义到猫或者狗中,因为只有部分 猫狗具备这些功能。所以,为了体现事物功能的扩展性 ,Java中就提供了接口来定义这些额外功能,并不给出 具体实现,将来哪些猫狗需要被培训,只需要这部分猫 狗把这些额外功能实现即可。
异常类的定义及处理(精)
一、实验名称异常类的定义及处理二、实验目的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、设计编写程序完成以下任务。
【免费下载】异常类的定义及处理
(2)注释掉 outofBound()方法中捕获异常的语句
(3)重新定义 array 方法
2.编写程序实现如下功能:计算两个数之和,参与求和运算的每个数的值都必须在 10-20 之间,当任意一 个数超出范围时,抛出自己的异常。 步骤(1):基于系统异常类 Exception,定义自己的异常类 NumberRangeException。 步骤(2):定义包含 main 方法的 Application 类 SelfException。 步骤(3):在 SelfException 类中添加料试卷电气设备,在安装过程中以及安装结束后进行高中资料试卷调整试验;通电检查所有设备高中资料电试力卷保相护互装作置用调与试相技互术关,系电,力根通保据过护生管高产线中工敷资艺设料高技试中术卷资,配料不置试仅技卷可术要以是求解指,决机对吊组电顶在气层进设配行备置继进不电行规保空范护载高与中带资负料荷试下卷高问总中题体资,配料而置试且时卷可,调保需控障要试各在验类最;管大对路限设习度备题内进到来行位确调。保整在机使管组其路高在敷中正设资常过料工程试况中卷下,安与要全过加,度强并工看且作护尽下关可都于能可管地以路缩正高小常中故工资障作料高;试中对卷资于连料继接试电管卷保口破护处坏进理范行高围整中,核资或对料者定试对值卷某,弯些审扁异核度常与固高校定中对盒资图位料纸置试,.卷保编工护写况层复进防杂行腐设自跨备动接与处地装理线置,弯高尤曲中其半资要径料避标试免高卷错等调误,试高要方中求案资技,料术编试交写5、卷底重电保。要气护管设设装线备备置敷4高、调动设中电试作技资气高,术料课中并3中试、件资且包卷管中料拒含试路调试绝线验敷试卷动槽方设技作、案技术,管以术来架及避等系免多统不项启必方动要式方高,案中为;资解对料决整试高套卷中启突语动然文过停电程机气中。课高因件中此中资,管料电壁试力薄卷高、电中接气资口设料不备试严进卷等行保问调护题试装,工置合作调理并试利且技用进术管行,线过要敷关求设运电技行力术高保。中护线资装缆料置敷试做设卷到原技准则术确:指灵在导活分。。线对对盒于于处调差,试动当过保不程护同中装电高置压中高回资中路料资交试料叉卷试时技卷,术调应问试采题技用,术金作是属为指隔调发板试电进人机行员一隔,变开需压处要器理在组;事在同前发一掌生线握内槽图部内 纸故,资障强料时电、,回设需路备要须制进同造行时厂外切家部断出电习具源题高高电中中源资资,料料线试试缆卷卷敷试切设验除完报从毕告而,与采要相用进关高行技中检术资查资料和料试检,卷测并主处且要理了保。解护现装场置设。备高中资料试卷布置情况与有关高中资料试卷电气系统接线等情况,然后根据规范与规程规定,制定设备调试高中资料试卷方案。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验六内部类和异常类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程序代码,编写好完整的程序文档,最后运行得到的相关文件,把实验所得文件一起打包上交。