java练习题答案

一、填空题
1、面向对象程序的主要特征：继承,__封装___,___多态_____。

2、java中的继承机制之所以能够降低程序的复杂性，提高程序的效率，主要是
因为它使代码可以__重用或复用___.
3、java语言中，为将源代码翻译成__字节码__文件时产生的错误称为编译错误，
而将程序在运行中产生的错误称为运行错误。

4、javac是java语言中的编译器，基本语法是:javac[选项] __文件名__,java是java
语言中的解释执行器，基本语法是：java[选项]___类名___.
5、java语言的主要贡献者是谁James gosling
二、单选题
1、编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的
扩展名为( B)。

A、java
B、.class
C、html
D、.exe
2、main方法是Java Application程序执行的入口点，关于main方法的方法首部，
以下（B）项是合法的。

A、public static void main()
B、public static void main(String args[])
C、public static int main(String[] arg)
D、public void main(String arg[])
三、判断
1、Java语言具有较好的安全性和可移植性及与平台无关等特性。

√
2、Java语言的源程序不是编译型的，而是编译解释型的。

√
四、问答题
1、编写、运行java程序需要经过哪些主要步骤？
答：1.编写源文件，扩展名必须是.java
2.编写java源程序，使用java编译器编写源文件，得到字节码文件
3.运行java程序，使用javaSE平台只不过的java解释器来解释执行字节码
文件。

2、阅读下列java源代码文件，并回答问题
public class Speak{
void speakHello(){
System.out.println("I'm glad to meet you");
}
}
class Xiti8{
public static void main(String args[]){
Speak sp=new Speak();
sp.speakHello();
}
}
（1）上述源文件的名字是什么？Speak.java
（2）上述源文件编译后生成几个字节码文件，这些字节码文件的名字分别是什
么？Speak.class Xiti8.class
第2章（1）基本数据类型练习题
一、填空题
1、java基本数据类型中整型，字符型分别占用字节数为___4___,___2____.
2、java语言中的浮点数根据数据存储长度和数值精度的不同，进一步分为_
float__和__double__两种具体类型。

3、Java中的浮点类型有两类，分别是float和double类型，其中float取7___位有
效数据，double取_15__位有效数据。

4、布尔类型常量只有两个__true___和__false____，其中前者表示逻辑真，后者表
示逻辑假。

5、浮点型常量又称实型常量，用于表示有小数部分的十进制数，它有两种表示形
式:__小数形式____和__指数形式______。

6、java语言中的各种数据类型之间提供自动转换，如第一种操作数为byte，而第
二种操作数为float,则其结果是__float___类型。

7、java语言的各种数据类型之间提供两种转换，分别是__自动转换__和_强制转换
____。

8、开发与运行Java程序需要经过的三个主要步骤为编写源程序、编译生
成字节码文件和解释运行字节码文件。

9、Java程序中的单行注释符是（// ），多行注释符是（/* */ ）。

10、Java中布尔类型的常量有两种，它们是（true）和（false）。

11、Java中用于定义小数的关键字有两个：（float）和（double ），后者
精度高于前者。

二、多选
1、下面有关char类型数据的定义中，正确得是_BE_______？
A. char ch = “a”;
B. char ch = ‘\’‘;
C. char ch = ‘cafe’;
D. char ch = “cafe”;
E. char ch = ‘\ucafe’;
F. char ch = ‘\u10100’;
G. char ch = (char) true;
三、判断
1、Java语言使用的是Unicode字符集，每个字符在内存中占8位。

×,16位
2、Java语言中不同数据类型的长度是固定的，不随机器硬件不同而改变。

√
四、单选
1、以下哪个不是Java的基本数据类型（B）
A、int
B、Boolean
C、float
D、char
2、如下哪个是Java中有效的关键字( c )
A、name
B、hello
C、false
D、good
第2章（2）数组练习题
一、填空题
1、当声明一个数组int arr[] = new int[5]; 时，这代表这个数组所保存的变量类型是
（int），数组名是（arr），数组的大小为（5），数组元素下标的使用范围是（0-4）。

二、多选
1、定义如下的二维数组b，下面的说法正确的是(ACD )。

int b[][]={{1, 2, 3}, {4, 5},{6, 7, 8}}};
A)b.length的值是3。

B)b[1].length的值是3。

B) C)b[1][1]的值是5。

