牛客网Java选择题练习

2021/1/12

1
在 main() 方法中给出数组buffer和下标i，如果将此下标中的元素显示到控制台上，需要使用（ ）。
在main中已经给出字节数组，直接System.out.print();输出即可。BC都是文件输出输入流，D是标准输入流，所以不符合题意。
正确答案: A 你的答案: A (正确)
System.out.print (buffer[i]);
FileOutputStream fout = new FileOutputStream(this.filename);
FileInputStream fin = new FileInputStream(this.filename);
System.in.read(buffer)。

2
类声明中，声明抽象类的关键字是 ( )
正确答案: B 你的答案: B (正确)
public
abstract
final
class

3
public class Test
{
static boolean foo(char c)
{
System.out.print©;
return true;
}
public static void main( String[] argv )
{
int i = 0;
for ( foo(‘A’); foo(‘B’) && (i < 2); foo(‘C’))
{
i++ ;
foo(‘D’);
}
}
}
What is the result?
考for循环的执行顺序，1.先执行初始化条件，2.执行判断条件，3.如果满足2的条件，执行循环体中代码；4.执行foo(‘c’), 5.初始化条件不在执行，友从2开始执行
正确答案: A 你的答案: A (正确)
ABDCBDCB
ABCDABCD
Compilation fails.
An exception is thrown at runtime.

4
以下代码执行的结果显示是多少（）？
public class Demo{
public static void main(String[] args){
System.out.print(getNumber(0));
System.out.print(getNumber(1));
System.out.print(getNumber(2));
System.out.print(getNumber(4));
}

public static int getNumber(int num){
    try{
        int result = 2 / num;
        return result;
    }catch (Exception exception){
        return 0;
    }finally{
        if(num == 0){
            return -1;
        }
        if(num == 1){
            return 1;
        }
    }
}

}
看错了
正确答案: B 你的答案: D (错误)
0110
-1110
0211
-1211

5
Math.round(11.5) 等于多少 (). Math.round(-11.5) 等于多少 ( ).
round函数是取最接近整数，如果遇到一样近，则取最大值。
正确答案: C 你的答案: C (正确)
11 ,-11
11 ,-12
12 ,-11
12 ,-12

6
在一个基于分布式的游戏服务器系统中，不同的服务器之间，哪种通信方式是不可行的（）？
管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。
正确答案: A 你的答案: D (错误)
管道
消息队列
高速缓存数据库
套接字

7
给出以下代码,请给出结果.

class Two{
Byte x;
}
class PassO{
public static void main(String[] args){
PassO p=new PassO();
p.start();
}
void start(){
Two t=new Two();
System.out.print(t.x+””);
Two t2=fix(t);
System.out.print(t.x+” ” +t2.x);
}
Two fix(Two tt){
tt.x=42;
return tt;
}
}
此处为Byte是byte的包装类型，初始化为null而不是0
正确答案: B 你的答案: B (正确)
null null 42
null 42 42
0 0 42
0 42 42
An exception is thrown at runtime
Compilation

8
下列不是 Java 关键字的是 （ ）

正确答案: B D 你的答案: D (错误)
abstract
false
native
sizeof

9
下面哪几个语句正确的声明一个整型的二维数组（）

1. 定义一维数组时，必须显式指明数组的长度；
2. 定义***数组时，其一维数组的长度必须首先指明，其他维数组长度可以稍后指定；
3. 采用给定值初始化数组时，不必指明长度；
4. “[]” 是数组运算符的意思，在声明一个数组时，数组运算符可以放在数据类型与变量之间，也可以放在变量之后。
   正确答案: C D 你的答案: A (错误)
   int a[][]=new int[][]
   int b[10][10]=new int[][]
   int c[][]=new int[10][10]
   int []d[]=new int[10][10]

10
下列方法中哪个是线程执行的方法？ （）
选A，start是启动线程对象，使之从新建状态转入就绪状态；sleep让线程睡眠一段时间，在此期间线程不消耗CPU资源；suspend使线程挂起，暂停执行， 如果想恢复线程，必须由其他线程调用 resume方法。
正确答案: A 你的答案: B (错误)
run（）
start（）
sleep（）
suspend（）

2021/1/13

1
下列关于修饰符混用的说法，错误的是( )
A、abstract修饰的类，不可实例化，所以需要子类去继承，然后重写其中的抽象方法。但是final修饰类是不可继承的。两者属性相冲。
B、看清楚，人家说的是不建议有，不是不能有。
C、抽象类中可以没有抽象方法，但是抽象方法必须在抽象类中或者接口中
D、static不可以修饰非static的属性，因为类加载的时候，static属性比非static先初始化，那么一个存在的总不能访问一个没有存在的吧。
正确答案: D 你的答案: A (错误)
abstract不能与final并列修饰同一个类
abstract 类中不建议有private的成员
abstract 方法必须在abstract类或接口中
static方法中能直接处理非static的属性

2
一个类中，有两个方法名、形参类型、顺序和个数都完全一样，返回值不一样的方法,这种现象叫覆盖。（ ）
运行不了，覆盖是子类和父类之间的，重载是一个类中方法的参数类型，顺序个数不同，如果全相同 就报错
正确答案: B 你的答案: B (正确)
正确
错误

3
Math.round(11.5) 等于多少 (). Math.round(-11.5) 等于多少 ( ).
正确答案: C 你的答案: C (正确)
11 ,-11
11 ,-12
12 ,-11
12 ,-12

4查看解析
以下程序的输出结果是
public class Print{
static boolean out(char c){
System.out.println©;
return true;
}
public static void main(String[] argv){
int i = 0;
for(out(‘A’);out(‘B’) && (i<2);out(‘C’)){
i++;
out(‘D’);
}
}
}

正确答案: A 你的答案: A (正确)
ABDCBDCB
BCDABCD
编译错误
运行错误

5
ResultSet中记录行的第一列索引为？
ResultSet结果集读取数据的方法主要是getXXX() ，他的参数可以使整型表示第几列（是从1开始的），还可以是列名。
正确答案: C 你的答案: B (错误)
-1
0
1
以上都不是

