Java习题06

合集下载

JAVA第六章习题

第六章异常和异常处理一、选择题1、下列关于异常和异常类的描述中，错误的是 D 。

A．异常是某种异常类的对象B．异常类代表一种异常事件C．异常对象中包含有发生异常事件的类型等重要信息D．对待异常的处理就是简单地结束程序2、下列关于异常处理的描述中，错误的是 C 。

A．程序运行时出现的异常是通过系统默认的异常处理程序进行处理的。

B．在程序中可以使用try-catch语句捕捉异常和处理异常事件C．对于捕获的异常只能在当前方法中处理D．使用throw语句可将异常抛出到调用当前方法的方法中处理二、简答题1、简述Java的异常处理机制。

Java系统中定义一些用来处理异常的类，称为异常类，该类中通常包含产生某种异常的信息和处理异常的方法等内容。

当程序运行中发生了可识别的异常时(该错误有一个异常类与之相对应时)系统就会产生一个相应的该异常类的对象，简称异常。

系统中一旦产生了一个异常，便去寻找处理该种异常的处理程序，以保证不产生死机，从而保证了程序的安全运行。

这就是Java的异常处理机制.三、写出运行结果题1、public class Exam6_4{ public static void main(String args[]){ fun(0);fun(1);fun(2);fun(3);}static void fun(int i){ System.out.println("调用方法:fun"+i);try{if(i==0) System.out.println("没有异常");else if(i==1){int a=0; int b=10; b/=a;}else if(i==2){int m[]=new int[5]; m[5]=100;}else if(i==3){String str="56k9"; intn=Integer.parseInt(str);}}catch(ArithmeticException e){System.out.println("捕捉异常:"+e.getMessage());} catch(ArrayIndexOutOfBoundsException e){System.out.println("捕捉异常:"+e);}catch(NumberFormatException e){System.out.println("捕捉异常:"+e);}finally{System.out.println("处理完毕! ");}}}2、public class Exam6_5{ public static void main(String args[]){ try{fun1();}catch(ArithmeticException e){System.out.println("捕捉异常:"+e.getMessage());} try{fun2( );}catch(ArrayIndexOutOfBoundsException e){System.out.println("捕捉异常:"+e);}finally {System.out.println("处理完毕! ");}}static void fun1() throws ArithmeticException{ System.out.println("调用方法:fun1");int a=0; int b=10; b/=a;throw new ArithmeticException();}static void fun2() throws ArrayIndexOutOfBoundsException { System.out.println("调用方法:fun2");int m[]=new int[5]; m[5]=100;throw new ArrayIndexOutOfBoundsException();}}。

Java试题答案(全)