D) 二维数组b的第一行有3个元素
三、单选
1、以下哪项是main方法的正确形参？（B）
A、String args
B、String ar[]
C、Char arg
D、StringBufferargs[]
2、有整型数组：int[] x={12,35,8,7,2};,则调用方法Arrays.sort(x)后，数组x中的元素值依次是(A ).
A) 2 7 8 12 35 B) 12 35 8 7 2 C) 35 12 8 7 2 D) 8 7 12 35 2
3、应用程序Test.java的源程序如下，在命令行键入：java Test aaa bb c，回车后输出的结果是( A)。

public class Test {
public static void main(String args[]) {
int k1=args.length;
int k2=args[1].length();
System.out.print(k1+" "+k2);
}
}
A) 3 2 B)1 2 C) 1 3 D) 3 3
4、关于下面代码的说法（C）是正确的？
public class Example{
public static void main(String[] args){
int[] arr= new int[10];
System.out.println(arr[1]);
}
}
A、编译时产生错误
B、编译时正确，运行时将产生错误
C、输出零
D、输出空(null)
第3章（1）运算符&表达式&if语句练习题
一、填空
1、Java中，除了_字符型____和___布尔型__外，其他的所有的基本数据类型都支持加，减,乘，除四则运算。

2、短路逻辑运算符包括___&&___和___||___。

3、Java提供了&，&&和|,||运算符，除了一点外，&运算符和&&运算符在使用中
完全相同，|运算符和||运算符也相同。

它们的不同点在于:__&__运算符和___|运算符中的两个运算对象都要运算。

4、顺序执行以下两个语句的输出结果是：__10_____。

String s=”我喜欢学习java!”;
System.out.println(s.length());
5、下面代码定义了两个整型变量和一个字节型变量，则将num1+num2的值赋给num3变量的语句是______num3=(byte)(num1+num2)_______。

int num1 = 53;
int num2=47;
byte num3;
6、下面代码中，“Type”应该换成什么类型__double______？
public class ReturnIt {
return Type methodA(byte x, double y) {
return (long)x / y * 2;
}
}
7、Java语言提供了两条基本的分支选择语句：_if___语句和switch____语句
8、以下程序段的输出结果为Message four
int x=0,y=4, z=5;
if ( x>2){
if (y<5){
System.out.println("Message one");
}
else {
System.out.println("Message two");
}
}
else if(z>5){
System.out.println("Message three");
}
else {
System.out.println("Message four");
}
二、单选
1、下面选项中，__D___的值与3*4的值相等？
A. 3/2
B. 3<2
C. 3*2^2
D. 3<<2
2、下面选项中，D_____的值与16/2^12的值相等？
A. 16>4
B. 16/2
C. 16*4
D. 16>>2
E.
16>>>2
3、有以下方法的定义，请选择该方法的返回类型（D）。

ReturnType method(byte x, double y) {
return (short) x/y*2;
}
A、byte
B、short
C、int
D、double
第3章（2）switch&循环语句练习题
一、填空题
1、设有数组定义：int MyIntArray[ ] = { 10 , 20 , 30 , 40 , 50 , 60 , 70}; 则执行以下几
个语句后的输出结果是120 。

int s = 0 ;
for (int i = 0 ; i < MyIntArray.length ; i + + )
if ( i % 2 = = 1 )
s += MyIntArray[i] ;
System.out.println(s); //s=20+40+60
2、下面程序段的执行结果是（6 5 4 3 2 ）
int a[] = { 2, 3, 4, 5, 6 };
for (int i = a.length - 1; i >= 0; i--)
System.out.print(a[i] + ""); //从大到小排序
3、以“java Sub 3”运行以下程序的结果是：3th season __。

public class Sub{
public static void main(String[] args) {
int i=Integer.parseInt(args[0]);
switch(i) {
case 1: System.out.println("First season"); break;
case 2: System.out.println("Second season"); break;
case 3: System.out.println("3th season"); break;
case 4: System.out.println("Last season"); break;
}
}
}
4.switch(X)中，X可以接受的类型有_byte____,____char___,short,int。

5、以下程序段的输出结果为
_value is two_
value is three ______。

int j=2;
switch ( j ) {
case 2: System.out.print(“Value is two.”);
case 2+1 : System.out.println(“Value is three.”); break;
default: System.out.println(“value is “+j); break;
}
6.如果x=2；则下面程序执行后的结果是_34_____？
switch (x) {
case 1: System.out.println(1);
case 2: case 3: System.out.print(3);
case 4: System.out.println(4);
}
7、下面代码执行结束后l和j的值分别是___5,6___?
public static void main(String[] args) {
int j=10;
int l=1;
do{
if(l++>--j) continue;
}while(l<5)；
}
8、下面程序序的运行结果为（20）
class test{
public static void main(String args[]){
int sum=0;
for(int i=0;i<10;i++){
if(i%2==0)
sum+=i;
else continue;
}
System.out.println(sum);
}
}
二、单选
1、应用程序的main方法中有以下语句，则输出的结果是 (B )。