6
URL u =new URL(“http://www.123.com”);。如果www.123.com不存在，则返回______。
new URL()时必须捕获检查异常，但这个异常是由于字符串格式和URL不符导致的，与网址是否存在无关。URL的toString方法返回字符串，无论网址是否存在。
正确答案: A 你的答案: D (错误)
http://www.123.com
””
null
抛出异常

7
以下集合对象中哪几个是线程安全的（）
简单记忆线程安全的集合类： 喂！SHE！ 喂是指 vector，S是指 stack， H是指 hashtable，E是指：Eenumeration
正确答案: C D 你的答案: A (错误)
LinkedList
ArrayList
Vector
Hashtable

8
下列关于if-else if选择结构的说法正确的是

正确答案: B D 你的答案: A D (错误)
多个else if块之间的顺序可以改变，改变之后对程序的执行结果没有影响
多个else if块之间的顺序可以改变，改变之后可能对程序的执行结果有影响
多个else if块之间的顺序不可以改变，改变后程序编译不通过
多个else if块之间的顺序可以改变，改变后程序编译可以通过

9
java中关于继承的描述正确的是（）
答案：ACD
在java中，子类构造器会默认调用super()(无论构造器中是否写有super（）),用于初始化父类成员，同时当父类中存在有参构造器时，必须提供无参构造器，子类构造器中并不会自动继承有参构造器，仍然默认调用super()，使用无参构造器。因此，一个类想要被继承必须提供无参构造器。
PS：方法没有继承一说，只有重载和重写
正确答案: A C D 你的答案: B C D (错误)
一个子类只能继承一个父类
子类可以继承父类的构造方法
继承具有传递性
父类一般具有通用性，子类更具体

10
哪个是不正确的字符常量？
字符常量用的单引号
正确答案: A B C D 你的答案: A D (错误)
”\n”
”1”
”a”
”\101”

2021/1/14

1
在 Java 中，存放字符串常量的对象属于（ ）类对象。

正确答案: B 你的答案: B (正确)
Character
String
StringBuffer
Vector

2
以下二维数组声明合法的是（ ）
定义数组，等号左边不能出现数字，也就是数组的不管什么大小 不能出现在左边
正确答案: C 你的答案: A (错误)
char[2][3] ch = new char[][]
char[2][] ch = new char[][3]
char[][] ch = new char[2][3]
char[][] ch = new [2]char[3]

3
Java语言与其它语言相比，独有的特点是（ ）
java的“一次编写，到处运行”的跨平台性是独有的特点~
正确答案: C 你的答案: A (错误)
面向对象
多线程
平台无关
网络编程

4
以下java程序代码，执行后的结果是（）
复制代码
public class Test {
public static void main(String[] args) {
Object o = new Object() {
public boolean equals(Object obj) {
return true;
}
};
System.out.println(o.equals(“Fred”));
}
}
B: 重写了object 的equals 的方法，使他怎么输出都是tue
正确答案: B 你的答案: B (正确)
Fred
true
编译错误
运行时抛出异常

5
请问所有的异常类皆直接继承于哪一个类？（）
正确答案: C 你的答案: C (正确)
java.applet.Applet
java.lang.Throwable
java.lang.Exception
java.lang.Error

6
String str =
“”;
System.out.print(str.split(",").length);
str.split(",")方法是把str字符串根据分割符",“划分成一个字符串数组，如果str字符串中找不到分隔符”,"，则把整个str字符串放入字符串数组的第一个元素。因此str.split(",").length=1。
输出结果为：
正确答案: B 你的答案: A (错误)
0
1
出现异常

7
下面哪个方法与Applet的显示无关？
正确答案: A 你的答案: C (错误)
draw
paint
repaint
update

8
在 hibernate 开发中，关于 POJO 类对象的状态说法正确的是（）。

正确答案: A B C 你的答案: B C (错误)
自由状态（Transient）：实体在内存中自由存在，与数据库中的记录无关
持久状态（Persistent）：实体处于由Hibernate框架所管理的状态，对应了数据库中的一条记录，同时与某个session实例发生了关联
游离状态（Detached）：在session 关闭之后,可以使对象从持久状态转换到游离状态。
不能将对象从游离状态转换成持久态

9
下列说法正确的是（）
A，java是强类型语言，所有的方法必须放在类里面，包括main
B ,java中可以有多个重载的main方法，只有public static void main(String[] args){}是函数入口
C，内部类的类名一般与文件名不同
D，函数都必须用{}括起来，不管是一条语句还是多条语句
正确答案: A B 你的答案: A D (错误)
JAVA程序的main方法必须写在类里面
JAVA程序中可以有多个名字为main方法
JAVA程序中类名必须与文件名一样
JAVA程序的main方法中，如果只有一条语句，可以不用{}（大括号）括起来

10
Which statement declares a variable a which is suitable for referring to an array of 50 string objects?（Java）
在java 中，声明一个数组时，不能直接限定数组长度，只有在创建实例化对象时，才能对给定数组长度.。
如下，1，2,3可以通过编译，4，5不行。而String是Object的子类，所以上述BCF均可定义一个存放50个String类型对象的数组。

1. String a[]=new String[50];
2. String b[];
3. char c[];
4. String d[50];
5. char e[50];
   正确答案: B C F 你的答案: D (错误)
   char a[][];
   String a[];
   String[] a;
   Object a[50];
   String a[50];
   Object a[];

2021/1/16

1
针对下面的代码块,哪个equal为true:（）
1
2
3
String s1 = “xiaopeng” ;
String s2 = “xiaopeng” ;
String s3 =new String (s1);
string是final修饰的，会将创建的变量放入字符串常量池，当再创建同样的字符串时，发现常量池中有则直接使用
正确答案: A 你的答案: A (正确)
s1 == s2
s1 = s2
s2 == s3
都不正确

2
执行如下代码后输出结果为（ ）
public class Test {
public static void main(String[] args) {
System.out.println("return value of getValue(): " + getValue());
}
public static int getValue() {
int i = 1;
try {
i = 4;
} finally{
i++;
return i;
}
}
}
i=4;i++ i=5
正确答案: C 你的答案: C (正确)
return value of getValue(): 1
return value of getValue(): 4
return value of getValue(): 5
其他几项都不对

3
下面哪个标识符是合法的？
（1）标识符可以由数字、字母、下划线或美元符号等组合而成。
（2）必须以字母、下划线或者美元符号开头，不能以数字开头路。
正确答案: D 你的答案: A (错误)
“9HelloWorld”
“_Hello World”
“Hello*World”
“Hello$World”

4查看解析
Given:
//point X
public class Foo {
public static void main(String[] args) throws Exception {

    PrintWriter out = new PrintWriter(
        new java.io.OutputStreamWriter(System.out), true);
    out.printIn(“Hello”)；
}

}

Which statement at PointX on line I allows this code to compile and run?

正确答案: A 你的答案: C (错误)
import java.io.PrintWriter;
include java.io.PrintWriter;
import java.io.OutputStreamWriter;
include java.io.OutputStreamWriter;
no statement is needed.

5
下列程序test 类中的变量c 的最后结果为
public class Test {
public static void main(String args[]) {
int a = 10;
int b;
int c;
if (a > 50) {
b = 9;
}
c = b + a;
}
}
方法内定义的变量没有初始值，必须要进行初始化
正确答案: D 你的答案: D (正确)
10
0
19
编译出错

6
给出以下代码
public class TestObj{
public static void main(String[] args){
Object o=new Object(){
public boolean equals(Object obj){
return true;
}
};
System.out.println(o.equals(“Fred”));
}
}
重写了equals(),不管参数是什么，都是返回true
请给出结果：（）
正确答案: B 你的答案: B (正确)
运行时抛出异常
true
Fred
第三行编译错误

7
如果进栈序列为e1，e2，e3，e4，则可能的出栈序列是()
注：一个元素进栈后可以马上出栈，不用等全部进栈

栈的规则：先进后出

正确答案: B C 你的答案: B C (正确)
e3，e1，e4，e2
e2，e4，e3，e1
e2，e3，e4，e1
任意顺序都有可能

8
往OuterClass类的代码段中插入内部类声明, 哪一个是错误的:

public class OuterClass{
private float f=1.0f;
//插入代码到这里
}
1.静态内部类才可以声明静态方法
2.静态方法不可以使用非静态变量
3.抽象方法不可以有函数体
正确答案: A B C D 你的答案: C D (错误)
class InnerClass{
public static float func(){return f;}
}
abstract class InnerClass{
public abstract float func(){}
}
static class InnerClass{
protected static float func(){return f;}
}
public class InnerClass{
static float func(){return f;}
}

9
关于Java中的数组，下面的一些描述，哪些描述是准确的：（ ）
正确答案: A C F 你的答案: A B C D F (错误)
数组是一个对象，不同类型的数组具有不同的类
数组长度是可以动态调整的
数组是一个连续的存储结构
一个固定长度的数组可类似这样定义: int array[100]
两个数组用equals方法比较时，会逐个便利其中的元素，对每个元素进行比较
可以二维数组，且可以有多维数组，都是在Java中合法的

10
关于ThreadLocal类 以下说法正确的是

ThreadLocal继承Object，相当于没继承任何特殊的。
ThreadLocal没有实现任何接口。
ThreadLocal并不是一个Thread，而是Thread的局部变量。
正确答案: D E 你的答案: A C (错误)
ThreadLocal继承自Thread
ThreadLocal实现了Runnable接口
ThreadLocal重要作用在于多线程间的数据共享
ThreadLocal是采用哈希表的方式来为每个线程都提供一个变量的副本
ThreadLocal保证各个线程间数据安全，每个线程的数据不会被另外线程访问和破坏

2021/1/17

1
基本数据类型均可任意互相转换。
正确答案: B 你的答案: B (正确)
对
错

2
如果希望某个变量只可以被类本身访问和调用，则应该使用下列哪一种访问控制修饰？
1、public：public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用
2、private：private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可以使用。
3、protected：protected对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，protected就变成private。
正确答案: B 你的答案: C (错误)
public
private
private protected
protected

3
以下哪个命令用于查看tar（backup.tar）文件的内容而不提取它?（）

正确答案: B 你的答案: A (错误)
tar -xvf backup.tar
tar -tvf backup.tar
tar -svf backup.tar
none of these

4
下列代码执行结果为（）
public static void main(String args[])throws InterruptedException{
Thread t=new Thread(new Runnable() {
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.print(“2”);
}
});
t.start();

        t.join();
        System.out.print("1");
    }

因为子线程的休眠时间太长，因此主线程很有可能在子线程之前结束也就是输出结果是12，但是子线程用了join函数，因此主线程必须等待子线程执行完毕才结束因此输出结果只能是21
正确答案: A 你的答案: C (错误)
21
12
可能为12，也可能为21
以上答案都不对

5
关于访问权限说法正确 的是 ？ ( )
可以把局部内部类当做一个局部变量，所以它是不需要加任何修饰符的
局部内部类前不能用修饰符public和private,protected
内部类就随意了。
正确答案: B 你的答案: D (错误)
外部类前面可以修饰public,protected和private
成员内部类前面可以修饰public,protected和private
局部内部类前面可以修饰public,protected和private
以上说法都不正确

6
运行代码，输出的结果是（）
public class P {
public static int abc = 123;
static{
System.out.println(“P is init”);
}
}
public class S extends P {
static{
System.out.println(“S is init”);
}
}
public class Test {
public static void main(String[] args) {
System.out.println(S.abc);
}
}
不会初始化子类的几种

1. 调用的是父类的static方法或者字段
   2.调用的是父类的final方法或者字段
2. 通过数组来引用
   正确答案: A 你的答案: D (错误)
   P is init
   123
   S is init
   P is init
   123
   P is init
   S is init
   123
   S is init
   123

7
Java语言中，方法的重写（Overriding）和重载（Overloading）是多态性的不同表现。下边哪些说法是对的？
A C 重写(Overriding)是父类与子类之间多态性的一种表现，类的不同实现可以重写父类方法，实现同方法名，同参数，同返回类型，不同的实现。重载(Overloading)最典型的就是一个类的不同构造函数，方法名相同，参数个数不同，返回类型也可以不同，重载是一个类中多态性的一种表现。
正确答案: A C 你的答案: A C (正确)
重写是父类与子类之间多态性的一种表现
重写是一个类中多态性的一种表现
重载是一个类中多态性的一种表现
重载是父类与子类之间多态性的一种表现

8
下面哪些写法能在 java8 中编译执行（）
（1） 形参列表。形参列表允许省略形参类型。如果形参列表中只有一个参数，甚至连形参列表的圆括号也可以省略。
（2） 箭头（→）。必须通过英文中画线和大于符号组成。
（3）代码块。如果代码块只包含一条语句，Lambda表达式允许省略代码块的花括号，那么那条语句就不要用花括号表示语句结束。Lambda代码块只有一条return语句，甚至可以省略return关键字。Lambda表达式需要返回值，而它的代码块中仅有一套省略了return的语句。Lambda表达式会自动返回这条语句的值。
正确答案: A D 你的答案: B D (错误)
dir.listFiles((File f)->f.getName().endsWith(“.Java”));
dir.listFiles((File f)=>f.getName().endsWith(“.Java”));
dir.listFiles((_.getName().endsWith(“.Java”)));
dir.listFiles( f->f.getName().endsWith(“.Java”));

9
以下代码定义了一个变量，如何输出这个变量的值？
正确答案: A C D 你的答案: A D (错误)
A.<% String myBean = (String)pageContext.getAttribute(“stringBean”,PageContext.PAGE_SCOPE);
%>
<%=myBean%>
<bean:write name=“helloworld”/>
<bean:write name=“stringBean”/>
<%=stringBean%>

10
关于Java中的数组，下面的一些描述，哪些描述是准确的：（ ）
数组是一种引用数据类型 那么他肯定是继承Object类的 所以里面有equals() 方法 但是肯定没有重写过 因为他并不是比较数组内的内容
使用Arrays.equals() 是比较两个数组中的内容。
正确答案: A C F 你的答案: D E F (错误)
数组是一个对象，不同类型的数组具有不同的类
数组长度是可以动态调整的
数组是一个连续的存储结构
一个固定长度的数组可类似这样定义: int array[100]
两个数组用equals方法比较时，会逐个便利其中的元素，对每个元素进行比较
可以二维数组，且可以有多维数组，都是在Java中合法的