一、选择题答案选择第1题B选择第2题A选择第3题C选择第4题B选择第5题A选择第6题A选择第7题B选择第8题C选择第9题B选择第10题B选择第11题C二、多项选择题答案多项选择第1题BD多项选择第2题AE多项选择第3题AC多项选择第4题AE多项选择第5题AE多项选择第6题DEF多项选择第7题AC多项选择第8题BC多项选择第9题AB多项选择第10题CD多项选择第11题CD多项选择第12题ACD多项选择第13题ABD三、填空题答案填空第1题x=10,a=3,b=4,c=5填空第2题java.util填空第3题(public )(static )(void)(main)(String args[])填空第4题1填空第5题26四、编程题答案1public class HelloWorld{public static void main(String args[]) {System.out.println("Hello,World!");}}import java.awt.Graphics;import java.applet.Applet;public class HelloWorld extends Applet{ String s;public void init(){s="Hello World!";}public void paint(Graphics g){g.drawString(s,25,25);}}2class yanghui{public static void main (String args[]) {int i,j;int yhlevel=10;int yanghui[][];System.out.println("杨晖三角形:");yanghui=new int[yhlevel][];for(i=0;i<yanghui.length;i++)yanghui[i]=new int[i+1];yanghui[0][0]=1;for (i=1; i<yanghui.length;i++){yanghui[i][0]=1;for(j=1;j<yanghui[i].length-1;j++)yanghui[i][j]=yanghui[i-1][j-1]+yanghui[i-1][j];yanghui[i][yanghui[i].length-1]=1;}for (i=0; i<yanghui.length;i++){for(j=0;j<yanghui[i].length;j++)System.out.print(yanghui[i][j]+" ");System.out.println();}}}输出结果是：杨晖三角形:11 11 2 11 3 3 11 4 6 4 11 5 10 10 5 11 6 15 20 15 6 11 7 21 35 35 21 7 11 8 28 56 70 56 28 8 11 9 36 84 126 126 84 36 9 13import java.io.*;public class MemoController{FileOutputStream fos;OutputStreamWriter osw;BufferedWriter bw;public MemoController(){try{fos=new FileOutputStream("memo.txt",true);osw=new OutputStreamWriter(fos);bw=new BufferedWriter(osw);}catch(FileNotFoundException e){};}public synchronized void append(String s){try{bw.write(s,0,s.length());bw.flush();bw.close();osw.close();fos.close();}catch(IOException e){}}public static void main(String args[]){MemoController mmc=new MemoController();mmc.append("I am xubin ");}}4import java.io.*;class Phones{static FileOutputStream fos;public static final int lineLength = 81;public static void main(String args[]) throws IOException{byte[] phone = new byte[lineLength];byte[] name = new byte[lineLength];int I;try{fos = new FileOutputStream("phone.numbers");}catch(FileNotFoundException e){ }while (true){System.err.println("Enter a name (enter 'done' to quit)");readLine(name);if ("done".equalsIgnoreCase(new String(name,0,0,4))){break;}System.err.println("Enter the phone number");readLine(phone);for (int i=0;phone[i]!= 0;i++){fos.write(phone[i]);}fos.write(',');for (int i=0;name[i]!= 0;i++){fos.write(name[i]);}fos.write('\n');}fos.close();}private static void readLine(byte line[]) throws IOException {int i=0,b=0;while ((i<lineLength-1)&&((b=System.in.read())!='\n')){line[i++] = (byte)b;}line[i]=(byte) 0;}}。

JAVA习题题目及答案

第1章问答题及作业题第1章问答题1、发明Java语言的原因是什么？发明Java语言的主要贡献者是谁？2、“Java编译器将源文件编译生成的字节码是机器码”，这句话正确吗？3、Java程序的主类必须含有怎样的方法？4、“Java应用程序必须含有一个类是public类”，这句话正确吗？5、“Java Applet程序的主类必须是public类”，这句话正确吗？6、请叙述Java源文件的命名规则。

7、源文件生成的字节码在运行时都加载到内存中吗？8、怎样编写加载运行Java Applet的简单网页？9、编译器使用“-source”参数的作用是什么？“-source”参数的默认取值是什么？第1章作业题1.参照例1-1编写一个Java应用程序，程序能在命令行中输出“早上好，Good Morning”。

2.参照例1-2编写一个Java Applet程序，程序能在浏览器中显示“你好，Hello”。

第2章问答题及作业题第2章问答题1、什么是标识符？标识符的规则是什么？2、什么是关键字？请说出5个关键字。

3、Java的基本数据类型是什么？4、下列哪些语句是错误的？int x=120;byte b=120;b=x;5、下列哪些语句是错误的？float x=12.0;float y=12;double d=12;y=d;6、下列两条语句的作用是等价的吗？char x=97;char x=’a’;7、下列语句输出的结果是什么？int a=97;byte b1=(byte)128;byte b2=(byte)-129;System.out.printf(“%c,%d,%d”,a,b1,b2);8、数组是基本数据类型吗？怎样获取一维数组的长度？9、假设有两个int类型数组：int[] a=new int[10];int[] b=new int[8];b=a;a[0]=100;b[0]的值一定是100吗？10、下列两条语句的作用等价吗？int[] a={1,2,3,4,5,6,7,8};int[] a=new int[8];}第2章作业题1.参照例2-1编写一个Java应用程序，输出俄文字母表。