int b[][]={{1}, {2,2}, {2,2,2}};
int sum=0;
for(int i=0;i<b.length;i++) {
for(int j=0;j<b[i].length;j++) {
sum+=b[i][j]; } }
System.out.println("sum="+sum);
A) 32 B)11 C) 2 D) 3
2、应用程序的main方法中有以下语句，则执行后输出的结果是(D)
int[] x={125,21,5,168,98};
int max=x[0];
for(int i=1;i<x.length;i++){
if(x[i]> max) max =x[i];
}
System.out.println(max);
A) 125 B) 5 C) 98 D) 168
第4章（1）类和对象练习题
一、填空
1、面向对象程序的主要特征：继承,____封装___________,___多态___________。

2、____构造方法_是类中的一种特殊方法，用来定义对象的初始状态。

3、构造方法在__创建对象__时被调用。

4、系统类Math的random()方法可用来产生0-1.0之间的实数，则产生一个50 -100之间的整数的程序语句是_（int）Math.random()*50+50______。

5、下面代码执行结束之后，打印出来的结果是__4____?
public class Happy {
public static void main(String args[]) {
int i=4; int j=2; methodA(i,j);
}
System.out.println(i);
}
static public void methodA(int i,int j) {
i<<=j;
}
}
☆6、在java语言中，有一个类是所有类和接口的父类，这个类的名称是
ng.Object(Object)_____。

7、构造方法在__创建对象__时被调用。

8、java运行系统通过垃圾回收机制/GC____周期性的释放无用对象所占用的内存，
以完成对象的消除。

9、阅读以下程序，输出结果为_1.23___。

class Q1{
public static void main(String args[ ]){
double d=1.23;
Dec dec=new Dec( );
dec.decrement(d);
System.out.println(d);
}
}
class Dec{
public void decrement(double decMe){
decMe = decMe -0.1;
}
}
10、阅读程序
public class Test{
int x=12; public void method1(int x){
x+=x;
System.out.println(x);
}
}
如果有如下的代码段：
Test t=new Test();
t.method1(5);
程序执行到这个地方，代码输出结果是__10___？
11、定义在类中的变量为_成员变量___，它不需要进行显式的初始化，
定义在方法中的变量为__局部变量__，它需要进行显式的初始化。

12、面向对象的模型中，最基本的概念是__类_和_对象__。

二、多选题
13、下面选项中，__AC_______是合法的构造方法的重载？//无返回值public class ConstOver {
public ConstOver (int x, int y, int z) { }
}
A. ConstOver ( ) { }
B. Protected int ConstOver ( ) { }
C. Private ConstOver (int z, int y, byte x) { }
D. Public Object ConstOver (int x, int y, int z) { }
E. Public void ConstOver (byte x, bytey, byte z) { }
14、下面说法中___AC___是对方法setVar()重载的方法。

public class MethodOver {
public void setVar (int a, int b, float c) { }
}
A. Private void setVar (int a, float c, int b) { }
B. Protected void setVar (int a, int b, float c) { }
C. Public int setVar (int a, float c, int b) {return a;}
D. Public int setVar (int a, int b, float c) {return a;}
E. Protected float setVar (int a, int b, float c) {return c;}
第4章(2)可变参数，static与this练习题
一、填空题
1、在下面程序划线处填入适当的内容。

class MyClass{
static int var=100；
____static
public static___
int getVar() { return var;
}
}
2、以下程序段的输出结果为int version______ 。

class Cruncher{ void crunch( int i ){
System.out.println(“int version”);
}
void crunch(String s){
System.out.println(“String version”);
}
public static void main(String args[ ]){
Cruncher crun=new Cruncher ( );
char ch=’p’;
crun.crunch(ch);
}
}
3、以下程序段的输出结果为_Integer String____。

class IntORString{ void iosM( int i ){
System.out.print(“Integer ”);
}
void iosM(String s){
System.out.print(“String ”);
}
public static void main(String args[ ])
{
IntORString ios=new IntORString ( );
ios.iosM(‘a’);
ios.iosM(“1”);
}
}
4、如果有个类A,该类中有成员变量b和成员方法c（）,则在创建该类得对象a
后，对该对象的成员变量和成员方法的调用方式分别是a.b___,__a,c()__。

