考点1

Java的Daemon线程,setDaemon( )设置必须要？

• A 在start之前
• B 在start之后
• C 前后都可以

解析

setDaemon()方法必须在线程启动之前调用，当线程正在运行时调用会产生异常。

java中线程分类

• 前台线程。通过Thread.setDaemon(false)设置为前台线程;
• 守护线程。通过Thread.setDaemon(true)设置为守护线程

前台线程创建的线程默认就是前台线程。

多线程方面的需要加强
有空了解一下

考点2

在java7中,下列不能做switch()的参数类型是？

• A int型
• B 枚举类型
• C 字符串
• D 浮点型

解析

switch支持：

• 支持小于等于int的类型（byte,short,char,int），
• 不支持八大基础数据类型中的boolean,long,float,double
• 支持枚举类型
• java7开始支持支持String类型

考点3

在Java图形用户界面编程中,如果需要显示信息,一般是使用__________类的对象来实现。

• A JLabel
• B JButton
• C JTextArea
• D JtextField

解析

• JTextField单行文本
• JTextArea多行文本
• JButton按键显示
• JLable显示标签 信息

考点4

以下哪些方法可以取到http请求中的cookie值()?

• A request.getAttribute
• B request.getHeader
• C request.getParameter
• D request.getCookies

解析

下面的方法可用在 Servlet 程序中读取 HTTP 头。这些方法通过 HttpServletRequest 对象可用：
1）Cookie[] getCookies()
返回一个数组，包含客户端发送该请求的所有的 Cookie 对象。
2）Object getAttribute(String name)
以对象形式返回已命名属性的值，如果没有给定名称的属性存在，则返回 null。
3）String getHeader(String name)
以字符串形式返回指定的请求头的值。Cookie也是头的一种；
4）String getParameter(String name)
以字符串形式返回请求参数的值，或者如果参数不存在则返回 null。

JSP servlet方面的知识忘记了，有空了解一下

考点5

下面程序段执行后b的值是()。
Integer integ =new Integer(9);
boolean b = integ instanceof Object;

• A 9
• B true
• C 1
• D false

解析

A instanceOf B，是判断对象A

• 是否属于B类的实例
• 是否属于B类的子类的实例
• 是否属于B接口的实现类的实例
• 是否属于B接口的子接口的实现类的实例。

任何数据类型都可以赋值给Object对象。

考点6

以下哪些类是线程安全的()

• A Vector
• B HashMap
• C ArrayList
• D StringBuffer
• E Properties

解析

考点1

以下哪一个不是JavaScript的数据类型:

• A String
• B Boolean
• C Integer
• D Undefined

解析

JavaScript中的数据类

• 基本类型:Undefined,Null,Boolean,Number.
• 引用类型:Object, Array, Function

考点2

以下代码执行的结果

1
2
3
4
5
6

for(var i=0;i<3;++i){
    setTimeout(function(){
        console.log(i);
    }
    ,100);
}

• A 0,1,2
• B 1,2,3
• C 3,3,3
• D 0,0,0

解析

每次for循环的时候setTimeout都会执行，因为setTimeout是异步函数，里面的function则不会立即执行，而是会被放入任务队列，因此放了3次；
任务队列中的函数会在for循环结束之后执行。
for循环的3次执行完之后,i变为3，也就是每次循环，i都会被后一个i值覆盖。所以就是输出3个3。

考点3

请问在javascript程序中,alert(undefined==null)的输出结果是

• A null
• B undefined
• C true
• D false
• E 以上答案都不正确

解析

==仅判断值是否相同，undefined值和null是相同的，故true
===在判断值是否相同的同时还判断类型是否相同，

• undefined类型为undefined，
• null类型为object，
• 因此为false

考点4

var str1=new RegExp(“e”);
document.write(str1.exec(“hello”));
以上代码输出结果为( )

• A e
• B null
• C 1
• D 其他几项都不对

解析

正则表达式方法 exec()方法

exec()方法用于检索字符串中的匹配正则表达式的子串
该函数返回一个数组，其中存放匹配的子串。如果未找到匹配，则返回值为 null。

JavaScript高级程序设计
有空了解一下

考点5

下列关于 JavaScript 的说法中正确的是()

• A 所有变量在使用之前必须做声明
• B JavaScript是面向对象的程序设计语言
• C JavaScript是解释性语言
• D JavaScript前身是Oak语言

解析

1
2
3
4
5
6
7
8

<script>
function a(){
    for(i=0;i<20;i++){
      // 没有 var i
    }      return i;
}
document.writeln(a());
</script> 

D选项中JAVA的前身才是Oak，而不是JavaScript。所以D错误。

考点6

下面有关JavaScript中 call和apply的描述,错误的是？

• A call与apply都属于Function.prototype的一个方法,所以每个function实例都有call、apply属性
• B 两者传递的参数不同,call函数第一个参数都是要传入给当前对象的对象,apply不是
• C apply传入的是一个参数数组,也就是将多个参数组合成为一个数组传入
• D call传入的则是直接的参数列表。call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象。

解析

有空了解一下

考点8

typeof Date.now() 的值是:

• A date
• B object
• C number
• D error

解析

Date.now() 方法返回自1970年1月1日 00:00:00 UTC到当前时间的毫秒数。
故该题为number

考点9

0xff ^ 33 的结果是:

• A 220
• B 221
• C 222
• D 223

解析

1
2
3
4
5
6

0xff＝1111 1111(255)

1111 1111(255)
0010 0001(33)
异或操作     
1101 1110(222)

考点1

执行下列代码的输出结果是( )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

public class Demo{
    public static void main(String args[]){
        int num = 10;
        System.out.println(test(num));
    }
    public static int test(int b){
        try{
            b += 10;
            return b;
        }
        catch(RuntimeException e){
        }
        catch(Exception e2){
        }
        finally{
            b += 10;
            return b;
        }
    }
}

• A 10
• B 20
• C 30
• D 40

解析

