java20题

欲定义类字段或类方法（静态方法），应该使用下列哪一个修饰符修饰（）
正确答案: B
public
static
protected
synchronized
解析:A、 public可以修饰类，数据成员，构造方法，方法成员。被public修饰的成员 ，可以在任何一个类中被调用，不管同包或不同包，是权限最大的一个修饰符。
B、 static用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。
C、 private可以修饰数据成员，构造方法，方法成员，不能修饰类（此处指外部 类，不考虑内部类）。被private修饰的成员，只能在定义它们的类中使用，在 其他类中不能调用。
D、 synchronized可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。

设有下面两个类的定义：
1
2
3
4
5
6
7
class Person {}
class Student extends Person {
public int id; //学号
public int score; //总分
public String name; // 姓名
public int getScore(){return score;}
}
类Person和类Student的关系是（）。
正确答案: B
包含关系
继承关系
关联关系
无关系，上述类定义有语法错误
解析:Java中类之间的六种关系：
第一种：继承关系，例如：子类继承父类，子接口继承父接口。
第二种：实现关系，例如：类实现接口。
第三种：依赖关系，例如：一个类作为另一个类中方法的参数存在，这种关系具有偶然性和临时性。
第四种：关联关系，例如：一个类作为另一个类中的成员变量存在，它是一种强依赖关系。
第五种：聚合关系，例如：整体和部分之间，他们是可以分离的拥有各自的生命周期，并且部分是相同的。像鸟群和鸟。
第六种：组合关系，它是一种强聚合，并且整体和部分之间不可分离，具有相同的生命周期，整体包含该部分，也包含其他部分，其他部分和该部分是不相同的，像cpu和计算机，计算机除了包括cpu还有键盘和显示器等。

定义一个 接口 必须使用的关键字是 ？ （ ）
正确答案: C
public
class
interface
static
public 公用的 共有的
class 类
interface 接口
static 静态
故选C.Interface 接口

列表述错误的是？（）

正确答案: D
int是基本类型，直接存数值，Integer是对象，用一个引用指向这个对象。
在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过
封装的主要作用在于对外隐藏内部实现细节，可以增强程序的安全性
final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性。
解析:抽象类：子类继承重写
final：不允许重写

下面有关servlet中init,service,destroy方法描述错误的是？
正确答案: D
init()方法是servlet生命的起点。一旦加载了某个servlet，服务器将立即调用它的init()方法
service()方法处理客户机发出的所有请求
destroy()方法标志servlet生命周期的结束
servlet在多线程下使用了同步机制，因此，在并发编程下servlet是线程安全的
解析:init方法： 是在servlet实例创建时调用的方法，用于创建或打开任何与servlet相的资源和初始 化servlet的状态，Servlet规范保证调用init方法前不会处理任何请求
service方法：是servlet真正处理客户端传过来的请求的方法，由web容器调用， 根据HTTP请求方法（GET、POST等），将请求分发到doGet、doPost等方法
destory方法：是在servlet实例被销毁时由web容器调用。Servlet规范确保在destroy方法调用之 前所有请求的处理均完成，需要覆盖destroy方法的情况：释放任何在init方法中 打开的与servlet相关的资源存储servlet的状态

多重继承的概念在Java中实现是通过如下哪些？（）
I. 扩展两个或多个类
II. 扩展一个类并实现一个或多个接口。
III. 实现两个或更多接口。

正确答案: B
只有I &II
只有II & III
只有III
都是
解析:Java只支持单继承，实现多重继承三种方式：（1）直接实现多个接口 （2）扩展(extends)一个类然后实现一个或多个接口 （3）通过内部类去继承其他类

在Java中，HashMap中是用哪些方法来解决哈希冲突的？
正确答案: C
开放地址法
二次哈希法
链地址法
建立一个公共溢出区
解析:使用的链地址法来解决冲突的

给出以下代码
复制代码
1
2
3
4
5
6
7
8
9
10
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”));
}
}
请给出结果：（）
正确答案: B
运行时抛出异常
true
Fred
第三行编译错误
解析:object是所有类的父类，肯定包含“fred”类，而且所有类均含有equal方法，前面内容等于是重写了equal方法，使其只能返回true。