5、以下代码段创建了__2_个对象，声明了_3____个变量。

Thing item, stuff;
item = new Thing();
Thing entity = new Thing();
6、通过类MyClass中的不含参数的构造函数象obj，可通过以下语句实现：_MyClass obj=new MyClass()________。

7、下面____AD_____情况下，系统会为类A自动产生构造函数？
A. class A { }
B. class A { public A() {} }
C. class A { public A(int x) {} }
D. class Z {} class A extends Z { void A() {} }
8、请问构造函数、成员变量初始化以及静态成员变量初始化三者的先后顺序是__
静态成员变量初始化，成员变量初始化，构造函数_____。

9、划线处应填的一句代码：_ this (a) _______。

public class Example{
int x,y;
public Example(int a){
x = a;
}
public Example(int a, int b){
_this (a) __________;//调用上面的一个参数的构造方法
y = b;
}
}
10.关键字___final____表明一个对象或变量在初始化后不能被修改。

11、类是对象的抽象，是属性和操作的封装体，其中属性是事物静态特征的抽象，
在程序中用数据成员描述，操作是事物动态特征的抽象，在程序中用成员方法描述。

第4章（3）包_访问权限_基本数据类型封装练习题
一、填空题
1、请填出在ng包中与下列基本数据类型相对应的封装类：
float：ng.Float，char：_ng.Character________ ，boolean：
_ng.Boolean __________.
2、java中提供了四种访问控制符，分别是：
public__________,___protected________,_private________,____缺省（friendly）________
3、以下程序段的输出结果为_true ,false_________。

public class EqualsMethod {
public static void main(String[] args) {
Integer n1 = new Integer(47);
Integer n2 = new Integer(47);
System.out.print(n1= =n2);
System.out.print(“,”);
System.out.println(n1! =n2);
}
}
4、在java中，将具有相同属性的对象抽象成_类___。

然后将它按照程序设计所需要的常用方法和接口封装成__包_。

5、创建一个名为MyPackage 的包的语句是package Mypackage ，
该语句应该放在程序的位置为：放在程序的第一句。

6、导入mypackage包中的所类的命令是import mypackage.*;
二、单选题
1、不允许作为类及类成员的访问控制符的是( C )。

A. public
B. private
C. static
D. protected
2、为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为( A )。

A. static void method( )
B. public void method( )
C. final void method( )
D. abstract void method( )
3、下列修饰符中与访问控制无关的是( D)
A．private B．Public C．protected D．final
4、void的含义：( A)
A．方法没有返回值B．方法体为空
C．没有意义 D. 定义方法时必须使用
5、关于对象成员占用内存的说法哪个正确？( B)
A．同一个类的对象共用同一段内存
B、同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间
C．对象的方法不占用内存
D．以上都不对
6、定义一个类，必须使用的关键字是( B)
A、public
B、class
C、interface
D、static
第5章（1）继承与多态练习题答案
一、选择题
1、关于继承的说法正确的是：( B )
A、子类将继承父类所有的属性和方法。

B、子类将继承父类的非私有属性和方法。

C、子类只继承父类public方法和属性
D、子类只继承父类的方法，而不继承属性
2、this和super：( B )
A、都可以用在main()方法中
B、都是指一个内存地址
C、不能用在main()方法中
D、意义相同
3、关于super的说法正确的是：( B )
A、是指当前对象的内存地址
B、是指当前对象的父类对象的内存地址
C、是指当前对象的父类
D、可以用在main()方法中
4、覆盖与重载的关系是( A )
A、覆盖只有发生在父类与子类之间，而重载可以发生在同一个类中B．覆盖方法可以不同名，而重载方法必须同名
C．final修饰的方法可以被覆盖，但不能被重载
D．覆盖与重载是同一回事
5、定义一个类，必须使用的关键字是( B )
A、public
B、class
C、interface
D、static
6、如果有如下这样一段代码
class A {
A() { }
}
class B extends A {
}
请在下面项中，正确的说法是：____________ B D
A、类B的构造函数的访问权限是public
B、类B的构造函数没有参数
C、类B的构造函数中包含this()方法的调用；
D、类B的构造函数中包含super()的调用
7、下面（AD）情况下，系统会为类A自动产生构造函数？
A. class A { }
B.class A {
public A() {} }
C. class A {
public A(int x) {} }
D. class Z {}
class A extends Z {
void A() {} }
二、填空题
1、java中提供了两种用于多态的机制重载,覆盖.
2、this代表了当前对象的引用,super表示的是当前对象的父类对象。