如果finally块中有return语句的话，它将覆盖掉try或者catch语句中其他return语句。

考点2

给出以下代码,请给出结果.
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;
}
}

• A null null 42
• B null 42 42
• C 0 0 42
• D 0 42 42
• E An exception is thrown at runtime
• F Compilation

解析

成员变量会默认初始化。
Byte是byte的包装类型，初始化为null而不是0

考点3

以下关于对象序列化描述正确的是

• A 使用FileOutputStream可以将对象进行传输
• B 使用PrintWriter可以将对象进行传输
• C 使用transient修饰的变量不会被序列化
• D 对象序列化的所属类需要实现Serializable接口

解析

使用ObjectOutputStream和ObjectInputStream可以将对象进行传输.

什么是对象序列化

Java平台允许我们在内存中创建可复用的Java对象，但一般情况下，只有当JVM处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比JVM的生命周期更长。但在现实应用中，就可能要求在JVM停止运行之后能够保存(持久化)指定的对象，并在将来重新读取被保存的对象。Java对象序列化就能够帮助我们实现该功能。

使用Java对象序列化，在保存对象时，会把其状态保存为一组字节，在未来，再将这些字节组装成对象。必须注意地是，对象序列化保存的是对象的”状态”，即它的成员变量。
由此可知，对象序列化不会关注类中的静态变量**。

A、B：使用ObjectInputStream和ObjectoutputStream进行对象的传输
注意：
1.基本数据类型的变量可以直接序列化
2.对象要被序列化，它的类必须实现Serializable接口，如果一个类中有引用类型的变量，这个引用类型的变量的类也必须实现Serializable接口。如果这个引用类型的变量不想被实例化，则用transient修饰（ObjectInputStream）

对象序列化只能保存对象的数据

而static代表类的状态， transient代表对象的临时数据。
所以声明为static和transient类型的成员数据不能被序列化。

考点5

What might cause the current thread to stop or pause executing

• A An InterruptedException is thrown.
• B The thread executes a wait() call.
• C The thread constructs a new Thread.
• D A thread of higher priority becomes ready.
• E The thread executes a waitforID()call on a MediaTracker.

解析

题目:什么操作会使得当前线程停止。
A:一个InterruptedException 异常被捕获 大家都知道的嘛 (一般通过interrupt方法 中断线程) 如果抓到一个线程 都会关紧catch里面 然后中断当前操作,A正确。
B:线程执行了wait()方法。 线程使用了wait方法,会强行打断当前操作,(暂停状态,不会中断线程) 进入阻塞(暂停)状态,然后需要notify方法或notifyAll方法才能进入就绪状态。 B 正确。
C:当前线程创建了一个新的线程。 新创建的线程不会抢占时间片,只有等当前线程把时间片用完,其他线程才有资格拿到时间片去执行。
D:一个高优先级别的线程就绪。 如C相同,你优先级别再高 也待等我现在弄完才会给你。(就像我们玩游戏,会员虽然有排队优先权,但是还是要等正在登陆的用户进去游戏之后才能抢到他原来那个位置,不能说我在过关卡的过程中你一脚把我踢开,然后霸占我的位置吧,我原来的那些数据咋办!!!)
E:线程在MediaTracker上执行了waitforID()调用。
这个应该大家也不太熟悉。这个类是awt里面的,我查API才知道。
然后他的功能是加载图像,直到完成之前,该方法一直等待!这个方法是必须要抛出A选项的InterruptedException 异常的 说明这玩意会让其他线程 wait他完成! 所以会暂停当前线程

考点6

下面哪些描述是正确的:( )

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

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;
        …
    }
}

• A b = null执行后b可以被垃圾回收
• B a = null执行后b可以被垃圾回收
• C a = null执行后a可以被垃圾回收
• D a,b必须在整个程序结束后才能被垃圾回收
• E 类A和类B在设计上有循环引用,会导致内存泄露
• F a, b 必须在start方法执行完毕才能被垃圾回收

解析

内存如下：
a -> “a(b)”
b -> “b”
a引用指向一块空间，这块空间里面包含着b对象
b引用指向一块空间，这块空间是b对象
A选项，b = null执行后b可以被垃圾回收。这里”b可以被垃圾回收”中的b指的是引用b指向的内存。这块内存即使不被引用b指向，还是被引用a指向着，不会被回收。
B选项，a = null执行后b可以被垃圾回收。从代码中可以看到，a = null是在b = null后执行的，该行执行后，引用a和b都没有指向对象，对象会被回收。

考点7

对 Map 的用法,正确的有:

• A new java.util.Map().put("key" , "value") ;
• B new java.util.SortedMap().put("key" , "value") ;
• C new java.util.HashMap().put( null , null ) ;
• D new java.util.TreeMap().put( 0 , null ) ;

解析

接口不能new

A选项Map属于接口类型，不可以new的方式创建对象。所以A错误。
B选项SortedMap属于接口类型，不可以new的方式创建对象。所以B错误。

TreeMap的key不能为null

C选项HashMap基于哈希表实现Map接口的类，并允许null的值和null键。
D选项TreeMap通过红黑树实现Map接口的类，key不可以为null，会报NullPointerException异常,value可以为null。

考点1

已知表达式int m[]={0,1,2,3,4,5,6};下面哪个表达式的值与数组下标量最大值相等？

• A m. length()
• B m. length-1
• C m. length()+1
• D m. length+1

解析

考点2

与未加访问控制符的缺省情况相比,public和protected修饰符扩大了属性和方法的被访问范围,private修饰符则缩小了这种范围。

• A 正确
• B 错误

解析

考点3

区分类中重载方法的依据是( )。

• A 不同的形参名称
• B 不同的返回值类型
• C 不同的形参列表
• D 不同的访问权限

解析

考点4

字符界面下接受用户从键盘输入,需要import的包是:( )

• A java.lang包
• B java.awt包
• C java.io包
• D java.applet包

解析

考点5

下面哪个Set类是排序的？

• A LinkedHashSet
• B TreeSet
• C HashSet
• D AbstractSet