2021/1/18

1
java语言中的数组元素下标总是从0开始，下标可以是整数或整型表达式。（）

正确答案: A 你的答案: A (正确)
正确
错误

2
给定以下方法声明，调用执行mystery（1234）的输出结果？
//precondition: x >=0
public void mystery (int x)
{
System.out.print(x % 10);

if ((x / 10) != 0)
{
mystery(x / 10);
}
System.out.print(x % 10);
}
优先会输出1234%10=4，选B。后面不用看了
正确答案: B 你的答案: B (正确)
1441
43211234
3443
12344321

3
以下说法错误的是（）
在java中,数组是一个对象, 不是一种原生类,对象所以存放在堆中,又因为数组特性,是连续的,只有C不对
正确答案: C 你的答案: C (正确)
数组是一个对象
数组不是一种原生类
数组的大小可以任意改变
在Java中，数组存储在堆中连续内存空间里

4
ArrayList和Vector主要区别是什么
都是通过数组来实现，Vector是线程安全的，也就是说是同步的
正确答案: A 你的答案: C (错误)
Vector与ArrayList一样，也是通过数组实现的，不同的是Vector支持线程的同步
Vector与ArrayList一样，也是通过数组实现的，不同的是ArrayList支持线程的同步
Vector是通过链表结构存储数据，ArrayList是通过数组存储数据
上述说法都不正确

5
如果要建立一个java.scut.computer的包，叙述正确的是？ ( )
正确答案: A 你的答案: D (错误)
只需在代码中加入“package java.scut.computer;”一个语句，并且必须放在代码的第一行
只需在代码中加入“package java.scut;”一个语句
必须在代码中加入“package java.scut;”和“package java.scut.computer;”两个语句
在代码中，不一定是第一句，只要是类定义前，加入package语句即可

6
用户不能调用构造方法，只能通过new关键字自动调用。（）
在类内部可以用户可以使用关键字this.构造方法名()调用（参数决定调用的是本类对应的构造方法）
在子类中用户可以通过关键字super.父类构造方法名()调用（参数决定调用的是父类对应的构造方法。）
反射机制对于任意一个类，都能够知道这个类的所有属性和方法，包括类的构造方法。
正确答案: B 你的答案: B (正确)
正确
错误

7
关于抽象类与最终类，下列说法错误的是？
最终类是被final修饰的类，最终方法是被final修饰的方法。最终类不能被继承，最终方法不能被重写。
正确答案: D 你的答案: C (错误)
抽象类能被继承，最终类只能被实例化。
抽象类和最终类都可以被声明使用
抽象类中可以没有抽象方法，最终类中可以没有最终方法
抽象类和最终类被继承时，方法可以被子类覆盖

8
有时为了避免某些未识别的异常抛给更高的上层应用，在某些接口实现中我们通常需要捕获编译运行期所有的异常， catch 下述哪个类的实例才能达到目的：（）

正确答案: B 你的答案: B (正确)
Error
Exception
RuntimeException
Throwable

9
关于中间件特点的描述.不正确的是（）
中间机：是连接两个独立应用程序或独立系统的软件
正确答案: A 你的答案: A (正确)
中间件运行于客户机/服务器的操作系统内核中，提高内核运行效率
中间件应支持标准的协议和接口
中间件可运行于多种硬件和操作系统平台上
跨越网络,硬件，操作系统平台的应用或服务可通过中间件透明交互

10
以下程序段执行后将有（）个字节被写入到文件afile.txt中。
try {
FileOutputStream fos = new FileOutputStream(“afile.txt”);
DataOutputStream dos = new DataOutputStream(fos);
dos.writeInt(3);
dos.writeChar(1);
dos.close();
fos.close();
} catch (IOException e) {}
byte 1个字节
short 2个字节
int 4个字节
long 8个字节
float 4个字节
double 8个字节
char 2个字节
正确答案: C 你的答案: B (错误)
3
5
6
不确定，与软硬件环境相关

2021/1/20

1
假设 A 类有如下定义，设 a 是 A 类的一个实例，下列语句调用哪个是错误的？（）
public class A
{
public int i;

static String s;

void method1(){}

static void method2(){}
}
静态成员和静态方法，可以直接通过类名进行调用；其他的成员和方法则需要进行实例化成对象之后，通过对象来调用。
正确答案: C 你的答案: A (错误)
System.out.println(a.i);
a.method1();
A.method1();
A.method2();

2
在为传统面向对象语言的程序做单元测试的时候,经常用到mock对象。Mock对象通过反射数。请问反射最大程度破坏了面向对象的以下哪个特性？
反射破坏代码的封装性，破坏原有的访问修饰符访问限制
正确答案: A 你的答案: C (错误)
封装
多态
继承
抽象

3
类 ABC 定义如下：

1 ． public class ABC{

2 ． public double max( double a, double b) { }

3 ．

4 ． }

将以下哪个方法插入行 3 是不合法的。（）

正确答案: B 你的答案: C (错误)
public float max(float a, float b, float c){ }
public double max (double c, double d){ }
public float max(float a, float b){ }
private int max(int a, int b, int c){ }

4
假设有以下代码String s = “hello”；String t = “hello”；char c [ ] = {‘h’,‘e’,‘l’,‘l’,‘o’}；下列选项中返回false的语句是？
equals强调对象的内容比较
正确答案: B 你的答案: B (正确)
s.equals (t)；
t.equals ©；
s==t；
t.equals (new String (“hello”))；

5
java语言中，按照一定格式生成程序的文档的工具是？
jar 将许多文件组合成一个jar文件
javac 编译
javadoc 它从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档。
javah 把java代码声明的JNI方法转化成C\C++头文件。 JNI可参考java核心技术卷二第12章
正确答案: C 你的答案: A (错误)
javac
javah
javadoc
jar

6
以下程序的运行结果是：( )
TreeSet set = new TreeSet();
TreeSet subSet = new TreeSet();
for(int i=606;i<613;i++){
if(i%2==0){
set.add(i);
}
}
subSet = (TreeSet)set.subSet(608,true,611,true);
set.add(629);
System.out.println(set+" "+subSet);

正确答案: C 你的答案: C (正确)
编译失败
发生运行时异常
[606, 608, 610, 612, 629] [608, 610]
[606, 608, 610, 612, 629] [608, 610,629]

7
以下代码段执行后的输出结果为
public class Test {
public static void main(String args[]) {
int x = -5;
int y = -12;
System.out.println(y % x);
}
}
无论是正数还是负数，在取余运算时都有：被除数=商×除数+余数，所以-12=2×(-5)+(-2)，-12是被除数，-5是除数，2是商，余数是-2。
正确答案: D 你的答案: D (正确)
-1
2
1
-2

8
下面叙述那个是正确的？（）
D.子类可以访问父类受保护的成员
正确答案: B 你的答案: D (错误)
java中的集合类（如Vector）可以用来存储任何类型的对象，且大小可以自动调整。但需要事先知道所存储对象的类型，才能正常使用。
在java中，我们可以用违例（Exception）来抛出一些并非错误的消息，但这样比直接从函数返回一个结果要更大的系统开销。
java接口包含函数声明和变量声明。
java中，子类不可以访问父类的私有成员和受保护的成员。

9
Which method you define as the starting point of new thread in a class from which n thread can be execution?

我的翻译：下面哪一个是你类中定义可以作为新线程的起始点，直到线程n被执行完毕的方法 ？
其实就是在问，线程执行的入口，start()是启动该线程的方法，是启动的动作
继承Thead,重写run方法或者实现Runable接口，实现run方法，run方法就是线程执行的入口
正确答案: B 你的答案: D (错误)
public void start()
public void run()
public void int()
public static void main(String args[])
public void runnable()

10
有关finally语句块说法正确的是（ ）
正确答案: A B C 你的答案: A C (错误)
不管catch是否捕获异常，finally语句块都是要被执行的
在try语句块或catch语句块中执行到System.exit(0)直接退出程序
finally块中的return语句会覆盖try块中的return返回
finally 语句块在 catch语句块中的return语句之前执行

2021/1/21

1
Java Application(Java 应用程序)源程序文件编译后的字节码文件的扩展名是( )。
A：源代码文件的扩展名
B：字节码文件的扩展名
C：java可以编写成.exe,虽然是exe文件，但是不代表是windows可执行文件，尽管扩展名一样
D：java真正运行包
正确答案: B 你的答案: B (正确)
java
class
exe
jar

2
分析以下代码，说法正确的是（）
public static void main(String[] args) {
System.out.println(val());
}

public static int val() {
int num = 5;
try {
num = num / 0;
} catch (Exception e) {
num = 10;
} finally {
num = 15;
}
return num;
}
无论有无异常，finally块中的代码一定会执行且在最后执行，因此num输出为15
正确答案: D 你的答案: D (正确)
运行时报错
程序正常运行，输出值为5
程序正常运行，输出值为10
程序正常运行，输出值为15

3
指出下来程序运行的结果是

正确答案: B 你的答案: D (错误)
good and abc
good and gbc
tst ok and abc
tst ok and gbc

4
下列程序执行后输出结果为（ ）
class BaseClass {
public BaseClass() {}
{
System.out.println(“I’m BaseClass class”);
}
static {
System.out.println(“static BaseClass”);
}
}
public class Base extends BaseClass {
public Base() {}
{
System.out.println(“I’m Base class”);
}
static {
System.out.println(“static Base”);
}
public static void main(String[] args) {
new Base();
}
}
父类静态代码块 ->子类静态代码块 ->父类非静态代码块 -> 父类构造函数 -> 子类非静态代码块 -> 子类构造函数。
正确答案: D 你的答案: B (错误)
static BaseClass
I’m BaseClass class
static Base
I’m Base class
I’m BaseClass class
I’m Base class
static BaseClass
static Base
I’m BaseClass class
static BaseClass
I’m Base class
static Base
static BaseClass
static Base
I’m BaseClass class
I’m Base class

5

