2024年3月31日发(作者：)

附录2：习题答案

第1章：Java简介 —— 自我检测（答案）

1、填空题

1、 Java源程序文件的后缀是 *.java ，Java字节码文件的后缀名称是 *.class 。

2、 Java程序实现可移值性，依靠的是 JVM 。

3、 Java语言的三个分支是： JAVA SE 、 JAVA ME 、 JAVA EE 。

4、 Java程序由 类 组成，如果Java使用 public class 声明类，则文件名称必须与类名称一致。

5、 Java执行是从 main() 方法开始执行的，此方法的完整定义是 public static void main(String args[]) 。

6、 从命名标准上来讲，Java类名的每个单词的首字母通常要求 大写 。

7、 当使用java命令解释一个程序时，一定需要 classpath 环境属性来定位类资源路径；

2、选择题

1、 下面那个是属于解释Java程序所使用到命令？（A）

A、

A、 path

A、 JavaSE

B、

C、

D、

D、TEMP

D、JavaME

2、 下面的那个环境变量java解释时所需要的 B 。

B、 classpath

B、 Java EE

C、 JAVA_HOME

C、 JavaCE

3、 下面那一种开发方向不属于Java定义的？ C

3、判断题

1、 Java语言属于编译型的开发语言。

（ × ）

（ × ） 2、 Java Application程序不是由main()方法开始执行的。

4、简答题

1、 简述Java实现可移值性的基本原理。

答：Java属于编译型和解释型的编程语言，所有的*.java程序必须编译为*.class文件之后才可以在电脑上执行，而执行*.class

文件的电脑并不是一台真实的电脑，而是利用软件和硬件模拟出来的一台虚拟电脑，称为Java虚拟机，而针对于不同的操

作系统平台，有不同版本的Java虚拟机，即：由Java虚拟机去适应不同的操作系统，即：只要Java虚拟机的支持没有改

变，同一个*.class可以在不同的平台上运行。

2、 简述Java语言的三个程序分支。

答： JAVA SE（Java标准版）：提供基础的Java类库及平台支持：

JAVA ME（Java微型版）：提供嵌入式开发支持：

JAVA EE（Java企业版）：提供企业平台支持。

3、 简述Java中path及classpath的作用。

答： PATH：是操作系统的环境属性，指的是可以执行命令的程序路径；

CLASSPATH：是所有*.class文件的执行路径，java命令执行的时候将利用此路径加载所需要的*.class文件。

4、 简述Java语言的主要特点。

答： Java语言的主要的特点如下：

1、 Java语言是一门面向对象语言，且语法足够简单；

2、 Java避免了C/C++之中复杂的指针关系，而使用了更为简单的引用方式来进行内存传递；

3、 Java是为数不多的支持多线程开发的编程语言；

4、 Java提供了自动的垃圾收集机制，可以定期释放出无用的垃圾空间；

5、 Java语言的安全性较高；

6、 Java最大的特点是具备可移植性，即：同一个程序在不同的操作系统上都可以运行。

5、 详细阐述Java中使用public class或class声明一个类的区别及注意事项。

答： 使用public class定义的类，要求文件名称和类名称保持一致，在一个*.java文件之中只能存在一个public class；

使用class定义的类，文件名称可以和类名称不一致，在一个*.java文件之中可以同时存在多个class定义，编译之后

会产生多个*.class文件。

5、编程题

1、 在屏幕上输出：“我喜欢学习 Java”的信息。

答案：

public class TestDemo {

}

2、 在屏幕上打印出以下的图形：

*************************************

********* Java 程序设计 *********

*************************************

public class TestDemo {

}

public static void main(String[] args) {

}

n("*************************************");

n("********* Java 程序设计 *********");

n("*************************************");

public static void main(String[] args) {

}

n("我喜欢学习 Java");

答案：

第2章 简单Java程序 —— 自我检测（答案）

1、填空题

1、 Java中的标识符组成原则： 由字母、数字、下划线、$所组成，其中不能以数字开头，不能是Java的关键字 。

2、 assert 关键字是在JDK 1.4时加入的， enum 关键字是在JDK 1.5时加入的。

3、 列举出已经知道的5个关键字： public、static、void、int、double 。

4、 Java注释分为以下三种： 单行注释（//） 、 多行注释（/* …*/） 、 文档注释 。

5、 Java中使用 int 关键字，可以定义一个整型数据。

6、 在一个Java源文件中定义了3个类和15个方法，编译该Java源文件时会产生 3 个字节码文件，其扩展名是

*.class 。

7、 布尔型数据类型的关键字是 boolean ，有 true 和 false 两种取值。

8、 整型数可以采用 byte 、 short 、 int 和 long 四种类型表示。

9、 根据占用内存长度的不同将浮点型分为 float 和 double 两种。

10、 Java程序结构分为： 顺序结构 、 分支结构 、 循环结构 三种。

11、 逻辑表达式：true&&false&&true的结果是 false 。

12、 逻辑表达式：!true||false的结果是 false 。

13、 在方法中可以使用 return 语句来结束方法的执行。

14、 方法中的 void 关键字用来表示方法不返回任何值。

2、选择题

1、 下面那些标识符是正确的 D 。

A、 class

A、 const

B、 hello world

C、 123$temp

C、 int

D、 Demo

D、 assert

D、 String args

2、 下面那些关键字是Java中未使用到的关键字 A、B （多选）。

B、 goto

3、 public static void main方法的参数描述是： A 。

A、 String args[] B、 int[] args C、 Strings args[]

4、 下面说法正确的是 C 。

A、 Java程序的源文件名称与主类（puublic class）的名称相同，后缀可以是.java或.txt等。

B、 JDK的编译命令是java。

C、 一个java源文件编译后可能产生多个class文件。

D、 在命令行编译好的字节码文件，只需在命令行直接键入程序名即可运行该程序。

A、 Java语言是面向对象的、解释执行的网络编程语言

B、 Java语言具有可移植性，是与平台无关的编程语言。

C、 Java语言可对内存垃圾自动收集。

D、 Java语言执行时需要Java的运行环境。

A、 integer B、 double C、 float

D、 char

5、 下面说法不正确的是 A 。

6、 下面 A 不是Java的关键字。

7、 在Java中，字节数据类型的关键字和默认值是 A 。

A、 byte和0

A、 3.15 × 2

A、 1

A、 1

B、 byte和1

B、 3.15 × 10

-2

B、 1 + 1 = 2

B、 3

C、 boolean和true D、 boolean和false

C、 3.15 × 10

2

C、 1 + 1 = 11