解析

• TreeSet排序，
• LinkedHashSet有序。

考点6

下列关于Java并发的说法中正确的是()

• A CopyOnWriteArrayList适用于写多读少的并发场景
• B ReadWriteLock适用于读多写少的并发场景
• C ConcurrentHashMap的写操作不需要加锁,读操作需要加锁
• D 只要在定义int类型的成员变量i的时候加上volatile关键字,那么多线程并发执行i++这样的操作的时候就是线程安全的了

解析

A，CopyOnWriteArrayList适用于写少读多的并发场景
B，ReadWriteLock即为读写锁，他要求写与写之间互斥，读与写之间互斥，
读与读之间可以并发执行。在读多写少的情况下可以提高效率
C，ConcurrentHashMap是同步的HashMap，读写都加锁
D，volatile只保证多线程操作的可见性，不保证原子性

有空了解一下

CopyOnWrite指的是修改容器之前，先将原来的容器拷贝一份副本，在副本中进行修改，修改之后使用原来的容器指向修改好的容器，这样保证了两个容器可以同时读，用于读多于写的场景

volatile变量自身具有以下特性：1。可见性2.原子性：对任意单个volatile变量的读写具有原子性，但类似i++这种复合操作或者多个volatile操作不具有原子性

考点7

由3 个”1”和 5 个”0”组成的 8 位二进制补码,能表示的最小整数()

• A -126
• B -125
• C -32
• D -3

解析

一个1作为符号位，表示负数，剩下两个1,最大值是3，-(128-3)＝-125

既然求最小整数，那肯定先想到负数，则最高位（符号位）一定为1，原码中肯定是1所在的位数越高，值越小，而补码是由原码取反加1得到的，则在补码中1所在的位数一定要越低，即补码为1000 0011；由补码求得原码：1111 1101=-(64+32+16+8+4+1)=-125;

考点8

下列Java代码中的变量a、b、c分别在内存的____存储区存放。

1
2
3
4
5
6
7

class A {
    private String a = "aa";
    public boolean methodB() {
        String b = "bb";
        final String c = "cc";
    }
}

• A 堆区、堆区、堆区
• B 堆区、栈区、堆区
• C 堆区、栈区、栈区
• D 堆区、堆区、栈区
• E 静态区、栈区、堆区
• F 静态区、栈区、栈区

解析

• a是类中的成员变量，存放在堆区
• b、c都是方法中的局部变量，存放在栈区

堆区:只存放类对象,线程共享;
方法区:又叫静态存储区,存放class文件和静态数据,线程共享;
栈区:存放方法局部变量,基本类型变量区、执行环境上下文、操作指令区,线程不共享;

考点9

Consider the following code:
Integer s=new Integer(9);
Integer t=new Integer(9);
Long u=new Long(9);
Which test would return true?

• A (s==u)
• B (s==t)
• C (s.equals(t))
• D (s.equals(9))
• E (s.equals(new Integer(9))

解析

B关于s==t，添加一点说明：
当Integer的值在-128~127之间时，使用拆箱方式创建Integer对象：

1
2
3
4

//自动拆箱
Integer i=9; 
//手动拆箱
Integer j=Integer.valueOf(9);

得到的对象使用==会得到true。
而使用new Integer()方式创建的对象，使用==会得到false。
当Integer的值不在这个范围内时，无论以何种方式创建两个Integer对象，使用==都会是false。

考点10

判断一块内存空间是否符合垃圾收集器收集的标准有哪些？

• A 给对象赋予了空值null,以下再没有调用过
• B 对象重新分配了内存空间
• C 给对象赋予了空值null
• D 给对象赋予了新值

解析

在java语言中，判断一块内存空间是否符合垃圾收集器收集标准的标准只有两个：
1.给对象赋值为null，以下没有调用过。
2.给对象赋了新的值，重新分配了内存空间。

一块内存空间符合了垃圾收集器的收集标准，并不意味着这块内存空间就一定会被垃圾收集器收集。

考点1

要表示10个学生的成绩,下列声明并初始化数组正确的是()

• A int[] score=new int[ ]
• B int score[10]
• C int score[]=new int[9]
• D int score[]=new int[10]

解析

以下两种写法都可以：
int score[] = new int[10];
int[] score = new int[10];

考点2

下面有关java基本类型的默认值和取值范围,说法错误的是？

• A 字节型的类型默认值是0,取值范围是-2^7—2^7-1
• B boolean类型默认值是false,取值范围是true`false`
• C 字符型类型默认是0,取值范围是-2^15 —2^15-1
• D long类型默认是0,取值范围是-2^63—2^63-1

解析

考点3

关于下列程序段的输出结果,说法正确的是:( )

1
2
3
4
5
6

public class MyClass{
    static int i;
    public static void main(String argv[]){
        System.out.println(i);
    }
}

• A 有错误,变量i没有初始化。
• B null
• C 1
• D 0

解析

成员变量会默认初始化
静态成员可以访问静态成员

考点4

java中下面哪个能创建并启动线程()

1
2
3
4
5

public class MyRunnable implements Runnable{
     public void run(){
         //some code here 
    }
}

• A new Runnable(MyRunnable).start()
• B new Thread(MyRunnable).run()
• C new Thread(new MyRunnable()).start()
• D new MyRunnable().start()

解析

考点5

list是一个ArrayList的对象,哪个选项的代码填到//todo delete处,可以在Iterator遍历的过程中正确并安全的删除一个list中保存的对象？()

1
2
3
4
5
6
7
8
9
10
11

Iterator it = list.iterator();
int index = 0;
while (it.hasNext()){
    Object obj = it.next();
    //needDelete返回boolean,决定是否要删除  
    if (needDelete(obj)){
        //todo delet
        e
    }
    index ++;
}

A it.remove();
B list.remove(obj);
C list.remove(index);
D list.remove(obj,index);

解析

Iterator 支持从源集合中安全地删除对象，只需在 Iterator 上调用 remove() 即可。这样做的好处是可以避免 ConcurrentModifiedException ，当打开 Iterator 迭代集合时，同时又在对集合进行修改。有些集合不允许在迭代时删除或添加元素，但是调用 Iterator 的remove() 方法是个安全的做法。

在循环中调用List的remove方法出现的问题

如果在循环的过程中调用集合的remove()方法，就会导致循环出错，例如：

1
2
3

for(int i=0;i<list.size();i++){
    list.remove(...);
}

循环过程中list.size()的大小变化了，就导致了错误。

所以，如果你想在循环语句中删除集合中的某个元素，就要用迭代器iterator的remove()方法，因为它的remove()方法不仅会删除元素，还会维护一个标志，用来记录目前是不是可删除状态，例如，你不能连续两次调用它的remove()方法，调用之前至少有一次next()方法的调用。

正确使用List的remove方法删除元素的写法

for循环删除问题，如果真想用，可以这样，既不出错，也能正确删除：

1
2
3
4

for(int i=0;i<list.size();i++){
    list.remove(i);
    i--;
}

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);
    }
}