以下哪个不属于JVM堆内存中的区域（）？
jvm堆分为：新生代（一般是一个Eden区，两个Survivor区），老年代（old区）。
常量池属于 PermGen（方法区）
正确答案: B 你的答案: B (正确)
survivor区
常量池
eden区
old区

6
根据以下代码段，下列说法中正确的是( )。

public class Parent {
private void m1(){}
void m2(){}
protected void m3(){}
public static void m4(){}
}
通过继承，子类可以拥有所有父类对其可见的方法和域
A.私有方法只能在本类中可见，故不能继承，A错误
B.缺省访问修饰符只在本包中可见，在外包中不可见，B错误
C.保护修饰符凡是继承自该类的子类都能访问，当然可被继承覆盖；C正确
D.static修饰的成员属于类成员，父类字段或方法只能被子类同名字段或方法遮蔽，不能被继承覆盖，D错误
正确答案: C 你的答案: C (正确)
子类中一定能够继承和覆盖Parent类的m1方法
子类中一定能够继承和覆盖Parent类的m2方法
子类中一定能够继承和覆盖Parent类的m3方法
子类中一定能够继承和覆盖Parent类的m4方法

7
以下哪些方法是Object类中的方法
正确答案: A B C D 你的答案: C (错误)
clone()
toString()
wait()
finalize()

8
下面代码在main()方法中第八行后可以正常使用的是（ ）
public class Test
{
private int a=10;
int b=20;
static int c=1;
public static void main(String arg[])
{
Test t = new Test();
}
}
t.a是Test实例对自己属性的访问，又因为这是在Test类内部，所以可以对private修饰的属性就行访问；Test.c是因为属性c是静态变量，可以直接通过类名访问
正确答案: A D 你的答案: A (错误)
t.a
this.c
Test.b
Test.c

10

关于struts项目中的类与MVC模式的对应关系，说法错误的是
Model： MVC系统中的Model部分从概念上可以分为两类――系统的内部状态，和改变系统状态的动作。Struts为Model部分提供了Action和ActionForm对象：所有的Action处理器对象都是开发者从Struts的Action类派生的子类。Action处理器对象封装了具体的处理逻辑，调用业务逻辑模块，并且把响应提交到合适的View组件以产生响应。Struts提供的ActionForm组件对象，它可以通过定义属性描述客户端表单数据。开发者可以从它派生子类对象，利用它和Struts提供的自定义标记库结合可以实现对客户端的表单数据的良好封装和支持，Action处理器对象可以直接对它进行读写，而不再需要和request、response对象进行数据交互。通过ActionForm组件对象实现了对View和Model之间交互的支持。Struts通常建议使用一组JavaBean表示系统的内部状态，根据系统的复杂度也可以使用像Entity EJB 和 Session EJB等组件来实现系统状态。Struts建议在实现时把"做什么"（Action）和"如何做"（业务逻辑）分离。这样可以实现业务逻辑的重用。
正确答案: C D 你的答案: B D (错误)
Jsp文件实现视图View的功能
ActionServlet这一个类是整个struts项目的控制器
ActionForm、Action都属于Model部分
一个struts项目只能有一个Servlet

2021/1/22

1
有以下代码片段：
String str1=“hello”;
String str2=“he”+ new String(“llo”);
System.out.println(str1==str2);
请问输出的结果是：
String str1=“hello”; 这样创建字符串是存在于常量池中
String str2=new String(“hello”); str2存在于堆中，
==是验证两个对象是否是一个（内存地址是否相同）
用+拼接字符串时会创建一个新对象再返回。
正确答案: D 你的答案: A (错误)
true
都不对
null
false

2
关于final说法正确的是？ ( )
final变量，如果是基本数据类型，则其数值一旦初始化后就不能被改变。如果是引用类型的变量，则对其初始化后，便不能再指向另一个对象，但是其里面的值是可以改变的。引用变量所指向的对象中的内容是可以改变的。
正确答案: B 你的答案: D (错误)
final类的方法肯定不能被同一个包的类访问
final类的方法能否被同一个包的类访问不是由final决定
final方法等同于private方法
final对象本身的引用和值都不能改变

3
下面程序的运行结果是：（ ）
public static void main(String args[]) {
Thread t = new Thread() {
public void run() {
pong();
}
};
t.run();
System.out.print(“ping”);

}

static void pong() {
  System.out.print("pong");

}
}
t.run是调用的Thead类中的run()方法，t.start才是执行线程，所以这题就是执行普通run()方法，先输出pong，在输出ping。
正确答案: B 你的答案: B (正确)
pingpong
pongping
pingpong和pongping都有可能
都不输出
pong
ping

4
下列代码的输出结果是_____
1
2
boolean b=true?false:true==true?false:true;
System.out.println(b);
是两个三目运算符，==优先级高于三目运算符
正确答案: B 你的答案: C (错误)
true
false
null
空字符串

5
有以下一个对象：

public class DataObject implements Serializable{
private static int i=0;
private String word=" ";
public void setWord(String word){
this.word=word;
}
public void setI(int i){
Data0bject. i=I;
}
}
创建一个如下方式的DataObject:
1
2
3
DataObject object=new Data0bject ( );
object. setWord(“123”);
object. setI(2);
将此对象序列化为文件，并在另外一个JVM中读取文件，进行反序列化，请问此时读出的Data0bject对象中的word和i的值分别为：
Java在序列化时不会实例化static变量和transient修饰的变量，因为static代表类的成员，transient代表对象的临时数据，被声明这两种类型的数据成员不能被序列化。D
正确答案: D 你的答案: B (错误)
“”, 0
“”, 2
“123”, 2
“123”, 0

6
public void test() {
int a = 10;
System.out.println(a++ + a–);
}
最后输出什么？
a++ 先把10赋值给a 再+1 所以左边是10 但此时a=11。右边a-- 也是先赋值 a=11，再-1。10+11=21 此时a=10。
正确答案: C 你的答案: C (正确)
19
20
21
22

7
正则表达式中，表示匹配非数字字符的字符是（）？
正确答案: D 你的答案: B (错误)
\b
\d
\B
\D

8
以下代码的运行结果是什么( )
class Supper{
public int get()
{
System.out.println(“Supper”);
return 5;
}
}
public class Sub{
public int get()
{
System.out.println(“Sub”);
return new Integer(“5”); }
public static void main(String args[]) {
new Supper().get();
new Sub().get(); }
}
newSupper().get()和newSub().get()只调用了get()方法，又没有打印输出get()返回的数值，所以肯定没有5
正确答案: A 你的答案: C (错误)
Supper Sub
Supper 5 Sub
Supper 5 5 Sub
Supper Sub 5 5

9

下列选项中是正确的方法声明的是？（）
（1）对于public修饰符，它具有最大的访问权限，可以访问任何一个在CLASSPATH下的类、接口、异常等。它往往用于对外的情况，也就是对象或类对外的一种接口的形式。

（2）对于protected修饰符，它主要的作用就是用来保护子类的。它的含义在于子类可以用它修饰的成员，其他的不可以，它相当于传递给子类的一种继承的东西。

（3）对于default来说，有点的时候也成为friendly（友员），它是针对本包访问而设计的，任何处于本包下的类、接口、异常等，都可以相互访问，即使是父类没有用protected修饰的成员也可以。

（4）对于private来说，它的访问权限仅限于类的内部，是一种封装的体现，例如，大多数的成员变量都是修饰符为private的，它们不希望被其他任何外部的类访问。
正确答案: A B C D 你的答案: A D (错误)
protected abstract void f1();
public final void f1() {}
static final void fq(){}
private void f1() {}

10
JDK1.7版本之前，接口和抽象类描述正确的有（ ）
JDK1.8后，接口中可以有静态方法，静态方法必须有方法体
正确答案: B C 你的答案: A D (错误)
抽象类没有构造函数。
接口没有构造函数。
抽象类不允许多继承。
接口中的方法可以有方法体。

2021/1/24

1
编译java程序的命令文件是( )
javac.exe是编译功能javaCompiler
java.exe是执行程序，用于执行编译好的.class文件
javadoc.exe用来制作java文档
jdb.exe是java的调试器
javaprof.exe是剖析工具
正确答案: B 你的答案: A (错误)
java.exe
javac.exe
applet.exe

2
在 Applet 中，方法执行的顺序是 ?（ ）

正确答案: A 你的答案: A (正确)
init(), start(), paint(),stop(),destroy().
init(),paint(),start(),stop(),destroy().
paint(),start(),stop(),destroy().
init(), start(),stop(),destroy(),paint().

3
在异常处理中，以下描述不正确的有
。用try-catch 捕获异常;
。用try-finally 清除异常;
。用try-catch-finally 处理所有的异常. 三者选一种即可
正确答案: D 你的答案: C (错误)
try块不可以省略
可以使用多重catch块
finally块可以省略
catch块和finally块可以同时省略

4
请问以下代码运行结果是：
结果为try catch finally,运行过程如下： 在执行到try代码块中，首先输出try，然后抛出异常，直接跳转到catch中，输出catch，然后跳转到finally块中，输出finally。
正确答案: D 你的答案: C (错误)
try catch
try finally catch
try finally
try catch finally

5
枚举（enum）属于原始数据类型（primitive type）。
枚举类是一种特殊对的类，既然是类。那他就不是原始数据类型了
正确答案: B 你的答案: A (错误)
正确
错误

6
下面哪种情况会导致持久区jvm堆内存溢出？
正确答案: C 你的答案: D (错误)
循环上万次的字符串处理
在一段代码内申请上百M甚至上G的内存
使用CGLib技术直接操作字节码运行，生成大量的动态类
不断创建对象

7
下面程序的运行结果（）
Object obj=new Object();
List aList=new ArrayList();
List bList=new LinkedList();

    long t1=System.currentTimeMillis();
    for(int i=0;i<50000;i++){
        aList.add(0,obj);
    }
    long t2=System.currentTimeMillis()-t1;
     
    t1=System.currentTimeMillis();
    for(int i=0;i<50000;i++){
        bList.add(0,obj);
    }
    long t3=System.currentTimeMillis()-t1; 

ArrayList内部是动态数组实现，在增加空间时会复制全部数据到新的容量大一些的数组中。而LinkedList内部为双向链表，可以按需分配空间，扩展容量简单，因此LinkedList用时少。
正确答案: D 你的答案: 空 (错误)
t2
t2=t3
不确定
t2>t3

