Java 异常(习题)
Java异常(Exception)处理以及常见异常总结
Java异常(Exception)处理以及常见异常总结⽬录前⾔异常简介异常类型总结前⾔很多事件并⾮总是按照⼈们⾃⼰设计意愿顺利发展的,经常出现这样那样的异常情况。
例如:你计划周末郊游,计划从家⾥出发→到达⽬的→游泳→烧烤→回家。
但天有不测风云,当你准备烧烤时候突然天降⼤⾬,只能终⽌郊游提前回家。
“天降⼤⾬”是⼀种异常情况,你的计划应该考虑到这样的情况,并且应该有处理这种异常的预案。
计算机程序的编写也需要考虑处理这些异常情况。
异常(exception)是在运⾏程序时产⽣的⼀种异常情况,已经成为了衡量⼀门语⾔是否成熟的标准之⼀。
⽬前的主流编程语⾔java也提供了异常处理机制。
异常简介Java中的异常⼜称为例外,是⼀个在程序执⾏期间发⽣的事件,它中断正在执⾏程序的正常指令流。
为了能够及时有效地处理程序中的运⾏错误,必须使⽤异常类,这可以让程序具有极好的容错性且更加健壮。
在 Java 中⼀个异常的产⽣,主要有如下三种原因:1. Java 内部错误发⽣异常,Java 虚拟机产⽣的异常。
2. 编写的程序代码中的错误所产⽣的异常,例如空指针异常、数组越界异常等。
3. 通过 throw 语句⼿动⽣成的异常,⼀般⽤来告知该⽅法的调⽤者⼀些必要信息。
Java 通过⾯向对象的⽅法来处理异常。
在⼀个⽅法的运⾏过程中,如果发⽣了异常,则这个⽅法会产⽣代表该异常的⼀个对象,并把它交给运⾏时的系统,运⾏时系统寻找相应的代码来处理这⼀异常。
我们把⽣成异常对象,并把它提交给运⾏时系统的过程称为拋出(throw)异常。
运⾏时系统在⽅法的调⽤栈中查找,直到找到能够处理该类型异常的对象,这⼀个过程称为捕获(catch)异常。
例 1为了更好地理解什么是异常,下⾯来看⼀段⾮常简单的 Java 程序。
下⾯的⽰例代码实现了允许⽤户输⼊ 1~3 以内的整数,其他情况提⽰输⼊错误。
package io.renren.config;import java.util.Scanner;/*** Created by LiYangYong*/public class TestException {public static void main(String[] args) {System.out.println("请输⼊您的选择:(1~3 之间的整数)");Scanner input = new Scanner(System.in);int num = input.nextInt();switch (num) {case 1:System.out.println("one");break;case 2:System.out.println("two");break;case 3:System.out.println("three");break;default:System.out.println("error");break;}}}正常情况下,⽤户会按照系统的提⽰输⼊ 1~3 之间的数字。
Java日常练习题,每天进步一点点(11)
Java⽇常练习题,每天进步⼀点点(11)⽬录1、对接⼝的描述正确的是()2、类中的数据域使⽤private修饰为私有变量,所以任何⽅法均不能访问它。
3、已知如下类定义:4、在java的⼀个异常处理中,可以包含多个的语句块是()。
5、关于Java语⾔中的final关键字的使⽤,下列说法正确的是()6、在 main() ⽅法中给出的整型数组,如果将其写到⼀个⽂件中,需要()。
7、下列有关Servlet的⽣命周期,说法不正确的是?8、What is displayed when the following is executed?9、假定Base b = new Derived(); 调⽤执⾏b.methodOne()后,输出结果是什么?10、下⾯关于变量及其范围的陈述哪些是不正确的()答案汇总:总结承蒙各位厚爱,我们⼀起每天进步⼀点点!(⿏标选中空⽩处查看答案)1、对接⼝的描述正确的是()正确答案: A⼀个类可以实现多个接⼝接⼝可以有⾮静态的成员变量在jdk8之前,接⼝可以实现⽅法实现接⼝的任何类,都需要实现接⼝的⽅法题解:A,⼀个类只能有⼀个直接⽗类,但是继承是有传递性的。
⼀个类可以实现多的接⼝。
⼀个接⼝可以继承多个类。
B,接⼝中没有普通变量(普通成员变量),接⼝中都是常量,默认修饰符:public static finalC,JDK8之前,接⼝中的⽅法都是默认public abstract的,JDK8之后,接⼝中可以有static、default的修饰的⽅法,⼀旦被修饰,⽅法必须有⽅法体(抽象⽅法可是没有⽅法体的),接⼝中的⽅法都不能被private和protected 修饰,同时外部接⼝、类只能被public修饰或者不写,但是内部接⼝、类可以被四个访问修饰符修饰。
D,实现接⼝,其实就是需要重写接⼝中的abstract⽅法,⼀旦实现的类没有重写完,那么这个类必须是个抽象类(抽象类中可以没有抽象⽅法,但是有抽象⽅法的类必须是抽象类)。
JAVA 习题题目及答案
第2章
作业题
1. 参照例 2-1 编写一个 Java 应用程序,输出俄文字母表。 2. 参照例 2-4 编写一个 Java 应用程序,用户从键盘只能输入整数,程序输出这些整数的乘 积。
第 3 章问答题及作业题
第 3 章 问答题
1、下列 System.out.printf 输出的结果是什么? int a=100,x,y; x=++a; y=a--; System.out.printf(“%d,%d,%d”,x,y,a); 2、下列哪些语句有错误? int x=0; x=5.0/2; float y=12.5F; y=5.0/2;
第 5 章问答题及作业题
第 5 章 问答题
1、子类在什么情况下可以继承父类的友好成员? 2、子类通过怎样的办法可以隐藏继承的成员变量? 3、子类重写继承的方法的规则是什么? 4、子类的构造方法的第一条语句是什么? 5、子类对象一旦重写了继承的方法,就会隐藏继承的方法,是这样吗? 6、子类重写继承的方法时,可以降低方法的访问权限吗? 7、关键字 super 的用法? 8、假设父类有一个方法? public double f(double x, double y){ return x+y; }
第 4 章问答题及作业题
第 4 章 问答题
1、在声明类时,类名应遵守哪些习惯? 2、类体内容有哪两种重要的成员?
3、实例方法可以操作类变量吗?类方法可以操作实例变量吗? 4、当类的字节码加载到内存时,类变量就一定分配了内存空间吗? 5、类的实例变量在什么时候会被封分配内存空间? 6、一个类的类变量被该类创建的所有对象共享吗? 7、不同对象的实例变量分配的内存空间地址一定不同吗? 8、什么叫方法重载?构造方法可以重载吗? 9、请阐述,为什么类方法不可以调用实例方法。 10、请阐述,为什么类方法不能操作实例成员变量。 11、实例方法可以用类名直接调用吗? 12、 关键字 this 可以出现在构造方法中吗?可以出现在实例方法中吗?可以出现在类方 法中吗? 13、源文件中声明编写的类一定在同一个包中吗? 14、 “import java.awt.*;”和“import java.awt.Button”有什么不同? 15、程序中如果使用了“import java.util.*” ,程序运行时,要加载 java.util 包中全部的 类到内存中吗? 16、有几种访问权限修饰符?说出其中一种修饰符的作用? 17、怎样反编译一个类?
Java日常练习题,每天进步一点点(60)
Java⽇常练习题,每天进步⼀点点(60)⽬录1、假设 A 类有如下定义,设 a 是 A 类同⼀个包下的⼀个实例,下列语句调⽤哪个是错误的?()2、Java中基本的编程单元为:3、下列代码的执⾏结果是:()4、给定以下JAVA代码,这段代码运⾏后输出的结果是()5、以下哪⼀项正则能正确的匹配⽹址: /video/av21061574 ()6、下列关于异常处理的描述中,错误的是()。
7、以下哪项不属于java类加载过程?8、对于⽂件的描述正确的是()9、有关hashMap跟hashtable的区别,说法正确的是?10、java中 String str = "hello world"下列语句错误的是?答案汇总:总结承蒙各位厚爱,我们⼀起每天进步⼀点点!(⿏标选中空⽩处查看答案)1、假设 A 类有如下定义,设 a 是 A 类同⼀个包下的⼀个实例,下列语句调⽤哪个是错误的?()class A{ int i; static String s; void method1() { } static void method2() { } }正确答案:CA System.out.println(a.i);B a.method1();C A.method1();D A.method2()题解:1、⾮静态⽅法只能通过实例对象来调⽤,不能直接通过类名调⽤。
静态⽅法(static)才能通过类名直接调⽤.2、类中变量:除了private权限外,其他权限的变量(没有表⽰默认default),均可以⽤“对象.变量名”来调⽤。
对于private变量,即使使⽤static,也不能⽤“类.变量名”来调⽤私有变量。
只能通过类中的public get()⽅法来调⽤。
类中⽅法:除了private权限外,其他权限的⽅法(没有表⽰默认default),均可以⽤“对象.⽅法名”来调⽤。
private ⽅法可以⽤java反射机制调⽤。
JAVA试题集锦(含答案)
JAVA习题锦集(含答案)一、判断题1.(×)接口和类一样也可以有继承关系,而且都只能支持单继承2.(√)可以用FileOutputStream对象作为PrintWrite类的构造方法的参数3.(×)A subclass inherits all methods ( including the constructor ) from the superclass4.(×)Java中所有的类都是ng的子类5.(×)由于URL对象对应的Internet地址可以划分为“协议名”、“端口号”和“文件名”3部分,所以创建一个URL对象后,可以通过修改这3部分内容来修改这个URL对象的Internet地址6.(×)abstract方法不一定要声明在abstract类中7.(×)在Java中,异常(Exception)是指程序在编译和运行进出现的错误8.(√)我们可以方便地编写Java客户机/服务器程序,在客户机/服务器模式中,客户机一般通过套接字(Socket)使用服务器所提供的服务,Socket由两部分组成:IP地址和端口号9.(√)子类的域和方法的数目一定大于等于父类的域和方法的数目10.(×)最终方法只能存在于最终类中二、单选题1、Java语言具有许多优点和特点,下列选项中,哪个反映了Java程序并行机制的特点?B(A)安全性(B)多线性(C)跨平台(D)可移植2、下列选项中不是JAVA语言特点的是()D(A)面向对象(B)平台无关(C)安全性高(D)单线程3、异常包含下列那些内容?()D(A)程序中的语法错误(B)程序的编译错误(C)程序执行过程中遇到的事先没有预料到的情况(D)程序事先定义好的可能出现的意外情况4、JAVA语言中的语句是以()为结尾的。
B(A)句号(B)分号(C)双引号(D)逗号5、下列选项中,哪一个是打印语句的正确表达式:()A(A)System.out.println(); (B)System.out.Println();(C)System.Out.print(); (D)System.Out.println();6、下列哪一个是合法的JAVA语句标示符()C(A)#xyz (B)10Year (C)_Hello (D)@yahoo7、下列哪一个是JAVA语言的关键字()B(A)hello (B)void (C)num_01 (D)abc8、关于数据类型转换下面描述错误的是()D(A)当两个数据的类型不统一时,必须先进行数据类型的转换,再运算或赋值(B)byte类型数据可以转换为short,int,long类型数据(C)long类型数据有可能转换为byte,short,int类型数据(D)在语句int i=(int) 78.67;中,变量i的值为799、下列定义String变量s的语句中,错误的是()A(A)String s=new “Yes!”;(B)String s=new String(“yes!”) ;(C)String s; (D)String s=”Yes!”;10、下列关于注释语句的描述错误的是()DA、多行注释语句的内容,从/*开始,到*/结束B、多行注释语句也可以是单行语句C、文档注释语句的内容,从/**开始,到*/结束D、单行注释语句的内容,从//开始,以分号为结尾句11、定义一个长整型变量a的语句是()DA、int a ;B、a long ;C、float a ;D、long a;12、下列哪个是反斜杠字符的正确表示()AA、\\;B、*\\;C、\;D、\’\’;13.Main()方法的返回类型是()BA、intB、voidC、booleanD、static14. 编译运行以下程序后,关于输出结果的说明正确的是()Bpublic class Con{public static void main(String args[ ]){int x=2;System.out.println(“value is “+ ((x<1) ?22:2));}}A、输出结果为:value is 22.2B、输出结果为:value is 2C、输出结果为:value is 2.0D、编译错误15.给出下面代码:public class test{static int a[] = new a[10];public static void main(String args[]) {System.out.println(arr[10]);}}那个选项是正确的?()AA、编译时将产生错误;B、编译时正确,运行时将产生错误;C、输出零;D、输出空。
JAVA教程(程序异常处理)(精)
程序异常处理引子O在调试航班体息录入程冲•时.町能会遇到这歼的情爲:应用程斤运行过程中.突然中止,屛棗上出现一丸堆英丈让人不知所培・o崔许多域市.很行ATM机随处可见,取歇非常方使•崔ATM机上取欲必须扶輒一定钓步裝携作.若挨作出会相应的災示传息.指导你下一步地楼作.比如密码输入错谖.ATM机将会显示诗码输入错谋・请重新输入”的消息•如是三次密碣伦入梆有谋.則呑卡没商量.o尢论什么斥因引起的程斤运行不正常.都认为是悝序出现了并常.知识要点。
异常的概念。
常见的异常情况。
异常处理的机制◎利用try catch finally实现异常处理o利用thro灵throws创建用户自定义异常知识学习一异常概念。
异常一血巾把程序运行中可能遇到的错罠分为两类.一类是非致命的.的过某种修正后程号还能键续执行.这类捲谖称为异常.边是一类特殊的运行错误対象. 另一类是致命的.即程序遇到了非常严重的不正常状态,不能简单地恢复轨行,这就是钳渓.叩异常类基类throwablcift生出两个子类:Error类:定义了Java程序运行时出现了灾难性失败的畀常.一股来说java程序不捕获也不拋出^Error的对象(包把动态磁接失败.虛拟机错逞等)•而只处理Except ion类的各子类对Exception类:定义了程序可以捕捉到的异常。
异営分两类:1)条统定义的2)用户定义的;・:・异常处理一对于异常,Java使用一种错误捕获方法进行) 处理,称为异常处理. 1斗处理异常的两种方式-是将异常交田Jam异常处理机制的预设处理方法来处理。
二是利用Java提供的try-cat ch-final ly语句对于㊁能出现的异常作预先处理。
"融辜习一程序运行的错误类型及位置识学习程序ArithmeticException 算术异常整数除法中,如果除数为0,则发生该类井常.Java虛拟机遇到这样的错i昊时会中止程序的执行流程,并新建~个ArithmeticException类的对象.即拋出一个算术运算异常.例如下面的程序将引发ArithmeticException异常:public class Test ArithmeticExceptionfpublic static void main(String args[])(int denominator=0,numerator=20jesult=0;resultanumerator/denominator;〃除数为0,将引发ArithmeticException异席System.out.prlntln(result);知识学习一程序运行的错误类型及位置NullPointerExcept ion异常发生的原因.通常是由于应用程序企图在某个需要的对鮫上使用mil I值。
java异常练习题
java异常练习题Java异常练习题在Java编程中,异常处理是非常重要的一部分。
通过合理地处理异常,我们可以提高程序的稳定性和可靠性。
为了加深对Java异常处理的理解,下面我将给大家提供一些常见的Java异常练习题。
1. 编写一个程序,要求用户输入两个整数,然后计算它们的商并输出。
如果用户输入的第二个数为0,则抛出一个自定义的异常"除数不能为0"。
```javaimport java.util.Scanner;public class DivideByZero {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.print("请输入两个整数:");int num1 = scanner.nextInt();int num2 = scanner.nextInt();try {if (num2 == 0) {throw new DivideByZeroException("除数不能为0");}int result = num1 / num2;System.out.println("结果为:" + result);} catch (DivideByZeroException e) {System.out.println(e.getMessage());}}}class DivideByZeroException extends Exception {public DivideByZeroException(String message) {super(message);}}```2. 编写一个方法,接收一个字符串参数,然后将字符串转换为整数并返回。
如果字符串无法转换为整数,则抛出一个自定义的异常"无法转换为整数"。
Java习题四
100 dots(.) 3 200 dots(.) 4 100 dashes(-) 5 100 dots(.) and 100 dashes(-) 12.如果一个线程调用了 wait()方法,下列哪些方法可以使这个线程继续运行?
2
join() 2 resume() 3 notify() 4 notifyAll() 5 high priority thread is ready 13.下列那个方法是用来定义具体的线程执行功能的?
1
start() 2 init() 3 run() 4 main() 5 synchronized() 14.下列哪些方法可以用来定义一个新的线程类?
1
implement the Runnable interface 2 add a run() method in the class 3 create an instance of Thread 4 extend the Thread class 15.一个方法在声明为同步方法时,只需要在方法名前面加上什么修饰符? 1 synchronized 2 abstract 3 final 4 static 5 public 16.下列哪种情况会p()方法 3 创建一个新的线程 4 有更高优先级的线程准备运行 5 调用输入流的 read()方法 17.给出程序 class Test{ public static void main(String[] args){ Thread t=new Thread(new RunHandler()); t.start(); } } 下列哪些说法可以使得上面程序得以运行? 1 RunHandler 类必须实现 ng.Runnable 接口 2 RunHandler 类必须继承 Thread 类 3 RunHandler 类必须提供一个 run()方法,并且该方法被声明为 public,返回值为 viod
java异常处理试题及参考答案
异常处理练习题一、选择题1.java中用来抛出异常的关键字是(C)A、tryB、catchC、throwD、finally2.关于异常,下列说法正确的是(A)A、异常是一种对象B、一旦程序运行,异常将被创建C、为了保证程序运行速度,要尽量避免异常控制D、以上说法都丌对3.(A)类是所有异常类的父类。
A、4.javaA、try{C、5.{{“除0}A、程序将输出第15行的异常信息B、程序第10行出错C、程序将输出“b=42”D、程序将输出第15和19行的异常信息6.下列程序的执行,说法正确的是(D)class ExMulti{static void procedure(){try{int c[]={1};c[42]=99;}catch(ArrayIndexOutOfBoundsException e){“数组超越界限异常:”+e);}}public static void main(String args[]){“除0}ABCD7.{{}{try{procedure();}catch(IllegalAccessExcepton e) ___________{“捕获:”+e);}}8.对于catch子句的排列,下列哪种是正确的(B )A、父类在先,子类在后B、子类在先,父类在后C、有继承关系的异常不能在同一个try程序段内D、先有子类,其他如何排列都无关9.在异常处理中,如释放资源、关闭文件、关闭数据库等由(C )来完成。
A、try子句B、catch子句C、finally子句D、throw子句10.当方法遇到异常又不知如何处理时,下列哪种说法是正确的(C )A、捕获异常B、抛出异常C、声明异常D、嵌套异常11.哪个关键字可以抛出异常?(C)JVM. int i=0;String greetings[]= {“Hello world!”,“No,I mean it!”,“HELLO WORLD!!”};while(i<4){____try________{}____catch__(ArrayIndexOutOfBoundsException e){i=-1;}finally{}i++;}}三、判断题1. ( F )程序中抛出异常时(throw …),只能抛出自己定义的异常对象。
JAVA各章习题及答案-全解
第1章Java入门一、选择题1.下列选项中,不属于Java语言特点的一项是〔C 〕.〔A〕分布式〔B〕安全性〔C〕编译执行〔D〕面向对象[解析]Java程序采用解释执行的方法.在系统编译运行Java程序时,Java编译器将Java程序转化为字节码,在运行时,解释器将编译得到的字节码进行解释执行.2.在Java语言中,〔 C 〕是最基本的元素?〔A〕方法〔B〕包〔C〕对象〔D〕接口[解析]构成Java程序的基本元素类〔抽象的对象〕. 3.编译一个定义了3个类和10个方法的Java源文件后,会产生〔D 〕个字节码文件?扩展名是〔D 〕?〔A〕13个字节码文件,扩展名为.class〔B〕1个字节码文件,扩展名为.class〔C〕3个字节码文件,扩展名为.java〔D〕3个字节码文件,扩展名为.class[解析]源文件中的每一个类编译后都会生成一个字节码文件,字节码文件的扩展名是.class.4.在创建Applet应用程序时,需要用户考虑问题是〔B 〕.〔A〕窗口如何创建〔B〕绘制的图形在窗口中的位置〔C〕程序的框架〔D〕事件处理[解析]创建Applet程序时必须继承系统类Applet,而Applet类中已经包含了如何创建窗口以与事件处理等内容,这类程序的框架也都是固定的,而绘制图形在窗口中的位置则需要由用户确定.5.Java语言属于〔B 〕种语言?〔A〕面向机器的语言〔B〕面向对象的语言〔C〕面向过程的语言〔D〕面向操作系统的语言[解析]Java语言是一种纯面向对象的语言.6.下列关于Application和Applet程序的说法中不正确的一项是〔B 〕.<A>Application使用解释器java.exe<B>Application不使用独立的解释器〔C〕Applet在浏览器中运行〔D〕Applet必须继承Java的Applet类[解析]Application程序包含main<>方法,它是一种独立执行的程序,因此必须使用独立的解释器解释执行. 7.下列选项中,不属于Java核心包的一项是〔A 〕.〔A〕javax.swing 〔B〕java.io〔C〕java.utile 〔D〕ng[解析]凡是以java开头的包都是Java核心包,以javax 开头的包则属于Java扩展包.8.下列描述中,不正确的是〔A 〕.〔A〕不支持多线程〔B〕一个Java源文件不允许有多个公共类〔C〕Java通过接口支持多重继承〔D〕Java程序分为Application和Applet两类[解析]Java是支持多线程的语言.9.阅读下列代码,选出该代码段正确的文件名〔C 〕.class A{void method1<>{System.out.println<"Method1 in class A">;}}public class B{void method2<>{System.out.println<"Method2 in class B">;}public static void main<String[] args>{System.out.println<"main<> in class B">;}}〔A〕A.java 〔B〕A.class〔C〕B.java 〔D〕B.class[解析]Java源文件名必须和公共类的名字完全一样,源文件的扩展名为.java. 10.编译下面源程序会得到哪些文件〔D 〕?class A1{}class A2{}public class B{public static void main<String[] args>{}}〔A〕只有B.class文件〔B〕只有A1.class 和A2.class文件〔C〕编译不成功〔D〕A1.class、A2.class和B.class文件[解析]由于该程序包含3个类,每个类编译后都会生成1个字节码文件,因此编译后会生成以这3个类名命名的字节码文件.11.编译Java程序时,用于指定生成class文件位置的选项是〔 A 〕.A.-d B.-g C.-verbose D.-nowarn 12.下列标识符〔名字〕命名原则中,正确的是〔 C 〕. A.类名的首字母小写 B.接口名的首字母小写C.常量全部大写 D.变量名和方法名的首字母大写13.下面哪种注释方法能够支持javadoc命令?〔C〕A.// B./*...*/ C./**...*/ D./**...**/ 14.下面哪些选项是正确的main方法说明?〔D〕A.void main<>B.private static void main<String args[]> C.public main<String args[]> D.public static void main<String args[]>二、填空题1.Java程序的编译和执行模式包括2点,是半编译和半解释.2.Java语言支持TCP/IP 协议,从而使得Java程序在分布式环境中能够很方便地访问处于不同地点的对象. 3.开发Java程序的一般步骤是:源程序编辑、生成字节码和解释执行.4.每个Java Application程序可以包括许多方法,但是必须有且只能有一个main<> 方法,统一格式为public static void main<String[] args> ,它是程序执行的入口.5.JVM把字节码程序与各种不同的操作系统和硬件分开,使得Java程序独立于平台.6.在Java程序中,能在WWW浏览器上运行的是Applet 程序.7.Java源程序文件和字节码文件的扩展名分别为.java 和.class .8.如果在Java程序中需要使用java.utile包中的所有类,则应该在程序开始处加上import java.utitle.* 语句.三、判断题1.Java语言具有较好的安全性和可移植性与与平台无关等特性.〔√ 〕2.Java语言的源程序不是编译型的,而是编译解释型的.〔√ 〕3.Java Application程序中,必有一个主方法main<>,该方法有没有参数都可以.〔√ 〕4.java.util.Scanner<System.in>可以接收用户从键盘输入的简单数据.〔√ 〕5.Java程序中不区分大小写字母.〔× 〕6.机器不能直接识别字节码文件,它要经过JVM中的解释器边解释边执行.〔√ 〕7.System类中的println<>方法分行显示信息,而print<>方法不分行显示信息.〔√ 〕8.当前路径的标识是".".〔√ 〕9.java命令不区分大小写,而javac命令区分大小写.〔× 〕10.printf<>和 format<>方法使用指定格式字符串和参数,将格式化字符串写入到PrintStream类型的输出流〔S ystem.out对象〕中.〔√ 〕11.在运行字节码文件时,使用java命令,一定要给出字节码文件的扩展名.class.〔× 〕第2章标识符与简单数据类型一、选择题1.下列〔D 〕是合法的标识符?〔A〕12class 〔B〕void 〔C〕-5 〔D〕_blank 2.下列〔B 〕不是Java中的保留字?〔A〕if 〔B〕sizeof 〔C〕private 〔D〕null 3.下列〔C 〕不是合法的标识符?〔A〕$million〔B〕$_million〔C〕2$_million 〔D〕$2_million4.下列选项中,〔B 〕不属于Java语言的基本数据类型?〔A〕整数型〔B〕数组〔C〕浮点型〔D〕字符型5.下列关于基本数据类型的说法中,不正确的一项是〔D 〕.〔A〕boolean类型变量的值只能取真或假〔B〕float是带符号的32位浮点数〔C〕double是带符号的64位浮点数〔D〕char是8位Unicode字符[解析]Java中的字符采用的是16位的Unicode字符. 6.下列关于基本数据类型的取值范围的描述中,正确的一个是〔B 〕.〔A〕byte类型的取值范围是-128~128〔B〕boolean类型的取值范围是真或假〔C〕char类型的取值范围是0~65536〔D〕short类型的取值范围是-32767~32767[解析]根据每种类型占几个字节即可推算出其取值范围,如byte类型占1个字节,即共包含28个数值,其取值范围范围应为-128~127,其他类型也是如此.7.下列关于Java语言简单数据类型的说法中,正确的一项是〔A 〕.〔A〕以0开头的整数代表8进制整型常量〔B〕以0x或0X开头的整数代表8进制整型常量〔C〕boolean类型的数据作为类成员变量的时候,相同默认的初始值为true〔D〕double型数据占计算机存储的32位8.下列Java语句中,不正确的一项是〔C 〕.〔A〕$e, a, b = 10; 〔B〕char c, d = ‘a’;〔C〕float e = 0.0d; 〔D〕double c = 0.0f;[解析]不能将double类型的常量赋值给float类型的变量.9.在编写Java程序时,如果不为类的成员变量定义初始值,Java会给出它们的默认值,下列说法中不正确的一个是〔D 〕.〔A〕byte的默认值是0 〔B〕boolean的默认值是false 〔C〕char类型的默认值是’\0’〔D〕long类型的默认值是0.0L10.下列语句中不正确的一个是〔B 〕.〔A〕float f = 1.1f; 〔B〕byte b = 128;〔C〕double d = 1.1/0.0; 〔D〕char c = <char>1.1f;[解析]bytel类型变量的取值范围是-128~127. 11.下列表达式1+2+ "aa"+3的值是〔B 〕.〔A〕"12aa3" 〔B〕"3aa3 " 〔C〕"12aa" 〔D〕"aa3"[解析]整数和整数相加得到两个整数的和,而整数和字符串相加得到的是字符串.12.已知y=2, z=3, n=4,则经过n=n+ -y*z/n运算后n的值为〔A 〕.〔A〕3〔B〕-1 〔C〕-1 〔D〕-3[解析]根据运算符的优先级,该表达式相当于n=n+ <<-y>*z>/n.13.已知a=2, b=3,则表达式a%b*4%b的值为〔A 〕.〔A〕2 〔B〕1 〔C〕-1 〔D〕-2[解析]根据运算符的优先级,该表达式相当于<<a%b>*4>%b.14.已知x=2, y=3, z=4,则经过z- = --y – x--运算后,z的值为〔D 〕.〔A〕1 〔B〕2 〔C〕3 〔D〕4[解析]在表达式运算过程中,--y的值变为2,x—的值还是2,等号右侧运算后的值为0,因此z的值没有变化. 15.表达式<12==0> && <1/0 < 1>的值为〔B 〕.〔A〕true B〕false 〔C〕0 〔D〕运行时抛出异常[解析]由于<12==0>的值为false,因此整个表达式发生短路运算,即<1/0 < 1>就没有参与运算,整个表达式的值为false.16.设有类型定义short i=32; long j=64; 下面赋值语句中不正确的一个是〔B 〕〔A〕j=i; 〔B〕i=j; 〔C〕i=<short>j; 〔D〕j=<long>i;[解析]long类型的数据不能自动转变为short类型,因此不能将long类型的变量直接赋值给short类型. 17.现有1个char类型的变量c1=66和1个整型变量i=2,当执行c1=c1+<char>i;语句后,c1的值为〔D 〕.〔A〕'd' 〔B〕'D' 〔C〕68 〔D〕语句在编译时出错[解析]两个字符型的数据相加,得到的是一个整数,而如果把整数再赋值给一个字符型变量则会在编译时出错. 18.下列说法中,正确的一项是〔D 〕.〔A〕字符串"\\abcd" 的长度为6〔B〕False是Java的保留字〔C〕123.45L代表单精度浮点型〔D〕False是合法的Java标识符[解析]Java语言对字符的大小写是敏感的,False不是false,因此False是合法的Java标识符.19.以下的变量定义语句中,合法的是〔D 〕〔A〕float _*5 = 123.456F; 〔B〕byte $_b1 = 12345; 〔C〕int _long_ = 123456L;〔D〕double d = Double.MAX_V ALUE;[解析]〔A〕中_*5不是合法的标识符,〔B〕中12345超出byte范围,〔C〕中不能将long类型的常量赋值给int 型的变量.20.下列关于运算符优先级的说法中,不正确的一个是〔C 〕〔A〕运算符按照优先级顺序表进行运算〔B〕同一优先级的运算符在表达式中都是按照从左到右的顺序进行运算的〔C〕同一优先级的运算符在表达式中都是按照从右到左的顺序进行运算的〔D〕括号可以改变运算的优先次序[解析]同一优先级的运算符在表达式中都是按照从左到右的顺序进行运算的.二、填空题1.变量是Java程序的基本存储单元之一,变量的主要类型包括2大类:字符型和数值型.2.Java语言的整数类型变量和常量一样,各自都包括4种类型的数据,它们分别是byte、int 、short 和long. 3.boolean 类型数据不可以做类型转换.4.在Java语言的基本数据类型中,占存储空间最少的类型是boolean ,该类型占用的存储空间为 1 位. 5.Java语言中的保留字具有特殊意义和作用,不能作为普通标识符使用.6.在Java语言中,浮点类型数据属于实型数据,可以分为单精度和双精度两种.7.char类型的数据可以表示的字符数共为65536 .8.定义初始值为10的8次方的常整型变量iLong的语句是final iLong = 100000000L.9.Java语言中的数据类型转换包括自动转换和强制转换两种.10.Java中的字符采用的是16位的Unicode 编码.11.数据类型中存储空间均为64位的两种数据类型是long 和double .12.表达式9*4/ -5%5的值为-2 .〔十进制表示〕13.表达式5&2的值为0 .〔十进制表示〕14.表达式42<<4的值为672 .〔十进制表示〕15.表达式11010011>>>3的值为11010 .〔二进制表示〕16.表达式7|3的值为7 .〔十进制表示〕17.表达式10^2的值为8 .〔十进制表示〕18.Java语言中的逻辑与<&&>和逻辑或<||>运算采用短路方式进行运算.19.若a、b为int型变量,并且已分别赋值为5和10,则表达式<a++>+<++b>+a*b的值为82 .20.假设i=10, j=20, k=30,则表达式!<i<j+k> || !<i+10<=j> 的值为false .三、判断题1.Java语言使用的是Unicode字符集,每个字符在内存中占8位.〔×〕2.Java语言中不同数据类型的长度是固定的,不随机器硬件不同而改变.〔√〕3.所有的变量在使用前都必须进行初始化.〔×〕4.已知byte i = <byte>127; i = i +1;这两个语句能被成功编译.〔√〕5.String str="abcdefghi"; char chr=str.charAt<9>; 〔×〕6.char[] chrArray={ 'a', 'b', 'c', 'd', 'e', 'f', 'g'}; char chr=chrArray[6]; 〔√〕7.int i,j; boolean booleanValue=<i==j>; 〔×〕8.int intArray[]={0,2,4,6,8}; int length=int Array.length<>;〔×〕9.String str="abcedf"; int length=str.length; 〔×〕10.short shortValue=220; byte byteValue=shortValue; 〔×〕11.int[] intArray[60]; 〔×〕12.char[] str="abcdefgh"; 〔×〕13.说明或声明数组时不分配内存大小,创建数组时分配内存大小.〔√〕14.强制类型转换运算符的功能是将一个表达式的类型转换为所指定的类型.〔√〕第3章运算符、表达式与语句一、选择题1.下列〔D 〕不属于Java语言流程控制结构?〔A〕分支语句〔B〕跳转语句〔C〕循环语句〔D〕赋值语句[解析]Java语言流程控制结构只包括分支、循环和跳转三种语句.2.假设a是int类型的变量,并初始化为1,则下列〔D 〕是合法的条件语句?〔A〕if<a>{} 〔B〕if<a<<=3>{}〔C〕if<a=2>{}〔D〕if<true>{}[解析]条件语句中的"条件表达式"只能是boolean类型,不能是其他类型.3.下列说法中,不正确的一个是〔C 〕.〔A〕switch语句的功能可以由if…else if语句来实现〔B〕若用于比较的数据类型为double型,则不可以用switch语句来实现〔C〕if …else if语句的执行效率总是比switch语句高〔D〕case子句中可以有多个语句,并且不需要大括号{}括起来[解析]语句执行效率高低要根据具体语句来确定,不能简单地说if…else if语句的执行效率总是比switch语句高. 4.设a、b为long型变量,x、y为float型变量,ch为char 类型变量且它们均已被赋值,则下列语句中正确的是〔 B 〕.〔A〕switch<x+y> {} 〔B〕switch<ch+1> {}〔C〕switch ch {} 〔D〕switch<a+b>; {}[解析]switch后面的表达式必须放在括号<>中,且表达式的类型只能是byte、short、int和char类型,不能是其他类型.5.下列循环体执行的次数是〔 C 〕.int y=2, x=4;while<--x != x/y>{ }〔A〕1 〔B〕2 〔C〕3 〔D〕4[解析]第1次执行while时,--x的值为3,3/2=1,满足等号两端值不等的条件,执行一次循环体;第2次执行while 时,--x的值为2,2/2=1,条件满足,又执行一次循环体;第3次执行while时,--x的值为1,1/2=0,条件满足,再次执行一次循环体;第4次执行while时,--x的值为0,0/2=0,条件不满足满足,结束循环.因此在这个循环语句执行的过程中,循环体共执行了3次.6.下列循环体执行的次数是〔 B 〕.int x=10, y=30;do{ y-=x;x++; }while<x++<y-->;〔A〕1 〔B〕2 〔C〕3 〔D〕4[解析]执行1次循环体后,y的值为20,x值为11,然后执行while,此时x++的值为11,y—的值为20,因此x++<y—条件满足,判断完后,x的值变为12,y的值变为19;接着执行第2次循环体,执行完第2次循环体后,y的值为9,x值为13,然后执行while,此时x++的值为13,y—的值为9,因此x++<y—条件不满足,结束循环.因此在这个循环语句执行的过程中,循环体共执行了2次.7.已知如下代码:switch<m>{case0:System.out.println<"Condition 0">;case1:System.out.println<"Condition 1">;case2:System.out.println<"Condition 2">;case3:System.out.println<"Condition3">;break;default:System.out.println<"OtherCondition">; }当m的值为< D >时,输出"Condition 3"〔A〕2 〔B〕0、1 〔C〕0、1、2〔D〕0、1、2、3 [解析]当m的值为0、1、2、3时,都能输出"Condition 3",因为case 0、case 1、case 2后面的语句都没有break,因此可以继续向后执行.二、填空题1.跳转语句包括break、continue、return和throw 2.switch语句先计算switch后面的表达式的值,再和各case 语句后的值做比较.3.if语句合法的条件值是boolean 类型. 4.continue语句必须使用于循环语句中. 5.break语句有两种用途:一种从switch 语句的分支中跳出,一种是从循环语句内部跳出.6.do -while循环首先执行一遍循环体,而while循环首先判断表达式的值 . 7.与C++语言不同,Java语言不通过goto 语句实现跳转.8.每一个else子句都必须和它前面的一个距离它最近的if 子句相对应.9.在switch语句中,完成一个case语句块后,若没有通过break语句跳出switch语句,则会继续执行后面的case 语句块.10.在for循环语句中可以声明变量,其作用域是for循环体.第4章类与对象一、选择题1.下列哪种类成员修饰符修饰的变量只能在本类中被访问?〔D 〕〔A〕protected 〔B〕public 〔C〕default〔D〕private2.在Java语言中,哪一个包中的类是自动导入的?〔 A 〕A〕ng B〕java.awtC〕java.io D〕java.applet[解析]只有ng包中的类能够被自动导入.3.给出下面的程序代码:public class X4_1_3 {private float a;public static void m< >{ }}如何使成员变量a被方法m< >访问〔 C 〕〔A〕将private float a改为protected float a〔B〕将private float a改为public float a〔C〕将private float a改为static float a〔D〕将private float a改为float a[解析]static类型的方法只能访问static类型的数据成员.4.有一个类B,下面为其构造方法的声明,正确的是〔 B 〕.〔A〕void B<int x> {} 〔B〕B<int x> {}〔C〕b<int x> {} 〔D〕void b<int x> {}5.下面关于类的说法,不正确的是〔 C 〕.〔A〕类是同种对象的集合和抽象〔B〕类属于Java语言中的复合数据类型〔C〕类就是对象〔D〕对象是Java语言中的基本结构单位[解析]类是对象的抽象,对象是类的实例6.下面关于方法的说法,不正确的是〔C 〕. 〔A〕Java中的构造方法名必须和类名相同〔B〕方法体是对方法的实现,包括变量声明和合法语句〔C〕如果一个类定义了构造方法,也可以用该类的默认构造方法〔D〕类的私有方法不能被其他类直接访问[解析]类中一旦用户定义了构造方法,该类默认的构造方法就不存在了,除非用户再自定义该类的默认构造方法. 7.关于内部类,下列说法不正确的是〔A 〕.〔A〕内部类不能有自己的成员方法和成员变量〔B〕内部类可用private或protected修饰符修饰〔C〕内部类可以作为其他类的成员,而且可访问它所在的类的成员〔D〕除static内部类外,不能在类内声明static成员8.定义外部类时不能用到的关键字是〔 C 〕.〔A〕final 〔B〕public 〔C〕protected 〔D〕abstract[解析]定义外部类不能使用protected修饰符.9.为AB类定义一个无返回值的方法f,使得使用类名就可以访问该方法,该方法头的形式为〔 D 〕〔A〕abstract void f<> 〔B〕public void f<>〔C〕final void f<> 〔D〕static void f<> [解析]只有static类型的方法才可以直接使用类名来引用.10.定义一个公有double型常量PI,哪一条语句最好?〔 B 〕〔A〕public final double PI;〔B〕public final static double PI=3.14;〔C〕public final static double PI;〔D〕public static double PI=3.14;[解析]用public final static来定义常量,既可以节省存储空间,又可以保证数值不会被改变.二、填空题1.对象是对事物的抽象,而类是对对象的抽象和归纳.2.从用户的角度看,Java源程序中的类分为两种:系统定义的类和用户自己定义的类.3.一个类主要包含两个要素:数据成员和成员方法.4.创建包时需要使用关键字package .5.类中的构造方法是一个特殊的方法,该方法的方法名和类名相同.6.如果用户在一个自定义类中未定义该类的构造方法,系统将为这个类定义一个默认构造方法.这个方法没有形式参数,也没有任何具体语句,不能完成任何操作.7.静态数据成员被保存在类的内存区的公共存储单元中,而不是保存在某个对象的内存区中.因此,一个类的任何对象访问它时,存取到的都是相同〔相同/不同〕的数值.8.静态数据成员既可以通过对象名来访问,也可以通过类名直接访问它.9.定义常量时要用关键字final ,同时需要说明常量的数据类型并指出常量的具体值 .10.方法体内定义变量时,变量前不能加修饰符;局部变量在使用前必须明确赋值,否则编译时会出错;而类变量在使用前可以不用赋值,它们都有一个默认的值.11.static方法中只能引用static 类型的数据成员和static 类型的成员方法;而非static类型的方法中既可以引用static 类型的数据成员和成员方法,也可以引用非static 类型的数据成员和成员方法.12.引用static类型的方法时,可以使用类名做前缀,也可以使用对象名做前缀.13.当程序中需要引用java.awt.event包中的类时,导入该包中类的语句为import java.awt.event.*.14.定义类时需要class 关键字,继承类时需要extends 关键字,实现接口时需要关键字implements .三、判断题1.类是一种类型,也是对象的模板.〔√〕2.类中说明的方法可以定义在类体外.〔×〕3.实例方法中不能引用类变量.〔×〕4.创建对象时系统将调用适当的构造方法给对象初始化.〔√〕5.使用运算符new创建对象时,赋给对象的值实际上是一个引用值.〔√〕6.对象赋值实际上是同一个对象具有两个不同的名字,它们都有同一个引用值.〔√〕7.对象可作方法参数,对象数组不能作方法参数.〔×〕8.class是定义类的惟一关键字.〔√〕9.Java语言会自动回收内存中的垃圾.〔√〕第5章子类与继承一、选择题1.已知有下面类的说明:public class X5_1_1 extends x{private float f =10.6f;int i=16;static int si=10;public static void main<String[] args> {X5_1_1 x=new X5_1_1<>;}}在main<>方法中,下面哪条语句的用法是正确的?〔 A 〕A.x.f B.this.si C.X5_1_1.i D.X5_1_1.f[解析]由于x是在main方法内部定义的对象,因此它可以引用类的非static类型的属性,因此选A,而this和super不能在main方法中使用,使用类名只能引用本类的静态属性,因此B、C、D不对. 2.下列程序的运行结果是〔C 〕.public class X5_1_2 extends x{int ab<>{static int aa=10;aa++;System.out.println<aa>;}public static void main<String[] args> { X5_1_2 x=new X5_1_2<>;x.ab<>;}}A.10 B.11C.编译错误D.运行成功,但不输出[解析]方法体内的局部变量不能使用static修饰符.3.下面关于接口的说法中不正确的是〔C 〕.A.接口中所有的方法都是抽象的B.接口中所有的方法都是public访问权限C.子接口继承父接口所用的关键字是implements D.接口是Java中的特殊类,包含常量和抽象方法[解析]子接口继承父接口所用的关键字也是extends,只有类实现接口时才使用implements.4.区分类中重载方法的依据是〔 A 〕.A.形参列表的类型和顺序B.不同的形参名称C.返回值的类型不同D.访问权限不同[解析]形参表的类型和顺序不同时区分重载方法的唯一标志.5.子类对象能否直接向其父类赋值?父类对象能否向其子类赋值?〔 B 〕A.能,能B.能,不能C.不能,能D.不能,不能[解析]子类对象可以直接赋值给父类对象,而父类对象不能直接赋值给子类对象.6.Java语言类间的继承关系是〔 A 〕.A.单继承B.多重继承C.不能继承D.不一定[解析]Java语言类间的继承关系是单继承,但一个类可以实现多个接口.7.Java语言接口间的继承关系是〔B 〕.A.单继承B.多重继承C.不能继承D.不一定[7.解析]Java语言接口间的继承关系允许多重继承. 8.一个类实现接口的情况是〔A 〕.A.一次可以实现多个接口B.一次只能实现一个接口C.不能实现接口D.不一定[解析]Java语言允许一个类一次实现多个接口.9.定义外部类的类头时,不可用的关键字是〔 C 〕. A.public B.finalC.protected D.abstract[解析]定义外部类时不能使用protected关键字.10.如果局部变量和成员变量同名,如何在局部变量作用域内引用成员变量?〔 B 〕A.不能引用,必须改名,使它们的名称不相同B.在成员变量前加this,使用this访问该成员变量C.在成员变量前加super,使用super访问该成员变量D.不影响,系统可以自己区分[解析]this可以用来引用本类对象.11.下面说法不正确的是〔 B 〕.A.抽象类既可以做父类,也可以做子类B.abstract和final能同时修饰一个类C.抽象类中可以没有抽象方法,有抽象方法的类一定是抽象类或接口D.声明为final类型的方法不能在其子类中重新定义[解析]abstract和final不能同时修饰一个类,因为abstract 类需要子类,而final类不能有子类.二、填空题1.消息就是向对象发出服务请求,是对数据成员和成员方法的引用.2.在面向对象系统中,消息分为两类公有消息和私有消息.3.在面向对象程序设计中,采用继承机制可以有效地组织程序结构.充分利用已有的类来创建更复杂的类,大大提高程序开发的效率,提高代码的复用率,降低维护的工作量.4.数据成员的隐藏是指在子类中重新定义一个与父类中已定义的数据成员名完全相同的数据成员.5.子类可以重新定义与父类同名的成员方法,实现对父类方法的覆盖.6.子类在重新定义父类已有的方法时,应保持与父类完全相同的方法名、返回值类型和参数列表,否则就不是方法的覆盖,而是子类定义自己特有的方法,与父类的方法无关. 7.this代表了当前对象的一个引用,super表示的是当前对象的直接父类对象的引用.8.抽象类不能创建对象,该工作由抽象类派生的非抽象子类来实现.9.如果父类中已有同名的abstract方法,则子类中就不能〔能/不能〕再有同名的抽象方法.10.abstract类中不能有private 访问权限的数据成员或成员方法.11.interface 是声明接口的关键字,可以把它看成一个特殊类.接口中的数据成员默认的修饰符是public static final ,接口中的成员方法默认的修饰符是public abstract .12.如果实现某接口的类不是abstract的抽象类,则在类的定义部分必须实现该接口的所有抽象方法;如果实现某接口的类是abstract的抽象类,则它可以不实现该接口所有的方法.但是对于这个抽象类任何一个非抽象的子类而言,它们父类所实现的接口中的所有抽象方法以与自身所实现接口中的抽象方法都必须有实在的方法体. 13.包的作用有两个,一是划分类名空间,二是控制类之间的访问.14.封装也称信息隐藏,是指类的设计者只为类的使用者提供类的可以访问的部分〔包括类的数据成员和成员方法〕,而把类中的其他成员隐藏起来,使用户不能访问的机制.15.Java提供了4种访问权限来实现封装机制,即private 、protected 、默认和public .16.Java中提供两种多态机制, 重载与覆盖.17.当一个构造方法需要调用另一个构造方法时,可以使用关键字this ,同时这个调用语句应该是整个构造方法的第一条可执行语句.18.如果子类自己没有构造方法,那么父类也一定没有〔有/没有〕带参的构造方法,此时它将继承父类的无参构造方法作为自己的构造方法;如果子类自己定义了构造方法,则在创建新对象时,它将先执行父类的构造方法,然后再执行自己的构造方法 .19.对于父类的含参数构造方法,子类可以通过在自己的构造方法中使用super 关键字来调用它,但这个调用语句必须是子类构造方法的第一条可执行语句.20.创建一个名为myPachkage的包的语句为package myPackage; ,该语句应该放在程序第一行位置.三、判断题1.Java语言中,构造方法是不可以继承的.〔√〕2.子类的成员变量和成员方法的数目一定大于等于父类的成员变量和成员方法的数目.〔×〕3.抽象方法是一种只有说明而无具体实现的方法.〔√〕4.Java语言中,所创建的子类都应有一个父类.〔√〕5.调用this 或super构造方法的语句必须放在第一条语句.〔√〕6.一个类可以实现多个接口,接口可以实现"多重继承".〔√〕7.实现接口的类不能是抽象类.〔√〕8.使用构造方法只能给实例成员变量赋初值.〔√〕9.Java 语言不允许同时继承一个类并实现一个接口.〔×〕。
(完整word版)异常处理练习题
异常处理练习题一、选择题1.java中用来抛出异常的关键字是A、tryB、catchC、throwD、finally2.关于异常,下列说法正确的是A、异常是一种对象B、一旦程序运行,异常将被创建C、为了保证程序运行速度,要尽量避免异常控制D、以上说法都不对3.()类是所有异常类的父类。
A、ThrowableB、ErrorC、ExceptionD、AWTError4.java语言中,下列哪一子句是异常处理的出口A、try{…}子句B、catch{…}子句C、finally{…}子句D、以上说法都不对5.下列程序的执行,说法正确的是public class MultiCatch{public static void main(String args[]){try{int a=args.length;int b=42/a;int c[]={1};c[42]=99;System.out.println(“b=”+b);}catch(ArithmeticException e){System.out.println(“除0异常:”+e);}catch(ArrayIndexOutOfBoundsException e){System.out.println(“数组超越边界异常:”+e);}}}A、程序将输出第15行的异常信息B、程序第10行出错C、程序将输出“b=42”D、程序将输出第15和19行的异常信息6.下列程序的执行,说法正确的是class ExMulti{static void procedure(){try{int c[]={1};c[42]=99;}catch(ArrayIndexOutOfBoundsException e){System.out.println(“数组超越界限异常:”+e);}}public static void main(String args[]){try{procedure();int a=args.length;int b=42/a;System.out.println(“b=”+b);}catch(ArithmeticException e){System.out.println(“除0异常:”+e);}}}A、程序只输出第12行的异常信息B、程序只输出第26行的异常信息C、程序将不输出异常信息D、程序将输出第12行和第26行的异常信息7.下面程序抛出了一个“异常”并捕捉它。
java试题练习题(第9套)
—— 学年第 学期 《 Java 程序设计 》课程试题 课程号: √ 考试 □ A 卷 √ 闭卷 □ 考查 □ B 卷 □ 开卷一、单项选择题(20题;每题2分,共40分) 1、下面选项中,___不可以用作变量名的首字符。
A )字母 B )下划线(_) C )数字 D )美元符号(¥) 答案:C (难度系数C )知识点:变量 2、下面语句中,____不会出现编译警告或错误。
A )float f=1.3; B )char c=”a”; C )byte b=25; D )boolean b=null; 答案:C (难度系数B )知识点:赋值相容 3、下列叙述正确的是___。
A )final 类可以有子类 B )abstract 类中只可以有 abstract 方法 C )abstract 类上可以有非abstract 方法,但该方法不可以用final 修饰 D )不可以同时用final 和abstract 修饰一个方法 答案:D (难度系数B ) 知识点:抽象类,抽象方法 4、创建一个标识有“关闭”按钮的语句是___。
A ) TextField b = new TextField(“关闭”);B ) Label b = new Label(“关闭”);C ) Checkbox b = new Checkbox(“关闭”);D ) Button b = new Button(“关闭”);答案:D (难度系数C ) 知识点:GUI 编程5、在编写异常处理的Java 程序中,每个catch 语句块都应该与___语句块对应,使得用该语句块来启动Java 的异常处理机制。
班级:姓名: 学号:试题共页加白纸张密封线A)if – else B)switch C)try D)throw答案:C(难度系数B)知识点:异常6、paint()方法使用_____类型的参数。
A)Graphics B)Graphics2D C)String D)Color 答案:A (难度系数B,知识点applet)7、下列语句正确的是________。
java 异常 练习题
java 异常练习题Java 异常练习题Java 异常处理是每个 Java 程序员都需要掌握的重要技能之一。
异常是在程序运行过程中出现的错误或异常情况,如除零错误、空指针异常等。
在编写 Java 程序时,我们需要预测并处理可能出现的异常,以保证程序的稳定性和可靠性。
下面,我将给出一些 Java 异常练习题,帮助大家巩固和提升自己的异常处理能力。
1. 编写一个方法,接收一个整数参数,如果参数为负数,则抛出一个自定义的异常 NegativeNumberException,异常信息为"输入的数字不能为负数"。
在主方法中调用该方法,并捕获并处理异常。
2. 编写一个方法,接收两个整数参数,计算它们的商,并返回结果。
在方法中捕获并处理可能出现的除零异常,如果除数为零,则抛出一个自定义的异常DivideByZeroException,异常信息为"除数不能为零"。
在主方法中调用该方法,并捕获并处理异常。
3. 编写一个方法,接收一个字符串参数,将其转换为整数并返回。
在方法中捕获并处理可能出现的数字格式异常,如果无法转换为整数,则抛出一个自定义的异常 NumberFormatException,异常信息为"无法将字符串转换为整数"。
在主方法中调用该方法,并捕获并处理异常。
4. 编写一个方法,接收一个文件路径参数,读取文件内容并打印。
在方法中捕获并处理可能出现的文件不存在异常,如果文件不存在,则抛出一个自定义的异常 FileNotFoundException,异常信息为"文件不存在"。
在主方法中调用该方法,并捕获并处理异常。
5. 编写一个方法,接收一个整数数组参数,计算数组中所有元素的平均值并返回。
在方法中捕获并处理可能出现的数组下标越界异常,如果数组下标越界,则抛出一个自定义的异常 ArrayIndexOutOfBoundsException,异常信息为"数组下标越界"。
2020年计算机二级《JAVA》章节练习题:异常和断言
2020年计算机二级《JAVA》章节练习题:异常和断言第6章异常和断言1[单选题]哪个关键字能够抛出异常? ( )A.transientB.finallyC.throwD.static参考答案:C2[单选题]给出一段程序,试判断哪个是准确的结果( )public class rtExcept{public static void throwit(){System.out.print(“throwit”);throw new RuntimeException();}public static void main(String [] aa){try{System.out.print(“hello “);throwit(); }catch(Exception re){System.out.print(“caught ”); }finally{System.out.print(“finally ”); }System.out.print(“after ”);}}A.hello throwit caughtB.hello throwit caught finally afterC.hello throwit RuntimeException afterD.hello throwit caught finally after RuntimeException 参考答案:B3[单选题]下列叙述中准确的是A.软件测试应该由程序开发者来完成B.程序经调试后一般不需要再测试C.软件维护只包括对程序代码的维护D.以上三种说法都不对参考答案:D4[单选题]参考答案:B5[单选题]给出一段程序,试判断哪个是准确的结果( ) public class myprogram{public static void main (String args[]){try{System.out.print(“Hello world ”); }finally{System.out.println(“Finally executing”); }}}A.无法编译,因为没有指定异常B.无法编译,因为没有catch子句C.Hello worldD.Hello world Finally executing参考答案:B6[填空题]数据独立性分为逻辑独立性与物理独立性。
Java里的异常(Exception)详解
Java⾥的异常(Exception)详解作为⼀位初学者, 本屌也没有能⼒对异常谈得很深⼊. 只不过⾥关于Exception的东西实在是很多. 所以这篇⽂章很长就是了..⼀, 什么是java⾥的异常由于java是c\c++ 发展⽽来的, ⾸先我们先看看c语⾔⾥的错误.1.1 c语⾔⾥的错误我们实现1个程序的过程包括, 代码编写, 编译代码成为程序, 执⾏程序..其中⼤部分常见的语法错误都会被编译代码这样部过滤掉. 但是即使通过了编译. 执⾏程序这⼀步可能还是会有错误.原因很多, 例如常见的除数为0, 内存溢出(数组的index超出界限), 或者内存被其他程序修改等.最简单的例⼦:[java]1. #include <stdio.h>2.3. int f(int a, int b){4. return a/b;5. }6.7. int main(){8. int i = f(8,0);9. printf("i is %d\n",i);10. return 0;11. }上⾯的例⼦编译时是⽆错的, 但是⼀旦执⾏就会提⽰吐核错误了.c语⾔⾥对这种执⾏时出现的错误是⽆能为⼒的, ⼀旦出错就会整个程序崩溃, 就不会在继续执⾏下⾯的代码.⽽且很多时候出错信息很少, 让你⽆法判断出错的原因和地⽅, 只能⼀步步⼩⼼debug...所以很多⽤c写的程序有时会出现⾮法关闭的现象.解决⽅法只能是在代码⾥对可能出错的地⽅添加if 判断.例如f()函数⾥可以对b进⾏判断, 如果是0就不执⾏.1.2 java⾥运⾏时出现的错误java⾥编译器对代码的规范性⽐c严格得多. 但是即使如此, 通过编译的java程序有时也很难避免执⾏时出错.例如, 将上⾯的c程序改编成java程序:[java]1. package Exception_kng;2.3. class Exp1{4. public int f(int a, int b){5. return a/b;6. }7. }8.9. public class Expt_1{10. public static void g(){11. Exp1 e = new Exp1();12. int i = e.f(8,0);13. System.out.printf("i is %d\n", i);14. }15. }运⾏时⼀样会出错, 下⾯是出错信息:[java]1. [java] Caused by: ng.ArithmeticException: / by zero2. [java] at Exception_kng.Exp1.f(Expt_1.java:5)3. [java] at Exception_kng.Expt_1.g(Expt_1.java:12)4. [java] at Enter_1.main(Enter_1.java:31)但是可以见到, java告诉你出错的类型: 运算错误(ArithmeticExcetion), 出错信息和出错的类与⽂件⾏数输出, ⽅便你调试. jvm虚拟机是会对错误作出⼀定的处理的.所以可以简单地将java⾥的异常理解成java运⾏时出现的错误, 异常机制就是对这种错误进⾏处理的机制.1.3 java异常的定义实际上, 当java程序执⾏时出现错误时, jvm会把执⾏时出错的信息(例如出错原因, 类型, 位置) 收集,然后打包成为1个对象(object), 程序员可以对这种对象进⾏处理. 这种对象就是所谓的异常.可能出现的异常的代码并不是肯定会出现异常, 取决于执⾏环境和数据.!⼆, java⾥的异常的分类.见下图:Throwable/ \Error Exception/ / \xxxxxx xxxxxx RuntimeException/ \xxxxxx ArithmeticException上图的所有对象都是类.Throwable 代表是可抛出的.Error 代表的是严重错误, 这种错误程序员⽆法进⾏处理, 例如操作系统崩溃, jvm出错, 动态链接库失败等. Error并不是异常, 不是本⽂的重点.Exception 代表的就是异常了. 它下⾯很多派⽣类, 其中它的派⽣类也分两种, ⼀种是RuntimeException(运⾏时异常), 其他的都是⾮运⾏时异常RuntimeException 包括除数为0, 数组下标超界等. 运⾏时异常的派⽣类有很多, 其产⽣频率较⾼. 它的派⽣类可以由程序处理或者抛给(throw) 给jvm处理. 例如上⾯的例⼦就是抛给了jvm处理, jvm把程序中断执⾏, 并把错误信息输出到终端上.⾮RuntimeExcption 这种异常属于Excepion的派⽣类(上⾯红⾊的xxx), 但是不是RuntimeException的派⽣类, 这种异常必须由程序员⼿动处理,否则不通过编译.ArithmeticExcpetion 算术异常, 它是RuntimeException的派⽣类, 所以程序员不⼿动处理也通过编译, 只不过出错时会被jvm处理.三, java⾥对异常的处理java⾥对异常的处理有三种.3.1 程序猿对有可能出现的异常使⽤try catch处理.例如我们将上⾯的例⼦改动⼀下:[java]1. package Exception_kng;2.3. class Exp2{4. public int f(int a, int b){5. int i = 0;6. try{7. i = a/b;8. }9. catch(Exception e){10. System.out.printf("Exception occurs!!\n");11. System.out.println(e.getMessage()); //print the root cause12. System.out.printf("===========================\n");13. e.printStackTrace(); //print the info of function stuck.14. }15.16. return i;17. }18. }19.20. public class Expt_2{21. public static void g(){22. Exp2 ex = new Exp2();23. int i = ex.f(8,0); //call f()24. System.out.printf("i is %d\n", i); //successfully executed25. }26. }在f()函数中对可能出现的异常的代码进⾏try catch处理后, 程序会执⾏catch⾥的代码. ⽽且不会中断整个程序, 继续执⾏try catch后⾯的代码.程序执⾏输出:[java]1. [java] Exception occurs!!2. [java] / by zero3. [java] ===========================4. [java] ng.ArithmeticException: / by zero5. [java] at Exception_kng.Exp2.f(Expt_2.java:7)6. [java] at Exception_kng.Expt_2.g(Expt_2.java:23)7. [java] at Enter_1.main(Enter_1.java:31)8. [java] i is 0注意最终也执⾏了g()函数中的最后⼀条语句, 输出了i的值.也就是说try catch处理后并不会终⽌程序, 令程序即使出现了错误, 也可以对错误进⾏⼀定的处理后继续执⾏. 这就是java异常机制⽐c语⾔安全的地⽅.下⾯会详细讲解 try catch.注:getMessage() ⽅法: Exception类的⽅法之⼀, 返回异常的原因, 上⾯的 / by zero 就是这个⽅法输出的.printStackTrace(): Exception类的⽅法之⼀, 在屏幕输出函数栈信息, 也就是异常出现的地⽅.3.2 函数⾥并不处理异常, 使⽤throw or throws 关键字把可能出现的异常抛给调⽤该函数的上级函数处理.例如我在f()函数中不想处理可能出现的异常, 想把它抛出上级函数处理:下⾯是个例⼦:[java]1. package Exception_kng;2.3. class Exp3{4. public int f(int a, int b){5. if (0 == b){6. throw new ArithmeticException("Shit !!! / by zero!");7.8. }9.10. return a/b;11. }12. }13.14. public class Expt_3{15. public static void g() throws ArithmeticException{16. Exp3 ex = new Exp3();17. int i = 22;18. i = ex.f(8,0); //throw excetpion19. System.out.printf("i is %d\n", i); //failed executed20. System.out.printf("g() is done!!\n"); //failed executed21. }22.23. public static void h(){24. try{25. g();26. }catch(ArithmeticException e){27. System.out.printf("Exception occurs!!\n");28. System.out.println(e.getMessage()); //print the root cause29. System.out.printf("===========================\n");30. e.printStackTrace(); //print the info of function stuck.31. }32.33. System.out.printf("h() is done!!\n"); //successfully executed34. }35. }可以见到f() 加了个条件判断, 如果参数b = 0, 使⽤throw 直接⼿动抛出1个异常. 让调⽤它的函数处理.g()调⽤f()函数, 预见到f()可能有异常, 但是也不想处理, 使⽤throws 关键字告诉调⽤它的函数本函数有可能抛出这种异常. // 注, 这⾥的throws 对程序并没有实质的影响.h()调⽤g(), 简单g()定义的throws, ⽤try catch在本函数进⾏处理.输出:[java]1. [java] Exception occurs!!2. [java] Shit !!! / by zero!3. [java] ===========================4. [java] ng.ArithmeticException: Shit !!! / by zero!5. [java] at Exception_kng.Exp3.f(Expt_3.java:6)6. [java] at Exception_kng.Expt_3.g(Expt_3.java:18)7. [java] at Exception_kng.Expt_3.h(Expt_3.java:25)8. [java] at Enter_1.main(Enter_1.java:31)9. [java] h() is done!!注意这个程序没有执⾏g() 最后的代码.throw 和 throws 后⾯也会详细讲解.3.3 交给jvm虚拟机处理假如上⾯的例⼦h() 也不处理怎么办? 就如1.2 的例⼦, 会抛给jvm处理.但是这种情况只适⽤于RuntimeExecption及其派⽣类.jvm怎么处理呢, 就是中断整个程序, 并把异常信息输出到屏幕上.实际上, 当java程序的1个函数抛出异常时,⾸先会检查当前函数有没有try catch处理, 如果⽆检查上⼀级函数有⽆try..catch处理....这样在函数栈⾥⼀级⼀级向上检查, 如果直⾄main函数都⽆try..catch, 则抛给jvm..项⽬中强烈建议尽量⼿动处理, 不要把异常交给jvm.四,Try catch finally 的处理机制.这⾥开始详解try catch finally了.语法是这样的.try{可能出异常的若⼲⾏代码;}catch(ExceptionName1 e){产⽣ExceptionName 1的处理代码;}catch(ExceptionName2 e){产⽣ExceptionName 2的处理代码;}...finally{⽆论如何, 最终肯定会执⾏的代码}4.1 try catch finally的执⾏路线.下⾯⽤个例⼦来说明:[java]1. try{2. f();3. ff();4. }5. catch(ArithmeticException e){6. g();7. }8. catch(IOException e){9. gg();10. }11. catch(AuthorizedException e){12. ggg();13. }14. finally{15. h();16. }17.18. k();4.1.1 当try⾥⾯的f()抛出了IOException当f()抛出了异常, 那么ff()就不会执⾏了. 程序会尝试捕捉异常.⾸先捕捉ArithmeticException, 捕捉失败.接下来捕捉IOException, 捕捉成功, 执⾏gg();⼀旦捕捉到⼀个异常, 不会再尝试捕捉其他异常, 直接执⾏finally⾥的h();执⾏后⾯的函数k().也就是说路线是:f() -> gg() -> h() -> k()有2点要注意的.1. f()函数极有可能未完整执⾏, 因为它抛出了异常, 抛出异常的语句执⾏失败, 之后的语句放弃执⾏.2. try{} ⾥⾯, f()之后的语句, 例如ff()放弃执⾏.4.1.2 没有任何异常抛出这种情况很简单, 就是try{}⾥⾯的代码被完整执⾏, 因为没有抛出任何异常, 就不会尝试执⾏catch⾥的部分, 直接到finally部分了.路线是:f() -> ff() -> h() -> k()4.2 如何确定要捕捉的异常名字.也许有⼈会问, 我们怎么知道到底会抛出什么异常?下⾯有3个解决⽅案.1.看代码凭经验, 例如看到1段除法的代码, 则有可能抛出算术异常.2.在catch的括号⾥写上Exception e, 毕竟Exception 是所有其他异常的超类, 这⾥涉及多态的知识, ⾄于什么是多态可以看看本⼈的另⼀篇⽂章.3. 观察被调⽤函数的函数定义, 如果有throws后缀, 则可以尝试捕捉throws 后缀抛出的异常4.3 为什么需要finally包括我在内很多⼈会觉得finally语句简直多勾余, 既然是否捕捉到异常都会执⾏, 上⾯那个例⼦⾥的h()为什么不跟下⾯的k() 写在⼀起呢.上⾯的例⼦的确看不出区别.但下⾯两种情况下就体现了finally独特的重要性.4.3.1 抛出了1个异常, 但是没有被任何catch⼦句捕捉成功.例如try⾥⾯抛出了1个A异常, 但是只有后⾯只有捕捉B异常, 和C异常的⼦句.这种情况下, 程序直接执⾏finally{}⾥的⼦句, 然后中断当前函数, 把异常抛给上⼀级函数, 所以当前函数finally后⾯的语句不会被执⾏.例⼦:[java]1. package Exception_kng;2.3. import .*;4. import java.io.*;5.6. class Exp4{7. public int f(int a, int b) throws IOException, BindException{8. return a/b;9. }10. }11.12. public class Expt_4{13. public static void g(){14. Exp4 ex = new Exp4();15. int i = 22;16. try{17. System.out.printf("g() : try!!\n"); //failed18. i = ex.f(8,0); //call f()19. }20. catch(BindException e){21. System.out.printf("g() : BindException!!\n"); //failed22. }23. catch(IOException e){24. System.out.printf("g() : IOException!!\n"); //failed25. }26. finally{27. System.out.printf("g() : finaly!!\n"); //successfully executed28. }29. System.out.printf("g() is done!!\n"); //failed30. }31.32. public static void h(){33. try{34. g();35. }catch(ArithmeticException e){36. System.out.printf("Exception occurs!!\n");37. System.out.println(e.getMessage()); //print the root cause38. System.out.printf("===========================\n");39. e.printStackTrace(); //print the info of function stuck.40. }41.42. System.out.printf("h() is done!!\n"); //successfully executed43. }44. }我所说的情况, 就在上⾯例⼦⾥的g()函数, g()函数⾥尝试捕捉两个异常, 但是抛出了第3个异常(ArithmeticException 算术异常).所以这个异常会中断g()的执⾏, 因为没有被捕捉到, 然后抛给调⽤g()的 h()函数处理, ⽽在h()捕捉到了, 所以h()函数是能完整执⾏的.也就是说g()⾥的[java]1. System.out.printf("g() is done!!\n"); //failed执⾏失败⽽h()⾥的[java]1. System.out.printf("h() is done!!\n"); //successfully executed执⾏成功但是⽆论如何, g()⾥的finally{}部分还是被执⾏了执⾏结果如下:[java]1. [java] g() : try!!2. [java] g() : finaly!!3. [java] Exception occurs!!4. [java] / by zero5. [java] ===========================6. [java] ng.ArithmeticException: / by zero7. [java] at Exception_kng.Exp4.f(Expt_4.java:8)8. [java] at Exception_kng.Expt_4.g(Expt_4.java:18)9. [java] at Exception_kng.Expt_4.h(Expt_4.java:34)10. [java] at Enter_1.main(Enter_1.java:31)11. [java] h() is done!!这种情况是1中编程的低级错误, 在项⽬中是不允许出现.避免⽅法也⼗分简单, 在catch⼦句集的最后增加1个catch(Exception e)就ok, 因为Exception是所有异常的超类, 只要有异常抛出, 则肯定会捕捉到.4.3.2 在catch⼦句内有return⼦句.下⾯例⼦:[java]1. try{2. f();3. ff();4. }5. catch(ArithException e){6. g();7. return j();8. }9. catch(IOException e){10. gg();11. return j();12. }13. catch(AuthorizedException e){14. ggg();15. return j();16. }17. finally{18. h();19. }20.21. k();假如在f()函数抛出了IOExcepion 异常被捕捉到.那么执⾏路线就是f() -> gg() -> j() -> h() -> 上⼀级function也就说, 这种情况下finally⾥的⼦句会在return回上⼀级function前执⾏. ⽽后⾯的k()就被放弃了.4.3.3 finally作⽤⼩结.可以看出, finally⾥的语句, ⽆论如何都会被执⾏.⾄有两种情况除外, ⼀是断电, ⼆是exit函数.在项⽬中, 我们⼀般在finally编写⼀些释放资源的动作, 例如初始化公共变量. 关闭connections, 关闭⽂件等.4.4 try catch finally⾥⼀些要注意的问题.4.4.1 ⽆论如何最多只有1个catch被执⾏这个上⾯提到过了, ⼀旦捕捉到1个异常, 就不会尝试捕捉其他异常.如果try⾥⾯的⼀段代码可能抛出3种异常A B C,⾸先看它先抛出哪个异常, 如果先抛出A, 如果捕捉到A, 那么就执⾏catch(A)⾥的代码. 然后finally.. B和C就没有机会再抛出了.如果捕捉不到A, 就执⾏finally{}⾥的语句后中断当前函数, 抛给上⼀级函数...(应该避免)4.4.2 有可能所有catch都没有被执⾏两种情况, 1就是没有异常抛出, 另⼀种就是抛出了异常但是没有捕捉不到(应该避免)4.4.3 先捕捉⼦类异常, 再捕捉⽗类异常, 否则编译失败加⼊try ⾥⾯尝试捕捉两个异常, 1个是A, 1个是B, 但是A是B的⽗类.这种情况下, 应该把catch(B)写在catch(A)前⾯.原因也很简单, 加⼊把catch(A)写在前⾯, 因为多态的存在, 即使抛出了B异常, 也会被catch(A)捕捉, 后⾯的catch(B)就没有意义了.也就是说如果捕捉Exception这个异常基类, 应该放在最后的catch⾥, 项⽬中也强烈建议这么做, 可以避免上述4.3.1的情况出现.4.4.4 catch与catch之间不能有任何代码.这个没什么好说的. 语法规则4.4.5 finally⾥不能访问catch⾥捕捉的异常对象e每1个异常对象只能由catch它的catch⼦句⾥访问.4.4.6 try⾥⾯的定义变量不能在try外⾯使⽤.跟if类似, 不多说了.4.4.7 try catch finally可以嵌套使⽤.这个也不难理解..五, throw 和throws的机制和⽤法.下⾯开始详讲异常另⼀种处理⽅法throw 和 throws了.注意的是, 这两种⽤法都没有真正的处理异常, 真正处理的异常⽅法只有try catch, 这两种⽅法只是交给上⼀级⽅法处理.就如⼀个组织⾥ , 有1个⼤佬, 1个党主, 1个⼩弟.⼤佬叫党主⼲活, 堂主叫⼩弟⼲活, 然后⼩弟碰上⿇烦了, 但是⼩弟不会处理这个⿇烦, 只能中断⼯作抛给党主处理, 然后堂主发现这个⿇烦只有⼤佬能处理, 然后抛给⼤佬处理..道理是相通的..5.1 throw 的语法与作⽤throws的语法很简单.语法:throw new XException();其中xException必须是Exception的派⽣类.这⾥注意throw 出的是1个异常对象, 所以new不能省略作⽤就是⼿动令程序抛出1个异常对象.5.2 throw 1个 RuntimeException及其派⽣类我们看回上⾯3.2 的例⼦:[java]1. public int f(int a, int b){2. if (0 == b){3. throw new ArithmeticException("Shit !!! / by zero!");4.5. }6.7. return a/b;8. }5.2.1 throw会中断当前函数, 当前函数执⾏失败(不完整)当这个函数的if 判断了b=0时, 就利⽤throws⼿动抛出了1个异常. 这个异常会中断这个函数. 也就是说f()执⾏不完整, 是没有返回值的.5.2.2, 接下来哪个调⽤这个函数就会在调⽤这个函数的语句上收到异常.[java]1. public void g(){2. int i;3. h();4. i = f(); //recevie excepton5. k();6. }例如上没的g()函数, 在调⽤f() 会收到1个异常.这时g()函数有三种选择.1. 不做任何处理这时, g()收到f()⾥抛出的异常就会打断g()执⾏, 也就是说g()⾥⾯的k(); 被放弃了, 然后程序会继续把这个函数抛给调⽤g()函数.然后⼀级⼀级寻求处理, 如果都不处理, 则抛给jvm处理. jvm会中断程序, 输出异常信息. 这个上没提到过了.2. 使⽤try catch处理如果catch成功, 则g()函数能完整执⾏, ⽽且这个异常不会继续向上抛.如果catch失败(尽量避免), 则跟情况1相同.5.3 throw 1个⾮RuntimeException派⽣类的异常将上⾯的例⼦改⼀下:[java]1. public int f(int a, int b){2. if (0 == b){3. throw new IOException("Shit !!! / by zero!");4. }5.6. return a/b;7. }例如, 我不想抛出ArithmeticException, 我想抛出IOExcetpion.注意这⾥, IOException虽然逻辑上是错误的(完全不是IO的问题嘛), 但是在程序中完全可⾏, 因为程序猿可以根据需要控制程序指定抛出任何1个异常.但是这段代码编译失败, 因为IOException 不是 RuntimeException的派⽣类.java规定:5.3.1 如果⼀个⽅法⾥利⽤throw⼿动抛出1个⾮RuntimeException异常, 必须在函数定义声明⾥加上throws 后缀改成这样就正确了:[java]1. public int f(int a, int b) throws IOException{2. if (0 == b){3. throw new IOException("Shit !!! / by zero!");4. }5.6. return a/b;7. }注意在⽅法定义⾥加上了throws⼦句. 告诉调⽤它的函数我可能抛出这个异常.5.3.2 调⽤该⽅法的⽅法则必须处理这个异常例如抄回上⾯的例⼦, g()调⽤f()函数.[java]1. public void g(){2. int i;3. h();4. i = f(); //recevie excepton5. k()6. }但是编译失败.因为f()利⽤throws 声明了会抛出1个⾮runtimeExcetpion. 这时g()必须做出处理.处理⽅法有两种:1. try catch⾃⼰处理:[java]1. public void g(){2. int i = 0;3. h();4. try{5. i = f(); //recevie excepton6. }7. catch(IOException e){8.9. }10. k();11. }需要注意的是, catch⾥⾯要么写上throws对应的异常(这⾥是 IOException), 要么写上这个异常的超类, 否则还是编译失败.2.g()利⽤throws 往上⼀级⽅法抛.[java]1. public void g() throws IOException{2. int i = 0;3. h();4. i = f(); //recevie excepton5. k();6. }这是调⽤g()的函数也要考虑上⾯的这两种处理⽅法了...但是最终上级的⽅法(main ⽅法)还是不处理的话, 就编译失败, 上⾯说过了, ⾮runtimeException⽆法抛给jvm处理.虽然这两种处理⽅法都能通过编译, 但是运⾏效果是完全不同的.第⼀种, g()能完整执⾏.第⼆种, g()被中断, 也就是g()⾥⾯的k(); 执⾏失败.5.4 throws 的语法.throws稍微⽐throw难理解点:语法是:public void f() throws Exception1, Exception2...{}也就是讲, thorws可以加上多个异常, 注意这⾥抛出的不是对象, 不能加上new.⽽且不是告诉别⼈这个函数有可能抛出这么多个异常. ⽽是告诉别⼈, 有可能抛出这些异常的其中⼀种.5.5 throws 的作⽤.如果为f()函数加上throws后续, 则告诉调⽤f()的⽅法, f()函数有可能抛出这些异常的⼀种.如果f()throws 了1个或若⼲个⾮RuntimeException, 则调⽤f()的函数必须处理这些⾮RuntimeException, 如上⾯的g()函数⼀样.如果f() throws的都是RuntimeException, 则调⽤f()的函数可以不处理, 也能通过编译, 但是实际上还是强烈建议处理它们.实际上, 如果1个⽅法f() throws A,B那么它有可能不抛出任何异常.(程序运⾏状态良好)也有能抛出C异常(应该避免, 最好在throws上加上C)5.6 什么时候应该⽤throws5.6.1 ⼀个函数体⾥⾯⼿动throw了1个RumtimeException, 则这个函数的定义必须加上throws⼦句这个是强制, 告诉别⼈这个函数内有炸弹.5.6.2 ⼀个函数内有可能由系统抛出异常.这个是⾮强制的, 但是如果你知道⼀个函数内的代码有可能抛出异常, 最好还是写上throws 后缀⽆论这个异常是否runtimeExcepion.5.7 ⼀般情况下,调⽤1个带有throws⽅法时怎么办个⼈建议, 如果你调⽤1个函数throws A, B, C那么你就在当前函数写上catch(A)catch(B)catch(C)catch(Exception)这样能处理能保证你的函数能完整执⾏, 不会被收到的异常中断.当然如果你允许你的函数可以被中断, 那么就可以在当前函数定义加上throws A, B 继续抛给上⼀级的函数.5.8 重写⽅法时, throws的范围不能⼤于超类的对应⽅法.例如你在⼀个派⽣类重写⼀个⽅法f(), 在超类⾥的f() throws A, B 你重写⽅法时就不throws出 A,,B,C 或者throws A和B的超类.原因也是由于多态的存在.因为1个超类的引⽤可以指向1个派⽣类的对象并调⽤不同的⽅法. 如果派⽣类throws的范围加⼤那么利⽤多态写的代码的try catch就不再适⽤.六, throw和throws⼀些主要区别.⾯试问得多,单独拉出来写了:6.1 throw 写在函数体内, throws写在函数定义语句中.应付⾯试官.6.2 throw 是抛出1个异常对象, throws是有能抛出异常的种类所以throw后⾯的⼀般加上new 和exception名字().⽽throws后⾯不能加上new的6.3 ⼀个⽅法最多只能throw1个异常, 但是可以throws多个种类异常因为⼀旦⼀个函数throw出1个异常, 这个函数就会被中断执⾏, 后⾯的代码被放弃, 如果你尝试在函数内写两个throw, 编译失败.⽽throws 是告诉别⼈这个函数有可能抛出这⼏种异常的⼀种. 但是最多只会抛出⼀种.6.4 如果在⼀个函数体内throw 1个⾮runtimeException, 那么必须在函数定义上加上throws后缀. 但反过来就不是必须的.原因上⾯讲过了.七, ⾃定义异常.我们可以⾃定义异常, 只需要编写1个类, 继承1个异常类就ok例⼦:[java]1. package Exception_kng;2.3. class User_Exception1 extends ArithmeticException{4. public User_Exception1(String Exception_name){5. super(Exception_name);6. }7.8. public void printStackTrace(){ //overwrite9. super.printStackTrace();10. System.out.printf("hey man, i am an user_defined excetpion\n");11. }12. }13.14. class Exp6{15. public int f(int a, int b){16. if (0 == b){17. throw new User_Exception1("Shit !!! / by zero!"); //use User_defined exception18. }19.20. return a/b;21. }22. }23.24. public class Expt_6{25. public static void g() {26. Exp6 ex = new Exp6();27. int i = 22;28. try{29. i = ex.f(8,0); //throw excetpion30. }catch(User_Exception1 e){31. e.printStackTrace();32. }33. System.out.printf("i is %d\n", i);34. System.out.printf("g() is done!!\n");35. }36. }上⾯的类User_Exception1 就是1个⾃定义异常, 并重写了printStackTrace()⽅法.⼋,java异常的优缺点.8.1 c语⾔是如何处理程序错误的.我们要理解异常的优缺点, ⾸先看看没有异常的是如何处理错误的.下⾯是个例⼦:[cpp]1. //openfile2. if (fileOpen() > 0){3. //check the length of the file4. if (gotLengthOfTheFile() > 0){5. //check the memory6. if (gotEnoughMemory() > 0){7. //load file to memory8. if (loadFileToMem() > 0){9. readFile();10. }else{11. errorCode = -5;12. }13.14. }else{15. errorCode = -5;16. }17.18. }else{19. errorCode = -5;20. }21.22. }else{23. errorCode = -5;24. }25.26. //handle error27. case errorCode....28.29. //release Source30. releaseSource();可以见到处理错误有这些特点1. ⼤部分精⼒都在错误处理.2. 需要把各种可能出现的错误全部考虑到, 才能保证程序的稳定性.3. 程序可读性差, 错误处理代码混杂在其他代码中.4. 出错返回信息少, ⼀旦出错难以调试.5. ⼀旦出现了未考虑到的错误, 资源释放代码⽆法执⾏.8.2 java异常机制下是如何编写上述代码的.[java]1. try{2. fileOpen();3. gotLengthOfTheFile();4. gotEnoughMemory();5. loadFileToMem();6. readFile();7. }8. catch(fileOpenFail) { handle1()}9. catch(gotLengthOfTheFileFail) { handle2()}10. catch(gotEnoughMemoryFail) { handle3()}11. catch(loadFileToMemFail) { handle4()}12. catch(readFileFail) { handle4()}13. catch(Exception e) { handle5()} //catch unexpected error14. finally{15. releasSource();16. }8.3 java异常机制的优点:由上⾯的代码可以看出部分优点:1. 业务代码和错误处理代码分离.2. 强制程序猿考虑程序的稳定性.3. 有利于代码调试(异常信息)4. 即使任何异常产⽣, 能保证占⽤的释放(finally)8.4 java异常机制的缺点:1. 异常嵌套难免影响代码可读性2. 并不能令程序逻辑更加清晰.3. 异常并不能解决所有问题。
java异常处理试题及参考答案
异常处理练习题一、选择题1.java中用来抛出异常的关键字是CA、tryB、catchC、throwD、finally2.关于异常;下列说法正确的是AA、异常是一种对象B、一旦程序运行;异常将被创建C、为了保证程序运行速度;要尽量避免异常控制D、以上说法都丌对3.A类是所有异常类的父类..A、ThrowableB、ErrorC、ExceptionD、AWTError4.java语言中;下列哪一子句是异常处理的出口CA、try{…}子句B、catch{…}子句C、finally{…}子句D、以上说法都丌对5.下列程序的执行;说法错误的是CpublicclassMultiCatch{publicstaticvoidmainStringargs{try{inta=args.length;intb=42/a;intc={1};c42=99;}catchArithmeticExceptione{“除0异常:”+e;} catchArrayIndexOutOfBoundsExceptione{“数组超越边界异常:”+e;}}}A、程序将输出第15行的异常信息B、程序第10行出错C、程序将输出“b=42”D、程序将输出第15和19行的异常信息6.下列程序的执行;说法正确的是D classExMulti{staticvoidprocedure{try{intc={1};c42=99;} catchArrayIndexOutOfBoundsExceptione {“数组超越界限异常:”+e;}}publicstaticvoidmainStringargs{try{procedure;inta=args.length;intb=42/a;}catchArithmeticExceptione{“除0异常:”+e;}}}A、程序只输出第12行的异常信息B、程序只输出第26行的异常信息C、程序将不输出异常信息D、程序将输出第12行和第26行的异常信息7.下面程序抛出了一个“异常”并捕捉它..请在横线处填入适当内容完成程序.. classTrowsDemo{staticvoidprocedurethrowsIllegalAccessExcepton{throw__new_____IllegalAccessException“demo”;}publicstaticvoidmainStringargs{try{procedure;}catchIllegalAccessExceptone___________{“捕获:”+e;}}8.对于catch子句的排列;下列哪种是正确的BA、父类在先;子类在后B、子类在先;父类在后C、有继承关系的异常不能在同一个try程序段内D、先有子类;其他如何排列都无关9.在异常处理中;如释放资源、关闭文件、关闭数据库等由C来完成..A、try子句B、catch子句C、finally子句D、throw子句10.当方法遇到异常又不知如何处理时;下列哪种说法是正确的CA、捕获异常B、抛出异常C、声明异常D、嵌套异常11.哪个关键字可以抛出异常CA、transientB、finallyC、throwD、static12.一个异常将终止AA、整个程序B、叧终止抛出异常的方法C、产生异常的try块D、×上面的说法都丌对1、catch子句都带一个参数;该参数是某个异常的类及其变量名;catch用该参数去与__出现异常_____对象的类进行匹配..2、java虚拟机能自动处理__运行异常_____异常..3、变量属性是描述变量的作用域;按作用域分类;变量有局部变量、类变量、方法参数和_______4、捕获异常要求在程序的方法中预先声明;在调用方法时用try-catch-_finally_____语句捕获并处理..5、java语言认为那些可预料和不可预料的出错称为____异常_____6、按异常处理不同可以分为运行异常、捕获异常、声明异常和_抛出异常_____几种..7、抛出异常的程序代码可以是_自定义的异常_____或者是JDK中的某个类;还可以是JVM.8、抛出异常、生成异常对象都可以通过__throws_______语句实现..9、捕获异常的统一出口通过___finally______语句实现..10、java语言的类库中提供了一个___Throwable_______类;所有的异常都必须是它的实例或它子类的实例..11、Throwable类有两个子类:RunException___类和Exception类..12、对程序语言而言;一般有编译错误和__运行____错误两类..13、下面程序定义了一个字符串数组;并打印输出;捕获数组超越界限异常..请在横线处填入适当的内容完成程序..publicclassHelloWorld{inti=0;Stringgreetings={“Helloworld”;“No;Imeanit”;“HELLOWORLD”};whilei<4{____try________{}____catch__ArrayIndexOutOfBoundsExceptione{i=-1;}finally{}i++;}}三、判断题1.F程序中抛出异常时throw…;只能抛出自己定义的异常对象..2.T一个异常处理中finally语句块只能有一个或者可以没有..3.T异常类对象代表当前出现的一个具体异常..4.T5.F如果异常发生时;没有捕获异常的代码;程序会正常执行..四、编程题1.参考下面的程序;试修改程序;捕获相关异常;使得程序能正常运行..提示:用错误数据测试;即可得到异常类名;运行时主方法参数输入abc测试publicclassStringIndexOutOf{publicstaticvoidmainStringargs{Stringstr=args0;“第四个字符为”+str.charAt3;“平方为”+aaaa;}}2.从命令行得到5个整数;放入一整型数组;然后打印输出;要求:如果输入数据丌为整数;要捕获Integer.parseInt产生的异常;显示“请输入整数”;捕获输入参数丌足5个的异常数组越界;显示“请输入至少5个整数”..3.写一个方法voidsanjiaointa;intb;intc;判断三个参数是否能构成一个三角形;如果丌能则抛出异常IllegalArgumentException;显示异常信息a;b;c+”丌能构成三角形”;如果可以构成则显示三角形三个边长;在主方法中得到命令行输入的三个整数;调用此方法;并捕获异常..4.自定义类Sanj;其中有成员x;y;z;作为三边长;构造方法Sanja;b;c分别给x;y;z赋值;方法求面积getArea和显示三角形信息三个边长showInfo;这2个方法中当三条边丌能构成一个三角形时要抛出自定义异常NotSanjiaoException;否则显示正确信息..在另外一个类中的主方法中构造一个Sanj对象三边为命令行输入的三个整数;显示三角形信息和面积;要求捕获异常..。
JAVA期末复习题及答案——第六章
JAVA期末复习题及答案——第六章一.填空题1.Java中的异常类对象是Error类或Exception类的对象,这两个类中 Error 类的对象不会被Java的应用程序捕获和抛出。
2.在下列程序的下划线处,填入适当语句使程序能正确执行并输出异常栈信息public class ThrowableException{public static void main(String args[]){try{throw new Throwable(“这是本人定义的异常”);}catch(Throwable e){System.out.println(“e.toString:”+e.toString());System.out.println(“e.printStackTrace():”);System.out.println(e.printStackTrace()) ;}}}二.选择题1.下列关于finally的说法正确的是:BA、如果程序在前面的catch语句中找到了匹配的异常类型,将不执行finally 语句块B、无论程序是否找到匹配的异常类型,都会去执行finally语句块中的内容C、如果在前面的catch语句块中找到了多个匹配的异常类型,将不执行finally 语句块D、只要有catch语句块,任何时候都不会执行finally语句块2.关于多个catch语句块的异常捕获顺序的说法正确的是:DA、父类异常和子类异常同时捕获B、先捕获父类异常C、先捕获子类异常D、依照catch语句块的顺序进行捕获,只能捕获其中的一个3.关于Java 异常,下列说法错误的是(D)A.异常是定义了程序中遇到的非致命的错误,而不是编译时的语法错误B.try……catch语句中对try 内语句监测,如果发生异常,则把异常信息放入对象e 中C.throws 用来表示一个方法有可能抛出异常给上一层,则在调用该方法时必须捕捉异常,否则无法编译通过D.主函数不可以使用 throws 抛出异常4.所有异常的父类是(B)。
java复习资料(习题版)(带参考答案)
一、选择题1、为AB类的一个无形式参数无返回值的方法method书写方法头,使得使用类名AB作为前缀就可以调用它,该方法头的形式为( A )A)static void method() B)public void method()C) final void method() D)abstract void method()2、Java中main()函数的返回值是什么类型(D )A) String B) int C) char D) void3、以下说法正确的是(A )A)Java中所有的方法都必须在类内定义B) Java中主方法可以不在类内定义,其他方法都必须定义在类内C) Java中主方法必须定义在类内,其他方法可以不必定义在类内D) Java中所有方法都不必在类内定义4、Java不支持多重继承,但我们可以通过(B )实现A)多态B) 接口C) 覆盖D) 抽象类5、已知表达式int[] m = {0, 1, 2, 3, 4, 5, 6 };下面B哪个表达式的值与数组元素个数相等(B )A) m.length() B) m.length C) m.length()+1 D) m.length+16、所有的异常类皆继承哪一个类(B )A)java.io.Exception B) ng.ThrowableC) ng.Exception D)ng.Error7、关于布尔类型说法正确的是(A )A)boolean表示布尔类型,它的取值只有true和falseB) bool表示布尔类型,它的取值只有true和falseC) boolean表示布尔类型,它的取值只有1和0D) bool表示布尔类型,它的取值只有1和08、在异常处理中,如释放资源、关闭文件等善后操作由(C )来完成A)try子句B) catch子句C) finally子句D) throw子句9、要开发Java程序,需要安装的开发包是(A )A)jdk B) eclipse C) notepad D) 记事本10、给出下面的代码段:public class Test{static int arr[] = new int[10];public static void main(String a[]){System.out.println(arr[1]);}}哪个语句是正确的( C )A)编译时将产生错误B) 编译时正确,运行时将产生错误C) 输出零D) 输出空11、如下哪个字符串是Java中的标识符(A )A)fieldname B) super C) 3number D) #number12、以下哪项是接口的正确定义(D )A) interface B { void print(){ }; }B) abstract class B { void print(); }C) abstract interface B extends A1,A2 //A1、A2为已定义的接口{ abstract void print(){ }; }D) interface B { void print(); }13、以下代码段执行后的输出结果为(B )int x=3; int y=10;System.out.println(y%x);A)0 B) 1 C) 2 D) 314、不允许作为类及类成员的访问控制符的是(C )A)public B) private C) static D) protected15、执行完代码int[ ] x = new int[25]; 后,以下哪项说明是正确的(A )A)x[24]为0 B) x[24]未定义C) x[25]为0 D) x[0]为空16、类Text定义如下:public class Test{public float aMethod(float a, float b){}// ***}将以下哪种方法插入行"//***"是不合法的。
实验1.7-JAVA实战练习-Banking项目step7-异常处理 (2)
实验题目7:(在6基础上修改)将建立一个OverdraftException 异常,它由Account 类的withdraw()方法抛出。
实验目的:自定义异常实验说明:创建OverdraftException 类1.在banking.domain 包中建立一个共有类OverdraftException. 这个类扩展Exception 类。
2.添加一个double 类型的私有属性deficit.增加一个共有访问方法getDeficit3.添加一个有两个参数的共有构造器。
deficit 参数初始化deficit 属性修改Account 类4.重写withdraw 方法使它不返回值(即void).声明方法抛出overdraftException 异常5.修改代码抛出新异常,指明“资金不足”以及不足数额(当前余额扣除请求的数额)修改CheckingAccount 类6.重写withdraw 方法使它不返回值(即void).声明方法抛出overdraftException 异常7.修改代码使其在需要时抛出异常。
两种情况要处理:第一是存在没有透支保护的赤字,对这个异常使用“no overdraft protection”信息。
第二是overdraftProtection 数额不足以弥补赤字:对这个异常可使用”Insufficient funds for overdraft protection” 信息编译并运行TestBanking 程序Customer [simms,Jane]has a checking balance of 200.0 with a 500.0 overdraft protectionChecking Acct[Jane Simms]: withdraw 150.00Checking Acct[Jane Simms]: deposit 22.50Checking Acct[Jane Simms]: withdraw 147.62Checking Acct[Jane Simms]: withdraw 470.00Exception: Insufficient funds for overdraft protection Deifcit:470.0Customer [Simms,Jane]has a checking balance of 0.0Customer [Bryant,Owen]has a checking balance of 200.0Checking Acct[Bryant,Owen]: withdraw 100.00Checking Acct[Bryant,Owen]: deposit25.00Checking Acct[Bryant,Owen]: withdraw 175.00Exception: no overdraft protection Deficit:50.0Customer [Bryant,Owen]has a checking balance of 125.0。
java练习题+答案
1、在下列说法中,选出最正确的一项是( )。
1.Java语言是以类为程序的基本单位的2.Java语言是不区分大小写的3.多行注释语句必须以//开始4.在Java语言中,类的源文件名和该类名可以不相同2、下列选项中不属于Java虚拟机的执行特点的一项是( )。
1.异常处理2.多线程3.动态链接4.简单易学3、下列选项中属于Java语言的垃圾回收机制的一项是( )。
1.语法检查2.堆栈溢出检查3.跨平台4.内存跟踪4、下列选项中属于 Java语言的安全性的一项是( )。
1.动态链接2.高性能3.访问权限4.内存跟踪5、下列选项中,属丁JVM执行过程中的特点的一项是( )。
1.编译执行2.多进程3.异常处理4.静态链接6、在Java语言中,那一个是最基本的元素?( )1.方法2.包3.对象4.接口7、如果有2个类A和B,A类基于 B类,则下列描述中正确的一个是( )。
1.这2个类都是子类或者超类2.A是B超类的子类3.B是A超类的子类4.这2个类郡是对方的子类8、使用如下哪个保留字可以使只有在定义该类的包中的其他类才能访问该类?( )1.abstract2.private3.protected4.不使用保留字9、编译一个定义了3个类和10个办法的Java源文件后,会产生多少个字符码文件,扩展名是什么?( )1.13个字节码文件,扩展名是.class2.1个字节码文件,扩展名是.class3.3个字节码文件,扩展名是.java4.3个字节码文件,扩展名是.class10、下列属于Java语言的特点的一项是( )。
1.运算符重载2.类间多重继承3.指针操作4.垃圾回收11、在创建Applet应用程序时,需要用户考虑的问题是( )。
1.窗口如何创建2.绘制的图形在窗口中的位置3.程序的框架4.事件处理12、于Java语言的内存回收机制,下列选项中最正确的一项是( )。
1.Java程序要求用户必须手工创建一个线程来释放内存2.Java程序允许用户使用指针来释放内存3.内存回收线程负责释放无用内存4.内存回收线程不能释放内存对象13、下列关于Java程序结构的描述中,不正确的一项是( )。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
java异常(习题)
练习
1. 填空
Java 中所有的错误都继承自______类;在该类的子类中,
_______类表示严重的底层错误,对于这类错误一般处理的方式是___________;
_______类表示例外、异常。
2. 查api,填空
异常类java.rmi.AlreadyBoundException,从分类上说,该类属于__________(已检查| 未检查)异常,从处理方式上说,对这种异常___________________;
异常类java.util.regex.PatternSyntaxException,从分类上说,该类属于_________(已检查|未检查)异常,从处理方式上说,对这种异常__________________。
4. (try-catch-finally)有如下代码:
问:当读入的n 分别为1,2,3,4,5 时,输出的结果分别是什么?
5. (自定义异常)创建两个自定义异常类MyException1 和MyException2。
要求:
1) MyException1 为已检查异常,MyException2 为未检查异常
2) 这两个异常均具有两个构造函数,一个无参,另一个带字符串参数,参数表示产生异常的详细信息。
问:
在//1 处,填入以下________代码可以编译通过,在//2 处,填入_________代码可以编译通过。
A. throws java.io.IOException
B. throws java.io.FileNotFoundException, java.io.EOFException
C. throws java.sql.SQLException
D. 不能抛出任何异常。
选择正确答案:
A.编译不通过
B.编译通过,输出No Exception C.编译通过,输出ex1
D.编译通过,输出ex2
E.编译通过,输出ex3
10. *(try-catch,局部变量)有如下代码
选择正确答案:
A. 编译不通过
B. 编译通过,输出-1
C. 编译通过,输出0
在ma 中,当读入的b 为100 时,输出结果为____,当读入的b 为0 时,输出结果为_____。
12. *(try-finally)写出下面代码运行的结果
在ma 中,读入整数b,如果读入的值为10,则输出:
如果读入的值为0,则输出:
以上代码是否能编译通过?如果不能,应该如何修改?
14. *(自定义异常)完成某个计费系统的用户登录和注册模块,要求如下:
1)创建一个User 类,包括:用户登录名(username)、密码(password)、用户真实姓
名(name)、电子邮件地址(email)属性和相应的构造方法及set/get 方法。
2)创建两个自定义异常类,一个LoginException,表示登录异常。
一个RegisterException,表示注册异常。
自定义的两个异常,都要求有一个接受字符串类型参数的构造方法。
3)创建一个UserBiz 接口,该接口中定义两个方法:
其中register 方法接受两个password 参数,原因是:在用户注册时,需要输入两遍password,只有两次输入的password 一致,才允许注册。
4)创建UserBiz 接口的实现类。
其中
为该实现类创建一个属性,该属性为一个Map,用来保存已注册的用户信息。
Map 的键为用户登录名,值为登录名对应的User 对象。
初始情况下,Map 中保存的对
象为以下两个:
用户名密码真实姓名电子邮件
//admin admin Administrator admin@
//tom cat tomcat tomcat@
register 方法在以下两种情况下抛出异常:
1)username 在Map 中已存在
2)两次输入的password 不一致
login 方法在以下两种情况下抛出异常:
1)username 不存在
2)username 和password 不匹配
5)创建一个UserView 接口,该接口中定义两个方法:
void login();
void register();
6)创建UserView 接口的实现类。
该实现类的login 方法中,利用命令行,让用户输入用户名和密码,之后调用UserBiz 中的login 方法。
部分代码如下:
void login(){
System.out.println(“请输入用户名:”);
String username = ;
System.out.println(“请输入密码”);
String password = ;
//调用UserBiz 中的login 方法
}
该类的register 方法采用类似的方法,让用户输入注册时需要的信息,然后调用UserBiz 中的register 方法。
注意:
1、密码应该让用户输入两遍。
2、UserViewImpl 中应当有一个UserBiz 类型的属性
7)编写测试代码。
类图如下:
15. **(异常的捕获和抛出)有以下代码:
import java.io.*;
import java.sql.*;
public class TestMyException {
public static void main(String args[]) {
try {
System.out.println("main1");
ma();
System.out.println("main2");
} catch (Exception e) {
System.out.println("Catch Exception in main");
System.out.println(e.getMessage());
}
}
public static void ma() throws IOException {
try {
System.out.println("ma1");
mb();
System.out.println("ma2");
} catch (SQLException e) {
System.out.println("Catch SQLException in ma");
throw new IOException(e.getMessage());
} catch (Exception e) {
System.out.println("Catch Exception in ma");
System.out.println(e.getMessage());
问:该程序输出结果是什么?
16. **(异常的捕获和抛出)有以下代码
选择正确答案:
A. 编译出错
B. 编译正常,输出main1 ma1 In Catch
C. 编译正常,运行时出错
17. **(异常的捕获和抛出)有如下代码
public static void ma() throws IOException { }
}
下面哪些代码放在处可以编译通过?
A. catch(NullPointerException npe){}
B. catch(IOException ioe){}
C. catch(SQLException sqle){}。