Java第06章--1(AWT与Swing)

• • 视图（view）：它专门负责组件的绘制工作，主要涉及 paint()方法。MVC设计范式的最大优点是一个模型可以有多个视图，每个视图是一个不同侧面但内容却是完整的。 • 一个模型的几个视图都是从不同侧面、用完整的内容来描述同一个模型。当模型的控制器要修改其内容时，均会通知这每个视图，它们都会自动地更新自己的视图显示。 • • 控制器（controller）：专门负责管理和处理组件所接收到的事件，这些事件可能来自用户的操作。如键盘输入、鼠标点击和拖放等，也可能来自系统，如系统计时器发出的事件。 • 视图和其控制器之间的通信不仅频繁且非常复杂，因此 JFC系统把两者封装成一个整体。
• • 模型（model）：模型负责获取和管理组件的状态，用户若需要询问组件的状态时，实际上是询问该组件的模型。 • 若要询问Swing型按钮组件（JButton 类的一个对象）的状态，可调用JButton 类的父类javax.swing.AbstractButton所提供的isSelected()方法，它定义为： – public boolean isSelected() { ... } – 该方法返回一个逻辑值，若为true则该按钮组件被压下，反之返回false则按钮是松开状态。 • javax.swing包中的各种组件，对于描述该组件状态和内容的模型都是用以 Model 结尾的接口实现，例如，对于按钮在 javax.swing包中有一个如下定义的接口： – public interface ButtonModel extends ItemSelectable { ... } • 每个JButton类的对象都保存着一个表示该按钮组件模型的对象，调用其父类AbstractButton的方法就可以得到它，即： – JButton b = new JButton( "确定" );

java答案第六章

Java语言程序设计第六章课后习题答案1.将本章例6-1至6-18中出现的文件的构造方法均改为使用File类对象作为参数实现。

个人理解：File类只能对整文件性质进行处理，而没法通过自己直接使用file.Read()或者是file.write()类似方法对文件内容进行写或者读取。

注意：是直接;下面只提供一个例2变化，其他的你自己做，10几道啊，出这题的人真他妈有病。

import java.io.*;public class test6_2{public static void main(String[] args) throws IOException { String fileName = "D:\\Hello.txt";File writer=new File(fileName);writer.createNewFile();BufferedWriter input = new BufferedWriter(newFileWriter(writer));input.write("Hello !\n");input.write("this is my first text file,\n");input.write("你还好吗？\n");input.close();}}运行结果：（电脑系统问题，没法换行，所以一般使用BuffereWriter中newLine()实现换行）2.模仿文本文件复制的例题，编写对二进制文件进行复制的程序.// CopyMaker类import java.io.*;class CopyMaker {String sourceName, destName;BufferedInputStream source;BufferedOutputStream dest;int line;//打开源文件和目标文件，无异常返回trueprivate boolean openFiles() {try {source = new BufferedInputStream(newFileInputStream( sourceName ));}catch ( IOException iox ) {System.out.println("Problem opening " + sourceName );return false;}try {dest = new BufferedOutputStream(newFileOutputStream( destName ));}catch ( IOException iox ){System.out.println("Problem opening " + destName );return false;}return true;}//复制文件private boolean copyFiles() {try {line = source.read();while ( line != -1 ) {dest.write(line);line = source.read();}}catch ( IOException iox ) {System.out.println("Problem reading or writing" );return false;}return true;}//关闭源文件和目标文件private boolean closeFiles() {boolean retVal=true;try { source.close(); }catch ( IOException iox ) {System.out.println("Problem closing " + sourceName );retVal = false;}try { dest.close(); }catch ( IOException iox ) {System.out.println("Problem closing " + destName );retVal = false;}return retVal;}//执行复制public boolean copy(String src, String dst ) {sourceName = src ;destName = dst ;return openFiles() && copyFiles() && closeFiles();}}//test6_2public class test6_2{public static void main ( String[] args ) {String s1="lin.txt",s2="newlin.txt";if(new CopyMaker().copy(s1, s2))S ystem.out.print("复制成功");elseS ystem.out.print("复制失败");}}运行前的两个文本：lin.txt和newlin.txt（为空）运行后：3.创建一存储若干随机整数的文本文件，文件名、整数的个数及范围均由键盘输入。

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 语言不允许同时继承一个类并实现一个接口.〔×〕。