8
关于 访问权限说法正确 的是 ？ ( )

正确答案: D 你的答案: B (错误)
外部类定义前面可以修饰public,protected和private
局部内部类前面可以修饰public,protected和private
匿名内部类前面可以修饰public,protected和private
以上说法都不正确

9
int，String，*point，union哪些不是 Java 的数据类型？
正确答案: C D 你的答案: C (错误)
int
String
*point
union

10
下面关于变量及其范围的陈述哪些是不正确的（）
正确答案: B C 你的答案: A C (错误)
实例变量是类的成员变量
实例变量用关键字static声明
在方法中定义的局部变量在该方法被执行时创建
局部变量在使用前必须被初始化

2021/1/25

1
下列类定义中哪些是合法的抽象类的定义？（）
首先，类的修饰符，都应该在class关键字之前，AB错；抽象方法不能有方法体，D错。
正确答案: C 你的答案: C (正确)
abstract Animal{abstract void growl();}
class abstract Animal{abstract void growl();}
abstract class Animal{abstract void growl();}
abstract class Animal{abstract void growl(){System.out.println( “growl”);};}

2
如下Java语句 double x=2.0; int y=4; x/=++y; 执行后，x的值是（）
++y 是先加再运行
y++ 是先运算再加
正确答案: C 你的答案: C (正确)
0.5
2.5
0.4
2.0

3
在 Java 中，属于整数类型变量的是（）
1：整数类型 byte short int long （int是整形，也属于整数类型）
2：浮点型 float double
3：逻辑型 boolean(它只有两个值可取true false)
4：字符型 char string
正确答案: C 你的答案: C (正确)
single
double
byte
char

4
若有定义语句： int a=10 ; double b=3.14 ; 则表达式 ‘A’+a+b 值的类型是（）
char < short < int < float < double 不同类型运算结果类型向右边靠齐。
正确答案: C 你的答案: C (正确)
char
int
double
float

5查看解析
String str1 = “abc”，“abc”分配在内存哪个区域？
栈：存放基本类型的数据和对象的引用，但对象本身不存放在栈中，而是存放在堆中
堆：存放用new产生的数据
静态域：存放在对象中用static定义的静态成员
常量池：存放常量
非RAM存储：硬盘等永久存储空间
正确答案: C 你的答案: B (错误)
堆
栈
字符串常量区
寄存器

6
对于非运行时异常，程序中一般可不做处理，由java虚拟机自动进行处理。
运行异常，可以通过java虚拟机来自行处理。非运行异常，我们应该捕获或者抛出
正确答案: B 你的答案: A (错误)
正确
错误

7
ServletConfig接口默认是哪里实现的？
正确答案: B 你的答案: C (错误)
Servlet
GenericServlet
HttpServlet
用户自定义servlet
GenericServlet类的实现接口中包括了ServletConfig接口，但是它自身的init(ServletConfig config)方法又需要外界给它传递一个实现ServletConfig的对象，就是说GenericServlet和ServletConfig的依赖关系既是继承关系，也是一种关联关系。

8查看解析
阅读如下代码。 请问，对语句行 test.hello(). 描述正确的有（）
package NowCoder;
class Test {
public static void hello() {
System.out.println(“hello”);
}
}
public class MyApplication {
public static void main(String[] args) {
// TODO Auto-generated method stub
Test test=null;
test.hello();
}
}

正确答案: A 你的答案: D (错误)
能编译通过，并正确运行
因为使用了未初始化的变量，所以不能编译通过
以错误的方式访问了静态方法
能编译通过，但因变量为null，不能正常运行

9
You have the following code.Which numbers will cause “Test2” to be printed?
switch (x)
{
case 1: System.out.println(“Test1”);
case 2:
case 3:
System.out.println(“Test2”);
break;
default:
System.out.println(“Test3”);
break;
}
正确答案: B C D 你的答案: B C D (正确)
0
1
2
3
4

10
在你面前有一个n阶的楼梯，你一步只能上1阶或2阶。请问，当N=11时，你可以采用多少种不同的方式爬完这个楼梯（）；当N=9时呢？
正确答案: B C 你的答案: B (错误)
11
144
55
89

2021/1/26

1
下列说法哪个正确( )
没有模板，怎么可能创建对象，创建对象必须先要定义类，常识
对象中的数据域和方法取决于该对象的类，类里面有就有，没有就没有
数据域不一定是基本类型，也可以是引用类型
正确答案: C 你的答案: C (正确)
不需要定义类，就能创建对象
对象中必须有数据域和方法
数据域可以是基本类型变量，也可以是一个对象
数据域必须是基本类型变量

2查看解析
定义：String s1 = “uml”; String s2 = “uml”; String s3= new String(“uml”); String s4= new String(“uml”);那么，s1==s2；s3 == s4；s1.equals(s3); 判断正确与否
正确答案: A 你的答案: A (正确)
T，F，T
F，T，F

==：比较两个引用的地址和值
equals：比较两个引用的值

3
正则表达式语法中 \d 匹配的是？（）
\d 匹配一个数字字符。等价于 [0-9]。
\D 匹配一个非数字字符。等价于 [^0-9]。
\f 匹配一个换页符。等价于 \x0c 和 \cL。
\n 匹配一个换行符。等价于 \x0a 和 \cJ。
\r 匹配一个回车符。等价于 \x0d 和 \cM。
\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t 匹配一个制表符。等价于 \x09 和 \cI。
\v 匹配一个垂直制表符。等价于 \x0b 和 \cK。
\w 匹配字母、数字、下划线。等价于’[A-Za-z0-9_]’。
\W 匹配非字母、数字、下划线。等价于 ‘[^A-Za-z0-9_]’。
正确答案: A 你的答案: B (错误)
数字
非数字
字母
空白字符

4
下列说法正确的是( )
关键字volatile是线程同步的轻量级实现，所以volatile性能肯定比synchronized要好，并且只能修改变量，而synchronized可以修饰方法，以及代码块。
多线程访问volatile不会发生阻塞，而synchronized会出现阻塞
volatile能保证数据的可见性，但不能保证原子性；而synchronized可以保证原子性，也可以间接保证可见性，因为它会将私有内存和公共内存中的数据做同步
关键字volatile解决的下变量在多线程之间的可见性；而synchronized解决的是多线程之间资源同步问题
正确答案: C 你的答案: D (错误)
volatile,synchronized
都可以修改变量，方法以及代码块
volatile，synchronized 在多线程中都会存在阻塞问题
volatile能保证数据的可见性，但不能完全保证数据的原子性，synchronized即保证了数据的可见性也保证了原子性
volatile解决的是变量在多个线程之间的可见性、原子性，而sychroized解决的是多个线程之间访问资源的同步性

5查看解析
下列描述中，错误的是
因为引用代表引用的是实际的对象，对引用的修改就是对对象的修改，可以理解为两把钥匙可以打开同一扇门，所以C错；其他几个选项都是对的
正确答案: C 你的答案: B (错误)
SQL语言又称为结构化查询语言
java中”static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问
面向对象开发中，引用传递意味着传递的并不是实际的对象，而是对象的引用，因此，外部对引用对象所做的改变不会反映到所引用的对象上
java是强类型语言，javascript是弱类型语言
面向对象的三大特性包括：封装，继承，多态

6查看解析
public class contained in a Java program file must have the same name as the file, except for the extension “.java”.
正确答案: A 你的答案: A (正确)
FALSE
TRUE

7查看解析
下面哪一项不属于优化Hibernate所鼓励的？
正确答案: A 你的答案: B (错误)
使用单向一对多关联，不使用双向一对多
不用一对一，用多对一取代
配置对象缓存，不使用集合缓存
继承类使用显式多态

优化Hibernate所鼓励的7大措施：
1.尽量使用many-to-one，避免使用单项one-to-many
2.灵活使用单向one-to-many
3.不用一对一，使用多对一代替一对一
4.配置对象缓存，不使用集合缓存
5.一对多使用Bag 多对一使用Set
6.继承使用显示多态 HQL:from object polymorphism=“exlicit” 避免查处所有对象
7.消除大表，使用二级缓存

8
package Wangyi;
class Base
{
public void method()
{
System.out.println(“Base”);
}
}
class Son extends Base
{
public void method()
{
System.out.println(“Son”);
}

public void methodB()
{
    System.out.println("SonB");
}

}
public class Test01
{
public static void main(String[] args)
{
Base base = new Son();
base.method();
base.methodB();
}
}
问这个程序的输出结果。
这句new 了一个派生类，赋值给基类，所以下面的操作编译器认为base对象就是Base类型的
Base类中不存在methodB()方法，所以编译不通过
编译看左边，运行看右边。意思编译时候，看左边有没有该方法，运行的时候结果看 new 的对象是谁，就调用的谁。
正确答案: D 你的答案: B (错误)
Base SonB
Son SonB
Base Son SonB
编译不通过

9查看解析
以下关于对象序列化描述正确的是
正确答案: C D 你的答案: C (错误)
使用FileOutputStream可以将对象进行传输
使用PrintWriter可以将对象进行传输
使用transient修饰的变量不会被序列化
对象序列化的所属类需要实现Serializable接口

10
下面程序输出结果为（）：
public class Demo{
public static void main (String [] args) {
String lx = “LeXin”;
String nb = lx;
lx = “Fenqile”;
System.out.println(nb);
}
}
正确答案: B C 你的答案: D (错误)
程序异常，编译不通过
程序编写正常，可正常运行
程序输出值为“LeXin”
程序输出值为“Fenqile”

2021/1/28

1
只有实现了()接口的类，其对象才能序列化。
Serializable要实现序列化对象必须要实现的接口
正确答案: A 你的答案: C (错误)
Serializable
Cloneable
Comparable
Writeable

2
以下代码的输出的正确结果是
public class Test {
public static void main(String args[]) {
String s = “祝你考出好成绩！”;
System.out.println(s.length());
}
}

正确答案: D 你的答案: D (正确)
24
16
15
8