3、如果子类中覆盖了父类中的同名方法，则在子类中调用父类中的同名方法是使用关键字super。

在一个类的内部可以直接调用本类的对象，也可以使用关键字this来调用。

4.子类可以继承父类的成员变量和成员方法，但是不能继承父类的构造函数。

5、下面代码执行后的结果是2
class Super {
public int i = 0;
public Super(String text) {
i = 1;
}
}
public class Sub extends Super {
public Sub(String text) {
super(text);
i = 2;
}
public static void main(String args[]) {
Sub sub = new Sub("Hello");
System.out.println(sub.i);
}
}
6、如果在一个文件中有package,import以及class的定义，请给出三者在文件中的先后顺序。

package,import ,class ．
7.父类的final方法可以被子类重写吗？答案：不可以
第5章（2）接口练习题答案
一、选择题
1、定义一个接口必须使用的关键字是( C )
A、public
B、class
C、interface
D、static
2、抽象方法：( C )
A、可以有方法体
B、可以出现在非抽象类中
C、是没有方法体的方法
D、抽象类中的方法都是抽象方法
3、关于接口哪个正确？( A )
A、实现一个接口必须实现接口的所有方法B．一个类只能实现一个接口
C．接口间不能有继承关系D．接口和抽象类是同一回事
二、填空题
1、抽象方法是一种仅有方法头，没有具体方法体和操作实现的方法，该方法必须在抽象类之中定义。

final方法是不能被当前类的子类重新定义的方法。

2、在Java程序中，通过类的定义只能实现单重继承，但通过接口的定义可以实现多重继承关系。

3、接口由两部分组成接口声明以及接口体。

4、接口可以看作是仅容纳抽象法以及常量，而又不能直接生成对象的特殊类。

5、用于将一个类修饰为最终类的关键字是final。

用于声明一个类为抽象类的关键字是abstract。

6、abstract不能和final 共同修饰一个类。

7、java中用extends 关键字指明继承关系.用implements关键字指明对接口的实现。

8、如果Alpha类继承Beta类，Alpha类被称为子（基）类，Beta类被称为父（超）类。

9、子类可以继承父类的成员变量和成员方法，但是不能继承父类的构造函数。

10、下面程序的输出结果是:_ Art constructor , Drawing constructor , Cartoon constructor 。

class Art {
Art() {
System.out.println("Art constructor");
}
}
class Drawing extends Art {
Drawing() {
super();
System.out.println("Drawing constructor");
}
}
class Cartoon extends Drawing {
Cartoon() {
super();
System.out.println("Cartoon constructor");
}
public static void main(String[] args) {
Cartoon x = new Cartoon();
}
}
11、写出以下程序的运行结果__4 ____
import java.io.*;
public class ATest{
public static void main(String args[]) {
SubClass sb = new SubClass( );
System.out.println(sb.fun( ));
}
}
class SuperClass{
int a =24 , b =5 ;
}
class SubClass extends SuperClass{
int fun( ) { return a%b;}
}
三、多项选择题
1、与第2行等价的定义方式是_____。

A B
1. public interface Foo {
2. int k = 4;
3. }
A. final int k = 4;
B. public int k = 4;
C. abstract int k = 4;
D. volatile int k = 4;
E. protected int k = 4;
2、下面几个方法中，_____可以放在接口(interface)中。

A B
A.void methoda();
B. public double methoda();
C. public final double methoda();
D. static void methoda(double d1);
E. protected void methoda(double d1);
3、请问如下选项中，_____可以使得以上代码编译没有错误。

E
1. public abstract class Test {
2. public abstract void methodA();
3.
4.public abstract void methodB()
5. {
6. System.out.println(“Hello”);
7. }
8.}
A 给methodA加上方法体；
B 将第5-7行的代码用“；”代替
C 将类Test前面的修饰符abstract去掉
D 将方法methodA前面的修饰符abstract去掉
E 将方法methodB前面的修饰符abstract去掉
4、下面选项中，_____可以是合法的方法重写的形式。