考点6

关于下面的程序Test.java说法正确的是( )。

• A 3
• B 112
• C 13
• D 程序有编译错误

解析

static不能修饰局部变量

被static修饰的变量称为静态变量，静态变量属于整个类，而局部变量属于方法，只在该方法内有效，所以static不能修饰局部变量

考点7

下面代码的运行结果为:()

1
2
3
4
5
6
7
8

import java.io.*;
import java.util.*;
public class foo{
    public static void main (String[] args){
        String s;
        System.out.println("s=" + s);
    }
}

• A 代码得到编译,并输出”s=”
• B 代码得到编译,并输出”s=null“
• C 由于String s没有初始化,代码不能编译通过
• D 代码得到编译,但捕获到 NullPointException异常

解析

局部变量不会默认初始化

局部变量可以先声明不用必须初始化，但使用局部变量之前一定要先初始化。

考点8

Java语言中,下面哪个语句是创建数组的正确语句？( )

• A float f[][] = new float[6][6];
• B float []f[] = new float[6][6];
• C float f[][] = new float[][6];
• D float [][]f = new float[6][6];
• E float [][]f = new float[6][];

解析

二维数组变量和两个中括号可以全排列

二维数组的一维长度必须确定

二维数组定义时，一维的长度必须定义，二维可以后续定义

考点1

1
2
3
4
5
6
7
8

public class Test
{
    public int x;
    public static void main(String []args)
    {
        System. out. println("Value is" + x);
    }
}

对于上面这段代码,以下说法正确的是:
A 程序会打出 “Value is 0”
B 程序会抛出 NullPointerException
C 非静态变量不能够被静态方法引用
D 编译器会抛出 “possible reference before assignment”的错误

解析

main方法是静态方法，静态成员不能访问非静态成员。

考点2

下列哪个说法是正确的()

• A ConcurrentHashMap使用synchronized关键字保证线程安全
• B HashMap实现了Collction接口
• C Array.asList方法返回java.util.ArrayList对象
• D SimpleDateFormat是线程不安全的

解析

A选项中，ConcurrentHashMap
使用segment来分段和管理锁，segment继承自ReentrantLock，因此ConcurrentHashMap使用ReentrantLock来保证线程安全。
B中，HashMap定义规则如下：

1
2
3

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

C中，应该是Arrays.asList()，其将一个数组转化为一个List对象，这个方法会返回一个ArrayList类型的对象，
这个ArrayList类并非java.util.ArrayList类，而是Arrays类的内部类

java并发集合有不懂有空了解一下

考点3

关于匿名内部类叙述正确的是？ ( )

• A 匿名内部类可以继承一个基类,不可以实现一个接口
• B 匿名内部类不可以定义构造器
• C 匿名内部类不能用于形参
• D 以上说法都不正确

解析

匿名内部类不能有构造器

由于构造器的名字必须与类名相同，而匿名类没有类名，所以匿名类不能有构造器。

考点4

下列关于构造方法的叙述中,错误的是()

• A java语言规定构造方法名与类名必须相同
• B java语言规定构造方法没有返回值,但不同void声明
• C java语言规定构造方法不可以重载
• D java语言规定构造方法只能通过new自动调用

解析

构造方法除了 new 关键字调用外，还可以通过如下方式调用

• 反射
• 反序列化
• this调用
• super调用

考点5

下面哪些具体实现类可以用于存储键,值对,并且方法调用提供了基本的多线程安全支持:( )

• A java.util.ConcurrentHashMap
• B java.util.Map
• C java.util.TreeMap
• D java.util.SortMap
• E java.util.Hashtable
• F java.util.HashMap

解析

线程安全的类有

• hashtable
• concurrentHashMap
• synchronizedMap

有空了解一下

考点6

关于Java中的ClassLoader下面的哪些描述是错误的:( )

• A 默认情况下,Java应用启动过程涉及三个ClassLoader: Boostrap, Extension, System
• B 一般的情况不同ClassLoader装载的类是不相同的,但接口类例外,对于同一接口所有类装载器装载所获得的类是相同的
• C 类装载器需要保证类装载过程的线程安全
• D ClassLoader的loadClass在装载一个类时,如果该类不存在它将返回null
• E ClassLoader的父子结构中,默认装载采用了父优先
• F 所有ClassLoader装载的类都来自CLASSPATH环境指定的路径

解析

反射相关的内容，有空了解一下

考点7

class A {}
class B extends A {}
class C extends A {}
class D extends B {}
Which four statements are true ?

• A The type List<A>is assignable to List.
• B The type List<B>is assignable to List<A>.
• C The type List<Object>is assignable to List<?>.
• D The type List<D>is assignable to List<?extends B>.
• E The type List<?extends A>is assignable to List<A>.
• F The type List<Object>is assignable to any List reference.
• G The type List<?extends B>is assignable to List<?extends A>.

解析

泛型相关的内容，有空了解一下