3
下面关于JAVA的垃圾回收机制，正确的是（ ）
java提供了一个系统级的线程，即垃圾回收器线程。用来对每一个分配出去的内存空间进行跟踪。当JVM空闲时，自动回收每块可能被回收的内存，GC是完全自动的，不能被强制执行。程序员最多只能用System.gc()来建议执行垃圾回收器回收内存，但是具体的回收时间，是不可知的。
正确答案: B 你的答案: D (错误)
当调用“System.gc()”来强制回收时，系统会立即回收垃圾
垃圾回收不能确定具体的回收时间
程序可明确地标识某个局部变量的引用不再被使用
程序可以显式地立即释放对象占有的内存

4
有如下代码：请写出程序的输出结果。
public class Test
{
public static void main(String[] args)
{
int x = 0;
int y = 0;
int k = 0;
for (int z = 0; z < 5; z++) {
if ((++x > 2) && (++y > 2) && (k++ > 2))
{
x++;
++y;
k++;
}
}
System.out.println(x + ”” +y + ”” +k);
}
}
&&当前面为假时，后面就不再执行了，&前面为假，后面还要执行
正确答案: B 你的答案: A (错误)
432
531
421
523

5
以下程序的运行结果是？
线程的启动方式只能通过start这种方式启动才能真正的实现多线程的效果，如果是手动调用run方法和普通方法调用没有区别，所以这个还是按照顺序执行首先执行run方法之后，执行输出语句所以最终得到结果foobar.
正确答案: A 你的答案: C (错误)
foobar
barfoo
foobar或者barfoo都有可能
Bar
Foo
程序无法正常运行

6
以下JAVA程序代码的输出是
public static void main(String args[]) {
System.out.println(17^5);
}
位异运算符号。
运算规则是：两个数转为二进制，然后从高位开始比较，如果相同则为0，不相同则为1。
17：0001 0001
5： 0000 0101
结果：0001 0100 转10进制：20
正确答案: C 你的答案: D (错误)
12
22
20
1419857

8
下列哪个是合法的 Java 标识符？（ ）
记住标识符只有英文，数字，下划线和$，而且数字不能做开头~
正确答案: B C 你的答案: A B C (错误)
Tree&Glasses
FirstJavaApplet
First_Applet
273.5

9查看解析
java中Hashtable, Vector, TreeSet, LinkedList哪些线程是安全的？
HashMap是线程安全的HashMap
Vector是线程安全的ArrayList
TreeSet和LinkedList都不是线程安全的
正确答案: A B 你的答案: B D (错误)
Hashtable
Vector
TreeSet
LinkedList

10
下面的switch语句中，x可以是哪些类型的数据：()
switch(x)
{
default:
System.out.println(“Hello”);
}
正确答案: B D 你的答案: A B C D E (错误)
long
char
float
byte
double
Object

2021/1/29

1查看解析
下列哪个类的声明是正确的？
只能有final和abstract的一个，因为final是最终类，不能继承，必须可以创建实例，而abstract是抽象类，只能继承，不有实例
正确答案: D 你的答案: D (正确)
abstract final class HI{}
abstract private move(){}
protected private number;
public abstract class Car{}

2查看解析
在异常处理中，如释放资源，关闭数据库、关闭文件应由（ ）语句来完成。
try:可能发生异常的语句
catch:捕获，并处理异常（printStackTrace()用来跟踪异常事件发生时执行堆栈的内容）
throw:方法内部抛异常
throws:声明方法异常
finaly：代码中无论是否有异常都会执行，清除资源
正确答案: C 你的答案: C (正确)
try子句
catch子句
finally子句
throw子句

3
下列代码的执行结果是：（ ）
public class Test3{
public static void main(String args[]){
System.out.println(100%3);
System.out.println(100%3.0);
}
}

正确答案: B 你的答案: B (正确)
1和1
1和1.0
1.0和1
1.0和1.0

4
指出下列程序运行的结果：
public class Example{
String str=new String(“tarena”);
char[]ch={‘a’,‘b’,‘c’};
public static void main(String args[]){
Example ex=new Example();
ex.change(ex.str,ex.ch);
System.out.print(ex.str+" and ");
System.out.print(ex.ch);
}
public void change(String str,char ch[]){
//引用类型变量，传递的是地址，属于引用传递。
str=“test ok”;
ch[0]=‘g’;
}
}

正确答案: B 你的答案: D (错误)
tarena and abc
tarena and gbc
test ok and abc
test ok and gbc

5
命令javac-d参数的用途是？（）
-d destination 目的地
-s source 起源地
javac -d 指定放置生成的类文件的位置
javac -s 指定放置生成的源文件的位置
正确答案: A 你的答案: B (错误)
指定编译后类层次的根目录
指定编译时需要依赖类的路径
指定编译时的编码
没有这一个参数

6查看解析
What will be printed when you execute the following code?
class C {
C() {
System.out.print(“C”);
}
}

class A {
C c = new C();

A() {
    this("A");
    System.out.print("A");
}

A(String s) {
    System.out.print(s);
}

}

class Test extends A {
Test() {
super(“B”);
System.out.print(“B”);
}

public static void main(String[] args) {
    new Test();
}

}
首先new了一个子类对象，那么就要调用构造方法来初始化该子类对象，但是该类继承自A，所以要先调用父类的构造方法，这里通过super(“B”)显示的调用了父类的带参构造。执行父类的带参构造前要先对父类中的对象进行初始化，对父类中的c成员进行初始化，调用了C类的无参构造，所以调用顺序为：
先调用C类的无参构造
再调用A类的带参构造
最后调用调用子类的构造
正确答案: B 你的答案: A (错误)
BB
CBB
BAB
None of the above

7查看解析
在Web应用程序中，( )负责将HTTP请求转换为HttpServletRequest对象
Apache就是一个Http服务器，Tomcat是一个web容器，静态的htmlApache还可以处理，但是动态的需要转发给Tomcat去处理了，比如jsp页面，请求先经由Apache转发给Tomcat再由Tomcat解析请求。所以应该是web容器去解析成request对象。
正确答案: C 你的答案: B (错误)
Servlet对象
HTTP服务器
Web容器
JSP网页

8
下列关于包（package）的描述，正确的是（）

正确答案: D 你的答案: B (错误)
包（package）是Java中描述操作系统对多个源代码文件组织的一种方式。
import语句将所对应的Java源文件拷贝到此处执行。
包（package）是Eclipse组织Java项目特有的一种方式。
定义在同一个包（package）内的类可以不经过import而直接相互使用。

外部类只能被public、abstract、final、（default）修饰
private修饰类的话只能修饰内部类
内部类可以被public、abstract、final、（default）、private修饰
内部类是外部类的一个成员，所以可以访问外部类的私有属性
5.同包无需导入即可使用，因为外部类不会是private的

9
以下代码段执行后的输出结果为
public class Test {
public static void main(String args[]) {
int i = -5;
i = ++(i++);
System.out.println(i);
}
}
这题编译错误在于这一句： i = ++(i++);
++（ ） 括号里面必须是一个变量，而 i ++ 是一个字面量。

正确答案: C 你的答案: B (错误)
-7
-3
编译错误
-5

10
以下哪些内存区域属于JVM规范？（　　）
JVM内存区：程序计数器、虚拟机栈、本地方法栈、堆、方法区（包括常量池）。
不属于JVM内存区：直接内存（Direct Memory），用户I/O操作
正确答案: A D E 你的答案: A B C E (错误)
方法区
实例变量
静态变量
程序计数器
虚拟机栈

2021/1/31

1
设Tree为已定义的类名，下列语句能正确创建 Tree 对象的是 。
正确答案: B 你的答案: B (正确)
Tree t=new Tree;
Tree t=new Tree();
Tree t=Tree();
Tree t[ ]=new Tree[10];

2
Continue语句跳出整个循环.
正确答案: B 你的答案: B (正确)
正确
错误

3
在Java中，什么是Garbage Collection?（）

正确答案: C 你的答案: A (错误)
自动删除在程序中导入但未使用的任何包
JVM检查任何Java程序的输出并删除任何没有意义的东西
当对象的所有引用都消失后，对象使用的内存将自动回收
操作系统定期删除系统上可用的所有java文件

4
下面代码的执行结果是 :
class Chinese{
private static Chinese objref =new Chinese();
private Chinese(){}
public static Chinese getInstance() { return objref; }
}

public class TestChinese {
public static void main(String [] args) {
Chinese obj1 = Chinese.getInstance();
Chinese obj2 = Chinese.getInstance();
System.out.println(obj1 == obj2);
}
}
正确答案: A 你的答案: A (正确)
true
false
TRUE
FALSE

5
下列关于异常处理的描述中，错误的是()。

正确答案: D 你的答案: B (错误)
程序运行时异常由Java虚拟机自动进行处理
使用try-catch-finally语句捕获异常
可使用throw语句抛出异常
捕获到的异常只能在当前方法中处理，不能在其他方法中处理

6
顺序执行下列程序语句后，则b的值是（）
String a=“Hello”;
String b=a.substring(0,2);

正确答案: C 你的答案: B (错误)
Hello
Hel
He
null

substring 方法将返回一个包含从 start 到最后（不包含 end ）的子字符串的字符串。

7
下面字段声明中哪一个在interface主体内是合法的? （）

正确答案: B 你的答案: D (错误)
private final static int answer = 42;
public static int answer = 42;
final static answer = 42;
int answer;

在接口中，属性都是默认public static final修饰的，所以：
A（错误）：不能用private修饰；
B（正确）：在接口中，属性默认public static final，这三个关键字可以省略；
C（错误）：没写属性的类型；
D（错误）：final修饰的属性必须赋值；

8查看解析
下面哪个不对？
正确答案: C 你的答案: B (错误)
RuntimeException is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.
A method is not required to declare in its throws clause any subclasses of RuntimeExeption that might be thrown during the execution of the method but not caught
An RuntimeException is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch.
NullPointerException is one kind of RuntimeException

9查看解析
在JAVA中，假设A有构造方法A(int a)，则在类A的其他构造方法中调用该构造方法和语句格式应该为（）

正确答案: B 你的答案: C (错误)
this.A(x)
this(x)
super(x)
A(x)

A.这是调用普通方法的写法
C.这时显示调用父类构造方法
D.调用静态方法

