Java期末考题
在线编辑器：https://c.runoob.com/compile/10/
大题
/根据一个百分制的成绩值，输出相应的等级，
//如：
//90分以上是A，
//80分以上是B，
//70分以上是C，
//60十分以上是D，
//其他分数是F。
package cn.gzlg;
import java.util.Scanner;
import sun.applet.Main;
/**
*
* @author NanKe
*/
public class IfElseDemo {
public static void demo1Func(){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩：");
int chenJi = scanner.nextInt();
char dengJi;
if (chenJi > 90) {
dengJi = 'A';
} else if (chenJi > 80) {
dengJi = 'B';
} else if (chenJi > 70) {
dengJi = 'C';
} else if (chenJi > 60) {
dengJi = 'D';
} else {
dengJi = 'F';
}
System.out.println("您输入的成绩对应的等级为：" + dengJi);
}
public static void main(String[] args) {
demo1Func();
}
}
//根据一个百分制的成绩值，输出相应的等级，
//如：
//90-100分以上是A，
//80-89分以上是B，
//70-79分以上是C，
//60-69十分以上是D，
//其他分数是F。
package cn.gzlg;
import java.util.Scanner;
import sun.applet.Main;
public class IfElseDemo {
public static void demo2Func(){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩：");
int chenJi = scanner.nextInt();
char dengJi;
if (chenJi >= 90 && chenJi <=100) {
dengJi = 'A';
} else if (chenJi >= 80 && chenJi <= 89) {
dengJi = 'B';
} else if (chenJi >= 70 && chenJi <= 79) {
dengJi = 'C';
} else if (chenJi >= 60 && chenJi <= 69) {
dengJi = 'D';
} else {
dengJi = 'F';
}
System.out.println("您输入的成绩对应的等级为：" + dengJi);
}
public static void main(String[] args) {
demo2Func();
}
}
Random
//随机生成1-100之间的数字
package cn.gzlg;
import java.util.Scanner;
public class Random {
public static void tm1() {
//Math.random()随机生成区间[0,1)的浮点数，
// 乘以100，区间[0-100),取[1-100],则加1，得[1,101)。
int a1 = (int) (Math.random() * 100 + 1);
System.out.println(a1);
}
public static void main(String[] args) {
tm1();
}
}
//随机生成26个字母中一个或多个字母（可控制大小写输出）
package cn.gzlg;
import java.util.Scanner;
public class Random {
public static void tm2() {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入想要生成几位字母(int)：");
int n = scanner.nextInt();
System.out.println("请输入A/a：");
char type = scanner.next().charAt(0);
String res = "";
for (int i = 0; i < n; i++) {
res += (char) (Math.random() * 26 + type);
}
System.out.println(res);
}
public static void main(String[] args) {
tm2();
}
}
接口
//利用接口做参数，写个计算器，能完成加减乘除运算。
//（1）定义一个接口Compute含有一个方法int computer(int n, int m)。
//（2）设计四个类分别实现此接口，完成加减乘除运算。
//（3）设计一个类UseCompute，类中含有方法：
//public void useCom(Compute com, int one, int two)，此方法能够用传递过来的对象调用computer方法完成运算，并输出运算的结果。
//（4）设计一个主类Test，调用UseCompute中的方法useCom来完成加减乘除运算。
新建接口Compute
package cn.gzlg;
public interface Compute {
int computer(int n, int m);
}
主类
package cn.gzlg;
class useCompute{
private int n;
private int m;
public void useCom(Compute com, int one, int two){
this.n = one;
this.m = two;
com.computer(one, two);
}
}
class Add implements Compute{
private int n;
private int m;
private int res;
public int computer(int n,int m){
this.n = n;
this.m = m;
this.res = n+m;
System.out.println("n+m is " + res);
return res;
}
}
class Reduct implements Compute {
private int n;
private int m;
private int res;
public int computer(int n, int m) {
this.n = n;
this.m = m;
this.res = n - m;
System.out.println("n-m is " + res);
return res;
}
}
class Take implements Compute {
private int n;
private int m;
private int res;
public int computer(int n, int m) {
this.n = n;
this.m = m;
this.res = n * m;
System.out.println("n*m is " + res);
return res;
}
}
class Remove implements Compute {
private int n;
private int m;
private int res;
public int computer(int n, int m) {
this.n = n;
this.m = m;
this.res = n / m;
System.out.println("n/m is " + res);
return res;
}
}
public class Test {
public static void main(String[] args) {
useCompute x = new useCompute();
Add add = new Add();
Reduct reduct = new Reduct();
Take take = new Take();
Remove remove = new Remove();
x.useCom(add, 5, 5);
x.useCom(reduct, 5, 5);
x.useCom(take, 5, 5);
x.useCom(remove, 5, 5);
}
}
//编写一个程序
//在控制台窗口中提示输入两个整数，然后接收这两个 整数，并输出它们的和。下面是运行过程的示例：
//请输入第一个整数：45
//请输入第二个整数：23
//计算结果：45+23=68
package cn.gzlg2;
import java.util.Scanner;
public class demo01 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("请输入第一个整数：");
int one = s.nextInt();
System.out.println("请输入第二个整数：");
int two = s.nextInt();
int result = one + two;
System.out.println("计算结果：" + one + "+" + two + "=" + result);
}
}
//1、定义一个ManKind类，包括
//成员变量int sex和int salary
//方法void manOrWoman()：根据sex的值显示“man" (sex==1)或"woman"(sex=0)
//方法void employeed():根据sal的值 显示“no job" (salary==0)或"job"(salary!=0)
//2、定义类KidsTest,在类的main方法中实例化Kids的对象someKid，用该对象访问其父类的成员变量及方法
package cn.gzlg;
class ManKind {
private int sex;
private int salary;
/**
* @return the sex
*/
public int getSex() {
return sex;
}
/**
* @param sex the sex to set
*/
public void setSex(int sex) {
this.sex = sex;
}
/**
* @return the salary
*/
public int getSalary() {
return salary;
}
/**
* @param salary the salary to set
*/
public void setSalary(int salary) {
this.salary = salary;
}
public void manOrWoman() {
if (getSex() == 1) {
System.out.println("man");
} else if (getSex() == 0) {
System.out.println("woman");
}
}
public void employeed() {
if (getSalary() == 0) {
System.out.println("no job");
} else if (getSalary() == 1) {
System.out.println("job");
}
}
}
class Kids extends ManKind {
private int yearsOld;
public int getYearsOld() {
return this.yearsOld;
}
public void setYearsOld(int yearsOld) {
this.yearsOld = yearsOld;
}
public void printYearsOld() {
System.out.println(this.yearsOld + " yearsOld");
}
public void employeed() {
System.out.println("kids shoueld study and no job");
}
}
public class tao {
public static void main(String[] args) {
Kids someKid = new Kids();
someKid.setSex(1);
someKid.setSalary(0);
someKid.setYearsOld(10);
someKid.manOrWoman();
someKid.employeed();
someKid.printYearsOld();
}
}
从屏幕输入10个数，在输入错误的情况下，给出相应的提示，并继续输入。在输入完成的情况下，找到最大最小数。
package cn.gzlg2;
import java.util.Arrays;
import java.util.Scanner;
public class demo2 {
public static void main(String[] args) {
int[] numArray = new int[10];
int index = 0;
while (true) {
if(index == numArray.length){break;}
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第" + (index + 1) + "个数字：");
try {
numArray[index] = scanner.nextInt();
index++;
} catch (Exception e) {
System.out.println("输入错误，请重新输入");
}
}
System.out.println(Arrays.toString(numArray));
int max = numArray[0];
int min = numArray[0];
for (int j = 0; j < numArray.length; j++) {
if (numArray[j] > max) {
max = numArray[j];
}
if (numArray[j] < min) {
min = numArray[j];
}
}
System.out.println("最大数为：" + max);
System.out.println("最小数为：" + min);
}
}
//写一个方法void triangle(inta,int b,int c)，判断三个参数是否能构成一个三角形。
//如果不能则抛出异常IllegalArgumentException，显示异常信息：a,b,c “不能构成三角形”；
//如果可以构成则显示三角形三个边长。在主方法中得到命令行输入的三个整数，调用此方法，并捕获异常。
package cn.gzlg2;
import java.util.InputMismatchException;
import java.util.Scanner;
class judgment {
public void triangle(int a, int b, int c) throws Exception {
if ((a + b) > c && (a + c) > b && (b + c) > a) {
System.out.println("构成三角形" + "边1为：" + a + "边2为：" + b + "边3为：" + c);
} else {
throw new Exception();
}
}
}
public class demo3 {
public static void main(String[] args) {
judgment j = new judgment();
Scanner scanner = new Scanner(System.in);
try {
System.out.println("请输入第一条边：");
int bian1 = scanner.nextInt();
System.out.println("请输入第二条边：");
int bian2 = scanner.nextInt();
System.out.println("请输入第三条边：");
int bian3 = scanner.nextInt();
j.triangle(bian1, bian2, bian3);
}catch (Exception e) {
System.out.println("不能构造三角形");
} finally {
System.out.println("感谢使用本程序");
}
}
}
//通过文件字节流实现文件复制
package cn.gzlg2;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class demo4 {
public static void main(String[] args) {
try {
File inputFile = new File("D:\\","a.txt");
File outputFile = new File("D:\\","b.txt");
FileInputStream in = new FileInputStream(inputFile);
FileOutputStream out = new FileOutputStream(outputFile);
int count;
while ((count = in.read()) != -1) {
out.write(count);
}
in.close();
out.close();
} catch (IOException iOException) {
System.out.println(iOException);
}
}
}
//在程序中写一个"HelloJavaWorld你好世界"输出到
//操作系统文件Hello.txt文件(D:/Hello.txt)中
package cn.gzlg2;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
public class demo6 {
public static void main(String[] args) throws IOException {
FileOutputStream fos = null;
try {
//创建文件
File file = new File("D://Hello.txt");
//创建输出流
fos = new FileOutputStream(file);
fos.write("HelloJavaWorld你好世界".getBytes());
} catch (FileNotFoundException ex) {
System.out.println("写入异常");
} finally {
try {
fos.close();
} catch (IOException ex) {
System.out.println("关闭失败");
}
}
}
}
//抽象 - 几何图形的面积计算
package cn.gzlg2;
//几何图形的面积计算
//(1)不同几何图形的面积计算，定义一个抽象类，在该抽象类中含有两个属性（long 和 width）和一个抽象方法 area( )。
public abstract class Shape {
public int width;
public int height;
public Shape(int width, int height) {
this.width = width;
this.height = height;
}
public abstract double area();
}
//(2) .定义一个正方形类，该类继承自形状类 Shape，并重写了 area( ) 抽象方法
class Square extends Shape {
public Square(int width, int height) {
super(width, height);
}
@Override
public double area() {
return width * height;
}
}
//(3).定义一个三角形类，该类与正方形类一样，需要继承形状类 Shape，并重写父类中的抽象方法 area()
class Triangle extends Shape {
public Triangle(int width, int height) {
super(width, height);
}
@Override
public double area() {
return (width * height) / 2;
}
}
//(4).创建一个测试类，分别创建正方形类和三角形类的对象，并调用各类中的 area() 方法，打印出不同形状的几何图形的面积
class Test {
public static void main(String[] args) {
Square square = new Square(5, 4);
System.out.println("正方形的面积为:" + square.area());
Triangle triangle = new Triangle(2, 5);
System.out.println("三角形的面积为:" + triangle.area());
}
}
抽象2
package cn.gzlg2;
//1、编写一个Employee类，声明为抽象类，包含三个属性：name、id、salary，提供必要的构造器和抽象方法：work()
abstract class Employee{
private String name;
private int id;
private double salary;
public Employee(){
}
public Employee(String name, int id, double salary) {
this.name = name;
this.id = id;
this.salary = salary;
}
public abstract void work();
}
//2、对于Manage类来说，它既是员工，还具有奖金bonus的属性
class Manage extends Employee{
private double bonus;
public Manage(double bonus) {
this.bonus = bonus;
}
public Manage(double bonus, String name, int id, double salary) {
super(name, id, salary);
this.bonus = bonus;
}
@Override
public void work() {
System.out.println("管理员工");
}
}
class Commonemployee extends Employee{
public Commonemployee() {
}
public Commonemployee(String name, int id, double salary) {
super(name, id, salary);
}
@Override
public void work() {
System.out.println("员工在一线车间生产产品!");
}
}
//3、请使用继承思想，设计Commonemployee和Manage,要求类中提供必要的方法进行属性访问
public class demo7 {
public static void main(String[] args) {
Commonemployee commonemployee = new Commonemployee("jack",11,1234);
commonemployee.work();
Manage manage =new Manage(99,"nanke",3433,444);
Employee manage1 = new Manage(99, "nan4e", 3543, 443);
manage1.work();
manage1.work();
}
}
//编写一个程序，能够从键盘上接收两个数字，然后计算这两个数的积
package cn.gzlg2;
import java.util.Scanner;
import sun.applet.Main;
class Jd{
public static double ser(double num1 ,double num2){
return num1*num2;
}
}
public class demo5 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第一个数字：");
double num1 = scanner.nextDouble();
System.out.println("请输入第二个数字：");
double num2 = scanner.nextDouble();
System.out.println("两个数的乘积为：" + Jd.ser(num1, num2));
}
}
填空
1. 面向对象的特征：封装、继承、多态、抽象
2. 如需运行程序需要的方法是：main()
3. “对外单接口，对内多实现“称为：多态
4. Java语言的8种基本数据类型 boolean 、 char 、 byte 、 short 、 int 、 long 、 double 、 float 。
5. 双目逻辑运算符包括 && 和 || 。
6. 在对一个复杂的表达式进行运算时，要按运算的优先顺序从高到低进行，同级运算符按照 从左到右 的顺序进行。
7. 赋值表达式的左边是 一个变量 ，右边是一个表达式。
8. Break语句最常见的用法是在switch语句中，通过break语句而退出switch语句，使程序从switch语句结构后面的 第一条语句 开始执行。
9. Java语言中循环语句中包括while语句、do while语句和 for 语句。
10. 定义数组需要完成以下三个步骤，即： 声明数组 、 创建数组空间 和 初始化 。
11. 在Java语言中，所有数组设置了一个表示数组元素个数的特性变量 length ，它作为数组的一部分存储起来。
12. Java数组下标的取值范围是 0 到数组长度减1.
13. 设有整型数组的定义：int a[ ] = new int[8]; 则a.length的值为 8 。
14. 若有定义int a[ ] = new int[10]; 则a的数组元素中第5个元素和第6个元素的下标分别是 4 和 5 。
15. 定义一个整型数组 a ，它有3个元素分别是1，2，3。用一个语句实现对数组a的声明、创建和赋值： int a[ ] = {1,2,3}; 。
16. 对象 是对事物的抽象，而 类 是对对象的抽象和归纳。
17. 从用户的角度看， Java源程序中的类分为两种: 系统定义的类 和 用户自己定义的类
18. 一个类主要包含两个要素: 数据成员 和 成员方法 。
19. 创建包时需要使用关键字 package_
20. 构造方法是一种特殊的成员方法，构造方法名与--（类名）--相同
21. Java语言只允许单继承，指每个类只能有一个---（父类）
22. 在Java程序中，通过类的定义只能实现—（单）—重继承，但通过接口的定义可以实现-(多)-重继承关系
23. 类是组成Java程序的基本要素，类体有两部分构成：一部分是变量的定义，另一部分是方法 的定义
24. 执行Person p = new Person();语句后，将在___堆内存________中给Person对象分配空间，并在栈内存中给引用变量p分配空间，存放Person对象的引用。
25. __构造方法_____是一种特殊方法，它的名字必须与它所在的类的名字完全相同，并且不书写返回值类型，在创建对象实例时由new运算符自动调用。
26. 接口的声明有__常量__和__抽象方法__。
27. _ package_ 语句作为java源文件的第一条语句指明该源文件定义的类所在的包。
28. 在java程序中，系统会自动引入_java.lang_这个包，因此不需要再使用_import_ 语句引入该包。
29. 接口中的成员只有静态变量和（成员变量）
30. 在Java中只能实现单继承(Java不支持多重继承),但可通过（接口）实现多重继承。
31. 在Java中，我们只能（单继承多实现），也可以通过interface实现（多继承）
32. Date一共有两个包引用他分别在（java.sql）和（java.util）
33. 泛型参数常用的是E、K、N、T、V，分别代表（元素，键值，数字，类型，值）
34. JAVA集合只能存放 引用类型 的数据
35. 集合不能存放 基 本数据类型。
36. Java中规定一个类只能继承一个（父类），但可以实现多个（接口）。
37. Java允许在泛型的类型形参中使用通配符，以提高程序的（灵活性）。
38. 接口定义使用的关键字是__interface_____
39. catch子句都带一个参数，该参数是某个异常的类及其变量名，catch用该参数去与____抛出异常 ___对象的类进行匹配。
40. java虚拟机能自动处理____ 运行 ___异常。
41. 变量属性是描述变量的作用域，按作用域分类，变量有局部变量、类变量、方法参数和___全局参数 ____
42. 同一段程序可能产生不止一种异常。可以放置多个____ catch ____子句，其中每一种异常类型都将被检查，第一个与之匹配的就会被执行。
43. 捕获异常要求在程序的方法中预先声明，在调用方法时用try-catch-___ finally___语句捕获并处理。
44. 按异常处理不同可以分为运行异常、捕获异常、声明异常、抛出异常 几种。
45. 异常类Exception的父类是Throwable类。
46. 抛出异常的程序代码可以是自定义异常类或者是JDK中的某个类，还可以是JVN.
47. 抛出异常、生成异常对象都可以通过____throw_____语句实现
48. 捕获异常的统一出口通过___finally______语句实现。
49. java语言的类库中提供了一个_____ Throwable_____类，所有的异常都必须是它的实例或它子类的实例。
50. Throwable类有两个子类：____ Error______类和Exception类。
51. 对程序语言而言，一般有编译错误和______运行______错误两类。
52. 一个try语句块后必须跟___catch_______语句块，____finally______语句块可以没有
53. 自定义异常类必须继承_____Exception_____类及其子类
54. 异常处理机制允许根据具体的情况选择在何处处理异常，可以在_____catch_____捕获并处理，也可以用throws子句把他交给____调用栈中上层的方法 ______处理
55. Java中所有的错误都继承自Throwable类；
56. 在该类的子类中，Error类表示严重的底层错误，对于这类错误一般的处理方式是不可处理；Exception类表示例外、异常。
57. 异常处理是通过5个关键词来实现的：try catch throw throws finally
58. 所有的输入字节流的父类是__InputStream______
59. 所有的输出字节流的父类是 OutputStream
60. Java提供了一个功能强大的类 RandomAccessFile 可以实现对文件的随机读写操作
61. 缓存流包括 BufferedInputStream、BufferedOutputStream 类和 BufferedReader、BufferedWriter 类
62. 将Java程序中的对象保存在外存中称为 对象永久化
63. 管道流可以实现 线程间数据 的直接传输
64. 数据流包括 DataInputStream、DataOutputStream 类，它们允许按Java的基本数据类型读写流中数据
65. 在对象序列化的时候给字段使用关键字 transient 可以使字段的数据不保存在硬盘上
66. Java中线程的模型由哪三部分构成 、 、
a) 答案：虚拟的CPU、程序代码、数据
67. Java线程的生命周期有5个状态 、 、 、 、
a) 答案：新建状态（new）、可运行状态（Runnable）、运行状态（Running）、阻塞状态（Blocked）、终止状态（Dead）
68. 创建线程的两种方法分别为(_____)和(_________).
答案：Thread类的构造;Runnable接口
69. 处于运行状态的线程在某些情况下，如执行了sleep（睡眠）方法，或等待I/O设备等资源，将让出CPU并暂时停止自己的运行，进入____状态。 （ **阻塞** ）
70. 一个正在执行的线程可能被人为地中断，让出CPU的使用权，暂时中止自己的执行，进入____状态 ( **阻塞** )
71. 处于新建状态的线程被启动后，将进入线程队列排队等待CPU，此时它已具备了运行条件，一旦轮到享用CPU资源就可以获得执行机会。上述线程是处于 ____ 状态。( **就绪**)
72. 在线程控制中，可以调用 ____ 方法，阻塞当前正在执行的线程，等插队线程执行完后后再执行阻塞线程 (**join()方法**)
73. 在线程通信中，可以调用wait()、notify()、notifyAll()三个方法实现线程通信，这三个方法都是____类提供的public方法，所以任何类都具有这三个方法 （**object**）
74. java中的线程体是由线程类的____方法定义 （ **run() 方法**）
判断
1. 被 ”final” 关键词修饰的类或方法能否被继承或重写吗？ （✖）
2. JAVA支持多继承吗？ （✖）
3. 一个“.java“源文件能否包含多个 public修饰的类 （✖）
4. 继承、多态、类和封装属于面向对象的方法（✔）
5. 类一定要声明变量为public的，才可以执行（✖）
6. 容器被重新设置大小后，FlowLayout布局管理器的容器中的组件大小不随容器大小的变化而改变。（✔）
7. 数组变量之间赋值是引用赋值，不能实现数组数据的复制（✔）
8. 一个class只能定义一个constructor（✖）
9. 抽象方法的body部分必须用一对打括号｛｝包住（✔）
10. 形式参数可以被字段修饰符修饰（✖）
11. 数组的大小可以任意改变（✖）
12. JAVA语言中的方法必定隶属于某一类（对象），调用方法与过程或函数相同（✔）
13. JAVA程序中起始类名称必须与存放该类的文件名相同（✔）
14. 类是一种类型，也是对象的模板。(√)
15. 类中说明的方法可以定义在类体外。(×)
16. 实例方法中不能引用类变量。(×)
17. 一个Java类可以有一个父类，并实现多个接口（√）
18. 接口是特殊的抽象类，所以接口也可以继承，子接口将继承父接口的所有常量和抽象方法（√）
19. 类有两种基本成分，分别为成员变量和成员方法。（√）
20. 内部类是在一个类的声明里声明的类，也称为嵌套类。（√）
21. 重载不是面向对象系统所包含的要素？（×）
22. 用final修饰的变量叫常量（✔）
23. 一个类可以实现多接口。（✔）
24. Java的类不允许多重继承，但接口支持多重继承。（✔）
25. （✖）子类可以继承父类所有的成员变量和成员方法。
26. （✖）HashSet、HashMap都是继承于Set接口。
27. 接口可以直接调用。（✖）
28. HashSet底层数据结构采用哈希表实现（✔） 。
29. 枚举类型不可以跟switch语句结合使用。（✖）
30. 一个集合对象或一个容器表示了一组对象，集合中的对象称为元素。（✔）
31. Java虚拟机对于泛型采用擦除机制的主要目的为了与JDK1.5之前的已有代码兼容。（✔）
32. final 用在变量的前面表示变量的值不可以改变 （✔）
33. final修饰的变量可以多次进行赋值(✖)
34. Java里面由于不允许多重继承，所以如果要实现多个类的功能，则可以通过实现多个接口来实现。（✔）
35. Java接口和Java抽象类最大的一个区别，就在于Java接口可以提供某些方法的部分实现，而Java抽象类不可以。（✖）
36. 抽象类中可以没有抽象方法。（✔）
37. 抽象类中的抽象方法的abstract关键字可以被省略。（✖）
38. 程序中抛出异常时，只能抛出自己定义的异常对象。（✘）
39. 一个异常处理中，finally语句块只能有一个或者可以没有。（✔）
40. 异常类对象代表当前出现的一个具体异常。（✔）
41. java语言中的所有异常类都是java.lang.Throwable的子类。（✔）
42. 如果异常发生时，没有捕获异常的代码，程序会正常执行。（✘）
43. 若父类中的方法声明了throws异常，则子类Override时一定也要throws异常。（✘）
44. 使用throw关键字抛出异常对象。（✔）
45. 如果发生异常，没有捕获异常的的代码，程序会正常运行（✘）
46. throws只能声明要产生的自定义异常，也就是后面只能加自定义异常类。（✘）
47. Errow是Throwable的子类。（✔）
48. printfln是PrintfStream的一个方法（✔）
49. Java对数据的操作是通过流的方式（✔）
50. 字符流可以操作任何数据（✖）
51. System.in是InputStream标准输入流，默认可以从键盘输入读取字节数据（✔）
52. 流一旦打开就必须关闭（✔）
53. 管道流可以实现线程间数据的直接传输（✔）
54. 对一个对象序列化，不需要实现Serializable接口（✖）
55. 任何用transient关键字标明的成员变量，都会被保存（✖）
56. 如果线程死亡，它便不能运行。（✔）
57. 在Java中，高优先级的可运行线程会抢占低优先级线程。（✔）
58. 线程可以用yield方法使低优先级的线程运行。（✖）
59. 程序开发者必须创建一个线程去管理内存的分配。（✔）
60. 一个线程在调用它的start方法之前，该线程将一直处于出生期。（ ✔）
61. Java程序中出现的输出方法println()和print()是完全一致的。 （✖）
62. 一个线程可以调用yield方法使其他线程有机会运行。（✔）
63. 多线程没有安全问题(✖)
64. 多线程安全问题的解决方案可以使用Lock提供的具体的锁对象操作(✔)
65. Stop()方法是终止当前线程的一种状态(✔)
选择Java开发工具包，提供Java的开发环境和运行环境是（ A ）
A: JDK B: JRE C: JVM D: JAR
Java虚拟机，实现跨平台的核心部分，所有Java程序都会编译成“.class”文件运行在虚拟机上的是（ C ）
A: JDK B: JRE C: JVM D: JAR
Java开发工具包，提供Java的开发环境和运行环境的是（ B ）
A: JDK B: JRE C: JVM D: JAR
JDK包括什么（ A ）
A: JRE、JVM B: JRE、JAR C: JVM、JAR D: JVM、JDBC
只限同包下能被访问的类，该类的前置修饰符为（ C ）
A: public B: private C: protected D: default
假设A类有如下定义，设a是A类的一个实例，下列语句调用哪个是错误的？( C )
class A
{ int i;
static String s;
void method1() { }
static void method2() { }
}
A、System.out.println(a.i)；
B、a.method1();
C、A.method1();
D、A.method2()
3_1_2（201090412430235+林怡怡）
运算符优先级别排序正确的是（ A ）
A、由高向低分别是：()、!、算术运算符、关系运算符、逻辑运算符、赋值运算符；
B、由高向低分别是：()、关系运算符、算术运算符、赋值运算符、!、逻辑运算符；
C、由高向低分别是：()、算术运算符、逻辑运算符、关系运算符、!、赋值运算符；
D、由高向低分别是：()、!、关系运算符、赋值运算符、算术运算符、逻辑运算符；
下面哪种情况能实现自动转换（ B ）。
A）int型转换成byte型 B）float型转换成double型
C)double型转换成int型 D）char型转换成String型
下列输出结果是（ C ）
int a = 0 ;
while ( a < 5 ) {
switch(a){
case 0:
case 3 : a = a + 2;
case 1 :
case 2 : a = a + 3;
default : a = a + 5;
}
}
System.out.print ( a ) ;
A、0
B、5
C、10
D、其他
switch语法说法正确的是（ A ）
A)switch语句()中的值的类型可以是一个整型和字符型的变量或表达式；
B)case后面的值可以重复；
C)case后面的代码必须要有break;
D)case和default的位置不可以随便放置；
下面关于switch...case语句正确的是（ AB ）
A)case语句是没有先后顺序的
B)break语句不是必须的，在需要的情况下可以省略
C)switch后面小括号表达式的值可以用double类型
D)case语句是有先后顺序的
关于类和对象说法正确的是： ( ABCD )
A) 类是对一组具有相同属性、操作和关系的同类对象的描述
B) 对象是实际存在的某类事物的每个个体
C) 可以通过[ new 类名( ); ]的方式可以创建某类的具体对象实例
D) 可以通过[对象名.成员变量名;]的方式访问具体对象中的属性
下面的哪些声明是合法的 ( ADE )
A) long a =4990
B) int i=4L
C) float f=1.1
D) double d=34.4
E) double t=0.9F
下面哪个是Java语言中正确的标识符( C )
A、com
B、import
C、that
D、this
下面的代码段中，执行之后i 和j 的值是什么? ( B )
int i = 1;
int j;
j = i++*2+3*--i;
A．1, 2 B．1, 5 C． 2, 1 D． 2, 2
为一个boolean类型变量赋值时，可以使用( B )方式
A、boolean = 1;
B、boolean a = (9 >= 10);
C、boolean a="真";
D、boolean a = = false;
关于类中的变量说法错误的是： （ C ）
A) 在同一个方法中，不允许有同名局部变
B）在不同的方法中，可以有同名局部变量
C）在同一个类中，全局变量和局部变量同名时，局部变量具有更高的优先级
D）在同一个类中，全局变量和局部变量同名时，全局变量具有更高的优先级
循环语句for(int i=0; i<4; i++){ }循环的次数为 ( B ) 。
A）无限次 B）4次
C）1次 D）3次
下列哪种类成员修饰符修饰的变量只能在本类中被访问?(D)
(A) protected
(B)public
(C)default
(D )private
下面关于类的说法，不正确的是(C)。
(A)类是同种对象的集合和抽象
(B)类属于Java语言中的复合数据类型
(C)类就是对象
(D)对象是Java语言中的基本结构单位
有一个类B，下面为其构造方法的声明，正确的是(B)
(A) void B(int x){ }
(B)B(int x){ }
(C)b(int x) { }
(D) void b(int x) { }
下面关于方法的说法，不正确的是(C)。
(A)Java中的构造方法名必须和类名相同
(B)方法体是对方法的实现，包括变量声明和合法语句
(C)如果一个类定义了构造方法，也可以用该类的默认构造方法
(D)类的私有方法不能被其他类直接访问
关于内部类，下列说法不正确的是(A)。
(A)内部类不能有自己的成员方法和成员变量
(B)内部类可用 private或 protected修饰符修饰
(C)内部类可以作为其他类的成员，而且可访问它所在的类的成员
(D)除 static内部类外，不能在类内声明 static成员
定义外部类时不能用到的关键字是(C)。
(A ) final
(B )public
(C)protected
(D abstract
为AB类定义一个无返回值的方法f，使得使用类名就可以访问该方法，该方法头的形式(D)
(A) abstract void fo
(B) public void f0
(C)final void fo
(D) static void fo
定义一个公有 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
下面关于变量及其作用范围的陈述nage2是不对的？（B）
A. 实例变量是类的成员变量。
B. 实例变量用关键字static声明。
C. 在方法中定义的局部变量在该方法被执行时创建。
D. 局部变量在使用前必须被初始化。
下面哪条语句把方法声明为抽象的公共方法？（B）
A. public abstract method();
B. public abstract void method();
C. public abstract void method(){}
D. public void method() extends abstract;
main方法是Java Application程序执行的入口点，关于main方法的方法头以下哪项是合法的（B）
A. public static void main()
B. public static void main(String[ ] args)
C. public static int main(String[ ]args)
D. public void main(String arg[ ])
在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数个数、类型或顺序各不相同，传回的值也可以不相同。这种面向对象的程序的特性称为（C）
A、隐藏
B、覆盖
C、重载 D、Java不支持此特性
下列关于构造方法的叙述中，错误的是（C）
A、 Java语言规定构造方法名与类名必须相同
B、 Java语言规定构造方法没有返回值，但不用void声明
C、 Java语言规定构造方法不可以重载
D、 Java语言规定构造方法只能通过new自动调用
下面选项中，(B )是Java 关键字
A、then
B、continue
C、java
D、PUBLIC
如下哪些字串是Java中的标识符？(A)
A.fieldname
B.super
C.number
D.NULL
如下哪些不是Java中有效的关键字？(B)
A.const
B.NULL
C.false
D.this
JAVA中关于类的继承，下面说法错误的是(D)
A、继承可以描述类与类之间的关系
A、继承可以描述类与类之间的关系
C、具有继承关系的子类和父类层次结构更加清晰
D、子类中可以重写父类中的所有方法
欲构造ArrayList类的一个实例，此类继承了List接口，下列哪个方法是正确的 (B) ？
A、 ArrayList myList=new Object（）；
B、 List myList=new ArrayList（）；
C、 ArrayList myList=new List（）；
D、 List myList=new List（）；
设有下面的两个类定义：
Class A{
Void show(){
System.out.println(“A study Java!”);
}
}
Class BB extends A{
Void show(){
System.out.println(“BB study C++!”);
}
}
则顺序执行如下语句输出结果为：（A）
A a=new A();
B b=new BB();
a.show(); b.show();
A．A study Java! B．A study C++!
BB study C++! BB study Java!
C．A study Java! D．A study C++!
BB study Java! BB study C++!
下列关于Object类的叙述错误的是(D)
A. Object类是所有类的父类
B. 所有类都可以继承Object中允许被继承的方法
C. 一个类没有使用extends关键字明确标识继承关系，则默认继承Object类
D. 要想继承Object类，必须使用extends关键字标识继承关系，否则不会实现继承
在Java中，关于继承的说法错误的是 (C)
A. 使用extends关键字实现一个类继承另一个类
B. 所有的Java类都直接或间接地继承了java.lang.Object类
C. 在子类的构造方法中，必须显式调用父类的构造方法
D. 在子类的构造方法中，可以通过super关键字调用父类的构造方法
在Java中，以下关于方法重载和方法重写描述正确的是 (D)
A. 方法重载和方法重写实现的功能相同
B. 方法重载出现在父子关系中，方法重写是在同一类中
C. 方法重载的返回类型必须一致，参数项必须不同
D. 方法重写需要出现在满足继承关系的子类中
有以下程序段
int k=0,a=1,b=2,c=3;
k=a<b?b:a;
k=k>c?c:k;
执行该程序段后，k的值是__( B_)
A)3 B)2 C)1 D)0
下列语句中，正确的是：（ ABC ）
A.while(1==j){}
B.while(true){}
C.do{}while(i==10);
D.do;while(i==j)
关于数组定义正确的是： ( BD )
A) int a [] = (1,2,3,4,5,6); B) char a[]; a = new char[10];
C) String str={"Hello","World"}; D) double d[] = new double[]{1,2,3,4,5};
Java中，关于枚举类的说法错误的是（ D ）
A.枚举类型也可以实现一个或多个接口
B.枚举类型实现接口时也要实现该接口中全部方法
C.枚举类型里定义抽象方法无须显示的使用abstract关键字
D.枚举类型继承接口要使用关键字是extends
解析:
本题考查的是枚举类型的使用。枚举类型实现接口使用implements关键字。应选择D。
在Java中，已定义两个接口B和C，要定义一个实现这两个接口的类，以下语句正确的是(C)。
a)interface A extends B,C
b) interface A implements B,C
c)class A implements B,C
d)class A implements B,implements C
关于被私有访问控制符private修饰的成员变量，以下说法正确的是＿C＿＿。
A、可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类
B、可以被两种类访问和引用：该类本身、该类的所有子类
C、只能被该类自身所访问和修改
D、 只能被同一个包中的类访问
关于类继承的说法，正确的是（B）
A、Java类允许多重继承
B、Java接口允许多继承
C、接口和类都允许多继承
D、接口和类都不允许多继承
类变量或者静态变量使用（C）修饰
A、this
B、final
C、static
D、abstract
被final标注的类和成员方法不能（A）
A、不能被继承，不能被重写
B、可以被继承，不能被重写
C、不可以被继承，可以被重写
D、可以被继承，可以被重写
使用final修饰的变量应该使用（C）命名
A、 xxyyzz
B、 XxYyZz
C、 XXYYZZ
D、 xxYyZz
抽象类在声明时应使用（B）
A、public
B、abstract
C、final
D、import
Java中提供了名为（C）的包装类来包装字符类型
A. Integer
B. String
C. Character
D. Char
下面关于方法的说法，错误的是( C )。
A、Java 中的方法参数传递时传值调用，而不是地址调用
B、方法体是对方法的实现，包括变量声明和Java 的合法语句
C、如果程序定义了一个或多个构造方法，在创建对象时，也可以用系统自动生成空的构造方法
D、类的私有方法不能被其子类直接访问
下面关于内部类的说法，错误的是( A )。
A、内部类不能有自己的成员方法和成员变量
B、内部类可用abstract 修饰定义为抽象类，也可以用private 或protected 定义
C、内部类可作为其他类的成员，而且可访问它所在类的成员
下面语句中，正确的是( B )。
A、boolean b=”true”;
B、double x=2.5f;
C、char c=”A”;
D、float y=0.8d;
设有定义“int k=3;” ，语法正确且值为true 的表达式是( D )。
A、k=3;
B、k++>3;
C、k--==3&&k++==3;
D、k++==3||++k>3;
类Test定义如下
1. public classTest{
2. public float aMethod(float a,float b,){}
3.
4.}
将以下那种方法插入行3是不合法的(B)
A、 public float aMethod(float a,float b,float c){}
B、 public float aMethod(float c,float d){}
C、 public int aMethod(int a,int b){}
D、 public float aMethod(int a,int b,int c){}
Java程序文件的扩展名是（ B）
A. .txt
B. .java
C. .class
D. .exe
下列哪个表达式不可以作为循环条件( A )
A. i = 5;
B. i < 3;
C. bEqual = str.equals(“q”);
D. count = = i;
以下哪个不属于包机制的好处（B）
A.容易确定包中的类是相关的，且容易根据所需功能找到对应的类。
B.一个类只能属于一个包。
C.包中的类名不会冲突。.
D.同一个包中的类之间有比较宽松的访问控制。
java程序中的类不能有多个父类，但可以通过（ C）的定义实现多重继承关系。
A）内部类 B) 适配器 C) 接口 D) 同步
（A）在加载类时就被分配了内存地址，因此加载后即可被任意对象调用，而（）需要在创建对象后才会被分配内存地址。
A）类方法 实例方法 B）构造方法 类方法
C）类方法 构造方法 D）实例方法 构造方法
字节流中的数据以（C）位字节为单位进行读写
A．2
B．4
C．8
D．16
字符流中的数据以（D）位字节为单位进行读写
A.2
B.4
C.8
D.16
下面哪个流类属于面向字符的输入流（D）
A. BufferedWriter
B. FileInputStream
C. ObjectInputStream
D. InputStreamReader
字节流的顶层父类是（A）
InputStream
FileInputStream
ObjectInputStream
BufferedInputStream
字符流的顶层父类是（C）
FileReader
BufferedReader
Reader
StringReader
为了提高读写性能，可以采用（A）
BufferedInputStream
InputStream
BufferedReader
OutputStream
（A）流能指定字符编码
InputStreamReader
Reader
Writer
OutputStream
Random Access File类包含的写方法主要包括（B）
WriteChar()
WriteInt()
WriteLong()
WriteString()
A、134 B、123 C、234 D、124
File Input Stream类重写了InputStream的3个read()方法，以下错误的选项是(C)
skip() B、avaliable() C、open() D、close()
Java类库中，将信息写入内存的类是（B）
A. Java.io.FileOutputStream
B. java.ByteArrayOutputStream
C. java.io.BufferedOutputStream
D. java.io.DataOutputStream
File类型中定义了什么方法来判断一个文件是否存在（D）
createNewFile
renameTo
delete
exists
File类型中定义了什么方法来创建一级目录（C）
createNewFile
exists
mkdirs
mkdir
凡是从中央处理器流向外部设备的数据流称为（D）
文件流
字符流
输入流
输出流
流的传递方式是（B）
A.并行的
B.串行的
C.并行和串行
D.以上都不对
新建一个流对象，下面那个选项的代码是错误的？（B）
A. new BufferedWriter(new FileWriter(“a.txt”));
B. new BufferedReader (new FileInputStream(“a.dat”));
C. new GZIPOutputStream(new FileOutputStream(“a.zip”));
D. new ObjectInputStream(new FileInputStream(“a.dat”));
要从文件”file.dat”文件中读出第10个字节到变量c中，下列哪个正确（A）（选择一项）
A.FileInputStream in=new FileInputStream("file.dat");
in.skip(9);
int c=in.read();
B.FileInputStream in=new FileInputStream("file.dat");
in.skip(10);
int c=in.read();
C.FileInputStream in=new FileInputStream("file.dat");
int c=in.read();
D.RandomAccessFile in=new RandomAccessFile("file.dat");
in.skip(7);
int c=in.readByte();
下列哪个方法可用于创建一个可运行的类（）
A. Public class X implements Runnable{public int run(){......}}
B. Public class X extends Thread{public void run(){......}}
C. Public class X extends Thread{public int run(){......}}
D. Public class X implements Runnable{protected void run(){......}}
答案：B
选择
Java开发工具包，提供Java的开发环境和运行环境是（ A ）
A: JDK B: JRE C: JVM D: JAR
Java虚拟机，实现跨平台的核心部分，所有Java程序都会编译成“.class”文件运行在虚拟机上的是（ C ）
A: JDK B: JRE C: JVM D: JAR
Java开发工具包，提供Java的开发环境和运行环境的是（ B ）
A: JDK B: JRE C: JVM D: JAR
JDK包括什么（ A ）
A: JRE、JVM B: JRE、JAR C: JVM、JAR D: JVM、JDBC
只限同包下能被访问的类，该类的前置修饰符为（ C ）
A: public B: private C: protected D: default
假设A类有如下定义，设a是A类的一个实例，下列语句调用哪个是错误的？( C )
class A
{ int i;
static String s;
void method1() { }
static void method2() { }
}
A、System.out.println(a.i)；
B、a.method1();
C、A.method1();
D、A.method2()
3_1_2（201090412430235+林怡怡）
运算符优先级别排序正确的是（ A ）
A、由高向低分别是：()、!、算术运算符、关系运算符、逻辑运算符、赋值运算符；
B、由高向低分别是：()、关系运算符、算术运算符、赋值运算符、!、逻辑运算符；
C、由高向低分别是：()、算术运算符、逻辑运算符、关系运算符、!、赋值运算符；
D、由高向低分别是：()、!、关系运算符、赋值运算符、算术运算符、逻辑运算符；
下面哪种情况能实现自动转换（ B ）。
A）int型转换成byte型 B）float型转换成double型
C)double型转换成int型 D）char型转换成String型
下列输出结果是（ C ）
int a = 0 ;
while ( a < 5 ) {
switch(a){
case 0:
case 3 : a = a + 2;
case 1 :
case 2 : a = a + 3;
default : a = a + 5;
}
}
System.out.print ( a ) ;
A、0
B、5
C、10
D、其他
switch语法说法正确的是（ A ）
A)switch语句()中的值的类型可以是一个整型和字符型的变量或表达式；
B)case后面的值可以重复；
C)case后面的代码必须要有break;
D)case和default的位置不可以随便放置；
下面关于switch...case语句正确的是（ AB ）
A)case语句是没有先后顺序的
B)break语句不是必须的，在需要的情况下可以省略
C)switch后面小括号表达式的值可以用double类型
D)case语句是有先后顺序的
关于类和对象说法正确的是： ( ABCD )
A) 类是对一组具有相同属性、操作和关系的同类对象的描述
B) 对象是实际存在的某类事物的每个个体
C) 可以通过[ new 类名( ); ]的方式可以创建某类的具体对象实例
D) 可以通过[对象名.成员变量名;]的方式访问具体对象中的属性
下面的哪些声明是合法的 ( ADE )
A) long a =4990
B) int i=4L
C) float f=1.1
D) double d=34.4
E) double t=0.9F
下面哪个是Java语言中正确的标识符( C )
A、com
B、import
C、that
D、this
下面的代码段中，执行之后i 和j 的值是什么? ( B )
int i = 1;
int j;
j = i++*2+3*--i;
A．1, 2 B．1, 5 C． 2, 1 D． 2, 2
为一个boolean类型变量赋值时，可以使用( B )方式
A、boolean = 1;
B、boolean a = (9 >= 10);
C、boolean a="真";
D、boolean a = = false;
关于类中的变量说法错误的是： （ C ）
A) 在同一个方法中，不允许有同名局部变
B）在不同的方法中，可以有同名局部变量
C）在同一个类中，全局变量和局部变量同名时，局部变量具有更高的优先级
D）在同一个类中，全局变量和局部变量同名时，全局变量具有更高的优先级
循环语句for(int i=0; i<4; i++){ }循环的次数为 ( B ) 。
A）无限次 B）4次
C）1次 D）3次
下列哪种类成员修饰符修饰的变量只能在本类中被访问?(D)
(A) protected
(B)public
(C)default
(D )private
下面关于类的说法，不正确的是(C)。
(A)类是同种对象的集合和抽象
(B)类属于Java语言中的复合数据类型
(C)类就是对象
(D)对象是Java语言中的基本结构单位
有一个类B，下面为其构造方法的声明，正确的是(B)
(A) void B(int x){ }
(B)B(int x){ }
(C)b(int x) { }
(D) void b(int x) { }
下面关于方法的说法，不正确的是(C)。
(A)Java中的构造方法名必须和类名相同
(B)方法体是对方法的实现，包括变量声明和合法语句
(C)如果一个类定义了构造方法，也可以用该类的默认构造方法
(D)类的私有方法不能被其他类直接访问
关于内部类，下列说法不正确的是(A)。
(A)内部类不能有自己的成员方法和成员变量
(B)内部类可用 private或 protected修饰符修饰
(C)内部类可以作为其他类的成员，而且可访问它所在的类的成员
(D)除 static内部类外，不能在类内声明 static成员
定义外部类时不能用到的关键字是(C)。
(A ) final
(B )public
(C)protected
(D abstract
为AB类定义一个无返回值的方法f，使得使用类名就可以访问该方法，该方法头的形式(D)
(A) abstract void fo
(B) public void f0
(C)final void fo
(D) static void fo
定义一个公有 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
下面关于变量及其作用范围的陈述nage2是不对的？（B）
A. 实例变量是类的成员变量。
B. 实例变量用关键字static声明。
C. 在方法中定义的局部变量在该方法被执行时创建。
D. 局部变量在使用前必须被初始化。
下面哪条语句把方法声明为抽象的公共方法？（B）
A. public abstract method();
B. public abstract void method();
C. public abstract void method(){}
D. public void method() extends abstract;
main方法是Java Application程序执行的入口点，关于main方法的方法头以下哪项是合法的（B）
A. public static void main()
B. public static void main(String[ ] args)
C. public static int main(String[ ]args)
D. public void main(String arg[ ])
在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数个数、类型或顺序各不相同，传回的值也可以不相同。这种面向对象的程序的特性称为（C）
A、隐藏
B、覆盖
C、重载 D、Java不支持此特性
下列关于构造方法的叙述中，错误的是（C）
A、 Java语言规定构造方法名与类名必须相同
B、 Java语言规定构造方法没有返回值，但不用void声明
C、 Java语言规定构造方法不可以重载
D、 Java语言规定构造方法只能通过new自动调用
下面选项中，(B )是Java 关键字
A、then
B、continue
C、java
D、PUBLIC
如下哪些字串是Java中的标识符？(A)
A.fieldname
B.super
C.number
D.NULL
如下哪些不是Java中有效的关键字？(B)
A.const
B.NULL
C.false
D.this
JAVA中关于类的继承，下面说法错误的是(D)
A、继承可以描述类与类之间的关系
A、继承可以描述类与类之间的关系
C、具有继承关系的子类和父类层次结构更加清晰
D、子类中可以重写父类中的所有方法
欲构造ArrayList类的一个实例，此类继承了List接口，下列哪个方法是正确的 (B) ？
A、 ArrayList myList=new Object（）；
B、 List myList=new ArrayList（）；
C、 ArrayList myList=new List（）；
D、 List myList=new List（）；
设有下面的两个类定义：
Class A{
Void show(){
System.out.println(“A study Java!”);
}
}
Class BB extends A{
Void show(){
System.out.println(“BB study C++!”);
}
}
则顺序执行如下语句输出结果为：（A）
A a=new A();
B b=new BB();
a.show(); b.show();
A．A study Java! B．A study C++!
BB study C++! BB study Java!
C．A study Java! D．A study C++!
BB study Java! BB study C++!
下列关于Object类的叙述错误的是(D)
A. Object类是所有类的父类
B. 所有类都可以继承Object中允许被继承的方法
C. 一个类没有使用extends关键字明确标识继承关系，则默认继承Object类
D. 要想继承Object类，必须使用extends关键字标识继承关系，否则不会实现继承
在Java中，关于继承的说法错误的是 (C)
A. 使用extends关键字实现一个类继承另一个类
B. 所有的Java类都直接或间接地继承了java.lang.Object类
C. 在子类的构造方法中，必须显式调用父类的构造方法
D. 在子类的构造方法中，可以通过super关键字调用父类的构造方法
在Java中，以下关于方法重载和方法重写描述正确的是 (D)
A. 方法重载和方法重写实现的功能相同
B. 方法重载出现在父子关系中，方法重写是在同一类中
C. 方法重载的返回类型必须一致，参数项必须不同
D. 方法重写需要出现在满足继承关系的子类中
有以下程序段
int k=0,a=1,b=2,c=3;
k=a<b?b:a;
k=k>c?c:k;
执行该程序段后，k的值是__( B_)
A)3 B)2 C)1 D)0
下列语句中，正确的是：（ ABC ）
A.while(1==j){}
B.while(true){}
C.do{}while(i==10);
D.do;while(i==j)
关于数组定义正确的是： ( BD )
A) int a [] = (1,2,3,4,5,6); B) char a[]; a = new char[10];
C) String str={"Hello","World"}; D) double d[] = new double[]{1,2,3,4,5};
Java中，关于枚举类的说法错误的是（ D ）
A.枚举类型也可以实现一个或多个接口
B.枚举类型实现接口时也要实现该接口中全部方法
C.枚举类型里定义抽象方法无须显示的使用abstract关键字
D.枚举类型继承接口要使用关键字是extends
解析:
本题考查的是枚举类型的使用。枚举类型实现接口使用implements关键字。应选择D。
在Java中，已定义两个接口B和C，要定义一个实现这两个接口的类，以下语句正确的是(C)。
a)interface A extends B,C
b) interface A implements B,C
c)class A implements B,C
d)class A implements B,implements C
关于被私有访问控制符private修饰的成员变量，以下说法正确的是＿C＿＿。
A、可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类
B、可以被两种类访问和引用：该类本身、该类的所有子类
C、只能被该类自身所访问和修改
D、 只能被同一个包中的类访问
关于类继承的说法，正确的是（B）
A、Java类允许多重继承
B、Java接口允许多继承
C、接口和类都允许多继承
D、接口和类都不允许多继承
类变量或者静态变量使用（C）修饰
A、this
B、final
C、static
D、abstract
被final标注的类和成员方法不能（A）
A、不能被继承，不能被重写
B、可以被继承，不能被重写
C、不可以被继承，可以被重写
D、可以被继承，可以被重写
使用final修饰的变量应该使用（C）命名
A、 xxyyzz
B、 XxYyZz
C、 XXYYZZ
D、 xxYyZz
抽象类在声明时应使用（B）
A、public
B、abstract
C、final
D、import
Java中提供了名为（C）的包装类来包装字符类型
A. Integer
B. String
C. Character
D. Char
下面关于方法的说法，错误的是( C )。
A、Java 中的方法参数传递时传值调用，而不是地址调用
B、方法体是对方法的实现，包括变量声明和Java 的合法语句
C、如果程序定义了一个或多个构造方法，在创建对象时，也可以用系统自动生成空的构造方法
D、类的私有方法不能被其子类直接访问
下面关于内部类的说法，错误的是( A )。
A、内部类不能有自己的成员方法和成员变量
B、内部类可用abstract 修饰定义为抽象类，也可以用private 或protected 定义
C、内部类可作为其他类的成员，而且可访问它所在类的成员
下面语句中，正确的是( B )。
A、boolean b=”true”;
B、double x=2.5f;
C、char c=”A”;
D、float y=0.8d;
设有定义“int k=3;” ，语法正确且值为true 的表达式是( D )。
A、k=3;
B、k++>3;
C、k--==3&&k++==3;
D、k++==3||++k>3;
类Test定义如下
1. public classTest{
2. public float aMethod(float a,float b,){}
3.
4.}
将以下那种方法插入行3是不合法的(B)
A、 public float aMethod(float a,float b,float c){}
B、 public float aMethod(float c,float d){}
C、 public int aMethod(int a,int b){}
D、 public float aMethod(int a,int b,int c){}
Java程序文件的扩展名是（ B）
A. .txt
B. .java
C. .class
D. .exe
下列哪个表达式不可以作为循环条件( A )
A. i = 5;
B. i < 3;
C. bEqual = str.equals(“q”);
D. count = = i;
以下哪个不属于包机制的好处（B）
A.容易确定包中的类是相关的，且容易根据所需功能找到对应的类。
B.一个类只能属于一个包。
C.包中的类名不会冲突。.
D.同一个包中的类之间有比较宽松的访问控制。
java程序中的类不能有多个父类，但可以通过（ C）的定义实现多重继承关系。
A）内部类 B) 适配器 C) 接口 D) 同步
（A）在加载类时就被分配了内存地址，因此加载后即可被任意对象调用，而（）需要在创建对象后才会被分配内存地址。
A）类方法 实例方法 B）构造方法 类方法
C）类方法 构造方法 D）实例方法 构造方法
java中用来抛出异常的关键字是（ C）
A.try B.catch C.throw D.finally
关于异常，下列说法正确的是（ B）
A. 异常是一种对象 B.一旦程序运行，异常将被创建
C．为了保证程序运行速度，要尽量避免异常控制 D.以上说法都不对
（A）类是所有异常类的父类。
A.Throwable B.Error C.Exception D. AWTError
java语言中，下列哪一子句是异常处理的出口（A ）
A.try{…}子句 B.catch{…}子句 C.finally{…}子句 D.以上说法都不对
下列程序的执行，说法错误的是（BCD ）
class MultiCatch
{
public static voidmain(String args[])
{
try
{
inta=args.length;
int b=42/a;
intc[]={1};
c[42]=99;
System.out.println(“b=”+b);
}
catch(ArithmeticException e)
{
System.out.println(“除0异常：”+e);
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println(“数组超越边界异常：”+e);
}
}
}
A.程序将输出第15行的异常信息
B.程序第10行出错
C.程序将输出“b=42”
D.程序将输出第19行的异常信息
6-1-6（20190412430215 冯明杰）下列程序的执行，说法正确的是（ D）
class ExMulti
{
static voidprocedure()
{
try
{
int c[]={1};
c[42]=99;
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println(“数组超越界限异常：”+e);
}
}
public static voidmain(String args[])
{
try
{
procedure();
inta=args.length;
int b=42/a;
System.out.println(“b=”+b);
}
catch(ArithmeticException e)
{
System.out.println(“除0异常：”+e);
}
}
}
A.程序只输出第12行的异常信息
B.程序只输出第26行的异常信息
C.程序将不输出异常信息
D.程序将输出第12行和第26行的异常信息
6_1_7（20190412430215 冯明杰）下面程序抛出了一个“异常”并捕捉它。请在横线处填入适当内容完成程序。
class TrowsDemo
{
static voidprocedure() throws IllegalAccessExcepton
{
System.out.println(“inside procedure”);
throw_______IllegalAccessException(“demo”);
}
public static voidmain(String args[])
{
try
{
procedure();
}
___________
{
System.out.println(“捕获：”+e);
}
}
finally语句块中的代码（ A ）
A．总是被执行
B．当try语句块后面没有catch时，finally中的代码才会执行
C．异常发生时才执行
D．异常没有发生时才被执行
6_1_8（20190412430215 冯明杰）抛出异常应该使用的关键字是（ A ）
A．throw B．catch C．finally D．throws
6_1_9（20190412430215 冯明杰）自定义异常类时，可以继承的类是（ C ）
A．Error B．Applet C．Exception及其子类 D．AssertionError
6_1_10（20190412430215 冯明杰）在异常处理中，将可能抛出异常的方法放在（ C ）语句块中
A．throws B．catch C．try D．finally
6_1_11（邬杨鹏20190412430250）对于try{……}catch子句的排列方式，下列正确的一项是（ A ）
A．子类异常在前，父类异常在后 B．父类异常在前，子类异常在后
C．只能有子类异常 D.父类异常与子类异常不能同时出现
6_1_12（邬杨鹏20190412430250）使用catch(Exception e)的好处是（ B ）
A．只会捕获个别类型的异常
B．捕获try语句块中产生的所有类型的异常
C．忽略一些异常
D．执行一些程序
6_1_13（邬杨鹏20190412430250）请问所有的异常类皆继承哪一个类？（ A ）
A．java.lang.Throwable B．java.lang.Exception
C．java.lang.Error D．java.io.Exception
6_1_14（邬杨鹏20190412430250）对于已经被定义过可能抛出异常的语句，在编程时（ A ）。
A．必须使用try／catch语句处理异常，或用throw将其抛出。
B．如果程序错误，必须使用 try／catch语句处理异常。
C．可以置之不理。
D．只能使用try／catch语句处理。
6_1_15（邬杨鹏20190412430250）下面程序段的执行结果是什么？（ B ）
public class Foo{
public static voidmain(String[] args){
try{
return;}
finally{System.out.println("Finally");
}
}
}
A．编译能通过，但运行时会出现一个例外。 B．程序正常运行，并输出 "Finally"。
C．程序正常运行，但不输出任何结果。 D．因为没有catch语句块，所以不能通过编译。
6_1_16（邬杨鹏20190412430250）下面是一些异常类的层次关系：
java.lang.Exception
java.lang.RuntimeException
java.lang.IndexOutOfBoundsException
java.lang.ArrayIndexOutOfBoundsException
java.lang.StringIndexOutOfBoundsException
假设有一个方法X，能够抛出两个异常，Array Index和String Index异常，假定方法X中没有try-catch语句处理这些异常，下面哪个答案是正确的？（ B ）
A．方法X 应该声明抛弃ArrayIndexOutOfBoundsException和StringIndexOutOfBounds-Exception。
B．如果调用X的方法捕获IndexOutOfBoundsException，则ArrayIndexOutOfBounds- Exception和StringIndexOutOfBoundsException都可以被捕获。
C．如果方法X声明抛弃IndexOutOfBoundsException，则调用X的方法必须用try-catch语句捕获。
D．方法X不能声明抛弃异常。
6_1_17（邬杨鹏20190412430250）下面的方法是一个不完整的方法，其中的方法unsafe()会抛出一个IOException，那么在方法的①处应加入哪条语句，才能使这个不完整的方法成为一个完整的方法？（ D ）
① ____________________________
② { if(unsafe()) {//do something…}
③ else if(safe()) {//do the other…}
④ }
A．public IOExceptionmethodName() B．public void methodName()throw IOException
C．public void methodName() D．public voidmethodName() throws IOException
6_1_18（邬杨鹏20190412430250）如果下列的方法能够正常运行，在控制台上将不显示什么？（ B ）
public void example( ){
try{
unsafe();
System.out.println("Test1");
}
catch(SafeException e)
{System.out.println("Test2");}
finally{System.out.println("Test3");}
System.out.println("Test4");
}
A．Test 1 B． Test 2 C．Test 3 D． Test 4
6_1_19（邬杨鹏20190412430250）数组下标越界，则发生异常，提示为 (D)
A. IOException
B. ArithmeticException
C. SQLException
D. ArrayIndexOutOfBoundsException
6_1_20（邬杨鹏20190412430250）下列代码中的异常属于(多选) (A D)
int a = 0;
System.out.println(2/a);
1
A. 非检查型异常
B. 检查型异常
C. Error
D. Exception
7_1_1（20190412430232+林柏辉）
字节流中的数据以（C）位字节为单位进行读写
A．2
B．4
C．8
D．16
7_1_2（20190412430206+陈俊全）
字符流中的数据以（D）位字节为单位进行读写
A.2
B.4
C.8
D.16
7_1_3（20190412430232+林柏辉）
下面哪个流类属于面向字符的输入流（D）
A. BufferedWriter
B. FileInputStream
C. ObjectInputStream
D. InputStreamReader
7_1_4（20190412430206+陈俊全）
字节流的顶层父类是（A）
InputStream
FileInputStream
ObjectInputStream
BufferedInputStream
7_1_5（20190412430232+林柏辉）
字符流的顶层父类是（C）
FileReader
BufferedReader
Reader
StringReader
7_1_6（20190412430206+陈俊全）
为了提高读写性能，可以采用（A）
BufferedInputStream
InputStream
BufferedReader
OutputStream
7_1_7（20190412430232+林柏辉）
（A）流能指定字符编码
InputStreamReader
Reader
Writer
OutputStream
7_1_8（20190412430255+许树宏）
Random Access File类包含的写方法主要包括（B）
WriteChar()
WriteInt()
WriteLong()
WriteString()
A、134 B、123 C、234 D、124
7_1_9（20190412430226+黄柯夫）
File Input Stream类重写了InputStream的3个read()方法，以下错误的选项是(C)
skip() B、avaliable() C、open() D、close()
7_1_10（20190412430261+赵镓镇）
Java类库中，将信息写入内存的类是（B）
A. Java.io.FileOutputStream
B. java.ByteArrayOutputStream
C. java.io.BufferedOutputStream
D. java.io.DataOutputStream
7_1_11（20190412430216+冯志海）
File类型中定义了什么方法来判断一个文件是否存在（D）
createNewFile
renameTo
delete
exists
7_1_12（20190412430216+冯志海）
File类型中定义了什么方法来创建一级目录（C）
createNewFile
exists
mkdirs
mkdir
7_1_13（20190412430216+冯志海）
凡是从中央处理器流向外部设备的数据流称为（D）
文件流
字符流
输入流
输出流
7_1_14（20190412430216+冯志海）
流的传递方式是（B）
A.并行的
B.串行的
C.并行和串行
D.以上都不对
7_1_15（20190412430254+许枫煜）
新建一个流对象，下面那个选项的代码是错误的？（B）
A. new BufferedWriter(new FileWriter(“a.txt”));
B. new BufferedReader (new FileInputStream(“a.dat”));
C. new GZIPOutputStream(new FileOutputStream(“a.zip”));
D. new ObjectInputStream(new FileInputStream(“a.dat”));
7_1_16（20190412430252+吴俊勋）
要从文件”file.dat”文件中读出第10个字节到变量c中，下列哪个正确（A）（选择一项）
A.FileInputStream in=new FileInputStream("file.dat");
in.skip(9);
int c=in.read();
B.FileInputStream in=new FileInputStream("file.dat");
in.skip(10);
int c=in.read();
C.FileInputStream in=new FileInputStream("file.dat");
int c=in.read();
D.RandomAccessFile in=new RandomAccessFile("file.dat");
in.skip(7);
int c=in.readByte();
10_1_1 (20190412430203+曾于桓)
下列哪个方法可用于创建一个可运行的类（）
A. Public class X implements Runnable{public int run(){......}}
B. Public class X extends Thread{public void run(){......}}
C. Public class X extends Thread{public int run(){......}}
D. Public class X implements Runnable{protected void run(){......}}
答案：B
10_1_2 (20190412430203+曾于桓)
在Java多线程中，请用下面哪种方式不会使线程进入阻塞状态（）
10_1_3 (20190412430203+曾于桓)
下列哪两个方法是Thread类的静态方法（）
A. run()和stop()
B. start()和sleep()
C. run()和start()
D. run()和sleep()
答案：C
10_1_4 (20190412430244 史寅)
3.下面的叙述中，正确的是( )。
A．同一进程内的线程可并发执行，不同进程的线程只能串行执行
B．同一进程内的线程只能串行执行，不同进程的线程可并发执行
C．同一进程或不同进程内的线程都只能串行执行
D．同一进程或不同进程内的线程都可以并发执行
答案：D
10_1_5( 20190412430237 刘燚平)
Java语言中提供了一个▁线程，自动回收动态分配的内存。D
A．异步
B．消费者
C．守护
D．垃圾收集
10_1_6 (20190412430237 刘燚平)
Java语言避免了大多数的▁错误。C
A．数组下标越界
B．算术溢出
C．内存泄露
D．非法的方法参数
10_1_7 (20190412430201 蔡创聪)
有三种原因可以导致线程不能运行，它们是▁。A B C
A．等待
B．阻塞
C．休眠
D．挂起及由于I/O操作而阻塞
10_1_8 (20190412430201 蔡创聪)
当▁方法终止时，能使线程进入死亡状态。A
A．run
B．setPrority//更改线程优先级
C．yield//暂停当前线程的执行 执行其他线程
D．sleep//线程休眠
10_1_9 (20190412430202 曾益凡)
用▁方法可以改变线程的优先级。B
A．run
B．setPrority
C．yield
D．Sleep
10_1_10 (20190412430202 曾益凡)
线程通过▁▁方法可以使具有相同优先级线程获得处理器。C
A．run
B．setPrority
C．yield
D．Sleep
10_1_11 (20190412430260 张运杰)
线程通过▁▁方法可以休眠一段时间，然后恢复运行。D
A．run
B．setPrority
C．yield
D．Sleep
10_1_12 (20190412430260 张运杰)
方法resume( )负责重新开始▁▁线程的执行。D
A．被stop( )方法停止
B．被sleep( )方法停止
C．被wait( )方法停止
D．被suspend( )方法停止
10_1_13 (20190412430260 张运杰)
▁▁方法可以用来暂时停止当前线程的运行。A
A．stop( )
B．sleep( )
C．wait( )
D．suspend( )
10_1_14(20190412430249 温悦霖)
方法resume( )负责重新开始哪个线程的执行？（ D ）
A. 被stop( )方法停止的线程
B. 被sleep( )方法停止的线程
C. 被wait( )方法停止
D. 被suspend( )方法停止
10_1_15(20190412430249 温悦霖)
下面哪个基于Unicode字符的输出流？（ B ）
A. Reader
B. Writer
C. InputStream
D. OutputStream
10_1_16(20190412430249 温悦霖)
以下锁机机制中，不能保证线程安全的是（）
A. Lock
B. Synchronized
C. Volatile
答案：C
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· AI与.NET技术实操系列：基于图像分类模型对图像进行分类
· go语言实现终端里的倒计时
· 如何编写易于单元测试的代码
· 10年+ .NET Coder 心语，封装的思维：从隐藏、稳定开始理解其本质意义
· .NET Core 中如何实现缓存的预热？
· 25岁的心里话
· 闲置电脑爆改个人服务器（超详细） #公网映射 #Vmware虚拟网络编辑器
· 零经验选手，Compose 一天开发一款小游戏！
· 通过 API 将Deepseek响应流式内容输出到前端
· AI Agent开发，如何调用三方的API Function，是通过提示词来发起调用的吗
2020-12-14 小程序微信支付申请与配置完整版操作流程