考点1

有关线程的叙述正确的是()

• A 可以获得对任何对象的互斥锁定。
• B 通过继承Thread类或实现Runnable接口,可以获得对类中方法的互斥锁定。
• C 线程通过使用synchronized关键字可获得对象的互斥锁定。
• D 线程的创建只能通过继承Thread类来实现。

解析

采用synchronized修饰符实现的同步机制叫做互斥锁机制，它所获得的锁叫做互斥锁。
每个对象都有一个monitor(锁标记)，当线程拥有这个锁标记时才能访问这个资源，没有锁标记便进入锁池。
任何一个对象系统都会为其创建一个互斥锁，这个锁是为了分配给线程的，防止打断原子操作。每个对象的锁只能分配给一个线程，因此叫做互斥锁。

考点2

设int x=1,float y=2,则表达式x/y的值是:()

• A 0
• B 1
• C 2
• D 以上都不是

解析

直接量2是int类型，可以自动转成float类型
表达式的计算结果的类型为操作数中范围最大的
x/y的结果为float类型，等于0.5

考点3

java接口的方法修饰符可以为？(忽略内部接口)

• A private
• B protected
• C final
• D abstract

解析

接口方法默认public abstract

考点4

java中提供了哪两种用于多态的机制

• A 通过子类对父类方法的覆盖实现多态
• B 利用重载来实现多态.即在同一个类中定义多个同名的不同方法来实现多态。
• C 利用覆盖来实现多态.即在同一个类中定义多个同名的不同方法来实现多态。
• D 通过子类对父类方法的重载实现多态

解析

多态分为 编译时多态 和 运行时多态 。
其中 编辑时多态是静态的 ， 主要是指方法的重载 ，它是根据参数列表的不同来区分不同的函数，通过编辑之后会变成两个不同的函数，在运行时谈不上多态。
而 运行时多态是动态的 ，它是 通过动态绑定来实现的 ，也就是我们所说的多态性(要有继承关系 2.子类要重写父类的方法 3.父类引用指向子类)

考点5

下列哪个选项是错误的。()

• A 一个文件中只能有一个public class。
• B 一个文件中可以有多个类。
• C 一个类中可以有两个main方法。
• D 若类中只含一个main方法,则必须是public的。

解析

A.一个文件中，可以有多个public class

1
2
3
4

public class Main {
     public class Inner{
    }
}

即，外部类为public，还可以有public的内部类。
B.一个文件中可以有多个类，可以是多个并列的类，也可以是外部类、内部类结合。
C.一个类中，可以有多个main方法，这是重载，但是
public static void main(String[] args)
的方法只能有一个。
D.类中，可以有main方法，也可以没有main方法，而有一个main()方法的时候，也可以是任意访问权限。因为这个类不一定要执行，可以只是辅助类。

考点6

下面有关java threadlocal说法正确的有？

• A ThreadLocal存放的值是线程封闭,线程间互斥的,主要用于线程内共享一些数据,避免通过参数来传递
• B 线程的角度看,每个线程都保持一个对其线程局部变量副本的隐式引用,只要线程是活动的并且 ThreadLocal 实例是可访问的;在线程消失之后,其线程局部实例的所有副本都会被垃圾回收
• C 在Thread类中有一个Map,用于存储每一个线程的变量的副本。
• D 对于多线程资源共享的问题,同步机制采用了”以时间换空间”的方式,而ThreadLocal采用了”以空间换时间”的方式

解析

有空了解一下

考点1

以下()不是合法的标识符？

• A STRING
• B x3x
• C void
• D deSf

解析

void属于java中的关键字

• Java标识符只能由数字、字母、下划线”_”或”$”符号以及Unicode字符集组成
• Java标识符必须以字母、下划线”_”或”$”符号以及Unicode字符集开头
• Java标识符不可以是Java关键字、保留字(const、goto)和字面量(true、false、null)
• Java标识符区分大小写,是大小写敏感的

考点2

在Java中,关于HashMap类的描述,以下错误的是()？

• A HashMap能够保证其中元素的顺序
• B HashMap允许将null用作值
• C HashMap允许将null用作键
• D HashMap使用键/值得形式保存数据

解析

HashMap的底层是由数组加链表实现的，对于每一个key值，都需要计算哈希值，然后通过哈希值来确定顺序，并不是按照加入顺序来存放的，因此可以认为是无序的，但不管是有序还是无序，它都一个自己的顺序。故A错。
最开始有Hashtable，Hashtable是不允许key和value的值为空的

A.HashMap不能保证元素的顺序，而LinkedHashMap可以保持数据的插入顺序，TreeMap可以按照键值进行排序（可自定比较器）
B.HashMap允许存在多条null值
C.HashMap允许且仅允许一条null键
D.Map就是通过键/值形式保存数据的
可能有误，仅供参考，欢迎大佬批评指正。
HashMap

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。
HashMap 继承于AbstractMap，实现了Map、Cloneable、java.io.Serializable接口。
HashMap 的实现不是同步的，这意味着它不是线程安全的。它的key、value都可以为null。此外，HashMap中的映射不是有序的。
HashTable是Java中的遗留类，现在不怎么用了，也许HashTable类的设计者当时认为null作为key 和value 是没有什么用的。

HashMap是之后的版本引进的类，它的接口Map表达的意义更为广泛，也许HashMap的设计者认为null作为key和value是有实际意义的，所以才允许为null.

当然实际项目中，真的是有value为null的情况的。key为null的情况比较少见，但不代表没有。HashMap允许null为key和value应当是类的设计者思考让这个类更有用的设计吧。

考点3

以下代码结果是什么？
public class foo {
public static void main(String sgf[]) {
StringBuffer a=new StringBuffer("A");
StringBuffer b=new StringBuffer("B");
operate(a,b);
System.out.println(a+"."+b);
}
static void operate(StringBuffer x,StringBuffer y) {
x.append(y);
y=x;
}
}