检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class HelloB extends HelloA
{
public HelloB()
{
}
{
System.out.println(“I’m B class”);
}
static
{
System.out.println(“static B”);
}
public static void main(String[] args)
{
new HelloB();
}
}
class HelloA
{
public HelloA()
{
}
{
System.out.println(“I’m A class”);
}
static
{
System.out.println(“static A”);
}
}

正确答案: C 你的答案: B (错误)
static A
I’m A class
static B
I’m B class

I’m A class
I’m B class
static A
static B

static A
static B
I’m A class
I’m B class

I’m A class
static A
I’m B class
static B
解析:1.静态代码块 2.构造代码块3.构造方法的执行顺序是1>2>3;明白他们是干嘛的就理解了。
1.静态代码块：是在类的加载过程的第三步初始化的时候进行的，主要目的是给类变量赋予初始值。
2.构造代码块：是独立的，必须依附载体才能运行，Java会把构造代码块放到每种构造方法的前面，用于实例化一些共有的实例变量，减少代码量。
3.构造方法：用于实例化变量。
1是类级别的，2、3是实例级别的，自然1要优先23.

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

Java的跨平台特性是指它的源代码可以在多个平台运行。（）
正确答案: B
正确
错误
解析:javac编译但是java自带有运行环境并非原代码可以

关于下面的程序Test.java说法正确的是( )。
1
2
3
4
5
6
7
8
public class Test {
static String x=“1”;
static int y=1;
public static void main(String args[]) {
static int z=2;
System.out.println(x+y+z);
}
}

正确答案: D
3
112
13
程序有编译错误
解析:static 修饰的变量属于类,只能定义在类中方法外

10. class Line {
11. public class Point { public int x,y;}
12. public Point getPoint() { return new Point(); }
13. }
14. class Triangle {
15. public Triangle() {
16. // insert code here
17. }
18. }
    在第16行插入哪段代码可以获得一个Point对象的坐标?( )
    正确答案: D
    Point p = Line.getPoint();
    Line.Point p = Line.getPoint();
    Point p = (new Line()).getPoint();
    Line.Point p = (new Line()).getPoint();
    解析:(1)把类定义在另一个类的内部，该类就被称为内部类。
    举例：把类B定义在类A中，类B就被称为内部类。
    (2)内部类的访问规则
    A:可以直接访问外部类的成员，包括私有
    B:外部类要想访问内部类成员，必须创建对象
    (3)内部类的分类
    A:成员内部类
    B:局部内部类
    C:匿名内部类
    (4)成员内部类访问规则
    成员内部类不是静态的：
    外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
    成员内部类是静态的：
    外部类名.内部类名 对象名 = new 外部类名.内部类名();
    (5)局部内部类
    A:局部内部类访问局部变量必须加final修饰。
    B:为什么呢?
    因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。
    所以，堆内存还是用该变量，而改变量已经没有了。
    为了让该值还存在，就加final修饰。
    通过反编译工具我们看到了，加入final后，堆内存直接存储的是值，而不是变量名。
    (6)匿名内部类(掌握)
    A:是局部内部类的简化形式
    B:前提
    存在一个类或者接口
    C:格式:
    new 类名或者接口名() {
    重写方法;
    }
    D:本质：
    其实是继承该类或者实现接口的子类匿名对象

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

DBMS 中实现事务持久性的子系统是()

正确答案: D
安全性管理子系统
完整性管理子系统
并发控制子系统
恢复管理子系统
解析:原子性：事务是一组不可分割的操作单元，这组单元要么同时成功要么同时失败（由DBMS的事务管理子系统来实现）；
一致性：事务前后的数据完整性要保持一致（由DBMS的完整性子系统执行测试任务）；
隔离性:多个用户的事务之间不要相互影响，要相互隔离（由DBMS的并发控制子系统实现）；
持久性:一个事务一旦提交，那么它对数据库产生的影响就是永久的不可逆的，如果后面再回滚或者出异常，都不会影响已提交的事务（由DBMS的恢复管理子系统实现的）