BD
class BaseClass {
private float x = 0f;
protected float getVar() { return x; }
}
class SubClass extends BaseClass {
private float x = 0f;
____________________
}
A. float getVar() { return x; }
B. public float getVar() { return x; }
C. public double getVar() { return x; }
D. protected float getVar() { return x; }
E. public float getVar(float f) { return f; }
5、如果有如下这样一段代码
class A { A() { } }
class B extends A { }
请在下面项中，正确的说法是：B D
A.类B的构造函数的访问权限是public
B、类B的构造函数没有参数
C、类B的构造函数中包含this()方法的调用；
D、类B的构造函数中包含super()的调用
三、课后习题答案
3．什么类中可以有abstract方法？
答案：abstract类。

4．什么叫对象的上转型对象？
答案：假设B类是A类子类或间接子类，当我们用子类B创建一个
对象，并把这个对象的引用放到A类的对象中时，称这个A类对象
是子类对象的上转型对象。

父引用指向子对象。

5．什么叫接口的回调？
答案：可以把实现某一接口的类创建的对象的引用赋给该接口声明
的接口变量中。

那么该接口变量就可以调用被类实现的接口中的方
法。

6．下列叙述哪些是正确的？AD
A. final类不可以有子类
B. abstract类中只可以有abstract方法。

C. abstract类中可以有非方法，但该方法不可以用final修饰。

D.不可以同时用final和abstract修饰一个方法。

9.写一个类A，该类创建的对象可以调用方法f输出英文字母表，
然后再编写一个该类的子类B，要求子类B必须继承A类的方法f
（不允许重写），子类创建的对象不仅可以调用方法f输出英文字
母表，而且可以调用子类新增的方法g输出希腊字母表。

class A {
public final void f() {
char cStart = 'a', cEnd = 'z';
for (char c = cStart; c <= cEnd; c++) {
System.out.print(" " + c);
}
}
}
class B extends A {
public void g() {
char cStart = 'α', cEnd = 'ω';
for (char c = cStart; c <= cEnd; c++) {
System.out.print(" " + c);
}
}
}
public class Xiti9 {
public static void main(String args[]) {
B b = new B();
b.f();
b.g();
}
}
10.写一个类，该类有一个方法public int f(int a,int b),该
方法返回a和b的最大公约数。

然后再编写一个该类的子类，要求子类
重写方法f，而且重写的方法将返回a和b的最小公倍数；要求在重写
的方法体中首先调用被隐藏的方法返回a和b的最大公约数m，然后将
乘积（a*b）/m返回；要求在应用的程序的主类中分别使用父类和子类
创建对象，并分别调用方法f计算两个正整数的最大公约数和最小公倍
数。

class A {
public int f(int a, int b) {
if (b < a) {
int temp = 0;
temp = a;
a = b;
b = temp;
}
int r = b % a;
while (r != 0) {
b = a;
a = r;
r = b % a;
}
return a;
}
}
class B extends A {
public int f(int a, int b) {
int division = super.f(a, b);
return (a * b) / division;
}
}
public class Xiti9 {
public static void main(String args[]) {
A a = new A();
B b = new B();
System.out.println("最大公约数：" + a.f(36, 24));
System.out.println("最小公倍数：" + b.f(36, 24));
}
}
第6章内部类与异常类练习题
一、填空题
1、Throwable类有两个子类，分别是Error和Exception.
2、所有异常的根类是Throwable类，throw关键字的作用是引发异常。

3、try关键字负责定义处理异常的程序，再来由catch关键字来捕获异常。

4、补足代码；调用两个函数，要求用匿名内部类
interface Inter {
void show(int a,int b);
void func();
}
class Demo {
public static void main(String[] args) { Inter in=new Inter(){
Void show(int a,int b){}
Void func(){}};
in.show(4,5);
in.func();
}
}
5.、下面程序的输出结果是：BCD
class Demo {
public static void func() throws Exception { try{
throw new Exception();
}
finally{
System.out.println("B");
}
}
public static void main(String[] args){
try{
func();
System.out.println("A");
}
catch(Exception e){
System.out.println("C");
}
System.out.println("D");
}
}
6.在java中所有的异常类都继承自ng.Throwable类，它有两个直接子类，一个是Error类，另一个是Exception类。

7、Java语言中，可以用throw语句和throws语句抛出异常，其中throws语句的作用是用来改变程序的执行流程，使程序跳到相应的异常处理语句中执行。

throw语句把异常向上移交给调用这个方法的方法来处理。