• A 代码可以编译运行,输出”AB.AB“。
• B 代码可以编译运行,输出”A.A“。
• C 代码可以编译运行,输出”AB.B“。
• D 代码可以编译运行,输出”A.B“。

解析

考点4

构造方法用于创建类的实例对象,构造方法名应与类名相同,返回类型为void。

• A 正确
• B 错误

解析

构造函数，名称与类相同，没有返回类型的
如果”构造器”有返回值，那就说普通方法，而不是构造器

考点5

以下程序的执行结果是:

1
2
3
4
5
6
7
8
9
10
11

static boolean foo(char c){
    System.out.print(c);
    return true;
}
public static void main(String[] args) {
    int i =0;
    for(foo('A');foo('B')&&(i<2);foo('C')){
        i++;
        foo('D');
    }
}

• A ABDCBDCB
• B ABCDABCD
• C 编译时出错
• D 运行时抛出异常

解析

考点

• for循环的执行顺序
• 短路与运算符

for循环格式

1
2
3

for(初始化语句; 布尔表达式; 更新语句) {
    循环体;
}

for循环执行顺序

1. 初始化语句, 仅在循环开始前执行一次;
2. 布尔表达式, 用于决定是否继续执行正文过程, 表达式中异常则结束循环;
3. 循环体, 如果过程中存在break, return或者异常, 循环结束(不会执行更新语句), 如果遇到continue, 则会执行更新语句后进入下一轮循环;
4. 更新语句, 注意更新语句不做逻辑真假判断, 到这里一轮循环结束;

考点6

下列说法正确的是( )

• A volatile,synchronized 都可以修改变量,方法以及代码块
• B volatile,synchronized 在多线程中都会存在阻塞问题
• C volatile能保证数据的可见性,但不能完全保证数据的原子性,synchronized即保证了数据的可见性也保证了原子性
• D volatile解决的是变量在多个线程之间的可见性、原子性,而sychroized解决的是多个线程之间访问资源的同步性

解析

synchronized关键字和volatile关键字比较

• volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized关键字要好。
• 但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。
• synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升，实际开发中使用 synchronized 关键字的场景还是更多一些。
• 多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞
• volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。
• volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized关键字解决的是多个线程之间访问资源的同步性。

synchronized: 具有原子性，有序性和可见性；（三个都有）
volatile：具有有序性和可见性（缺一个原子性）

考点7

经过强制类型转换以后,变量a, b的值分别为( )short a = 128; byte b = (byte) a;

• A 128 127
• B 128 -128
• C 128 128
• D 编译错误

解析

byte在内存中占一个字节，范围是 -128到127之间。
java中short占用2bytes，强转short类型为byte，会将多出的高8位进行截断，short类型的 128的补码：0000 0000 1000 0000，强转为byte后的补码：1000 0000,最高位是符号位，

这样就表示-0，但是注意，没有-0，只有0，为了充分利用资源，java就将原来本应该表示“-0”的原码规定为-128，故结果为-128，类型也就能够表示的范围是-128。

考点8

以下JAVA程序代码的输出是

1
2
3

public static void main(String args[]) {
    System.out.println(14^3);
}

• A 2744
• B 13
• C 17
• D 11

解析

异或

^表示异或 就是相同是0 不同是1
14是1110
3是0011
所以14^3=1101，即13

考点9

下面这条语句一共创建了多少个对象:String s=”welcome”+”to”+360;

• A 1
• B 2
• C 3
• D 4

解析

编译器对直接量的优化

“welcome”，”to”，360这三个都是直接量,直接量的连接在编译阶段就可以确定下来。编译器会将其优化成”welcometo360”，也就是只有一个对象。
字符串直接量的连接只生成一个对象

考点10

Java 提供的事件处理模型是一种人机交互模型。它有三个基本要素

• A 事件源
• B 事件对象
• C 事件过程
• D 事件监听器

解析

Java提供的事件处理模型是一种人机交互模型。它有三个基本要素：

1. 事件源(Event Source):即事件发生的场所,就是指各个组件,如按钮等,点击按钮其实就是组件上发生的一个事件;

2)事件(Event):事件封装了组件上发生的事情,比如按钮单击、按钮松开等等;
3) 事件监听器(Event Listener):负责监听事件源上发生的特定类型的事件,当事件到来时还必须负责处理相应的事件;

考点11

常用的servlet包的名称是？

• A java.servlet
• B javax.servlet
• C servlet.http
• D javax.servlet.http

解析

JEE5.0中的Servlet相关的就下面这几个包:

• javax.servlet
• javax.servlet.jsp
• java.servlet.jsp.el
• java.servlet.jsp.tagext

而最用得多的就是
javax.servlet
javax.servlet.http
这两个包了.

考点1

下列哪个样式定义后,内联(非块状)元素可以定义宽度和高度

• A display:inline
• B display:block
• C display:none
• D display:inherit

解析

• block:将行级别元素转为块级别元素
• inline:将块级别元素转为行级别元素
• inline-block:不能自动换行,但是可以设置宽高

内联元素加上display：block后被块级化，块级元素一般是其他元素的容器，可容纳其他内联元素和其他块状元素。块状元素排斥和其他元素一行，高度和宽度起作用，因此可以定义宽高。

考点2

css属性font-style用于设置字体的粗细。请判断这句话的正确与否。

• A T
• B F

解析

font-style属性定义字体的风格

注意：该属性设置使用斜体、倾斜或正常字体。
语法: font-style: normal | italic | oblique | inherit;

• normal:默认正常情况;
• italic:显示文字为斜体(该字体有斜体样式时使用)
• oblique:显示文字为斜体(该字体没有斜体样式时使用,文字斜体显示)
• inherit:从父亲那继承一个样式字体;

font-weight属性设置文本的粗细

注意：该属性用于设置显示元素的文本中所用的字体加粗。

语法: font-weight: normal | bold | bolder | lighter | 100-900 | inherit;

考点3

表示有序列表的是

• A ul
• B dl
• C li
• D ol

解析