一般有两种用于创建线程的方法,一是(),二是()。
正确答案: B D
从Java.lang.Thread类派生一个新的线程类，重写它的runnable()方法
从Java.lang.Thread类派生一个新的线程类，重写它的run()方法
实现Thread接口，重写Thread接口中的run()方法
实现Runnable接口，重写Runnable接口中的run()方法
解析:创建线程对象两种方式：
1.继承Thread类，重载run方法；
2.实现Runnable接口，实现run方法

如下哪些是 java 中有效的关键字（）

正确答案: A D
native
NULL
false
this
解析:关键字大写首字母
CMS垃圾回收器在那些阶段是没用用户线程参与的
初始标记
并发标记
重新标记
并发清理
解析:用户线程（user-level threads）指不需要内核支持而在用户程序中实现的线程，其不依赖于操作系统核心，应用进程利用线程库提供创建、同步、调度和管理线程的函数来控制用户线程。
CMS的GC过程有6个阶段（4个并发，2个暂停其它应用程序）

1. 初次标记(STW initial mark)
2. 并发标记(Concurrent marking)
3. 并发可中断预清理(Concurrent precleaning)
4. 最终重新标记(STW remark)
5. 并发清理(Concurrent sweeping)
6. 并发重置(Concurrent reset)
   在初次标记，重新标志的时候，要求我们暂停其它应用程序，那么这两个阶段用户线程是不会参与的

以下哪几种方式可用来实现线程间通知和唤醒：( )
正确答案: A C
Object.wait/notify/notifyAll
ReentrantLock.wait/notify/notifyAll
Condition.await/signal/signalAll
Thread.wait/notify/notifyAll
解析:wait()、notify()和notifyAll()是 Object类 中的方法
从这三个方法的文字描述可以知道以下几点信息：

1）wait()、notify()和notifyAll()方法是本地方法，并且为final方法，无法被重写。

2）调用某个对象的wait()方法能让当前线程阻塞，并且当前线程必须拥有此对象的monitor（即锁）

3）调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程，如果有多个线程都在等待这个对象的monitor，则只能唤醒其中一个线程；

4）调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程；

有朋友可能会有疑问：为何这三个不是Thread类声明中的方法，而是Object类中声明的方法

（当然由于Thread类继承了Object类，所以Thread也可以调用者三个方法）？其实这个问

题很简单，由于每个对象都拥有monitor（即锁），所以让当前线程等待某个对象的锁，当然

应该通过这个对象来操作了。而不是用当前线程来操作，因为当前线程可能会等待多个线程

的锁，如果通过线程来操作，就非常复杂了。

上面已经提到，如果调用某个对象的wait()方法，当前线程必须拥有这个对象的monitor（即

锁），因此调用wait()方法必须在同步块或者同步方法中进行（synchronized块或者

synchronized方法）。

调用某个对象的wait()方法，相当于让当前线程交出此对象的monitor，然后进入等待状态，

等待后续再次获得此对象的锁（Thread类中的sleep方法使当前线程暂停执行一段时间，从

而让其他线程有机会继续执行，但它并不释放对象锁）；

notify()方法能够唤醒一个正在等待该对象的monitor的线程，当有多个线程都在等待该对象

的monitor的话，则只能唤醒其中一个线程，具体唤醒哪个线程则不得而知。

同样地，调用某个对象的notify()方法，当前线程也必须拥有这个对象的monitor，因此调用

notify()方法必须在同步块或者同步方法中进行（synchronized块或者synchronized方法）。

nofityAll()方法能够唤醒所有正在等待该对象的monitor的线程，这一点与notify()方法是不同的。
Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。因此通常来说比较推荐使用Condition，在阻塞队列那一篇博文中就讲述到了，阻塞队列实际上是使用了Condition来模拟线程间协作。
Condition是个接口，基本的方法就是await()和signal()方法；
Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition()
调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用Conditon中的await()对应Object的wait()； Condition中的signal()对应Object的notify()； Condition中的signalAll()对应Object的notifyAll()

JDK提供的用于并发编程的同步器有哪些？
正确答案: A B C
Semaphore
CyclicBarrier
CountDownLatch
Counter
解析:同步器是一些使线程能够等待另一个线程的对象，允许它们协调动作。最常用的同步器是CountDownLatch和Semaphore，不常用的是Barrier 和Exchanger