10
下列哪些操作会使线程释放锁资源？
正确答案: B C 你的答案: D (错误)
sleep()
wait()
join()
yield()

1.sleep()方法
在指定时间内让当前正在执行的线程暂停执行，但不会释放“锁标志”。不推荐使用。
sleep()使当前线程进入阻塞状态，在指定时间内不会执行。
2.wait()方法
在其他线程调用对象的notify或notifyAll方法前，导致当前线程等待。线程会释放掉它所占有的“锁标志”，从而使别的线程有机会抢占该锁。
当前线程必须拥有当前对象锁。如果当前线程不是此锁的拥有者，会抛出IllegalMonitorStateException异常。
唤醒当前对象锁的等待线程使用notify或notifyAll方法，也必须拥有相同的对象锁，否则也会抛出IllegalMonitorStateException异常。
waite()和notify()必须在synchronized函数或synchronized　block中进行调用。如果在non-synchronized函数或non-synchronized　block中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。
3.yield方法 暂停当前正在执行的线程对象。
yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
yield()只能使同优先级或更高优先级的线程有执行的机会。
4.join方法等待该线程终止。
等待调用join方法的线程结束，再继续执行。如：t.join();//主要用于等待t线程运行结束，若无此句，main则会执行完毕，导致结果不可预

2021/2/1

1. 在使用 interface 声明一个外部接口时，只可以使用（ ）修饰符修饰该接口。
   正确答案: D 你的答案: D (正确)
   private
   protected
   private protected
   public
   接口的方法都是 public abstract 变量都是public static final的 ，方法只能通过接口调用，不能通过实现类调用

2. 下列不属于访问控制符的是（）
   静态
   正确答案: D 你的答案: D (正确)
   public
   private
   protected
   static

3. 容器panel缺省使用的布局编辑策略是( )
   正确答案: B 你的答案: D (错误)
   Border Layout
   Flow Layout
   GridLayout
   Card Layout
   FlowLayout的布局管理器

4. 下列哪一项的实现不可以添加为 TextField 对象的监听器（）
   正确答案: C 你的答案: C (正确)
   MouseMotionListener
   FocusListener
   WindowsListener
   ActionListener

5. 关于数据库连接的程序，以下哪个语句的注释是错误的（ ）

   正确答案: A 你的答案: B (错误)
   Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”); //指定MySQL JDBC驱动程序
   String url=”jdbc:odbc:student_access”; //指定数据源为student_access
   Connection con=DriverManager.getConnection(url); //创建连接指定数据库的对象
   Statement stmt=con.creatStatement();//创建执行SQL语句的Statement对象
   //声明数据库驱动，数据源的url，用于登录数据库的账户和密码（将其他功能封装成方法的时候方便使用）
   String driver = “数据库驱动名称”；
   String url = “数据库连接地址”
   String user = “用来连接数据库的用户名”；
   String pwd = “用来连接数据库的密码”；
   //加载数据库驱动
   Class.forName(driver);
   //根据url创建数据库连接对象Connection
   Connection con = DriverManage.getConnection(url,user,pwd);
   //用数据库连接对象创建Statement对象(或PrepareStatement)
   Statement s = con.createStatement();
   或
   PrepareStatement ps = con.PrepareStatement(sql);
   //做数据库的增删改查工作
   ResultSet rs = s.executeQuery();
   //关闭结果集对象Resultset，statement对象，connection对象，
   rs.close();
   s.close();
   con.close();
   //各个步骤的异常处理

6. 以下代码执行的结果显示是多少（ ）？
   public class Demo { class Super{ int flag=1;
   Super(){
   test();
   } void test(){
   System.out.println(“Super.test() flag=”+flag);
   }
   } class Sub extends Super{
   Sub(int i){ flag=i;
   System.out.println(“Sub.Sub()flag=”+flag);
   } void test(){
   System.out.println(“Sub.test()flag=”+flag);
   }
   } public static void main(String[] args) { new Demo().new Sub(5);
   }
   }

   正确答案: A 你的答案: B (错误)
   Sub.test() flag=1
   Sub.Sub() flag=5
   Sub.Sub() flag=5
   Sub.test() flag=5
   Sub.test() flag=0
   Sub.Sub() flag=5
   Super.test() flag=1
   Sub.Sub() flag=5
   在继承中代码的执行顺序为：1.父类静态对象，父类静态代码块
   2.子类静态对象，子类静态代码块
   3.父类非静态对象，父类非静态代码块
   4.父类构造函数
   5.子类非静态对象，子类非静态代码块
   6.子类构造函数

7. Math.floor(-8.5)=( )
   正确答案: D 你的答案: A (错误)
   (float)-8.0
   (long)-9
   (long)-8
   (double)-9.0
   Math.floor() 表示向下取整，返回double类型 （floor—地板）
   Math.ceil() 表示向上取整，返回double类型 （ceil—天花板）
   Math.round() 四舍五入，返回int类型

8. 下列关于系列化和反序列化描述正确的是：
   正确答案: A B 你的答案: A B C (错误)
   序列化是将数据转为n个 byte序列的过程
   反序列化是将n个 byte转换为数据的过程
   将类型int转换为4 byte是反序列化过程
   将8个字节转换为long类型的数据为序列化过程

   序列化是把对象转换为字节序列的过程，为了存储在磁盘上或者进行网络传输。 反序列化是把存储在磁盘或网络节点上的字节序列恢复为对象的过程。 这是java进程之间通信的方式

9. 关于下面的一段代码，以下哪些说法是正确的：
   public static void main(String[] args) {
   String a = new String(“myString”);
   String b = “myString”;
   String c = “my” + “String”;
   String d = c;
   System.out.print(a == b);
   System.out.print(a == c);
   System.out.print(b == c);
   System.out.print(b == d);
   }
   正确答案: A D 你的答案: B D (错误)
   System.out.print(a == b)打印出来的是false
   System.out.print(a == c)打印出来的是true
   System.out.print(b == c)打印出来的是false
   System.out.print(b == d)打印出来的是true
   A：a指向堆内存，b指向常量池，因此地址不相等，false
   B：java有常量优化机制，c也指向常量池，且与b指向同一个，则a与c地址不相等,false；
   C：b与c地址相等，true
   D：d是c的副本，地址相同，所以b与d地址相等，true

10. 下面哪些描述是正确的：（ ）
    public class Test {
    public static class A {
    private B ref;
    public void setB(B b) {
    ref = b;
    }
    }
    public static Class B {
    private A ref;
    public void setA(A a) {
    ref = a;
    }
    }
    public static void main(String args[]) {
    …
    start();
    ….
    }
    public static void start() { A a = new A();
    B b = new B();
    a.setB(b);
    b = null; //
    a = null;
    …
    }
    }
    正确答案: B C 你的答案: D E (错误)
    b = null执行后b可以被垃圾回收
    a = null执行后b可以被垃圾回收
    a = null执行后a可以被垃圾回收
    a,b必须在整个程序结束后才能被垃圾回收
    类A和类B在设计上有循环引用，会导致内存泄露
    a, b 必须在start方法执行完毕才能被垃圾回收

2021/2/2

1. 蔺相如，司马相如；魏无忌，长孙无忌。下列哪一组对应关系与此类似()
   正确答案: C 你的答案: C (正确)
   PHP，Python
   JSP，servlet
   Java，Javascript
   C，C++

2. 以下定义一维数组的语句中，正确的是：（）

   正确答案: D 你的答案: D (正确)
   int a [10]
   int a []=new [10]
   int a[]
   int a []=new int [10]
   int a []={1,2,3,4,5}

3. 基本的Java语言函数存储在以下哪个java包中？（）

   正确答案: A 你的答案: D (错误)
   java.lang
   java.io
   java.net
   java.util
   1.lang包主要是集合类、时间处理模式、日期时间工具等各类常用工具包。
   2.util包 包括基本Object类、Class类、String类、基本类型的包装类、基本的数学类等最基本的类。

4. public static void main(String[] args) {
   Thread t = new Thread() {
   public void run() {
   my360DW();
   }
   };
   t.run();
   System.out.print(“DW”);
   }
   static void my360DW() {
   System.out.print(“360”);
   }
   正确答案: C 你的答案: D (错误)
   DW
   360
   360DW
   都不输出
   第一：方法名不能以数字开头，所以编译通不过 第二：改正确方法名后输出“360DW”，本题意在考察开启线程的方法t.start()和直接调用t.run()的区别。但在题目中没有提现 注：直接调用线程的run()方法不是开启线程，就是普通调用，会直接执行run()方法中的内容

5. 子类要调用继承自父类的方法，必须使用super关键字。
   正确答案: B 你的答案: A (错误)
   正确
   错误
   1、子类构造函数调用父类构造函数用super
   2、子类重写父类方法后，若想调用父类中被重写的方法，用super
   3、未被重写的方法可以直接调用。

6. 检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。
   package algorithms.com.guan.javajicu;
   public class Example {
   String str = new String(“good”);
   char[] ch = {‘a’,‘b’,‘c’};
   public static void main(String[] args) {
   Example ex = new Example();
   ex.change(ex.str, ex.ch);
   System.out.print(ex.str +“and”);
   System.out.print(ex.ch);
   }

   public void change(String str, char ch[]){
   str= “test ok”;
   ch[0]= ‘g’;
   }
   }
   正确答案: D 你的答案: D (正确)
   test okandabc
   test okandgbc
   goodandabc
   goodandgbc

7. 定义有StringBuffer s1=new StringBuffer(10);s1.append(“1234”)则s1.length()和s1.capacity()分别是多少?
   正确答案: A 你的答案: C (错误)
   4 10
   4 4
   10 10
   10 4
   length 返回当前长度
   如果字符串长度没有初始化长度大，capacity返回初始化的长度

8. 关于异常的编程，以下描述错误的是：（ ）

   正确答案: A 你的答案: A (正确)
   在有除法存在的代码处，为了防止分母为零，必须抛出并捕获异常
   int i=Integer.parseInt(”123a”);将产生NumberFormatException
   int a[]=null; a[0]=1; 将产生NullPointerException
   输入输出流编程中，读和写时都要抛出IOException