C、 3.3

D、 0.315 × 10

-2

8、 3.15E2表示的数据是 C 。

9、 程序n("1 + 1 = " + 1 + 1) ;的输出结果是 C 。

D、 2

D、 3.33333

10、 程序n(10 / 3) ;的输出结果是 B 。

11、 执行下面的语句后，a、b、c的值分别是 C 。

int a = 2 ;

int b = (a++) * 3 ;

int c = (++a) * 3 ;

B、 4、9、9 C、 4、6、12

D、 "123"

D、 8.6F

D、 3、9、9 A、 2、6、6

A、 35.d

A、 33.8

12、 以下的 B 能正确表示Java语言中的一个整型常量。

B、 -20

B、 129

C、 1,234

C、 89L

13、 下面的数据类型 D 是float型

14、 下列关于自动类型转换的说法中，正确的一个是 B 。

A、 int类型数据可以自动转换为char类型数据

B、 char类型数据可以被自动转换为int类型数据

C、 boolean类型数据不可以做自动类型转换，但是可以做强制转换

D、 long类型数据可以被自动转换为short类型数据

A、 构造方法 B、 递归方法 C、 成员方法 D、 抽象方法

15、 一个方法在定义过程中又调用自身，这种方法称为 B 。

3、判断题

1、 变量的内容可以修改，常量的内容不可修改。

2、 goto是Java中未使用到的关键字。

3、 enum关键字是在JDK 1.4版本中增加的。

5、 主方法编写：public void main(String arg)。

6、 字符$不能作Java标识符的第一个字符。

8、 使用break语句可以跳出一次循环。

9、 byte的取值范围是：0~255。

（

（

（

（

（

（

（

（

（

（

（

（

（

（

（

√ ）

√ ）

× ）

× ）

× ）

× ）

× ）

× ）

× ）

× ）

× ）

√ ）

× ）

√ ）

× ）

4、 使用public class定义的类，文件名称可以与类名称不一致。

7、 n()输出后是不加换行的，而()输出后是加换行的。

10、 int和double进行加法操作，int会自动转换为double类型。

11、 使用“&”操作时，如果第一个条件是false，则后续的条件都不再判断。

12、 使用“&&”操作时，如果第一个条件是false，则后续的条件都不再判断。

13、 使用“|”操作时，如果第一个条件是true，则后续的条件都不再判断。

14、 使用“||”操作时，如果第一个条件是true，则后续的条件都不再判断。

15、 定义多个同名方法时，可以依靠返回值区别同名方法。

4、简答题

1、 请解释常量与变量的区别？

答： 常量就是一个固定的数值。是不可改变的，例如：数字1、2就是一个整型的常量。

变量是利用声明的方式，将内存中的某个内存块保留下来以供程序使用。可以声明的数据类型为整型、字符型、浮

点型或是其他数据类型，作为变量的保存之用。变量在程序语言中扮演了最基本的角色。变量可以用来存放数据，而使用

变量之前必须先声明它的数据类型。

2、 解释方法重载的概念，并举例说明。

答： 方法重载指的是多个方法的方法名称相同，但是方法中的参数类型及个数不同。

代码说明：

public static int add(int x, int y) {

}

return x + y;

public static int add(int x, int y, int z) {

}

public static double add(double x, double y) {

}

return x + y;

return x + y + z;

5、编程题

1、 打印出100~1000范围内的所有 “水仙花数”，所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数本身。

例如：153是一个“水仙花数”，因为153=1的三次方＋5的三次方＋3的三次方。

public class TestDemo {

}

程序运行结果：

2、 通过代码完成两个整数内容的交换。

实现一：引用第三方变量

public class TestDemo {

}

程序运行结果：

public static void main(String[] args) {

}

int x = 10;

int y = 20;

int temp = x;

x = y;

y = temp;

n("x = " + x);

n("y = " + y);

实现二：利用数学计算完成

public class TestDemo {

}

x = 20

y = 10

3、 判断某数能否被3，5，7同时整除。

public class TestDemo {

public static void main(String[] args) {

public static void main(String[] args) {

}

int x = 10;

int y = 20;

x += y ;

y = x - y;

x = x - y ;

n("x = " + x);

n("y = " + y);

153、370、371、407、

public static void main(String[] args) {

}

int i, j, k;

for (int x = 100; x < 1000; x++) {

}

i = x / 100;

k = x % 10;

}

// 计算百位数字

// 计算十位数字

// 计算个位数字

j = (x / 10) % 10;

if (x == i * i * i + j * j * j + k * k * k) {

(x + "、");

}

}

int data = 105;

if (data % 3 == 0 && data % 5 == 0 && data % 7 == 0) {

}

n(data + "可以同时被3、5、7整除。");