• ul 无序列表
• ol 有序列表
• li 定义列表项目
• dl 定义列表

考点4

请选出结构正确的选项

• A <a href=www.nowcoder.com>牛客网</a>
• B <a href="www.nowcoder.com">牛客网</a>
• C <a href="http://www.nowcoder.com/">牛客网</a>
• D <a href="http://www.nowcoder.com/">牛客网

解析

href属性值是URL，而URL里包含协议，但不一定是http协议。如果没协议就会解析为相对路径。在浏览器地址栏中不输入协议名也行是因为浏览器发现这个相对路径没东西之后自动帮你加的协议。

• 属性值要写在引号里面，A错误
• URL中要有协议,B错误
• a标签为双标签故应为<a></a>，所以D错误

考点5

从四个选项选出不同的一个。

• A <nav>
• B <footer>
• C <meta>
• D <canvas>

解析

• A选项<nav></nav>，位于<body></body>中。标签定义导航链接；
• B选项<footer></footer>,位于<body></body>中。标签定义文档或节的页脚；
• C选项<meta>,<meta> 元素可提供有关页面的元信息（meta-information），比如针对搜索引擎和更新频度的描述和关键词。
• <meta>标签位于文档的头部（<head></head>），不包含任何内容。<meta> 标签的属性定义了与文档相关联的名称/值对。
• D选项<canvas>。<canvas>位于<body></body>中， 标签定义图形，比如图表和其他图像。

考点6

HTML 语言中,设置表格中文字与边框距离的标签是( )

• A <table boder="">
• B <table cellspacing="">
• C <table cellpadding="">
• D <table width="">

解析

表格标记的常用属性有9个

• cellpadding:单元格边沿与其内容之间的空白 cellspacing:单元格之间的空白
• border:表格边框的宽度(也可以理解我边框的粗细程度)
• height:表格高度
• width:表格的宽度
• bgcolor:表格背景颜色
• align:表格相对周围元素的对齐方式(也可以理解为表格中的文字内容的对齐方式)
• frame:规定外侧边框哪些部分是可见的
• rules:规定内侧边框哪些部分是可见的

考点7

以下说法,错误的是

• A mark用于显示变粗的文字
• B <del>用于显示删除的文本
• C <ins>的文字会带下划线
• D <strong>用于强调文本

解析

• <mark> 标签定义带有记号的文本。请在需要突出显示文本时使用 <m> 标签。
• <del>定义文档中已被删除的文本。
• <ins> 标签定义已经被插入文档中的文本。
• <strong> 标签和<em> 标签一样，用于强调文本，但<strong> 强调的程度更强一些。

考点8

以下哪个CSS属性是继承属性(inherited)？

• A vertical-align
• B background-color
• C text-indent
• D justify-content

解析

什么是CSS中的继承

继承就是指子节点默认使用父节点的样式属性。

那些属性可以继承

不可继承的属性太多了不要背，记住可以继承的属性有哪些就行了。
可以继承的属性很少，只有颜色，文字，字体间距，行高，对齐方式，和列表的样式可以继承。

• 所有元素可继承：visibility和cursor。
• 内联元素可继承：letter-spacing、word-spacing、white-space、line-height、color、font、font-family、font-size、font-style、font-variant、font-weight、text-decoration、text-transform、direction。
• 终端块状元素可继承：text-indent和text-align。
• 列表元素可继承：list-style、list-style-type、list-style-position、list-style-image。

考点9

关于web表单登录中用到的图形验证码的实现,以下做法不正确的有

• A 返回给浏览器的html代码中包含图形验证码和文本字符串,登录前客户端判断输入内容和页面中保存的内容是否一致
• B 服务器端在返回的图片和cookie中同时包含图形验证码,登录前客户端判断输入内容和cookie保存的内容是否一致
• C 服务器端生成验证码后一方面通过图片将验证码返回给客户端,同时在服务器端保存文本的验证码,由服务器端验证输入内容是否正确
• D 浏览器通过识别图形验证码中的内容和用户输入的内容判断是否一致

解析

放浏览器判断太不安全啦，当然要给服务器来判断啦

考点1

What will be printed when you execute the following code?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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();
    }
}

• A BB
• B CBB
• C BAB
• D None of the above

解析

父类和子类的初始化顺序

1. 父类静态初始化代码，包括静态初始化块，或者静态变量声明。
2. 子类静态初始化代码，包括静态初始化块，或者静态变量声明。
3. 父类实例初始化块
4. 父类构造器
5. 子类实例初始化块
6. 子类构造器

考点2

说明输出结果。

1
2
3
4
5
6
7
8
9
10
11

package test;
import java.util.Date;
public class SuperTest extends Date{
    private static final long serialVersionUID = 1L;
    private void test(){
        System.out.println(super.getClass().getName());
    }public static void main(String[]args){
        new SuperTest().test();
    }
}

• A SuperTest
• B SuperTest.class
• C test.SuperTest
• D test.SuperTest.class

解析

• Object的getClass方法是final的,所以TestSuper和Date都不能重写getClass方法。
• 调用的都是Object的getClass方法，而Object的getClass作用是返回的是运行时的类的名字。这个运行时的类就是当前类SuperTest
• class对象.getName()的返回返回值为:包名+类名

考点3

以下说法中正确的有？

• A StringBuilder是 线程不安全的
• B Java类可以同时用 abstract和final声明
• C HashMap中,使用 get(key)==null可以 判断这个Hasmap是否包含这个key
• D volatile关键字不保证对变量操作的原子性

解析

• abstract修饰的类是抽象类，是可以继承的，而final修饰的类表示不能再被继承，故肯定不能共同使用。故B错。
• HashMap中提供的get(key)获取的是变量，无法判断是否存在key。所以C是错的
• volatile关键字是一种轻量级的同步机制，只保证数据的可见性，而不保证数据的原子性。故D对

考点4

Java是一门支持反射的语言,基于反射为Java提供了丰富的动态性支持,下面关于Java反射的描述，哪些是错误的:( )