8.下述代码执行后的结果是ACD
class X {
public static void main(String [] args) {
try {
badMethod();
System.out.print("A");
}
catch (Exception ex) {
System.out.print("B");
}
finally {
System.out.print("C");
}
System.out.print("D");
}
public static void badMethod() {}
}
单选题：
1、下面选项中，C不能用在throw语句中？
A. Error
B. RuntimeException
C. Object
D. Throwable
E. Exception
第9章String类练习题答案
一、填空
1、程序执行后的显示结果是abcdefabcDEF。

public class Question {
public static void main (String args[]) {
String s1 = "abc";
String s2 = "def";
String s3 = s1.concat(s2.toUpperCase());
System.out.println(s1+s2+s3);
}
}
2.
String s1 = "ab";
String s2 = "abcd";
System.out.print("s1 "+ (( s1== s2)? "==": "!=") + " s2"); 这个代码段显示的结果是s1 != s2？
3.下面程序段输出结果的第一行是rtrme，第二行是r。

String s="false()rtrme";
String s2=s.substring(7);
String s3=s2.replace('m','u');
System.out.println(s2);
System.out.println(s3.charAt(2));
System.out.println(s3.toUpperCase());
第三行输出结果为RTRUE。

4.第5行的时候foo的值是baseball
String foo = "base";
foo.substring(0,3);
foo.concat("ket");//是返回 foo + "ket",但foo本身的值并不必变, foo+="ball";//改成foo = foo.concat("ket"),结果就是baseketball了System.out.println(foo);
5、如下这段代码执行后，字符串s的值是hellothere
String s="hello";
s.concat("mrs");
s.toUpperCase();
s+="there";
System.out.println(s);
6.下面这段程序执行后，屏幕上显示的是：true。

public class Exam{
public static void main(String[] args){
char char1[]={'t','e','s','t'};
char char2[]={'t','e','s','t','1'};
String s1=new String(char1);
String s2=new String(char2,0,4);//提取字符数组char2[]，从索引0开始，提取个数为4个。

System.out.println(s1.equals(s2));//s1与s2中的实体(即内容)是否相同
}
}
7、请问执行完这段代码后，显示结果是abcd？
String a = "ABCD";
String b = a.toLowerCase(); //将字符串a的值小写
b.replace('a', 'd');//不影响字符串b,因为并未赋值给b
b.replace('b', 'c');//不影响字符串b,因为并未赋值给b
System.out.println(b);
8、Java中，用来获取字符串长度的函数是length(),用来取字符串子串的函数是substring()。

9、以下代码段将创建1个对象。

String s1="bc";
String s2="bc";
10、有下面这样的代码段，总共产生了2个对象。

String A, B, C ;
A = new String( "1234" ) ;
B = A ;
C = A + B ;
11、有如下一段代码：
Integer s = new Integer(9);
Integer t = new Integer(9);
Long u = new Long(9);
则下面选项中返回值为true的是：CE。