JAVA练习题(第6章)

System.out.println(sl.concat(s2));
}
}
Hello World!
请写出该程序的运行结果：
3.写出以下程序的运行结果
public class ChangeStrDemo {
public static void changestr(String str){
str="welcome";
Hello World!
2.阅读以下程序运行结果是：
import java.io.*;
public class abc {
public static void main(String args[]) {
String sl = "Hello!";
String s2 = new String("World!");
if (cArray[i]>’m’)
sb2.insert(j++,cArray[i]);
sb3.setCharAt(0,’h’);
sb3.setCharAt(6,’m’); System.out.println(sb1);yaorsineeudtyCeeoxhm,uaCrphAetamty(ri?ncpthty)主?w要h是y用?
A. arit
B. arit
C. amit
amit
arit
amit
false
false
false
true
true
true
D. arit amit true true
10.运行以下的main（）方法，结果是( )
1. public static void main(String[] args)

java-试题练习题(第6套)

—— 学年第学期《 Java 程序设计》课程试题课程号：√ 考试□ A 卷 √ 闭卷□ 考查 □ B 卷 □ 开卷一、单项选择题（20题；每题2分，共40分） 1、165/2的值是＿＿＿。

A ）0 B ）82 C ）3 D ）83 答案：B （难度系数 C ）知识点：表达式 2、在HTML 中,用________标签来强制显示Applet 。

A ） name,height,width B ）codebase, height,width C ） code ，name D ） code, height,width 答案：D （难度系数B ）知识点：小应用程序3、在Applet 中显示文字、图形等信息时，应使用的方法是__ _____。

A) paint() B) init() C) start() D) destroy()答案：A （难度系数B ,知识点：APPLET ）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 – elseB ）switchC ）tryD ） throw答案：C （难度系数B ）知识点：异常班级：姓名：学号：密封6、下列语句关于内存回收的说明是正确的是＿＿＿。

A）程序员必须创建一个线程来释放内存；B）内存回收程序负责释放无用内存C）内存回收程序允许程序员直接释放内存D）内存回收程序可以在指定的时间释放内存对象答案：B 难度系数： C 知识点：内存释放7、编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为＿＿＿。

Java实战经典(第六章课后题答案)

