java程序设计项目案例化教程题库及答案

最新推荐文章于 2024-04-27 17:30:34 发布

高校知识店铺合集汇总

最新推荐文章于 2024-04-27 17:30:34 发布

阅读量5.5k

点赞数 11

文章标签： java jvm servlet

本文链接：https://blog.csdn.net/m0_63394128/article/details/126167847

版权

章节自测

1、第01章：走进Java的世界

1.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、在MacOS系统中，所有的JDK的路径可以在 ~/.bash_profile 文件中进行配置；

8、 MacOS为便于多JDK的管理，提供了 jenv 管理工具，该工具可以 brew 通过命令安装；

1.2、选择题

1、现在的Java语言是由 B 公司维护的。

A、 IBM B、 Oracle C、 Apple D、 Microsoft

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

A、 path B、 classpath C、 JAVA_HOME D、TEMP

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

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

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

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

B、 JDK的编译命令是java。

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

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

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

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

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

C、 Java语言无法对内存垃圾自动收集，需要开发者手工处理。

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

1.3、判断题

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

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

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

5、主方法定义：public void main(String arg)。（ × ）

6、 System.out.println()输出后是不加换行的，而System.out.print()输出后是加换行的。（ × ）

1.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文件。

1.5、编程题

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

答案：

public class TestDemo {

public static void main(String[] args) {

System.out.println("我喜欢学习 Java");

}

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

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

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

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

答案：

public class TestDemo {

public static void main(String[] args) {

System.out.println("*************************************");

System.out.println("********* Java 程序设计 *********");

System.out.println("*************************************");

}

2、第02章：程序基础概念

2.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、布尔型数据类型的关键字是 boolean ，有 true 和 false 两种取值。

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

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

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

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

2.2、选择题

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

A、 class B、 hello world C、 123$temp D、 Demo

2、下面那些关键字是Java中未使用到的关键字 A 。

A、 const B、 native C、 int D、 assert

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

A、 integer B、 double C、 float D、 char

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

A、 byte和0 B、 byte和1 C、 boolean和true D、 boolean和false

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

A、 3.15 × 2 B、 3.15 × 10-2 C、 3.15 × 102 D、 0.315 × 10-2

6、程序System.out.println("1 + 1 = " + 1 + 1) ;的输出结果是 C 。

A、 1 B、 1 + 1 = 2 C、 1 + 1 = 11 D、 2

7、程序System.out.println(10 / 3) ;的输出结果是 B 。

A、 1 B、 3 C、 3.3 D、 3.33333

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

int a = 2 ;

int b = (a++) * 3 ;

int c = (++a) * 3 ;

A、 2、6、6 B、 4、9、9 C、 4、6、12 D、 3、9、9

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

A、 35.d B、 -20 C、 1,234 D、 "123"

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

A、 33.8 B、 129 C、 89L D、 8.6F

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

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

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

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

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

2.3、判断题

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

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

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

4、字符$不能作Java标识符的第一个字符。（ √ ）

5、使用break语句可以跳出一次循环。（ × ）

6、 byte的取值范围是：0~255。（ × ）

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

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

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

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

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

2.4、简答题

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

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

变量是利用声明的方式，将内存中的某个内存块保留下来以供程序使用。可以声明的数据类型为整型、字符型、浮点型或是其他数据类型，作为变量的保存之用。变量在程序语言中扮演了最基本的角色。变量可以用来存放数据，而使用变量之前必须先声明它的数据类型。

2、请解释“&”和“&&”的区别？

&在进行逻辑运算时表示所有判断条件都需要判断，而“&&”为短路与，在前面的判断返回false时后面判断将不再执行，最终的结果就是false。

&还可以应用在位操作上。

3、请解释“|”和“||”的区别？

|在进行逻辑运算时表示所有判断条件都需要判断，而“|”为短路或，在前面的判断返回true时后面判断将不再执行，最终的结果就是true。

|还可以应用在位操作上。

3、第03章：程序逻辑结构

3.1、填空题

1、在程序开发中一般会提供有三种逻辑结构，分别是：顺序结构、分支结构、循环结构。

2、当使用if语句进行分支判断不满足时，可以通过 else 关键字定义的语句进行处理。

3、在Java编程中三种循环结构分别为： while循环、 do…while循环、 for循环。

4、如果现在要跳出当前的一次循环处理可以使用 continue 关键字。

5、循环结构中如果要结束全部的循环结构执行可以使用 break 关键字。

6、当定义一个方法不需要返回任何数据时，方法的返回值类型应该使用 void 关键字定义。

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

3.2、选择题

1、在执行if分支结构处理时，可以作为判断条件的表达式返回的数据类型为 A ；

A、 boolean B、 char C、 int D、 long

2、下列 B 关键字可以实现switch的内容判断

A、 break B、 case C、 void D、 yield

3、下列 D 关键字可以结束switch的内容匹配处理；

A、 continue B、 goto C、 void D、 break

4、如果要想实现1到100的累加操作，下面代码处的判断条件为： A 。

int sum = 0;
int num = 100;
while (          ) {
    sum += num;
    num--;
}

A、 num > 0 B、 num < 100 C、 num -- > 0 D、 ++num < 0

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

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

6、下列关于方法重载的描述错误的一项为 D 。

A、方法重载时，要求方法名称必须保持一致；

B、方法重载时没有对方法的返回值有所限制，即同一方法的重载可以返回不同的数据类型；

C、方法重载时每个方法的参数类型及个数不能相同；

D、调用重载方法时只能传入一种类型的参数。

3.3、判断题

1、在使用循环结构时，如果没有进行合理的循环条件控制则容易出现死循环。（ √ ）

2、在循环结构中使用continue或break语句时需要结合分支结构一同处理。（ √ ）

3、 do…while循环是先进行循环条件判断，而后再进行循环处理。（ × ）

4、使用switch语句进行开关处理时，若没有break会在第一个匹配的case后持续向下执行（ √ ）

5、在进行方法重载时返回值类型必须相同，否则无法通过程序编译。（ × ）

3.4、简答题

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

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

代码说明：

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

return x + y;

}

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

return x + y + z;

}

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