n(data + "不可以同时被3、5、7整除。");

} else {

程序运行结果： 105可以同时被3、5、7整除。

4、 编写程序，分别利用while循环、do…while循环和for循环求出100~200的累加和。

实现一：使用while循环

public class TestDemo {

}

实现二：使用do…while循环

public class TestDemo {

}

实现三：使用for循环

public class TestDemo {

}

public static void main(String[] args) {

}

int sum = 0;

for (int x = 100; x <= 200; x++) {

}

n("累加结果：" + sum);

sum += x;

public static void main(String[] args) {

}

int sum = 0;

int x = 100;

do {

sum += x;

x++;

public static void main(String[] args) {

}

int sum = 0;

int x = 100;

while (x <= 200) {

}

n("累加结果：" + sum);

sum += x;

x++;

} while (x <= 200);

n("累加结果：" + sum);

第3章、面向对象（基础） —— 自我检测（答案）

1、填空题

1、 面向对象有那三大特征： 封装 、 继承 、 多态 。

2、 类由 属性 和 方法 组成。

3、 new 运算符的作用是根据对象的类型分配内存空间。当对象拥有内存空间时，会自动调用类中的 构造方法

为对象 实例化 。

4、 使用 private 修饰的类成员称为私有成员。私有成员只能在 类 中使用。

5、 构造方法的名称与 类名称 相同。

6、 private 关键字可以让类中的属性和方法对外部不可见。

7、 this关键字可以调用本类中的 属性 、 方法 、 构造方法 ，调用 构造方法 时必须放在 构造方

法 的首行。

8、 在Java中数组排序的方法是 () 。

2、选择题

1、 如果希望方法直接通过类名称访问，在定义时要使用的修饰符是 A 。

A、 static B、 final C、 abstract D、 this

2、 如果类中没有定义构造方法，系统会提供一个默认的构造方法。默认构造方法的特点是 C 。

A、 无参数有操作 B、 有参数无操作 C、 即无参数也无任何操作

A、 void Demo(int x){…}

C、 Demo Demo(int x){…}

B、 Demo(int x){…}

D、 int Demo(){}

D、 有参数有操作

3、 有一个类Demo，对与其构造方法的正确声明是 B 。

4、 以下关于面向对象概念的描述中，不正确的一项是 C 。

A、 在现实生活中，对象是指客观世界的实体

B、 程序中的对象就是现实生活中的对象

C、 在程序中，对象是通过一种抽象的数据类型来描述的，这种抽象数据类型称为类（class）

D、 在程序中，对象是一组变量和相关方法的集合

A、 类 B、 对象 C、 方法 D、 安全

5、 下列那一项不属于面向对象程序设计的基本要素？ D

6、下列程序的执行结果是 A

public class TestDemo {

}

A、 编译错误 B、 0 C、 1 D、 运行成功，但不输出

public void fun() {

}

public static void main(String args[]) {

}

Demo d = new Demo();

();

static int i = 0;

i++;

n(i);

7、 顺序执行下列程序语句后，则b的值是 C 。

String str = "Hello" ;

String b = ing(0,2) ;

A、 Hello B、 hello C、 He D、 null

3、判断题

1、 没有实例化的对象不能使用。

2、 不可以为类定义多个构造方法。

（

（

（

（

（

（

（

（

（

（

√

×

×

√

×

√

×

√

√

√

）

）

）

）

）

）

）

）

）

）

3、 使用static声明的方法可以调用非static声明的方法。

4、 非static声明的方法可以调用static声明的属性或方法。

5、 String对象可以使用==进行内容的比较。

7、 构造方法可以有返回值类型的声明。

6、 垃圾是指无用的内存空间，会被垃圾收集机制回收。

8、 匿名对象是指使用一次的对象，使用之后将等待被垃圾回收。

9、 使用static定义的内部类就成为外部类。

10、 多个实例化对象之间不会互相影响，因为保存在不同的内存区域之中。

4、简答题

1、 String类的操作特点。

答： String类的对象有两种实例化方式：

|- 方式一：直接赋值，只开辟一块堆内存空间，并且对象可以入池；

|- 方式二：构造方法，开辟两块堆内存空间，有一块将称为垃圾，不会自动入池，使用intern()方法手工入池；

|- ==：比较的是两个字符串对象的内存地址数值；

|- equals()：字符串内容比较；

String对象的比较方法：

字符串对象一旦声明，则内容不可改变，改变的只能是字符串对象的地址指向。

2、 简述垃圾对象的产生。

答： 垃圾指的是一块无用的引用内存，当将变量设置为null或者长时间不使用时，就将成为垃圾。

3、 static方法如何调用？非static方法如何调用？

答： static方法可以使用类名称或实例化对象调用，而非static方法只能依靠实例化对象才可以调用。

4、 类与对象的关系是什么？如何创建及使用对象？

答： 类规定了对象所具有的属性及行为（方法），类只有通过产生对象才可以分配属性或者是调用方法，对象的创建依靠

关键字new创建。

5、 举例说明子类对象的实例化过程。

答： 当通过关键字new实例化子类对象时，会默认调用父类的无参构造方法，为父类对象实例化，而后才会调用子类的

构造方法，为子类对象实例化。

7、 简述this与super关键字的区别。

答： this和super都可以调用类中的属性、方法、构造方法，但是this调用的是本类操作，而super是由子类调用父类操作。

5、编程题

1、 编写并测试一个代表地址的Address类，地址信息由：国家，省份，城市，街道，邮编组成，并可以返回完整的地址

信息。

class Address {

}

public class TestDemo {

}

程序运行结果： 国家：中国，省份：北京，城市：北京市，街道：MLDN，邮政编码：100088

2、 定义并测试一个代表员工的Employee类。员工属性包括“编号”、“姓名”、“基本薪水”、“薪水增长额”；还包括 “计

算增长后的工资总额”。的操作方法。

class Employee {

private int empno ;

private String ename ;

private double sal ;

private double rate ;

public Employee() {

}

public Employee(int empno, String ename, double sal, double rate) {

super();

= empno;

= ename;

= sal;

= rate;

// 雇员编号

// 雇员姓名

public static void main(String args[]) {

}

Address ad = new Address("中国", "北京", "北京市", "MLDN", "100088");

n(ad);

private String national;

private String provincial;

private String city;

private String street;

private String zipcode;

public Address() {

}

public Address(String national, String provincial, String city,

}

public String toString() {

}

// setter、getter略

return "国家：" + al + "，省份：" + cial + "，城市："

+ + "，街道：" + + "，邮政编码：" + e;

String street, String zipcode) {

super();

al = national;

cial = provincial;

= city;

= street;

e = zipcode;

// 基本工资

// 工资增长额

}

}

public String toString() {

}

public void growthin() {

}

// setter、getter略

// 增长薪水

= * ;

return "雇员编号：" + + "，雇员姓名：" + + "，基本工资：" + ;

public class TestDemo {

}

程序运行结果： 雇员编号：7369，雇员姓名：SMITH，基本工资：1500.0

3、 编写程序在将字符串“want you to know one thing”，统计出字母“n”和字母“o”的出现次数。

public class TestDemo {

}

程序运行结果：

4

字母n的出现次数：4

设计一个Dog类，有名字、颜色、年龄等属性，定义构造方法来初始化类的这些属性，定义方法输出Dog信息。编

public static void main(String args[]) {

}

String str = "want you to know one thing" ;

int sum = 0 ;

while (f("n") != -1) {

}

n("字母n的出现次数：" + sum);

sum ++ ;

// 是否还有字母n

// 数据统计量增加

// 定义字符串

public static void main(String args[]) {

}

Employee emp = new Employee(7369, "SMITH", 1000, 1.5);

in() ; // 工资增长

n(emp);

str = ing(f("n") + 1); // 改变字符串内容

写应用程序使用Dog类。

class Dog {

private String name ;

private String color ;

private int age ;

public Dog() {

}

public Dog(String name, String color, int age) {

}

public String toString() {

return "狗的名字：" + + "，狗的颜色：" + + "，狗的年龄：" + ;

super();

= name;

= color;

= age;

}

}

// setter、getter略

public class TestDemo {

}

程序运行结果：

5、 字符串操作：

· 从字符串“MLDN中心Java技术学习班20130214”中提取开班日期。

public class TestDemo {

}

程序运行结果：

20130214

· 将“MLDN JAVA高端技术培训”字符串中的“Java”替换为“JAVA EE”。

public class TestDemo {

}

程序运行结果：

·

MLDN JAVA EE高端技术培训

取出“Java技术学习班20130214”中的第八个字符。

public static void main(String args[]) {

}

String str = "MLDN JAVA高端技术培训" ;

n(eAll("Java".toUpperCase(), "JAVA EE"));

public static void main(String args[]) {

}

String str = "MLDN中心Java技术学习班20130214" ;

n(ing(f("20130214")));

狗的名字：金毛，狗的颜色：金黄色，狗的年龄：3

public static void main(String args[]) {

}

Dog dog = new Dog("金毛", "金黄色", 3);

n(dog);

public class TestDemo {

}

程序运行结果：

· 清除“Java技术学习班20130214”中的所有‘0’。

public class TestDemo {

}

程序运行结果：

· 从任意给定的身份证号码中提取此人的出生日期。

public class TestDemo {

Java技术学习班213214

public static void main(String args[]) {

}

String str = "Java技术学习班20130214" ;

n(eAll("0", ""));

班

public static void main(String args[]) {

}

String str = "Java技术学习班20130214" ;

n((8));

}

public static void main(String args[]) {

}

19760919

String str = "1100520" ;

n(ing(6,14));

程序运行结果：

6、 编写一个银行帐户类,类的构成包括：

}