A. (s==u)
B. (s==t)
C. (s.equals(t))
D. (s.equals(9)) //有疑问，但输出结果也为true.
E. (s.equals(new Integer(9))
三、完成课后习题
课后习题1，3，5，6，7
1.下列叙述哪些是正确的？ABD
A.String类是final类，不可以有子类
B.String类在ng包中
C.”abc”==”abc”的值是false
D.”abc”.equals(“abc”)的值是true
3.请说出E类中的输出结果为13abc夏日
public class E {
public static void main(String args[]){
byte d[]="abc夏日的海滩".getBytes();
System.out.println(d.length);
String s=new String(d,0,7);
System.out.println(s);
}
}
5.请说出E类中的输出结果为9javaHello
public class E {
public static void main(String args[]){
String regex="\\djava\\w{1,}";
String str1="88javaookk";
String str2="9javaHello";
if(str1.matches(regex)){
System.out.println(str1);
}
if(str2.matches(regex)){
System.out.println(str2);
}
}
}
6.字符串调用public.String.toUpperCase()方法返回一个字符串，该字符串把当前字符串中的小写字母变成大写字母；字符串调用
public.String.toLowerCase()方法返回一个字符串，该字符串把当前字符串中的大写字母变成小写字母；String类的public.String.concat(String str)方法返回一个字符串，该字符串是把调用该方法的字符串与参数指定的字符串相连接。

编写一个程序，练习使用这3个方法。

public class E {
public static void main(String args[]){
String s1,s2,s3,t1="ABCDabcd";
System.out.println("字符串原来是这个样子: "+t1);
s1=t1.toUpperCase();
System.out.println("字符串中的小写字母变成大写是这个样子: "+s1);
s2=t1.toLowerCase();
System.out.println("字符串中的大写字母变成小写是这个样子: "+s2);
s3=s1.concat(s2);
System.out.println("大写字符串连接小写字符串是这个样子: "+s3);
}
}
7.String类的public char charAt(int index)方法可以得到当前字符串index位置上的一个字符。

编写程序，使用该方法得到一个字符串中的第一个和最后一个字符。

public class Xiti7 {
public static void main(String args[ ]){
String s ="中华人民共和国";
char a=s.charAt(0);
char b=s.charAt(6);
System.out.println("第一个字符: "+a);
System.out.println("最后一个字符: "+b);
}
}
第9章（2）实用常用类练习题答案
一、填空题
1、如果method()方法会抛出NullPointerException，则该代码段执行结束后b的值是______?1345
StringBuffer b=new StringBuffer();
try{
b.append("1");
method();
b.append("2");
}catch(Exception a{
b.append("3");
}
finally{
b.append("4");
}
b.append("5");
2、String s1=”JAVA”;String s2=”java”; 则s1.equals(s2)的返回值是_____,s1.equalsIgnoreCase(s2)的返回值是_____。

false true
3、StringBuffer s1=new StringBuffer();StringBuffer s2=new StringBuffer(“Hello”); 则s1.capacity()的返回值是_____。

s2.capacity()的返回值是____.16 21
4、程序执行后的输出结果是：_____?
JavacJava public static void main(String a[]) {
StringBuffer s=new StringBuffer("Java");
String c=new String("Java");
Hello(s,c);
System.out.println(s+c);
}
public static Hello(StringBuffer s, String c) {
s.append("c");
c.repalce('a','d')
}
5、下列代码，执行的时候会错的是______? 4,6
1．StringBuffer sb = new StringBuffer("abc");
2．String s = new String("abc");
3．sb.append("def");
4．s.append("def");
5．sb.insert(1, "zzz");
6．s.concat(sb);
7．s.trim();
二、单项选择题
1、 _______选项插在第三行处,程序执行后可以得到结果4247？B
1.public class Cer{
2. public static void main(String[] args){
3. ___________________________________
4. System.out.println(s);
5.}
6.}
A.String s=”123456789”; s=(s-“123”).replace(1,3,,”24”)-“89”;
B.StringBuffer s=new StringBuffer(“123456789”);
s.delete(0,3).replace(1,3,”24”).delete(4,6);
C.StringBuffer s=new StringBuffer(“123456789”);
s.subString(3,6).delete(1,3).insert(1,”24”);
D.StringBuilder s=new StringBuilder(“123456789”);
s.subString(3,6).delete(1,2).insert(1,”24”);
2、应用程序的main方法中有以下语句，则输出的结果是 ( B )。

String s = "xxxxxxxxxxxxxxx#123#456#zzzzz";
int n = s.indexOf("#");
int k = s.indexOf("#", n+1);
String s2 = s.substring(n+1, k);
System.out.println(s2);
A) 123456 B) 123 C) xxxxxxxxxxxxxxx D) zzzzz
3、下列程序段执行后的结果是( A )。

String s = new String("abcdefg");
for(inti=0;i<s.length();i+=2){
System.out.print(s.charAt(i));
}
A)aceg B) ACEG C) abcdefg D) abcd
4、应用程序的main方法中有以下语句，则输出的结果是( A )。

String s1=new String("abc");
String s2=new String("abc");
boolean b1=s1.equals(s2);
boolean b2=(s1==s2);
System.out.print(b1+" "+b2);
A)true false B) false true C) true true
D)false false
5、应用程序的main方法中有以下语句，则输出的结果是 ( A )。

String s1="0.5", s2="12";
double x=Double.parseDouble(s1);
int y=Integer.parseInt(s2);
System.out.println(x+y);
A) 12.5 B) 120.5 C) 12 D) “12.5”
三、程序设计题：
按以下要求编写程序 (1) 创建一个Rectangle类，添加width和height两
个成员变量 (2) 在Rectangle中添加两种方法分别计算矩形的周长和面积 (3) 编程利用Rectangle输出一个矩形的周长和面积
解答：
public class Rectangle {
float width, height;
public Rectangle(float width, float height) {
this.width = width;
this.height = height;
}
public float getLength(){
return (this.width + this.height) * 2;
}
public float getArea(){
return this.width * this.height;
}
public static void main(String [] args) {
Rectangle rect = new Rectangle(10, 20);
System.out.println("周长是：" + rect.getLength());
System.out.println("面积是：" + rect.getArea());
}
}。