return x + y;

}

3.5、编程题

1、打印出100~1000范围内的所有 “水仙花数”，所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个“水仙花数”，因为153=1的三次方＋5的三次方＋3的三次方。

public class TestDemo {

public static void main(String[] args) {

int i, j, k;

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

i = x / 100; // 计算百位数字

j = (x / 10) % 10; // 计算十位数字

k = x % 10; // 计算个位数字

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

System.out.print(x + "、");

}

程序运行结果：

153、370、371、407、

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

实现一：引用第三方变量

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

public class TestDemo {

public static void main(String[] args) {

int x = 10;

int y = 20;

int temp = x;

x = y;

y = temp;

System.out.println("x = " + x);

System.out.println("y = " + y);

}

public class TestDemo {

public static void main(String[] args) {

int x = 10;

int y = 20;

x += y ;

y = x - y;

x = x - y ;

System.out.println("x = " + x);

System.out.println("y = " + y);

}

程序运行结果：

x = 20

y = 10

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

public class TestDemo {

public static void main(String[] args) {

int data = 105;

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

System.out.println(data + "可以同时被3、5、7整除。");

} else {

System.out.println(data + "不可以同时被3、5、7整除。");

}

程序运行结果：

105可以同时被3、5、7整除。

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

实现一：使用while循环

public class TestDemo {

public static void main(String[] args) {

int sum = 0;

int x = 100;

while (x <= 200) {

sum += x;

x++;

}

System.out.println("累加结果：" + sum);

}

实现二：使用do…while循环

public class TestDemo {

public static void main(String[] args) {

int sum = 0;

int x = 100;

do {

sum += x;

x++;

} while (x <= 200);

System.out.println("累加结果：" + sum);

}

实现三：使用for循环

public class TestDemo {

public static void main(String[] args) {

int sum = 0;

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

sum += x;

}

System.out.println("累加结果：" + sum);

}

4、第04章：类与对象

4.1、填空题

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

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

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

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

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

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

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

4.2、选择题

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

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

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

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

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

A、 void Demo(int x){…} B、 Demo(int x){…}

C、 Demo Demo(int x){…} D、 int Demo(){}

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

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

B、类定义后会为类中的成员属性直接开辟堆内存空间；

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

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

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

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

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

public class TestDemo {

public void fun() {

static int i = 0;

i++;

System.out.println(i);

}

public static void main(String args[]) {

Demo d = new Demo();

d.fun();

}

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

4.3、判断题

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

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

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

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

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

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

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

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

4.4、简答题

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

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

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

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

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

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

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

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

4.5、编程题

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

class Address {

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,

String street, String zipcode) {

super();

this.national = national;

this.provincial = provincial;

this.city = city;

this.street = street;

this.zipcode = zipcode;

}

public String toString() {

return "国家：" + this.national + "，省份：" + this.provincial + "，城市："

+ this.city + "，街道：" + this.street + "，邮政编码：" + this.zipcode;

}

// setter、getter略

}

public class TestDemo {

public static void main(String args[]) {

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

System.out.println(ad);

}

程序运行结果：

国家：中国，省份：北京，城市：北京市，街道：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();

this.empno = empno;

this.ename = ename;

this.sal = sal;

this.rate = rate;

}

public String toString() {

return "雇员编号：" + this.empno + "，雇员姓名：" + this.ename + "，基本工资：" + this.sal ;

}

public void growthin() { // 增长薪水

this.sal = this.sal * this.rate ;

}

// setter、getter略

}

public class TestDemo {

public static void main(String args[]) {

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

emp.growthin() ; // 工资增长

System.out.println(emp);

}

程序运行结果：

雇员编号：7369，雇员姓名：SMITH，基本工资：1500.0

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

class Dog {

private String name ;

private String color ;

private int age ;

public Dog() {

}

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

super();

this.name = name;

this.color = color;

this.age = age;

}

public String toString() {

return "狗的名字：" + this.name + "，狗的颜色：" + this.color + "，狗的年龄：" + this.age ;

}

// setter、getter略

}

public class TestDemo {

public static void main(String args[]) {

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

System.out.println(dog);

}

程序运行结果：

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

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

· 数据成员：

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

· 方法包括：

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

· 查询余额

class Account {

private String name ;

private double balance ;

public Account() {

}

public Account(String name, double balance) {

super();

this.name = name;

this.balance = balance;

}

public String toString() {

return "账户名称：" + this.name + "，余额：" + this.balance;

}

public double getBalance() {

return balance;

}

// setter、getter略

}

public class TestDemo {

public static void main(String args[]) {

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

System.out.println(acc);

System.out.println("账户余额：" + acc.getBalance());

}

程序运行结果：

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

账户余额：5000.0

5、第05章：数组

5.1、填空题

1、 Java中的数组属于引用类型，其实例化操作需要通过 new 关键字完成；

2、数组通过索引访问时下标从 0 开始，数组可以使用 length 属性获得数组长度；

3、对象数组采用动态初始化时，数组中的每个元素内容为对应数据类型默认值。

4、为了便于数组排序，JDK提供了 java.util.Arrays.sort() 方法；

5、为了便于多个参数的接收，Java提供了可变参数，可变参数接收时，其对应的类型为数组。

6、采用动态初始化方式开辟的对象数组，数组中的每一个内容均为 null 。

7、在输出全部数组数据时，可以依靠循环结构并结合索引的方式完成全部内容的获取。

5.2、选择题

1、关于“int data [] = new int[10]”的语句以下那种描述是错误的？（ B ）

（A）、data是一个引用数据类型，使用关键字new开辟堆内存空间；

（B）、开辟了10个元素的数组，其访问索引为：1 ~ 10；

（C）、可以通过“data[索引]”的形式来获取指定索引的数组；

（D）、数组长度为10，不可以扩充。

2、如果现在有一个double型数组那么正确的实例化格式是那一个？（ A ）

（A）、double scores[] = new double[] {9.9,9.5,9.3}

（B）、double scores = new double[] {9.9,9.5,9.3}；

（C）、double scores[] = new double {9.9,9.5,9.3}；

（D）、double scores = {9.9,9.5,9.3}；

3、如果有数组“data[3][4]”，则对数组正确的引用格式是那一个？（ C ）

（A）、data[4][3] （B）、data{2}{1} （C）、data[1][2] （D）、data(1)(1)

5.3、编程题

1、现在任意定义一个整型数组，将奇数数据和偶数数据分别保存在不同的数组之中，随后按照升序排序输出；

public class TestDemo {

public static void main(String[] args) {

int data[] = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

int result [] = count(data) ;

int even [] = new int [result[0]] ; // 保存偶数数据

int odd [] = new int [result[1]] ; // 保存奇数数据

int evenIndex = 0 ; // 偶数索引

int oddIndex = 0 ; // 奇数索引

for (int x = 0 ; x < data.length ; x ++) {

if (data[x] % 2 == 0) { // 偶数

even[evenIndex ++] = data[x] ;

} else {

odd[oddIndex ++] = data[x] ;

}

java.util.Arrays.sort(even);

java.util.Arrays.sort(odd);

printArray(even) ;

printArray(odd) ;

}

public static void printArray(int data[]) {

for (int x = 0 ; x < data.length ; x ++) {

System.out.print(data[x] + "、");

}

System.out.println();

}

public static int[] count(int data[]) { // 统计个数

// result[0]保存偶数个数

// result[1]保存奇数个数

int result[] = new int[2];

for (int x = 0 ; x < data.length ; x ++) {

if (data[x] % 2 == 0) { // 偶数

result[0] ++ ;

} else {

result[1] ++ ;

}

return result;

}

2、现在有五个评委给出了比赛成绩（10分制）：第一位评委（8.0分）、第二位评委（9.9分）、第三位评委（9.0分）、第四位评委（8.9分）、第五位评委（9.2分），要求去掉最高分与最低分，而后计算平均分；

public class TestDemo {

public static void main(String[] args) {

double data[] = new double[] { 8.0, 9.9, 9.0, 8.9, 9.2 };

java.util.Arrays.sort(data); // 数组排序

double sum = 0 ;

for (int x = 1 ; x < data.length - 1 ; x ++) {

sum += data[x] ;

}

System.out.println("平均分：" + (sum / (data.length - 2)));

}

6、第06章：String类

6.1、填空题

1、字符串常量属于String类的匿名对象，采用直接赋值实例化形式可以自动将实例化对象保存到对象池之中，供下个相同对象使用；

2、如果要进行字符串内容比较则应该使用 public boolean equals(String str) ；

3、当通过关键字new调用String类有参构造实例化时，可以使用 public String intern() 方法让字符串保存到对象池之中；

4、字符串变为字符数组的方法是： public char[] toCharArray() ；

5、字符串拆分的方法是： public String [] split(String regex) ；

6、可以实现字符串大小比较的方法是： public int compareTo(String str) ；

6.2、选择题

1、下面那个操作可以在Java中实现字符串的拆分处理？（ B ）

（A）、slice() （B）、split() （C）、replace() （D）、charAt()

2、下面那个方法不能够实现字符串的查找？（ B ）

（A）、contains() （B）、substring （C）、indexOf() （D）、startsWith()

3、下面那个方法不能够实现字符串比较操作？（ D ）

（A）、equals() （B）、compareTo() （D）、equalsIgnoreCase() （D）、trim()

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

String str = "Hello" ;

String b = str.substring(0,2) ;

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

6.3、判断题

1、字符串使用关键字new通过构造方法实例化对象时，所产生字符串不会自动保存在对象池之中。（√）

2、字符串对象如果直接赋值实例化，则所有采用同方式并且内容相同时会自动实现同一对象引用。（×）

3、使用substring()进行字符串截取的时候，索引下标可以设置为负数，表示由后向前截取。（×）

4、字符串在进行IP地址拆分时可以直接通过“.”拆分，即：“replaceAll(".")”。（×）

5、 String类的trim()方法可以删除掉字符串中间的空格。（×）

6.4、简答题

1、请解释String类两种实例化方式的区别？

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

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

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

2、请解释在字符串比较中“==”和“equals()”的区别？

答： String对象的比较方法：

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

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

6.5、编程题

1、从字符串“李兴华高薪就业编程训练营20220628”中提取开班日期。

public class TestDemo {

public static void main(String[] args) {

String str = "李兴华高薪就业编程训练营20220628" ;

System.out.println(str.substring(str.indexOf("20220628")));

}

2、将“Yootk Java”字符串中的“Java”替换为“JavaEE”；

public class TestDemo {

public static void main(String[] args) {

String str = "Yootk Java" ;

System.out.println(str.replaceAll("Java", "JavaEE"));

}

3、取出“Java公益直播课20230628”中的第八个字符；

public class TestDemo {

public static void main(String[] args) {

String str = "Java公益直播课20230628" ;

System.out.println(str.charAt(8));

}

4、清除“Java技术学习班20240628”中所有的“0”；

public class TestDemo {

public static void main(String[] args) {

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

System.out.println(str.replaceAll("0", ""));

}

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

public class TestDemo {

public static void main(String args[]) {

String str = "1101051976091900520" ;

System.out.println(str.substring(6,14));

}

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

public class TestDemo {

public static void main(String args[]) {

String str = "want you to know one thing" ; // 定义字符串

int sum = 0 ;

while (str.indexOf("n") != -1) { // 是否还有字母n

sum ++ ; // 数据统计量增加

str = str.substring(str.indexOf("n") + 1); // 改变字符串内容

}

System.out.println("字母n的出现次数：" + sum);

}

7、第07章：继承与多态

7.1、填空题

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

2、 Object 类是所有类的父类，该类中判断两个对象是否相等的方法是 public boolean equals(Object oth) ，取得对象完整信息的方法是 public String toString() 。

3、当子类中定义的方法与父类方法同名且参数类型及个数、返回值类型相同时，称子类方法覆写父类方法，子类默认使用本类已经覆写方法，使用父类的同名方法，必须使用 super 关键字说明。

4、当子类定义的成员变量与父类的成员变量同名时，称子类覆盖父类的成员变量，子类默认使用本类属性。使用父类的同名成员变量，必须用 super 关键字说明。

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

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

7.2、选择题

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

A、方法重载 B、方法覆写 C、方法继承 D、方法重用

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

A、 class A extends B B、 class B implements A

C、 class A implements D、 class B extends A

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

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

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

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

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

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

A、 X x = new X() ; B、 X x = new Y() ;

C、 Y x = new Y() ; D、 Y x = new X() ;

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

public class A {

public static void main(String args[]) {

B b = new B();

b.test();

}

void test() {

System.out.print("A");

}

class B extends A {

void test() {

super.test();

System.out.println("B");

}

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

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

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

public class A {

public static void main(String args[]) {

B b = new B();

b.test();

}

public void test() {

System.out.print("A");

}

class B extends A {

void test() {

super.test();

System.out.println("B");

}

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

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

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

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

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

A、 class A extends B B、 class B implements A

C、 class A implements D、 class B extends A

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

A、 final B、 abstract D、 static D、 interface

7.3、判断题

1、一个类不能即是子类又是父类。（ √ ）

2、子类只能继承父类的成员，但不能修改父类成员。（ × ）

3、 Java语言只支持单继承，不支持多继承。（ √ ）

4、子类可以继承父类的所有成员。（ √ ）

7.4、简答题

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

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

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

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

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

答：方法重载是发生在一个类之中，方法名称相同、参数的类型及个数不同，不受权限的限制。而覆写是发生在继承关系之中，子类定义了和父类定义了方法名称相同、参数类型及个数、返回值类型完全相同的方法时所发生的操作，在子类覆写父类方法时，被覆写的方法不能拥有比父类更严格的访问权限。

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

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

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

答：子类使用extends继承父类，子类可以继承父类中的全部内容，但是对于私有操作属于隐式继承，而非私有操作属于显式继承。

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

答：多态性主要分为两个方面：

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

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

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

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

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

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

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

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

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

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

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

7.5、编程题

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

A、 Person中包含4个保护型的数据成员name、address、sex、age分别为字符串，字符串，字符及整型。表示：姓名、地址、性别和年龄。一个四参构造方法，一个无参构造方法，及一个输出方法用于显示四种属性。

B、 Student继承Person，并增加输出成员math、english存放数学和英语成绩。一个六参构造方法，一个两参构造方法，一个无参构造方法，重写输出方法用于显示全部六种种属性.

class Person {

private String name ;

private String address ;

private char sex ;

private int age ;

public Person() {

}

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

super();

this.name = name;

this.address = address;

this.sex = sex;

this.age = age;

}

public String toString() {

return "姓名：" + this.name + "，地址：" + this.address + "，性别：" + this.sex

+ "，年龄：" + this.age;

}

// setter、getter略

}

class Student extends Person {

private double math ;

private double english ;

public Student() {

}

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

double english) {

super(name, address, sex, age);

this.math = math;

this.english = english;

}

public String toString() {

return super.toString() + "，数学成绩：" + this.math + "，英语成绩：" + this.english;

}

// setter、getter略

}

public class TestDemo {

public static void main(String args[]) {

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

System.out.println(stu);

}

程序运行结果：

姓名：张三，地址：北京西城区甲11号德外大街德胜科技园美江大厦 A座 - 6层，性别：男，年龄：25，数学成绩：90.0，英语成绩：99.0

2、定义员工类，具有姓名，年龄，性别属性，并具有构造方法，显示数据方法，定义管理层类，继承员工类，并有自己的属性：职务，年薪。定义职员类，继承员工类，并有自己的属性：所属部门，月薪。

class Employee {

private String name ;

private int age ;

private char sex ;

public Employee() {

}

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

super();

this.name = name;

this.age = age;

this.sex = sex;

}

public String toString() {

return "雇员姓名：" + this.name + "，年龄：" + this.age + "，性别：" + this.sex;

}

// setter、getter略

}

class Manager extends Employee {

private String job ;

private double income ;

public Manager() {

}

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

super(name, age, sex);

this.job = job;

this.income = income;

}

public String toString() {

return super.toString() + "，职位：" + this.job + "，年薪：" + this.income ;

}

// setter、getter略

}

class Staff extends Employee {

private String dept ;

private double salary ;

public Staff() {

}

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

super(name, age, sex);

this.dept = dept;

this.salary = salary;

}

public String toString() {

return super.toString() + "，部门：" + this.dept + "，月薪：" + this.salary ;

}

// setter、getter略

}

public class TestDemo {

public static void main(String args[]) {

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

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

System.out.println(ea);

System.out.println(eb);

}

程序运行结果：

雇员姓名：张三，年龄：30，性别：男，职位：总监，年薪：200000.0

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

8、第08章：抽象类与接口

8.1、填空题

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

2、抽象类必须使用______abstract class________关键字定义，抽象类中的抽象方法必须___abstract________关键字定义。

3、接口使用____interface_____关键字定义，子类通过_____implements_______关键字实现接口。

4、接口中的所有访问权限都是___public___。

5、 Integer类是对 int 基本数据类型的封装。Float类是对 float 基本数据类型的封装。Double类是对 double 基本数据类型的封装。字符类Character是对 char 基本数据类型的封装。

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

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

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

8.2、选择题

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

A、 extends B、 class C、 interface D、 public

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

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

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

public class A implements B {

public static void main(String args[]) {

int m, n;

A a = new A();

m = a.K;

n = B.K;

System.out.println(m + "，" + n);

}

interface B {

int K = 5;

}

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

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

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

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

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

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

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

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

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

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

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

8.3、判断题

1、抽象类可以实现接口，接口也可以继承抽象类。（×）

2、接口中可以定义普通方法也可以定义抽象方法。（√）

3、接口不会继承任何父类，所以不可以使用Object接收接口对象。（×）

4、抽象类之中必须定义有抽象方法。（×）

5、抽象类中的抽象方法可以不使用abstract定义。（×）

6、泛型的主要目的是避免ClassCastException。（√）

8.4、简答题

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

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

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

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

No.	区别	抽象类	接口
1	定义关键字	abstract class	interface
2	组成	常量、变量、抽象方法、普通方法、构造方法	全局常量、抽象方法
3	权限	可以使用各种权限	只能是public
4	关系	一个抽象类可以实现多个接口	接口不能够继承抽象类，却可以继承多接口
5	使用	子类使用extends继承抽象类	子类使用implements实现接口
5	使用	抽象类和接口的对象都是利用对象多态性的向上转型，进行接口或抽象类的实例化操作
6	设计模式	模板设计模式	工厂设计模式、代理设计模式
7	局限	一个子类只能够继承一个抽象类	一个子类可以实现多个接口

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

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

4、简述泛型的作用

答：泛型的主要作用是解决对象向下转型所带来的ClassCastException，使用泛型之后，类之中的属性或方法中的参数类型就由调用处来决定，而如果调用处不设置泛型，为了保证程序不出错，则会使用Object类型进行定义。

8.5、编程题

1、定义一个ClassName接口，接口中只有一个抽象方法getClassName()。设计一个类Company，该类实现接口ClassName中的方法getClassName()，功能是获取该类的类名称。编写应用程序使用Company类。

interface ClassName {

public String getClassName() ;

}

class Company implements ClassName {

public String getClassName() {

return "Company";

}

public class TestDemo {

public static void main(String args[]) {

ClassName name = new Company() ;

System.out.println(name.getClassName());

}

程序运行结果：

Company

2、定义类Shape表示一般二维图形。Shape具有抽象方法area和perimeter，分别计算形状的面积和周长。试定义一些二维形状类（如矩形、三角形、圆形等），这些类均为Shape类的子类。

abstract class Shape {

public abstract double area();

public abstract double perimeter();

}

class Rectangle extends Shape { // 矩形

private double wide ; // 宽

private double longs ; // 长

public Rectangle() {

}

public Rectangle(double wide, double longs) {

super();

this.wide = wide;

this.longs = longs;

}

public double area() {

return this.longs * this.wide ;

}

public double perimeter() {

return (this.longs + this.wide) * 2;

}

class Triangle extends Shape { // 三角形

private double edgea ; // 边长

private double edgeb ; // 边长

private double edgec ; // 边长

public Triangle() {

}

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

super();

this.edgea = edgea;

this.edgeb = edgeb;

this.edgec = edgec;

}

public double area() {

return this.edgea * this.edgeb / 2 ;

}

public double perimeter() {

return this.edgea + this.edgeb + this.edgec ;

}

class Round extends Shape { // 圆形

private double radius ; // 半径

public Round() {

}

public Round(double radius) {

super();

this.radius = radius;

}

public double area() {

return this.radius * this.radius * Math.PI;

}

public double perimeter() {

return this.radius * 2 * Math.PI;

}

public class TestDemo {

public static void main(String args[]) {

Shape rectangle = new Rectangle(10.5, 20.6);

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

Shape round = new Round(30.3) ;

System.out.println("矩形面积：" + rectangle.area() + "，矩形周长：" + rectangle.perimeter());

System.out.println("三角形面积：" + triangle.area() + "，三角形周长：" + triangle.perimeter());

System.out.println("圆形面积：" + round.area() + "，圆形周长：" + round.perimeter());

}

程序运行结果：

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

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

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

9、第09章：类结构扩展

9.1、填空题

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

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

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

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

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

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

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

9.2、选择题

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

A、 java.lang B、 java.util C、 java.net D、 java.sql

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

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

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

A、 java.lang.Integer是接口

B、 String定义在java.util包中

C、 Double类在java.lang包中

D、 Double类在java.lang.object包中

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

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

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

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

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

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

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

9.3、判断题

1、 java.lang包必须由用户手工导入，否则无法使用。（ × ）

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

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

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

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

9.4、简答题

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

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

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

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

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

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

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

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

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

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

9.5、编程题

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

enum ComputerBrand {

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

private String title;

private ComputerBrand(String title) {

this.title = title;

}

@Override

public String toString() {

return this.title ;

}

10、第10章：异常的捕获与处理

10.1、填空题

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

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

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

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

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

10.2、选择题

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

A、 throws B、 throw C、 assert D、 class

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

A、 throws B、 assert C、 class D、 interface

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

A、 try块 B、 catch块 C、 throws块 D、 finally块

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

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

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

5、 finally块中的代码将 A 。

A、总是被执行

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

C、异常发生时才被执行

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

6、一个异常将终止 A 。

A、整个程序 B、只终止抛出异常的方法

C、产生异常的try块 D、上面的说法都不对

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

A、 Error B、 Exception C、 Throwable D、 RuntimeException

10.3、判断题

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

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

10.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

11、第11章：内部类

11.1、填空题

1、一个内部类如果需要被其它包所访问，则在定义时要使用 public 访问控制权限；

2、一个内部类需要独立于外部类存在，则在定义时要使用 static 关键字定义；

3、 Lambda表达式解决了匿名内部类的定义问题，在使用时需要结合接口结构一起定义；

4、 Java中为了便于函数式接口的定义提供了 @FunctionalInterface 注解；

5、 Java提供了四个核心的内置函数式接口： Function 、 Consumer 、 Supplier、 Predicate 。

11.2、判断题

1、内部类的主要特点是可以与外部类之间进行私有属性的互访问。（ √ ）

2、使用static定义的内部类就是外部类，该内部类可以直接访问外部类中的非static成员属性。（ × ）

3、匿名内部类主要功能是可以直接进行接口和抽象类的对象实例化处理。（ √ ）

4、 Lambda表达式是一种简化接口子类的处理，接口中的方法数量可以随意定义。（ × ）

5、函数式接口必须使用“@FunctionalInterface”定义，否则不生效。（ × ）

6、使用static定义的内部类就成为外部类。（ √ ）

12、第12章：多线程

12.1、填空题

1、 Java多线程可以依靠 Runnable 和 Callable 两个接口实现，但是不管使用何种方式一定要通过 Thread 类 start() 方法启动多线程。

2、多个线程操作同一资源的时候需要注意同步，依靠 synchronized 关键字实现，实现手段是：同步代码块和同步方法，过多的使用，则会出现死锁问题。

3、 Java程序运行时，在每一个JVM进程之中一定会存在有 main 线程。

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

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

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

12.2、选择题

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

A、 run() B、 start() C、 begin() D、 accept()

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

A、 MAX_PRIORITY B、 MIN_PRIORITY

C、 NORMAL_PRIORITY D、 NORM_PRIORITY

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

A、 setPriority() B、 getPriority() C、 getName() D、 setName()

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

A、 stop() B、 suspend() C、 resume() D、全部都是

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

A、 serialize B、 transient C、 synchronized D、 static

12.3、判断题

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

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

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

12.4、简答题

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

答：多线程的两种实现方式都需要一个线程的主类，而这个类可以实现Runnable接口或继承Thread类，不管使用何种方式都必须在子类之中覆写run()方法，此方法为线程的主方法；

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

2、简述死锁的产生。

答：当多个线程访问某一共享资源时，为保证数据的正确性，需要使用同步进行控制，线程同步指的是某一线程要等待其他线程对象操作完成之后才可以进行操作，但是在程序之中过多的线程等待就会出现死锁。

12.5、编程题

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

package com.yootk.demo;

public class ThreadDemo {

public static void main(String[] args) throws Exception {

Resource res = new Resource() ;

SubThread st = new SubThread(res) ;

AddThread at = new AddThread(res) ;

new Thread(at,"加法线程 - A").start() ;

new Thread(at,"加法线程 - B").start() ;

new Thread(st,"减法线程 - X").start() ;

new Thread(st,"减法线程 - Y").start() ;

}

class Resource { // 定义一个操作的资源

private int num = 0 ; // 这个要进行加减操作的数据

private boolean flag = true ; // 加减的切换

// flag = true：表示可以进行加法操作，但是无法进行减法操作；

// flag = false：表示可以进行减法操作，但是无法进行加法操作。

public synchronized void add() throws Exception { // 执行加法操作

if (this.flag == false) { // 现在需要执行的是减法操作，加法操作要等待

super.wait();

}

Thread.sleep(100);

this.num++;

System.out.println("【加法操作 - " + Thread.currentThread().getName() + "】num = " + this.num);

this.flag = false ; // 加法操作执行完毕，需要执行减法处理

super.notifyAll(); // 唤醒全部等待线程

}

public synchronized void sub() throws Exception { // 执行减法操作

if (this.flag == true) { // 减法操作需要等待

super.wait();

}

Thread.sleep(200);

this.num--;

System.out.println("【减法操作 - " + Thread.currentThread().getName() + "】num = " + this.num);

this.flag = true ;

super.notifyAll();

}

class AddThread implements Runnable {

private Resource resource ;

public AddThread(Resource resource) {

this.resource = resource ;

}

@Override

public void run() {

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

try {

this.resource.add() ;

} catch (Exception e) {

e.printStackTrace();

}

class SubThread implements Runnable {

private Resource resource ;

public SubThread(Resource resource) {

this.resource = resource ;

}

@Override

public void run() {

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

try {

this.resource.sub() ;

} catch (Exception e) {

e.printStackTrace();

}

}}

2、设计一个生产电脑和搬运电脑类，要求生产出一台电脑就搬走一台电脑，如果没有新的电脑生产出来，则搬运工要等待新电脑产出；如果生产出的电脑没有搬走，则要等待电脑搬走之后再生产，并统计出生产的电脑数量。

package com.yootk.demo;

public class ThreadDemo {

public static void main(String[] args) throws Exception {

Resource res = new Resource() ;

new Thread(new Producer(res)).start(); ;

new Thread(new Consumer(res)).start(); ;

}

class Producer implements Runnable {

private Resource resource ;

public Producer(Resource resource) {

this.resource = resource ;

}

public void run() {

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

try {

this.resource.make();

} catch (Exception e) {

e.printStackTrace();

}

};

}

class Consumer implements Runnable {

private Resource resource ;

public Consumer(Resource resource) {

this.resource = resource ;

}

public void run() {

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

try {

this.resource.get();

} catch (Exception e) {

e.printStackTrace();

}

};

}

class Resource {

private Computer computer ;

public synchronized void make() throws Exception {

if (this.computer != null) { // 已经生产过了

super.wait();

}

Thread.sleep(100);

this.computer = new Computer("MLDN牌电脑",1.1) ;

System.out.println("【生产电脑】" + this.computer);

super.notifyAll();

}

public synchronized void get() throws Exception {

if (this.computer == null) { // 没有生产过

super.wait();

}

Thread.sleep(10);

System.out.println("【取走电脑】" + this.computer);

this.computer = null ; // 已经取走了

super.notifyAll();

}

class Computer {

private static int count = 0 ; // 表示生产的个数

private String name ;

private double price ;

public Computer(String name,double price) {

this.name = name ;

this.price = price ;

count ++ ;

}

public String toString() {

return "【第" + count + "台电脑】" + "电脑名字：" + this.name + "、价值：" + this.price;

}

3、实现一个竞拍抢答程序：要求设置三个抢答者（三个线程），而后同时发出抢答指令，抢答成功者给出成功提示，未抢答成功者给出失败提示。

package com.yootk.demo;

import java.util.concurrent.Callable;

import java.util.concurrent.FutureTask;

public class ThreadDemo {

public static void main(String[] args) throws Exception {

MyThread mt = new MyThread() ;

FutureTask<String> taskA = new FutureTask<String>(mt) ;

FutureTask<String> taskB = new FutureTask<String>(mt) ;

FutureTask<String> taskC = new FutureTask<String>(mt) ;

new Thread(taskA,"竞赛者A").start();

new Thread(taskB,"竞赛者B").start();

new Thread(taskC,"竞赛者C").start();

System.out.println(taskA.get());

System.out.println(taskB.get());

System.out.println(taskC.get());

}

class MyThread implements Callable<String> {

private boolean flag = false ; // 抢答处理

@Override

public String call() throws Exception {

synchronized(this) { // 数据同步

if (this.flag == false) { // 抢答成功

this.flag = true ;

return Thread.currentThread().getName() + "抢答成功！" ;

} else {

return Thread.currentThread().getName() + "抢答失败！" ;

}

}}

高校知识店铺合集汇总

关注

11
点赞
踩
51

收藏

觉得还不错? 一键收藏
打赏
1
评论
java程序设计项目案例化教程题库及答案

1、 Java源程序文件的后缀是 *.java ，Java字节码文件的后缀名称是 *.class 。2、 Java程序实现可移值性，依靠的是 JVM 。3、 Java语言的三个分支是： JAVA SE 、 JAVA ME 、 JAVA EE 。4、 Java程序由类组成，如果Java使用 public class 声明类，则文件名称必须与类名称一致。5、 Java执行是从 main() 方法开始执行的，此方法的完整定
复制链接

扫一扫