public class TestDemo {

}

程序运行结果：

public static void main(String args[]) {

}

· 数据成员：

|- 用户的帐户名称、用户的帐户余额；

· 方法包括：

|- 开户（设置帐户名称，及余额），利用构造方法完成

· 查询余额

class Account {

private String name ;

private double balance ;

public Account() {

}

public Account(String name, double balance) {

}

public String toString() {

}

public double getBalance() {

}

// setter、getter略

return balance;

return "账户名称：" + + "，余额：" + e;

super();

= name;

e = balance;

Account acc = new Account("张三", 5000.0);

n(acc);

n("账户余额：" + ance());

账户名称：张三，余额：5000.0

账户余额：5000.0

第4章、面向对象（高级） —— 自我检测（答案）

1、填空题

1、 Java中通过 extends 关键字实现继承。

2、 一个类只能继承 一 个父类，但能实现 多个 接口。

3、 Object 类是所有类的父类，该类中判断两个对象是否相等的方法是 public boolean equals(Object oth) ，取

得对象完整信息的方法是 public String toString() 。

4、 Integer类是对 int 基本数据类型的封装。Float类是对 float 基本数据类型的封装。Double类是对 double

基本数据类型的封装。字符类Character是对 char 基本数据类型的封装。

5、 当子类中定义的方法与父类方法同名且参数类型及个数、返回值类型相同时，称子类方法 覆写 父类方法，子

类默认使用 本类已经覆写 方法，使用父类的同名方法，必须使用 super 关键字说明。

6、 当子类定义的成员变量与父类的成员变量同名时，称子类 覆盖 父类的成员变量，子类默认使用 本类 属性。

使用父类的同名成员变量，必须用 super 关键字说明。

7、 如果子类定义了构造方法，在创建子类对象时首先默认调用 父类无参构造方法 ，然后再本类的构造方法。

2、选择题

1、 不能直接使用new创建对象的类是 B 。

A、 静态类 B、 抽象类 C、 最终类 D、 公有类

2、 为类定义多个名称相同、但参数的类型或个数不同的方法的做法称为 B 。

A、 方法重载

A、 extends

B、 方法覆写

B、 class

C、 方法继承

D、 方法重用

D、 public

3、 定义接口的关键字是 C 。

C、 interface

4、 现在有两个类A、B，以下描述中表示B继承自A的是 D 。

A、 class A extends B

C、 class A implements

B、 class B implements A

D、 class B extends A

5、 下面关于子类调用父类构造方法的描述正确的是 C 。

A、 子类定义了自己的构造方法，就不会调用父类的构造方法。

B、 子类必须通过super关键字调用父类有参的构造方法。

C、 如果子类的构造方法没有通过super调用父类的构造方法，那么子类会先调用父类中无参构造方法，之后再调

D、 创建子类对象时，先调用子类自己的构造方法，让后再调用父类的构造方法。

A、 X x = new X() ;

C、 Y x = new Y() ;

public class A {

public static void main(String args[]) {

}

void test() {

B b = new B();

();

B、 X x = new Y() ;

D、 Y x = new X() ;

用子类自己的构造方法。

6、 假设类X是类Y的父类，下列声明对象x的语句中不正确的是 D 。

7、 编译并运行下面的程序，结果 B 。

}

}

("A");

class B extends A {

}

A、 产生编译错误 B、 代码可以编译运行，并输出结果：AB

D、 编译没有错误，但会运行时会产生异常 C、 代码可以编译运行，但没有输出

public class A {

}

class B extends A {

}

A、 产生编译错误，因为类B覆盖类A的方法test()时，降低了其访问控制的级别。

B、 代码可以编译运行，并输出结果：AB

C、 代码可以编译运行，但没有输出

D、 代码可以编译运行，并输出结果：A

A、 final

A、 final

B、 abstract

B、 abstract

C、 static

D、 static

D、 interface

D、 interface

void test() {

}

();

n("B");

public static void main(String args[]) {

}

public void test() {

}

("A");

B b = new B();

();

void test() {

}

();

n("B");

8、 编译运行下面的程序，结果是 A 。

9、 下面 B 修饰符所定义的方法必须被子类所覆写。

10、 下面 A 修饰符所定义的方法不能被子类所覆写。

11、下面的程序编译运行的结果是 A

public class A implements B {

}

interface B {

public static void main(String args[]) {

}

int m, n;

A a = new A();

m = a.K;

n = B.K;

n(m + "，" + n);

}

int K = 5;

A、 5，5 B、 0，5 C、 0，0 D、 编译程序产生编译结果

12、 下面关于接口的说法中不正确的是 C 。

A、 接口所有的方法都是抽象的

B、 接口所有的方法一定都是public类型

C、 用于定义接口的关键字是implements

D、 接口是Java中的特殊类，包含全局常量和抽象方法

A、 abstract和final能同时修饰一个类

B、 抽象类不光可以做父类，也可以做子类

C、 抽象方法不一定声明在抽象类中，也可以在接口中

D、 声明为final的方法不能在子类中覆写

13、 下面关于Java的说法不正确的是 A

3、判断题

1、 final声明的类可以有子类。

（

（

（

（

（

（

（

（

（

（

×

√

√

√

×

√

√

×

√

×

）

）

）

）

）

）

）

）

）

）

2、 一个类继承了抽象类，则抽象类中的抽象方法需要在其子类中覆写。

3、 final类型的变量是常量，其内容不可改变。

4、 一个类不能即是子类又是父类。

5、 子类只能继承父类的成员，但不能修改父类成员。

6、 Java语言只支持单继承，不支持多继承。

7、 子类可以继承父类的所有成员。

8、 一个接口可以继承一个抽象类。

9、 一个接口可以同时继承多个接口。

10、在程序中this和super调用构造方法时可以同时出现。

4、简答题

1、 简述this与super关键字的区别。

答： this和super都可以调用类中的属性、方法、构造方法，但是this调用的是本类操作，而super是由子类调用父类操作。

2、 简述方法的重载与覆写的区别。

答： 方法重载是发生在一个类之中，方法名称相同、参数的类型及个数不同，不受权限的限制。而覆写是发生在继承关

系之中，子类定义了和父类定义了方法名称相同、参数类型及个数、返回值类型完全相同的方法时所发生的操作，在子类

覆写父类方法时，被覆写的方法不能拥有比父类更严格的访问权限。

3、 在已有类的基础上派生新的类有什么好处？

答： 扩充已有类的功能，并且利用方法的覆写扩充已有方法的功能。

4、 如何区分子类和父类？子类可以继承父类的那些内容？

答： 子类使用extends继承父类或使用implements实现多个接口，子类可以继承父类中的全部内容，但是对于私有操作属

于隐式继承，而非私有操作属于显式继承。

5、 什么是多态？实现都态的方法有那些？

答： 多态是面向对象的最后一个主要特征，它本身主要分为两个方面：

· 方法的多态性：重载与覆写

|- 重载：同一个方法名称，根据不同的参数类型及个数可以完成不同的功能；

|- 覆写：同一个方法，根据操作的子类不同，所完成的功能也不同。

· 对象的多态性：父子类对象的转换。

|- 向上转型：子类对象变为父类对象，格式：父类 父类对象 = 子类实例，自动；

|- 向下转型：父类对象变为子类对象，格式：子类 子类对象 = (子类) 父类实例，强制；

6、 接口有那些特征？如何定义和实现接口。

答： 接口之中全部由全局常量及抽象方法所组成，一个类可以同时实现多个接口，在Java中使用interface定义接口，子

类使用implements实现接口。

7、 接口和抽象类有那些区别？

答： 抽象类及接口区别如下。

No.

1

2

3

4

5

6

7

区别

定义关键字

组成

权限

关系

使用

设计模式

局限

抽象类

abstract class

常量、变量、抽象方法、普通方法、构造方法

可以使用各种权限

一个抽象类可以实现多个接口

子类使用extends继承抽象类

接口

interface

全局常量、抽象方法

只能是public

接口不能够继承抽象类，却可以继承多接口

子类使用implements实现接口

抽象类和接口的对象都是利用对象多态性的向上转型，进行接口或抽象类的实例化操作

模板设计模式

一个子类只能够继承一个抽象类

工厂设计模式、代理设计模式

一个子类可以实现多个接口

8、 简述基本数据类型的自动装箱及自动拆箱操作。

答： 在JDK 1.5之后，基本数据类型可以采用直接赋值的方式为包装类进行对象的实例化操作，而包装类的对象也可以通

过直接赋值的方式变回基本数据类型。

5、编程题

1、 定义一个ClassName接口，接口中只有一个抽象方法getClassName()。设计一个类Company，该类实现接口ClassName

中的方法getClassName()，功能是获取该类的类名称。编写应用程序使用Company类。

interface ClassName {

}

class Company implements ClassName {

}

public class TestDemo {

}

程序运行结果：

Company

2、 建立一个人类（Person）和学生类（Student）功能要求：

A、 Person中包含4个保护型的数据成员name、address、sex、age分别为字符串，字符串，字符及整型。表示：姓

名、地址、性别和年龄。一个四参构造方法，一个无参构造方法，及一个输出方法用于显示四种属性。

B、 Student继承Person，并增加输出成员math、english存放数学和英语成绩。一个六参构造方法，一个两参构造

方法，一个无参构造方法，重写输出方法用于显示全部六种种属性.

public static void main(String args[]) {

}

ClassName name = new Company() ;

n(ssName());

public String getClassName() {

}

return "Company";

public String getClassName() ;

class Person {

}

class Student extends Person {

}

public class TestDemo {

}

程序运行结果： 姓名：张三，地址：北京西城区甲11号德外大街德胜科技

园美江大厦 A座 - 6层，性别：男，年龄：25，数学成绩：

90.0，英语成绩：99.0

public static void main(String args[]) {

}

Student stu = new Student("张三", "北京西城区甲11号德外大街德胜科技园美江大厦 A座 - 6层", '

n(stu);

private double math ;

private double english ;

public Student() {

}

public Student(String name, String address, char sex, int age, double math,

}

public String toString() {

}

// setter、getter略

return ng() + "，数学成绩：" + + "，英语成绩：" + h;

double english) {

super(name, address, sex, age);

= math;

h = english;

private String name ;

private String address ;

private char sex ;

private int age ;

public Person() {

}

public Person(String name, String address, char sex, int age) {

}

public String toString() {

}

// setter、getter略

return "姓名：" + + "，地址：" + s + "，性别：" +

+ "，年龄：" + ;

super();

= name;

s = address;

= sex;

= age;

男', 25, 90.0, 99.0);

3、 定义员工类，具有姓名，年龄，性别属性，并具有构造方法，显示数据方法，定义管理层类，继承员工类，并有自

己的属性：职务，年薪。定义职员类，继承员工类，并有自己的属性：所属部门，月薪。

class Employee {

}

class Manager extends Employee {

}

class Staff extends Employee {

private String dept ;

private double salary ;

public Staff() {

}

public Staff(String name, int age, char sex, String dept, double salary) {

}

public String toString() {

return ng() + "，部门：" + + "，月薪：" + ;

super(name, age, sex);

= dept;

= salary;

private String job ;

private double income ;

public Manager() {

}

public Manager(String name, int age, char sex, String job, double income) {

}

public String toString() {

}

// setter、getter略

return ng() + "，职位：" + + "，年薪：" + ;

super(name, age, sex);

= job;

= income;

private String name ;

private int age ;

private char sex ;

public Employee() {

}

public Employee(String name, int age, char sex) {

}

public String toString() {

}

// setter、getter略

return "雇员姓名：" + + "，年龄：" + + "，性别：" + ;

super();

= name;

= age;

= sex;

}

}

// setter、getter略

public class TestDemo {

}

程序运行结果： 雇员姓名：张三，年龄：30，性别：男，职位：总监，年薪：200000.0

雇员姓名：李四，年龄：25，性别：女，部门：业务部，月薪：1500.0

4、 定义类Shape表示一般二维图形。Shape具有抽象方法area和perimeter，分别计算形状的面积和周长。试定义一些二

维形状类（如矩形、三角形、圆形等），这些类均为Shape类的子类。

abstract class Shape {

}

class Rectangle extends Shape {

}

class Triangle extends Shape {

private double edgea ;

private double edgeb ;

private double edgec ;

public Triangle() {

}

public Triangle(double edgea, double edgeb, double edgec) {

super();

= edgea;

// 三角形

// 边长

// 边长

// 边长

private double wide ;

private double longs ;

public Rectangle() {

}

public Rectangle(double wide, double longs) {

}

public double area() {

}

public double perimeter() {

}

return ( + ) * 2;

return * ;

super();

= wide;

= longs;

// 矩形

// 长

// 宽

public abstract double area();

public abstract double perimeter();

public static void main(String args[]) {

}

Employee ea = new Manager("张三", 30, '男', "总监", 200000.0);

Employee eb = new Staff("李四", 25, '女', "业务部", 1500.0);

n(ea);

n(eb);

}

}

= edgeb;

= edgec;

public double area() {

}

public double perimeter() {

}

// 圆形

// 半径

return + + ;

return * / 2 ;

class Round extends Shape {

}

public class TestDemo {

}

程序运行结果：

private double radius ;

public Round() {

}

public Round(double radius) {

}

public double area() {

}

public double perimeter() {

}

return * 2 * ;

return * * ;

super();

= radius;

public static void main(String args[]) {

}

矩形面积：216.3，矩形周长：62.2

三角形面积：102.99，三角形周长：60.599999999999994

圆形面积：2884.2647993342534，圆形周长：190.38

Shape rectangle = new Rectangle(10.5, 20.6);

Shape triangle = new Triangle(10.1, 20.2, 30.3);

Shape round = new Round(30.3) ;

n("矩形面积：" + () + "，矩形周长：" + ter());

n("三角形面积：" + () + "，三角形周长：" +

n("圆形面积：" + () + "，圆形周长：" + ter());

ter());

第5章、包及访问控制权限 —— 自我检测（答案）

1、填空题

1、 package 关键字可以定义一个包， import 关键字可以导入包。

2、 Java中存在四种访问权限： private 、 default 、 protected 、 public 。

3、 Java中可以使用 import static 包.类.* 导入一个类的全部静态方法。

4、 jar 命令可以将全部的class打成一个压缩包。

5、 Java中 包是自动导入的。

2、选择题

1、 String和Object类在 A 包中定义的。

A、 B、 C、 D、

2、 C 权限是同一包可以访问，不同包的子类可以访问，不同包的非子类不可以访问。

A、 private B、 default C、 protected D、 public

3、 下列说法正确的一项是 C 。

A、 r是接口

B、 String定义在包中

C、 Double类在包中

D、 Double类在包中

4、 下列关于包、类和源文件的描述中，不正确的一项是 C 。

A、 一个包可以包含多个类

B、 一个源文件中，只能有一个public class

C、 属于同一个包的类在默认情况不可以互相访问，必须使用import导入

D、 系统不会为源文件创建默认的包

5、 定义类时不可能用到的关键字是 C 。

A、 final B、 public C、 protected D、 static

3、判断题

1、 包必须由用户手工导入，否则无法使用。

2、 定义包后类的完整名称是：包.类名称。

4、简答题

1、 简述包的作用及使用。

答： 使用包可以将功能近似的类统一管理，同时可以避免项目之中同名类名称冲突问题；

2、 简述Java的四种访问权限的区别。

答： Java一共有四种访问控制权限：

· private：只可以在一个类中访问，其他类不允许访问；

· default：可以在一个包中访问，但是不同包不允许访问；

× ）

√ ）

（

（

· protected：可以在同一个包中和不同包的子类所访问，其他包的类不允许访问；

· public：可以被所有包的类所访问。

class Singleton {

}

public class TestDemo {

}

程序运行结果：

Hello World .

public static void main(String args[]) {

}

Singleton inst = null;

();

// 声明对象

// 利用“类.static方法()”取得实例化对象

// 调用方法

// 定义一个类

// 构造方法私有化

3、 编写一个单例设计模式，并简要说明其特点：

private final static Singleton instance = new Singleton() ;

private Singleton() {

}

public void print() {

}

public static Singleton getInstance() {

}

return instance;

// 取得本类对象

n("Hello World .");

inst = tance();

构造方法被私有化，只能够通过getInstance()方法取得Singleton类的实例化对象，这样不管外部如何操作，最终也只

有一个实例化对象，在单例设计模式之中，一定会存在一个static方法，用于取得本类的实例化对象。

第6章、异常的捕获及处理 —— 自我检测（答案）

1、填空题

1、 Throwable下有那两个子类： Error 、 Exception 。

2、 ArthmeticException类表示 算术 异常，ArraysIndexOutOfBoundsException表示 数组越界 异常。

3、 一个try代码后面必须跟着若干个 catch 代码段或者一个 finally 代码段。

4、 如果一个方法使用了 throws ，则编译器会强制在使用此方法时进行异常的处理。

5、 异常处理中使用 finally 作为异常的统一出口。

2、选择题

1、 使用那个关键字可以在程序中手工抛出异常 B 。

A、 throws

A、 throws

A、 try块

B、 throw

B、 assert

B、 catch块

C、 assert

C、 class

D、 class

D、 interface

D、 finally块

2、 下面 A 关键字可以用在方法的声明处？

3、 为了捕获一个异常，代码必须放在下面 A 语句块中。

C、 throws块

4、 下面关于try块的说法正确的是 C 。

A、 try块后至少应有一个catch块 B、 try块后必须有finally块

D、 对抛出的异常的处理应放在try块中 C、 可能抛出异常的方法应放在try块中

A、 总是被执行

5、 finally块中的代码将 A 。

B、 如果try块后面没有catch块时，finally块中的代码才会执行

C、 异常发生时才被执行

D、 异常没有发生时才执行

A、 整个程序

B、 只终止抛出异常的方法

D、 上面的说法都不对

D、 RuntimeException

6、 一个异常将终止 A 。

C、 产生异常的try块

A、 Error

7、 所有异常的共同父类是 B 。

B、 Exception C、 Throwable

3、判断题

1、 一个try语句后有多个catch时，捕获范围大的异常要放在捕获范围小的异常之后。 （

2、 finally语句可以根据需要有选择的添加。 （

√

√

）

）

4、简答题

1、 简述RuntimeException和Exception的区别。

答： 异常（Exception）表示程序运行过程中可能出现的非正常状态，运行时异常（RuntimeException）表示虚拟机的通常

操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要

求必须声明抛出未被捕获的运行时异常，即：Exception定义了必须处理的异常，而RuntimeException定义的异常可以选择

性的进行处理。

RuntimeException是Exception的子类；

2、 try、catch、finally三种语句的功能是什么？

答： try语句负责捕获程序之中产生的异常；

catch负责匹配异常类型，并且对指定的异常进行处理；

finally作为异常处理的统一出口，不管是否发生异常，都会执行本程序。

3、 简述Java中的异常处理机制。

答： （1）、如果程序之中产生了异常，那么会自动的由JVM根据异常的类型，实例化一个指定异常类的对象；

（2）、如果这个时候程序之中没有任何的异常处理操作，则这个异常类的实例化对象将交给JVM进行处理，而JVM

的默认处理方式就是进行异常信息的输出，而后中断程序执行；

（3）、如果程序之中存在了异常处理，则会由try语句捕获产生的异常类对象；

（4）、与try之后的每一个catch进行匹配，如果匹配成功，则使用指定的catch进行处理，如果没有匹配成功，则向

后面的catch继续匹配，如果没有任何的catch匹配成功，则这个时候将交给JVM执行默认处理；

（5）、不管是否有异常都会执行finally程序，如果此时没有异常，执行完finally，则会继续执行程序之中的其他代码，

如果此时有异常没有能够处理（没有一个catch可以满足），那么也会执行finally，但是执行完finally之后，将默认交给JVM

进行异常的信息输出，并且程序中断；

4、 简述Error和Exception的区别。

答： Error：指的是JVM错误，这个时候的程序并没有执行，无法处理；

Exception：指的是程序之中出现的错误信息，可以进行异常处理，主要关心Exception。

5、 列举三个常见的RuntimeException子类。

答： NumberFormatException、ClassCastException、NullPointerException

5、编程题

1、 编写应用程序，从命令行输入两个小数参数，求它们的商。要求程序中捕获NumberFormatException异常和

ArithmeticException异常。

class MyMath {

}

public class TestDemo {

}

public static void main(String args[]) {

}

if ( != 2) {

}

try {

}

MyMath mm = new MyMath() ;

n((args[0], args[1])); // 被调用处处理异常

tackTrace();

n("程序运行出错！");

(1) ; // 程序退出

public int div(String x, String y) throws NumberFormatException,

}

ArithmeticException { // 出现异常要交给被调用处出

int result = 0;

try {

}

return result;

int numa = nt(x) ;

int numb = nt(y) ;

result = numa / numb;

throw e;

// 除法计算

// 向上抛

} catch (Exception e) {

} catch (Exception e) {

第8章、Java新特性 —— 自我检测（答案）

1、填空题

1、 在使用泛型类时，没有指定泛型的类型，则编译会出现 不安全的警告 信息，程序在使用时会使用 Object 类

型进行接收。

2、 通过 ? extends 类 指定泛型的上限，通过 ? super 类 指定泛型的下限。

3、 使用 ? 通配符可以接收全部的泛型类型实例，但却不可修改泛型属性内容。

4、 Java中通过 enum 关键字定义一个枚举，使用此关键字实际上就相当于一个类继承 。

5、 枚举中通过 values() 方法取得枚举的全部内容。

6、 Java提供的三个内建的Annotation是： @Override 、 @Deprecated 、 @SuppressWarnings 。

7、 从JDK 1.8之中，接口内可以定义有三类方法： 抽象方法 、 default定义的普通方法 、 static定义的静态方法。

8、 在Java中一共提供有四个函数式接口，分别为：Funcation、Consumer、Supplier、Predicate；

2、判断题

1、 在枚举类中可以定义抽象方法，而抽象方法只需要实现一次即可。

3、 枚举中定义的构造方法可以使用public权限声明。

4、 作为函数式接口里面可以定义任意多个抽象方法。

（

（

（

（

×

√

×

×

）

）

）

）

2、 枚举中可以定义构造方法，但要求每个枚举对象都必须调用此构造方法。

3、简答题

1、 简述泛型的作用

答： 泛型的主要作用是解决对象向下转型所带来的ClassCastException，使用泛型之后，类之中的属性或方法中的参数类

型就由调用处来决定，而如果调用处不设置泛型，为了保证程序不出错，则会使用Object类型进行定义。

2、 简述枚举的作用及实现特点。

答： 枚举定义出了一个类所能使用的若干几个实例化对象，枚举可以直接采用“枚举类型.对象”的方式取得类中的实例

化对象进行操作。

3、 简述JAVA SE中三个内建的Annotation的作用。

答： 在JAVA SE之中定义了三种Annotation：

· @Override：准确的方法覆写；

· @Deprecated：某个结构（类、方法、属性）不再建议被用户所使用；

· @SuppressWarnings：压制编译时所产生的警告信息。

4、编程题

1、 定义一个品牌电脑的枚举类，里面只有固定的几个电脑品牌，例如：Lenovo、HP、Dell、Apple、Acer。

enum ComputerBrand {

}

LENOVO("联想"), HP("惠普"), DELL("戴尔"), APPLE("苹果"), ACER("宏基");

private String title;

private ComputerBrand(String title) {

}

@Override

public String toString() {

}

return ;

= title;

第9章、多线程 —— 自我检测（答案）

1、填空题

1、 Java多线程可以依靠 继承Thread类 、 实现Runnable接口 、 实现Callable接口 三种方式实现。

2、 多个线程操作同一资源的时候需要注意 同步 ，依靠 synchronized 关键字实现，实现手段是： 同步代

码块 和 同步方法 ，过多的使用，则会出现 死锁 问题。

3、 Java程序运行时，至少启动 两个 个线程，分别是： main线程 和 gc线程 。

4、 main线程的优先级是 中等优先级 。

5、 线程在生命周期中要经历五种状态，分别是 创建 状态、 就绪 状态、 运行 状态、 堵塞 状态、

销毁 状态。

6、 Object类提供的 wait() 、 notify() 、 notifyAll() 三个方法可以控制线程。

2、选择题

1、 线程的启动方法是 B 。

A、 run() B、 start()

C、 begin()

D、 accept()

2、 Thread类提供表示线程优先级的静态常量，代表普通优先级的静态常量是 D 。

A、 MAX_PRIORITY B、 MIN_PRIORITY

D、 NORM_PRIORITY

C、 getName()

D、 全部都是

D、 static

D、 setName()

C、 NORMAL_PRIORITY

A、 setPriority()

A、 stop()

A、 serialize

3、 设置线程优先级的方法是 A 。

B、 getPriority()

4、 Thread类的 D 方法是不建议使用的？

B、 suspend()

C、 resume()

5、 下列 C 关键字通常用赖对对象加锁，从而似的对对象的访问是排他的。

B、 transient C、 synchronized

3、判断题

1、 Java中直接调用Thread类中的run()方法可以启动一个线程。

2、 进程是在线程的基础之上的进一步划分。

3、 Java是多线程的编程语言。

（

（

（

（

×

√

√

√

）

）

）

） 4、 不管使用Callable还是Runnable接口实现的多线程最终都需要通过Thread类启动。

4、简答题

1、 简述线程两种实现方式及区别？

答： 多线程的两种实现方式都需要一个线程的主类，而这个类可以实现Runnable接口或继承Thread类，不管使用何种方

式都必须在子类之中覆写run()方法，此方法为线程的主方法；

念。

2、 简述死锁的产生。

Thread类是Runnable接口的子类，而且使用Runnable接口可以避免单继承局限，以及更加方便的实现数据共享的概

答： 当多个线程访问某一共享资源时，为保证数据的正确性，需要使用同步进行控制，线程同步指的是某一线程要等待

其他线程对象操作完成之后才可以进行操作，但是在程序之中过多的线程等待就会出现死锁。

5、编程题

1、 设计四个线程对象，两个线程执行减操作，两个线程执行加操作。

class Message {

}

private int data = 10 ;

private boolean flag = true;

public synchronized void add() {

}

public synchronized void subtract() {

}

// setter、getter略

if ( == true) {

}

try {

}

n("减法操作：" + --);

= true;

();

// 已经取走了，可以继续生产

// 唤醒等待线程

(100);

tackTrace();

} catch (InterruptedException e) {

try {

}

(); // 等待

} catch (InterruptedException e) {

tackTrace();

// 减法操作

// 未生产，不能取走

if ( == false) {

}

try {

}

n("加法操作：" + ++);

= false;

();

// 已经生产完成，修改标志位

// 唤醒等待线程

(200);

tackTrace();

} catch (InterruptedException e) {

try {

}

(); // 等待

} catch (InterruptedException e) {

tackTrace();

// 加法操作

// 已经生产过了，不能生产

// 初始值

class Addition implements Runnable {

}

class Subtraction implements Runnable {

}

public class TestDemo {

}

private Message msg = null ;

public Subtraction (Message msg) {

}

@Override

public void run() {

}

for (int x = 0; x < 50; x++) {

}

ct() ;

= msg ;

private Message msg = null ;

public Addition(Message msg) {

}

@Override

public void run() {

}

for (int x = 0; x < 50; x++) {

}

() ;

= msg ;

// 定义生产者

// 加法执行50次

// 加法操作

// 定义消费者

// 减法执行50次

// 执行减法

public static void main(String args[]) {

}

Message msg = new Message();

new Thread(new Addition(msg), "加法对象A").start();

new Thread(new Addition(msg), "家访对象B").start();

// 启动线程

// 启动者线程

new Thread(new Subtraction(msg), "减法对象A").start(); // 取得线程

new Thread(new Subtraction(msg), "减法对象B").start(); // 取得线程

第10章、常用类库 —— 自我检测（答案）

1、填空题

1、 在包中提供了两个字符串类，分别是 String 和 StringBuffer。这两个类都是 CharSequence 接

口的子类，字符串类提供的求字符串长度的方法是 public int length() 。

2、 Java中提供的两个大数操作类是： BigInteger 和 BigDecimal 。

3、 对象克隆方法是 Object 类提供的，方法名称是 public Object clone () thorws CloneNotSupportException ，对

象所在的类必须实现 ble 接口。

4、 String类的 matches() 、 split() 、 replaceAll() 、 replaceFirst() 四个方法可以使用正则。

5、 通过Object类中的 public Class getClass() 方法可以取得一个类的Class对象。

6、 Constructor类定义在 t 包中。

7、 Class类对象的三种实例化方式： getClass()方法 、 类.class 、 forName(className) 方法 。

2、选择题

1、 使用Runtime类的 D 方法，可以释放垃圾内存。

A、 exec() B、 run() C、 invoke()

C、 clone()

C、 clone()

D、 gc()

D、 finalize()

D、 finalize()

2、 Object类中的 B 方法不能被覆写？

A、 toString()

A、 toString()

B、 getClass()

B、 getClass()

3、 如果要为对象回收做收尾操作，则应该覆写Object类中的 D 方法。

3、判断题

1、 任何类的对象数组都可以使用()方法进行排序操作。

2、 Random类存放在包中。

3、 Runtime类的对象可以直接通过构造方法实例化。

（

（

（

（

（

×

√

×

×

√

）

）

）

）

）

4、 Class类的对象可以通过关键字new进行实例化操作。

5、 可以通过Class实例化一个类的对象，但是要求此类必须存在无参构造。

4、简答题

1、 String类和StringBuffer类的区别是什么？StringBuffer类提供了那些独特的方法？

答： String类的内容一旦声明则不可修改，而StringBuffer类的内容定义之后可以修改。StringBuffer类使用append()方法

可以完成字符串的连接操作，而String类使用“+”完成；

特殊方法：insert()、reverse()、replace()。

2、 简述final、finally、finalize的区别及作用？

答： final表示终结器，用于定义不能被继承的父类，不能被覆写的方法，常量；

finally是异常处理的出口；

finalize()是Object类定义的一个方法，用于执行对象回收前的收尾操作。

3、 解释Comparable和Comparator的区别。

答： able是在一个类定义的时候默认实现好的接口，里面只有一个compareTo()方法；

ator是需要单独定义一个比较的规则类，里面有两个方法；compare()、equals()。

5、编程题

1、 定义一个StringBuffer类对象，然后通过append()方法向对象里添加26个小写字母，要求每次只添加一次，共添加

26次。

public class TestDemo {

public static void main(String args[]) {

StringBuffer buf = new StringBuffer() ;

for (char c = 'a' ; c <='z' ; c++){