9. 关于匿名内部类叙述正确的是？ ( )
   由于构造器的名字必须与类名相同，而匿名类没有类名，所以匿名类不能有构造器。
   正确答案: B 你的答案: D (错误)
   匿名内部类可以继承一个基类，不可以实现一个接口
   匿名内部类不可以定义构造器
   匿名内部类不能用于形参
   以上说法都不正确

10. 下面关于面向对象的一些理解哪些是错误的( )
    正确答案: C 你的答案: C F (错误)
    面向对象的最重要的特性是支持继承、封装和多态
    系统设计应该遵循开闭原则，系统应该稳定不不可修改，但应支持通过继承、组合等方式进行扩展
    函数式的语言必然是面向对象的语言
    面向对象设计时，每个类的职责应该单一，不要再一个类中引入过多的接口
    过程式语言和面向对象的语言各有其优势，过程式语言更加灵活，面向对象语言更加强调抽象和封装
    Java和C++都是静态类型的面向对象编程语言

2021/2/23

1. abstract和final可以同时作为一个类的修饰符。（ ）

   正确答案: B 你的答案: A (错误)
   正确
   错误
   abstract修饰一个类，这个类肯定可以被继承，但是final类是不能继承的，所以有矛盾，肯定不能同时用

2. 一个以”.java”为后缀的源文件

   正确答案: C 你的答案: C (正确)
   只能包含一个类，类名必须与文件名相同
   只能包含与文件名相同的类以及其中的内部类
   只能有一个与文件名相同的类，可以包含其他类
   可以包含任意类

3. 有程序片段如下，以下表达式结果为 true 的是（ ）

   Float s=new Float(0.1f);

   Float t=new Float(0.1f);

   Double u=new Double(0.1);

   正确答案: B 你的答案: B (正确)
   s==t
   s.equals(t)
   u.equals(s)
   t.equals(u)
   题目A比较的是两个对象的地址，显然不同的对象地址不同，A是false。B同属于Float对象且值相等，true。C和D比较的对象不同，false。

4. 以下程序的执行结果是：

   static boolean foo(char c)
   {
   System.out.print©;
   return true;
   }
   public static void main(String[] args) {
   int i =0;
   for(foo(‘A’);foo(‘B’)&&(i<2);foo(‘C’))
   {
   i++;
   foo(‘D’);
   }
   }
   正确答案: A 你的答案: A (正确)
   ABDCBDCB
   ABCDABCD
   编译时出错
   运行时抛出异常

5. 对文件名为Test.java的java代码描述正确的是()
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   class Person {
   String name = “No name”;
   public Person(String nm) {
   name = nm;
   }
   }
   class Employee extends Person {
   String empID = “0000”;
   public Employee(String id) {
   empID = id;
   }
   }
   public class Test {
   public static void main(String args[]) {
   Employee e = new Employee(“123”);
   System.out.println(e.empID);
   }
   }
   正确答案: C 你的答案: B (错误)
   输出：0000
   输出：123
   编译报错
   输出：No name
   子类的构造方法总是先调用父类的构造方法，如果子类的构造方法没有明显地指明使用父类的哪个构造方法，子类就调用父类不带参数的构造方法。
   而父类没有无参的构造函数，所以子类需要在自己的构造函数中显示的调用父类的构造函数。

6. 以下程序的输出结果为
   class Base{
   public Base(String s){
   System.out.print(“B”);
   }
   }
   public class Derived extends Base{
   public Derived (String s) {
   System.out.print(“D”);
   }
   public static void main(String[] args){
   new Derived(“C”);
   }
   }

   正确答案: D 你的答案: A (错误)
   BD
   DB
   C
   编译错误
   在调用子类构造器之前，会先调用父类构造器，当子类构造器中没有使用"super(参数或无参数)"指定调用父类构造器时，是默认调用父类的无参构造器，如果父类中包含有参构造器，却没有无参构造器，则在子类构造器中一定要使用“super(参数)”指定调用父类的有参构造器，不然就会报错。

7. 关于 java 的异常处理机制的叙述哪些正确？
   正确答案: A B 你的答案: A B (正确)
   不论程序是否发生错误及捕捉到异常情况，都会执行finally部分
   当try区段的程序发生异常时，才会执行catch区段的程序
   catch部分捕捉到异常情况时，才会执行finally部分
   其它选项都不正确

8. 下面属于JSP内置对象的是？

   正确答案: A B C D 你的答案: B D (错误)
   out对象
   response对象
   application对象
   page对象

9. 有关hashMap跟hashTable的区别，说法正确的是？
   正确答案: A B C D 你的答案: A (错误)
   HashMap和Hashtable都实现了Map接口
   HashMap是非synchronized，而Hashtable是synchronized
   HashTable使用Enumeration，HashMap使用Iterator
   HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。
   A正确。Map是一个接口，hashtable,hashmap都是它的实现。
   B正确。由于Hashtable是线程安全的也是synchronized，所以在单线程环境下它比HashMap要慢。如果你不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。
   C正确。 HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。所以当有其它线程改变了HashMap的结构（增加或者移除元素），将会抛出ConcurrentModificationException，但迭代器本身的remove()方法移除元素则不会抛出ConcurrentModificationException异常。但这并不是一个一定发生的行为，要看JVM。这条同样也是Enumeration和Iterator的区别。
   D正确。 哈希值的使用不同，HashTable直接使用对象的hashCode，代码是这样的：
   int hash = key.hashCode();
   int index = (hash & 0x7FFFFFFF) % tab.length;
   而HashMap重新计算hash值，而且用与代替求模：
   int hash = hash(k);
   int i = indexFor(hash, table.length);

10. 下列哪些操作会使线程释放锁资源？
    正确答案: B C 你的答案: A B D (错误)
    sleep()
    wait()
    join()
    yield()

2021/2/23

1. Java Applet在被浏览器加载的时候首先被执行且在applet整个生命周期中被运行一次的方法是（）
   正确答案: A 你的答案: A (正确)
   init()
   stop()
   opreationcrawl()
   reader()
   init()方法是初始化，自然只有一次。

2. 关于继承和实现说法正确的 是 ？ ( )
   正确答案: A 你的答案: B (错误)
   类可以实现多个接口，接口可以继承（或扩展）多个接口
   类可以实现多个接口，接口不能继承（或扩展）多个接口
   类和接口都可以实现多个接口
   类和接口都不可以实现多个接口
   类与类之间的关系为继承，只能单继承，但可以多层继承。 2.类与接口之间的关系为实现，既可以单实现，也可以多实现。 3.接口与接口之间的关系为继承，既可以单继承，也可以多继承。 故为A

3. 下面哪个修饰符修饰的变量是所有同一个类生成的对象共享的（ ）

   正确答案: C 你的答案: B (错误)
   public
   private
   static
   final
   static表示静态变量，归类所有，该类的所有对象公用

4. 字符界面下接受用户从键盘输入，需要import的包是：（ ）
   正确答案: C 你的答案: A (错误)
   java.lang包
   java.awt包
   java.io包
   java.applet包

5. 关于 Socket 通信编程，以下描述正确的是：（ ）

   正确答案: C 你的答案: C (正确)
   客户端通过new ServerSocket()创建TCP连接对象
   客户端通过TCP连接对象调用accept()方法创建通信的Socket对象
   客户端通过new Socket()方法创建通信的Socket对象
   服务器端通过new ServerSocket()创建通信的Socket对象
   客户端通过socket()方法创建socket对象 服务端通过serverSocket()方法创建TCP对象，通过accept()方法接受客户端请求

6. 关于Java语言描述正确的是？ ( )
   正确答案: B 你的答案: B (正确)
   java和C++都保留了指针
   java和C++都有三个特征：封装、继承和多态
   java的垃圾回收机制是指程序结束时系统自动回收内存
   以上说法都不正确

7. 以下代码将打印出

   public static void main (String[] args) {
   String classFile = “com.jd.”. replaceAll(".", “/”) + “MyClass.class”;
   System.out.println(classFile);
   }
   正确答案: C 你的答案: B (错误)
   com. jd
   com/jd/MyClass.class
   ///MyClass.class
   com.jd.MyClass
   由于replaceAll方法的第一个参数是一个正则表达式，而".“在正则表达式中表示任何字符，所以会把前面字符串的所有字符都替换成”/"。如果想替换的只是"."，那么久要写成"\.".

8. jdk1.8版本之前的前提下，接口和抽象类描述正确的有（ ）
   正确答案: B C 你的答案: A D (错误)
   抽象类没有构造函数
   接口没有构造函数
   抽象类不允许多继承
   接口中的方法可以有方法体
   jdk1.8后接口中用static或default修饰的方法可以有方法体

9. 下列关于JAVA多线程的叙述正确的是（）

   正确答案: B C 你的答案: B C (正确)
   调用start()方法和run()都可以启动一个线程
   CyclicBarrier和CountDownLatch都可以让一组线程等待其他线程
   Callable类的call()方法可以返回值和抛出异常
   新建的线程调用start()方法就能立即进行运行状态
   A，start是开启线程，run是线程的执行体，run是线程执行的入口。
   B，CyclicBarrier和CountDownLatch都可以让一组线程等待其他线程。前者是让一组线程相互等待到某一个状态再执行。后者是一个线程等待其他线程结束再执行。
   C，Callable中的call比Runnable中的run厉害就厉害在有返回值和可以抛出异常。同时这个返回值和线程池一起用的时候可以返回一个异步对象Future。
   D，start是把线程从new变成了runnable

10. 以下哪种JAVA的变量表达式使得变量a和变量b具有相同的内存引用地址( )
    正确答案: A B 你的答案: A D (错误)
    String a = “hello”; String b = “hello”;
    Integer a; Integer b = a;
    int a = 1; Integer b = new Integer(1);
    int a = 1; Integer b = 1;

2021/7/7

1. 下列程序test 类中的变量c 的最后结果为
   public class Test {
   public static void main(String args[]) {
   int a = 10;
   int b;
   int c;
   if (a > 50) {
   b = 9;
   }
   c = b + a;
   }
   }
   正确答案: D 你的答案: A (错误)
   10
   0
   19
   编译出错

方法内定义的变量没有初始值，必须要进行初始化。 类中定义的变量可以不需要赋予初始值，默认初始值为0。