super(name,age,sex); this.yearsalary=yearsalary; this.post=post; } public String Info() { return ()+"，工资："+this.yearsalary+"，职位："+this.post; } } class Staff extends Employee { private float monthsalary; private String post; public Staff(String name,int age,String sex,float monthsalary,String post) { super(name,age,sex); this.monthsalary=monthsalary; this.post=post; } public String Info() { return ()+"，工资："+this.monthsalary+"，职位： "+this.post; } } public class Six04
public float getFoot(){ return this.foot ;
} public float getHeight(){
return this.height ; } } class Cycle extends Shape{ private float radius ; private static final float PI = 3.1415926f ; public Cycle(){} public Cycle(float radius){
4

《Java程序设计案例教程》第六章练习答案

第6章共享与数据保护一、单选题1.已知print()函数是一个类的常成员函数，无返回值，下列正确的原型声明（A）。

A.void print()const；B.const void print()；C.void const print()；D.void print(const)；2.有以下类的说明，请指出错误的地方(A)。

class CSample{const int a=2.5；//Apublic:CSample()；//BCSample(int val)；//C～CSample()；//D}；3.下列关于静态成员的描述中，错误的是(C)。

A.静态成员都使用static来说明B.静态成员属于某一个类，而不专属于某一对象C.静态成员只能用类名加作用域运算符引用，不可以通过对象来引用D.静态数据成员的初始化是在类体外进行的4.下列关于常成员的描述中，错误的是(C)。

A.常成员是用关键字const来说明的B.常成员有常数据成员和常成员函数两种C.常数据成员的初始化可以在定义类的类体内用形如const int a=10；的方式进行D.常数据成员的值是不可以改变的5.有以下类的说明，下列哪一种构造函数无法对常数据成员a正确初始化(C)。

class CSample{const int a；public://构造函数代码，见下面的选项｝；A.CSample()：a(24){}B.CSample(int m):a(m){}C.CSample(){a=24；}D.CSample(int m):a(m+24){}6.设类AA内定义了一个int型的静态数据成员a，下列哪种方式对a的初始化正确(D)。

A.在类AA的定义体内用static int a＝20；B.在类AA的定义体外单独用语句static int a=20 ；C.在类AA的定义体外单独用语句static int AA∷a=20；D.在类AA的定义体外单独用语句int AA∷a=20；7.关于静态成员函数，下列说法不正确的是(A)。

《Java语言程序设计-基础篇》答案-第06章

第6章类与对象复习题6.1 答: 略6.2答: 略6.3答: 构造方法 ShowErrors(int) 没有定义.原因是默认的构造函数是没有参数的.6.4答: 略6.5答: 变量c 没有初始化,也可以说是没有将对象引用到实例.即c 为null. 6.6 答: 构造函数A()没有定义.原因是类中有了有参的构造方法A(String s),但没有无参构造方法,而系统不会再提供默认的构造函数A()。

系统找不到默认的构造函数.在这种情况下,如果还要用A(),则需要重新定义. 6.7 答：构造函数C(double)没有定义.原因是默认的构造函数是没有参数的. 6.8 答：输出:false;原因是boolean 类型的变量如果没有初始化,则默认初始值为false; 6.9 答：方法x()没有定义;6.10答：略6.11答：略6.12答：输出:1.0;私有变量可以被类里的成员方法访问.6.13答：略6.14答：略6.15答：传递基本类型参数值的变化不能被带回,而引用类型参数的变化可以带回.输出: count is 101 times is 06.16答：After swap1 : circle1= 1.0 circle2=2.0After swap2 : circle1= 2.0 circle2=1.0课后答案网ww w.kh da w .c om6.17答：a[0]= 1 a[1]= 2 (a)a[0]= 2 a[1]= 1 (b)e1 = 2 e2= 1 (c)t1's i = 2 and j= 1 (d)t2's i = 2 and j= 1第四个值得注意，因为 i 为静态的，因此经过二次实例化后，i 就变成2了。

而j 是没有变的，一直为1。

6.18答：System.out .println(f.i);System.out .println(f.s ); f.imethod(); f.smethod ();System.out .println(Foo.s ); Foo.smethod ();但静态成员最好直接用类访问.像 System.out .println(f.s ); f.smethod ();6.19答：i + j is 23k is 2 j is 06.20答：不能在静态方法中调用非静态方法,不能在静态方法中调用非静态变量.反之可以.错误是:不能调用method1(),不能调用c.6.22答：错误没有,但会提出警告:p 不明确,这里应该用this.p;6.23答：第一个输出为:null,因为一个对象的默认值是null,而第二个输出有错,原因是没有将对象引用到实例,即dates[0]为空课后答案网ww w.kh da w .c om。

Java新教材第六章面试题

第6章异常处理 (159)6.1 异常概述 (159)●什么是异常？答案：在程序的开发过程中产生的一些错误。

6.2 Java中的异常 (160)6.2.1 Error/Exception层次关系 (160)●请简要介绍Error和Exception的层次关系。

答案：在Java中，异常对象分为两大类：Error和Exception。

Error类和Exception类都是Throwable类的子类。

Error类只有四个子类：AWTError、LinkageError、VirtualMachineError以及ThreadDeat。

正如前面所述，它处理的是Java运行系统中的内部错误以及资源耗尽等情况，这种情况是程序员所无法掌握的，我们只有通知用户并安全退出程序的运行。

而Exception的子类就很多了，可以大致将它的子类分为三类：有关I/O的IOException，有关运行时的异常RuntimeException以及其它的异常。

RuntimeExcepiton异常是由于程序编写过程中的不周全的代码引起的，而IOException是由于IO系统出现阻塞等原因引起的。

●error和exception有什么区别?答案：error 表示恢复不是不可能但很困难的情况下的一种严重问题。

比如说内存溢出。

不可能指望程序能处理这样的情况。

exception 表示一种设计或实现问题。

也就是说，它表示如果程序运行正常，从不会发生的情况。

6.2.2 异常示例 (160)6.3 处理Exception (163)6.3.1 常见异常 (163)●引起RuntimeException异常的原因有很多，请举两个例子。

答案：●RuntimeException常见的异常有哪些？答案：·VI ·● 引起IOException 异常的原因有很多，请举两个例子。

答案：● IOException 常见的异常有哪些？答案：● 运行时异常与一般异常有何异同？答案：异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。

JAVA语言程序设计基础课后习题第六章

JAVA语⾔程序设计基础课后习题第六章//exercise 6.1package second;import java.util.Scanner;public class first {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubScanner in=new Scanner(System.in);System.out.print("Enter the number of students:");int number=in.nextInt();System.out.print("Enter "+number+" scores:");int []score=new int[number];getscores(score);int best=max(score);for(int i=0;i<number;i++){System.out.println("Student "+i+" score is "+score[i]+" and grade is "+grade(score[i],best));}}public static void getscores(int []score){Scanner in=new Scanner(System.in);for(int i=0;i<score.length;i++){score[i]=in.nextInt();}}public static int max(int[] score){int max=score[0];for(int i=0;i<score.length;i++){if(max<score[i])max=score[i];}return max;}public static char grade(int score,int max){if(score>=max-10)return 'A';else if(score>=max-20)return 'B';else if(score>=max-30)return 'C';else if(score>=max-40)return 'D';elsereturn 'F';}}//exercise 6.2package second;import java.util.Scanner;public class second {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubint []number=get();reverseprint(number);}public static int[] get(){Scanner in=new Scanner(System.in);int[] number=new int[10];System.out.println("input 10 number:");for(int i=0;i<number.length;i++){number[i]=in.nextInt();}return number;}public static void reverseprint(int[]Array){for(int i=Array.length-1;i>=0;i--){System.out.print(Array[i]+" ");}}}//exercise 6.3package second;import java.util.Scanner;public class third {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubScanner in=new Scanner(System.in);int[] newarray=new int[100];int temp;for(int i=0;i<newarray.length;i++){newarray[i]=0;}System.out.print("Enter the integers between 1 and 100：");while((temp=in.nextInt())!=0){newarray[temp]++;}resultprint(newarray);}public static void resultprint(int []array){for(int i=0;i<array.length;i++){if(array[i]==1)System.out.println(i+" occurs "+array[i]+" time");if(array[i]!=0&&array[i]!=1)System.out.println(i+" occurs "+array[i]+" times");}}}//exercise 6-4package first;import java.util.Scanner;public class first {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubScanner in=new Scanner(System.in);int []score=new int[100];int i=0,sum=0,count=0;System.out.print("input integer:");while((score[i]=in.nextInt())!=-1){sum+=score[i++];count++;}int average=sum/count;int big=0,small=0;for(int j=0;j<count;j++){if(score[j]<average)small++;elsebig++;}System.out.println("average is "+average);System.out.println("better than average is "+big);System.out.println("small than average is "+small);}}//exercise 6-5package first;import java.util.Scanner;public class second {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stub Scanner in=new Scanner(System.in); System.out.print("Enter ten numbers:");int []integer=new int[10];int count=0;for(int i=0;i<10;i++){boolean judge=false;int temp=in.nextInt();for(int j=0;j<count;j++){if(temp==integer[j]){judge=true;}}if(!judge){integer[count++]=temp;}}System.out.print("input integer:");for(int i=0;i<count;i++){System.out.print(integer[i]+" ");}}}//exercise 6-7package first;public class third {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubint []counts=new int[10];for(int i=0;i<100;i++){int random=(int)(Math.random()*10); counts[random]++;}for(int i=0;i<10;i++){System.out.print(i+" ");}System.out.println();for(int i=0;i<10;i++){System.out.print(counts[i]+" ");}}}//exercise 6-8package first;public class fourth {/*** @param args*/public static int average(int[]array){int sum=0,count=0;for(int i=0;i<array.length;i++){sum+=array[i];count++;}return sum/count;}public static double average(double []array){double sum=0;int count=0;for(int i=0;i<array.length;i++){sum+=array[i];count++;}return sum/count;}}//exercise 6-9package first;public class fifth {/*** @param args*/public static double min(double []array){double min=array[0];for(int i=0;i<array.length;i++){if(min>array[i])min=array[i];}return min;}}//exercise 6-10package first;public class seventh {/*** @param args*/public static int indexOfSmallestElement(double[] array){ double min=array[0];for(int i=0;i<array.length;i++){if(min>array[i])min=array[i];}for(int i=0;i<array.length;i++){if(min==array[i])return i;}return 0;}}。

Java基础第6章编程题答案

第六章集合编程题1.遍历一个LinkedList集合，写一个可以删除所有与“tom”相同的元素的静态方法。

（集合中的元素自行添加）注意：不要使用for循环遍历删除，会出现删除不干净的情况【参考答案】import java.util.ArrayList;import java.util.Iterator;import java.util.LinkedList;public class Test {public static void main(String[] args) {LinkedList<String> list=new LinkedList<String>();list.add("tom");list.add("jack");list.add("jone");list.add("tom");System.out.println(list);removes(list,"tom");System.out.println(list);}public static void removes(LinkedList<String> list, String s) {Iterator iterator = list.iterator();while (iterator.hasNext()) {String str = (String) iterator.next();if (str.equals(s)) {iterator.remove();}}}}2.如何判断两个集合是否有交集，并打印出他们的交集提示：判断这两个集合是否包含相同的对象或元素，可以使用retainAll方法：oldCourses.retainAll(newCoures)。

如果存在相同元素，oldCourses中仅保留相同的元素。

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习题集(含答案)

JAVA习题集（含答案）习题一：1．简述Java的发展过程。

2．什么是软件？3．什么叫做源程序？4．什么叫做编译？5．什么是Java 的byte-codes？它的最大好处是什么？6．机器语言程序、高级语言程序以及可表示成Java字节码的程序之间的区别是什么？7．Java程序可分为哪两种？分别如何运行？8．试简述J2SE、J2ME与J2EE的简单区别。

9．练习使用浏览器查看Java API文档。

10．SDK的编译命令是什么？11．试修改例1-1程序，使其输出的字符串为“I’d like to study Java !”，并在DOS命令行环境下编译与运行该程序。

习题一参考答案：1．答：1991：Sun Microsystems公司进军消费电子产品（IA）市场。

1991．4：Sun 成立“Green”小组，以C++为基础开发新的程序设计语言，并将其命名为Oak。

1992．10：Green小组升格为First Person公司，他们将Oak的技术转移到Web上，并把Oak改名为Java。

1993~1994：Web在Internet上开始流行，致使Java得以迅速发展并获得成功。

1995．5：Sun Microsystems公司正式发表Java与HotJava产品。

1995．10：Netscape与Sun Microsystems合作，在Netscape Nevigator中支持Java。

1995．12：微软（Microsoft）IE加入支持Java的行列。

1996．2：Java Beta测试版结束，Java 1.0版正式诞生。

1997．2：Java发展至1.1版。

Java的第一个开发包JDK（Java Development Kit）发布。

1999．7：Java升级至1.2版。

2000．9：Java升级至1.3版。

2001．7：Java升级至1.4版。

2．答：软件可以理解为程序的另一种名称。

3．答：直接使用高级语言书写的程序代码称为源程序4．答：把用高级语言编写的源程序翻译成可执行（目标）程序的过程称为编译。

java编程练习题及答案

java编程练习题及答案Java编程练习题及答案一、选择题1. 在Java中，哪个关键字用于定义类？A. classB. interfaceC. enumD. struct答案：A2. 下列哪个是Java中的合法标识符？A. 2variableB. forC. variable2D. class答案：C3. 在Java中，哪个方法用于获取当前对象的引用？A. this()B. super()C. clone()D. new()答案：A4. 以下哪个是Java的访问修饰符？A. publicB. staticC. finalD. abstract答案：A5. 在Java中，哪个关键字用于定义接口？A. classB. interfaceC. abstractD. enum答案：B二、简答题1. 请简述Java中的继承是如何工作的？答案：Java中的继承允许一个类（子类）继承另一个类（父类）的属性和方法。

子类可以扩展或修改父类的行为，实现代码复用。

继承是面向对象编程的核心概念之一。

2. 请解释Java中接口和抽象类的区别？答案：接口定义了一组方法规范，但不提供实现。

任何实现接口的类都必须提供接口中所有方法的具体实现。

抽象类可以包含抽象方法和具体方法，并且可以有成员变量。

抽象类可以作为其他类的基类，但不能被实例化。

三、编程题1. 编写一个Java程序，实现一个简单的计算器，可以进行加、减、乘、除运算。

```javaimport java.util.Scanner;public class SimpleCalculator {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.print("请输入第一个数字: ");double num1 = scanner.nextDouble();System.out.print("请选择运算符(+, -, *, /): "); char operator = scanner.next().charAt(0);System.out.print("请输入第二个数字: ");double num2 = scanner.nextDouble();double result = 0;switch (operator) {case '+':result = num1 + num2;break;case '-':result = num1 - num2;break;case '*':result = num1 * num2;break;case '/':if (num2 != 0) {result = num1 / num2;} else {System.out.println("除数不能为0"); }break;default:System.out.println("无效的运算符");}if (result != 0) {System.out.println("结果是: " + result);}scanner.close();}}```2. 编写一个Java程序，实现一个简单的学生管理系统，可以添加学生信息、显示所有学生信息。

Java语言程序设计(一)课后习题第六章(附答案)

·getRealPart()获得复数对象的实部。
·getlmaginaryPart()获得复数对象的虚部。
·setRealPart(doubled)把当前复数对象的实部设置为给定的形参的数字。
·setlmaginaryPart(doubled)把当前复数对象的虚部设置为给定形参的数字。
·complexAdd(ComplexNumberc)当前复数对象与形参复数对象相加，所得的结果也是复数值，返回给此方法的调用者。
+ cNumber_2.toString() + “等于“
+ cNumber_plexMinus(cNumber_2).toString());
System.out.println(cNumber_1.toString() + “减“
+ d + “等于“
+ cNumber_plexMinus(d).toString());
System.out.println(cNumber_1.toString() + “乘“
+ cNumber_2.toString() + “等于“
+ cNumber_plexMulti(cNumber_2).toString());
System.out.println(cNumber_1.toString() + “乘“
{
public abstract string subMethod()；
}
参考答案：
1. trueLeabharlann 2.A3．答：子类重新定义父类中已经存在的方法，称为方法的覆盖。注意：方法覆盖与域的隐藏不同。子类重新定义父类已有的域，并不能完全取代它从父类那里继承的同名的域，这个域仍然占用子类的内存空间，在某些情况下会被使用；而当子类重新定义父类的方法时，从父类那里继承来的方法将被新方法完全取代，不再在子类的内存空间中占一席之地。与方法的覆盖不同，重载不是子类对父类同名方法的重新定义，而是在一个类中定义了同名的不同方法。