• A Java反射主要涉及的类如Class, Method, Filed,等，他们都在java.lang.reflet包下
• B 通过反射可以动态的实现一个接口，形成一个新的类，并可以用这个类创建对象，调用对象方法
• C 通过反射，可以突破Java语言提供的对象成员、类成员的保护机制，访问一般方式不能访问的成员
• D Java反射机制提供了字节码修改的技术，可以动态的修剪一个类
• E Java的反射机制会给内存带来额外的开销。例如对永生堆的要求比不通过反射要求的更多
• F Java反射机制一般会带来效率问题，效率问题主要发生在查找类的方法和字段对象，因此通过缓存需要反射类的字段和方法就能达到与之间调用类的方法和访问类的字段一样的效率

解析

反射指的是在运行时能够分析类的能力的程序。
反射机制可以用来：
1.Field、Method、Constructor位于java.lang.reflect包中。Class类在java.lang中。
2.在运行时查看对象。
3.实现通用的数组操作代码。

反射机制的功能：
在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
反射机制常见作用：
动态加载类、动态获取类的信息（属性、方法、构造器）；动态构造对象；动态调用类和对象的任意方法、构造器；动态调用和处理属性；获取泛型信息（新增类型：ParameterizedType,GenericArrayType等）；处理注解（反射API:getAnnotationsdeng等）。
反射机制性能问题：
反射会降低效率。
void setAccessible(boolean flag):是否启用访问安全检查的开关，true屏蔽Java语言的访问检查，使得对象的私有属性也可以被查询和设置。禁止安全检查，可以提高反射的运行速度。
可以考虑使用：cglib/javaassist操作。

考点5

在异常处理中,若try中的代码可能产生多种异常则可以对应多个catch语句，若catch中的参数类型有父类子类关系，此时应该将父类放在后面，子类放在前面。

• A 正确
• B 错误

解析

如果将父类放在前面的话，异常将被父类完全捕获，子类永远不能捕获异常

考点6

如何跳出Array的forEach循环？( )

• A break
• B return true
• C return false
• D 以上都不是

解析

foreach循环是for循环的增强版,for循环怎么跳,foreach就怎么跳。
这里让人迷惑分点就是这个Array，不要理解成ArrayList的forEach方法。

考点7

下列哪个选项是Java调试器？如果编译器返回程序代码的错误,可以用它对程序进行调试。

• A java.exe
• B javadoc.exe
• C jdb.exe
• D javaprof.exe

解析

• javac.exe是编译.java文件
• java.exe是执行编译好的.class文件
• javadoc.exe是生成Java说明文档
• jdb.exe是Java调试器
• javaprof.exe是剖析工具

jdb是”java debuger”的简写

考点8

ResultSet中记录行的第一列索引为？

• A -1
• B 0
• C 1
• D 以上都不是

解析

ResultSet跟普通的数组不同，索引从1开始而不是从0开始

考点9

下列关于final、finally、finalize说法正确的是( )

• A final可以用来修饰类、方法、变量
• B finally是java保证重点代码一定要被执行的一种机制
• C 变量被final修饰后不能再指向其他对象,但可以重写
• D finalize设计的目的是保证对象在被垃圾收集前完成特定资源的回收

解析

finalize()是Object的方法，子类可以覆盖该方法以实现资源清理工作的目的，GC会在回收对象之前调用该方法
final修饰的变量也不能重写(重新赋值)

考点10

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

public class NameList{
    private List names = new ArrayList();
    public synchronized void add(String name){
        names.add(name);
    }
    public synchronized void printAll() {
        for(int i = 0;i < names.size();i++){
            System.out.print(names.get(i) + "");
        }
    }
    public static void main(String[]args){
        final NameList sl = new NameList();
        for(int i = 0;i < 2;i++){
            new Thread(){
                public void run(){
                    sl.add("A");
                    sl.add("B");
                    sl.add("C");
                    sl.printAll();
                }
            }
             .start();
        }
    }
}

Which two statements are true if this class is compiled and run?

• A An exception may be thrown at runtime.
• B The code may run with no output, without exiting.
• C The code may run with no output, exiting normally(正常地).
• D The code may rum with output “A B A B C C “, then exit.
• E The code may rum with output “A B C A B C A B C “, then exit.
• F The code may ruin with output “A A A B C A B C C “, then exit.
• G The code may ruin with output “A B C A A B C A B C “, then exit.

解析

首先最主要的是，有两条线程在同时进行。

• 线程内的是顺序进行，
• 线程之间的顺序不定，可能是交叉执行，也有可能是先执行了一个线程后执行了另一个线程。

但是无论怎样，两个线程不可能同时执行一个操作，这就说明
执行慢的那个线程s1.println();这行代码将会打印出完整的6个字符的字串（但是两个进程添加顺序不确定，有可能是ABCABC，也有可能最后字串是AABBCC或ABABCC等），这就意味着最后6个字符就是真正的添加顺序。
根据逻辑判断，第一次s1.println()结束时，可能两个线程添加都已经添加完，此时第一次s1.println()输出字符最多6个，第二次s1.println()输出字符个数是6个，也就是最多输出12个。
最少的情况，也就是s1.println()结束时，只有第一个线程进行了add()操作，此时字符输出最少3个，第二次是6个，也就是9个。
也就是输出的字符串个数一定在9~12个之间。所以A、B、C、D排除。
所以看选项E的话，最后字串是ABCABC，那第一次s1.println()操作可能在第一个s1.add(“c”)操作结束到第二个s1.add(“c”)操作之间。比如：(ABC)ABCABC、(ABCA)ABCABC、(ABCAB)ABCABC、(ABCABC)ABCABC。这些都是可能的输出，所以G也正确。所以E、G正确
而选项F。最后6个字符是BCABCC。首先这不可能，因为虽然添加字符顺序是不确定的，但是确定的是第一个添加的字符肯定是A，并且字符串必须由2个A、2个B、2个C组成。

这题烧脑