考点2

1
2
3
4
5
6
7
8
9
10
11
12
13

public static void main(String args[]) {
        Thread t=new Thread(){
        public void  run(){
            dianping();
            
        }
    };
    t.run();
    System.out.print("dazhong");
    }
    static void dianping(){
        System.out.print("dianping");
}

• A dazhongdianping
• B dianpingdazhong
• C a和b都有可能
• D dianping循环输出，dazhong夹杂在中间

正确答案: B

解析

• 调用run()方法不会创建一个新的线程，也就是现在只有一个main线程，run方法在main线程中执行。
• 一个线程中的代码执行顺序是固定的，所以先执行run()，在输出dazhong
• 调用start()方法才会创建线程。

考点3

下面有关java object默认的基本方法，说法错误的是？

• A equals(Object obj) 指示某个其他对象是否与此对象“相等”
• B copy() 创建并返回此对象的一个副本
• C wait() 导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法
• D toString() 返回该对象的字符串表示

正确答案: B

解析

Object中没有copy方法，想不到吧！

考点4

结构型模式中最体现扩展性的模式是（）

• A 装饰模式
• B 合成模式
• C 桥接模式
• D 适配器

正确答案: A

解析

什么是结构型模式

结构型模式是描述如何将类对象结合在一起，形成一个更大的结构。
结构模式描述两种不同的东西：类与类的实例。故可以分为类结构模式和对象结构模式。

GoF结构型模式

在GoF设计模式中，结构型模式有：

1.适配器模式 Adapter

适配器模式是将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
两个成熟的类需要通信，但是接口不同，由于开闭原则，我们不能去修改这两个类的接口，所以就需要一个适配器来完成衔接过程。

2.桥接模式 Bridge

桥接模式将抽象部分与它的实现部分分离，是它们都可以独立地变化。它很好的支持了开闭原则和组合锯和复用原则。实现系统可能有多角度分类，每一种分类都有可能变化，那么就把这些多角度分离出来让他们独立变化，减少他们之间的耦合。

3.组合模式 Composite

组合模式将对象组合成树形结构以表示部分-整体的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。

4.装饰模式 Decorator

装饰模式动态地给一个对象添加一些额外的职责，就增加功能来说，它比生成子类更灵活。也可以这样说，装饰模式把复杂类中的核心职责和装饰功能区分开了，这样既简化了复杂类，有去除了相关类中重复的装饰逻辑。
装饰模式没有通过继承原有类来扩展功能，但却达到了一样的目的，而且比继承更加灵活，所以可以说装饰模式是继承关系的一种替代方案。

5.外观模式 Facade

外观模式为子系统中的一组接口提供了同意的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
外观模式中，客户对各个具体的子系统是不了解的，所以对这些子系统进行了封装，对外只提供了用户所明白的单一而简单的接口，用户直接使用这个接口就可以完成操作，而不用去理睬具体的过程，而且子系统的变化不会影响到用户，这样就做到了信息隐蔽。

6.享元模式 Flyweight

享元模式为运用共享技术有效的支持大量细粒度的对象。因为它可以通过共享大幅度地减少单个实例的数目，避免了大量非常相似类的开销。享元模式是一个类别的多个对象共享这个类别的一个对象，而不是各自再实例化各自的对象。这样就达到了节省内存的目的。

7.代理模式 Proxy

为其他对象提供一种代理，并由代理对象控制对原对象的引用，以间接控制对原对象的访问。

考点5

下面有关 java 类加载器,说法正确的是?()

• A 引导类加载器(bootstrap class loader):它用来加载 Java 的核心库,是用原生代码来实现的
• B 扩展类加载器(extensions class loader):它用来加载 Java 的扩展库。
• C 系统类加载器(system class loader):它根据 Java 应用的类路径(CLASSPATH)来加载 Java 类
• D tomcat 为每个 App 创建一个 Loader,里面保存着此 WebApp 的 ClassLoader。需要加载 WebApp 下的类时,就取出 ClassLoader 来使用

正确答案: ABCD

解析

1）Bootstrap ClassLoader

负责加载$JAVA_HOME中jre/lib/rt.jar里所有的class，由C++实现，不是ClassLoader子类

2）Extension ClassLoader

负责加载java平台中扩展功能的一些jar包，包括$JAVA_HOME中jre/lib/*.jar或-Djava.ext.dirs指定
目录下的jar包

3）App ClassLoader

负责记载classpath中指定的jar包及目录中class

4）Custom ClassLoader

属于应用程序根据自身需要自定义的ClassLoader，如tomcat、jboss都会根据j2ee规范自行实现ClassLoader

自底向上检查类是否加载

加载过程中会先检查类是否被已加载，检查顺序是自底向上，
从Custom ClassLoader到BootStrap
ClassLoader逐层检查，
只要某个classloader已加载就视为已加载此类

加载顺序自顶向下

而加载的顺序是自顶向下，也就是由上层来逐层尝试加载此类。

考点6

Java类Demo中存在方法func0、func1、func2、func3和func4，请问该方法中，哪些是不合法的定义？( )

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

public class Demo{
　　float func0()
　　{
　　　　byte i=1;
　　　　return i;
　　}
　　float func1()
　　{
　　　　int i=1;
　　　　return;
　　}
　　float func2()
　　{
　　　　short i=2;
　　　　return i;
　　}
　　float func3()
　　{
　　　　long i=3;
　　　　return i;
　　}
　　float func4()
　　{
　　　　double i=4;
　　　　return i;
　　}
}

• A func1
• B func2
• C func3
• D func4

正确答案: AD

解析

这道题考的是数据类型转换问题。由大到小需要强制转换，由小到大不需要。
A：return; 没有返回值，错误
B：short 转成 float 无须强制转换，正确
C：long 转成 float 无须强制转换（这个最选项容易出错），正确。
float占4个字节为什么比long占8个字节大呢，因为底层的实现方式不同。
浮点数的32位并不是简单直接表示大小，而是按照一定标准分配的。
第1位，符号位，即S
接下来8位，指数域，即E。
剩下23位，小数域，即M，取值范围为[1 ,2 ) 或[0 , 1)
然后按照公式：
V=(-1)^s * M * 2^E
也就是说浮点数在内存中的32位不是简单地转换为十进制，而是通过公式来计算而来

虽然float只有4个字节，但浮点数最大值要比长整型的范围要大。
D：double → float 没有强制转换，错误。

考点1

下面语句正确的是（）

• A x+1=5
• B i++=1
• C a++b=1
• D x+=1

正确答案: D

解析

赋值运算左值必须是变量

赋值运算符“=”右值可以是任何常数、变量或者表达式（只要能生成一个值就行）。但左值必须是一个明确的、已命名的变量
所以对于i++ = 1，a++b = 1，x+1=5来说，赋值运算符的左边不是一个变量当然是错误的。

考点2

类Person里面有个方法sleep()，如果直接用Person.sleep()，则方法sleep前面必须用的关键词是？ ( )

• A class
• B static
• C public
• D final

正确答案: B

解析

考点3

下列描述中，错误的是

• A SQL语言又称为结构化查询语言
• B java中”static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问
• C 面向对象开发中，引用传递意味着传递的并不是实际的对象，而是对象的引用，因此，外部对引用对象所做的改变不会反映到所引用的对象上
• D java是强类型语言，javascript是弱类型语言
• E 面向对象的三大特性包括：封装，继承，多态

正确答案: C

解析

这道题选C，因为引用代表就是所引用的是实际的对象，对引用的修改就是对对象的修改，可以理解为两把钥匙可以打开同一扇门，所以C错；其他几个选项都是对的

考点4

下列说法正确的是()

• A WebLogic中开发消息Bean的non－persistent 方式可以保证消息的可靠
• B EJB容器发生错误，non－persistent方式下JMS容器仍然会将消息发送
• C EJB容器发生错误，persistent方式下JMS容器仍然会将消息发送
• D EJB容器发生错误，两种方式下JMS容器仍会在MDB可用的时候将消息发送

正确答案: C

解析

我不懂，解析我也看不懂，有空了解一下

考点5

下列语句正确的是：

• A 形式参数可被字段修饰符修饰
• B 形式参数不可以是对象
• C 形式参数为方法被调用时真正被传递的参数
• D 形式参数可被视为local variable

正确答案: D

解析

A：形式参数只能被final修饰
B：形式参数可以是对象
C：形式参数被调用时被传递的是实际参数的拷贝
D：local variable：局部变量

修饰符待整理

Java语言提供了很多修饰符，大概分为两类：

1. 访问权限修饰符
2. 非访问权限修饰符
   访问权限修饰符
   public：共有访问。对所有的类都可见。
   protected：保护型访问。对同一个包可见，对不同的包的子类可见。
   default：默认访问权限。只对同一个包可见，注意对不同的包的子类不可见。
   private：私有访问。只对同一个类可见，其余都不见。
   非访问权限修饰符
   static 修饰符，用来创建类方法和类变量。
   final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
   abstract 修饰符，用来创建抽象类和抽象方法。
   synchronized 用于多线程的同步。
   volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
   transient：序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
   类
   外部类修饰符
   public（访问控制符），将一个类声明为公共类，它可以被任何对象访问，一个程序的主类必须是公共类。
   default（访问控制符），类只对包内可见，包外不可见。
   abstract（非访问控制符），将一个类声明为抽象类，抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充，抽象类可以包含抽象方法和非抽象方法。。
   final（非访问控制符），将一个类生命为最终（即非继承类），表示它不能被其他类继承。
   注意：

1.protected 和 private 不能修饰外部类，是因为外部类放在包中，只有两种可能，包可见和包不可见。
2. final 和 abstract不能同时修饰外部类，因为该类要么能被继承要么不能被继承，二者只能选其一。
3.不能用static修饰类，因为类加载后才会加载静态成员变量。所以不能用static修饰类和接口，因为类还没加载，无法使用static关键字。
内部类修饰符
内部类与成员变量地位一直，所以可以public,protected、default和private，同时还可以用static修饰，表示嵌套内部类，不用实例化外部类，即可调用。
方法修饰符
public（公共控制符），包外包内都可以调用该方法。
protected（保护访问控制符）指定该方法可以被它的类和子类进行访问。具体细节可参考：http://blog.csdn.net/dawn_after_dark/article/details/74453915
default(默认权限），指定该方法只对同包可见，对不同包（含不同包的子类）不可见。
private（私有控制符）指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类），非常严格的控制。
final ,指定方法已完备，不能再进行继承扩充。
static，指定不需要实例化就可以激活的一个方法，即在内存中只有一份，通过类名即可调用。
synchronize，同步修饰符，在多个线程中，该修饰符用于在运行前，对它所属的方法加锁，以防止其他线程的访问，运行结束后解锁。
native，本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。
abstract ,抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。抽象方法不能被声明成 final 和 static。 任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。 如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。 抽象方法的声明以分号结尾，例如：public abstract sample();。
成员变量修饰符
public（公共访问控制符），指定该变量为公共的，它可以被任何对象的方法访问。
protected（保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。
default(默认权限），指定该变量只对同包可见，对不同包（含不同包的子类）不可见。
private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。
final，最终修饰符，指定此变量的值不能变。
static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。
transient（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。不持久化。
volatile（易失修饰符）指定该变量可以同时被几个线程控制和修改，保证两个不同的线程总是看到某个成员变量的同一个值。
final 和 static 经常一起使用来创建常量。
局部变量修饰符
only final is permitted。
为什么不能赋予权限修饰符？
因为局部变量的生命周期为一个方法的调用期间，所以没必要为其设置权限访问字段，既然你都能访问到这个方法，所以就没必要再为其方法内变量赋予访问权限，因为该变量在方法调用期间已经被加载进了虚拟机栈，换句话说就是肯定能被当前线程访问到，所以设置没意义。
为什么不能用static修饰
我们都知道静态变量在方法之前先加载的，所以如果在方法内设置静态变量，可想而知，方法都没加载，你能加载成功方法内的静态变量？
接口
接口修饰符
接口修饰符只能用public、default和abstract。
不能用final、static修饰。
接口默认修饰为abstract。
接口中方法修饰符
only public & abstract are permitted 。
意思只能用 public abstract修饰，当然如果你什么都不写，默认就是public abstract。
注意：在Java1.8之后，接口允许定义static 静态方法了！所以也可以用static来修饰！

考点6

变量a是一个64位有符号的整数，初始值用16进制表示为：0Xf000000000000000； 变量b是一个64位有符号的整数，初始值用16进制表示为：0x7FFFFFFFFFFFFFFF。 则a-b的结果用10进制表示为多少？（）

• A 1
• B -(2^62+2^61+2^60+1)
• C 2^62+2^61+2^60+1
• D 2^59+(2^55+2^54+…+2^2+2^1+2^0)

正确答案: C

解析

1
2
3
4
5
6
7
8
9
10

0Xf000000000000000补码为1111000000000000000000000000000000000000000000000000000000000000
0x7FFFFFFFFFFFFFFF补码为0111111111111111111111111111111111111111111111111111111111111111
a-b=a+(-b)=
1111000000000000000000000000000000000000000000000000000000000000+
1000000000000000000000000000000000000000000000000000000000000001=
10111000000000000000000000000000000000000000000000000000000000001(高位溢出舍去)
则结果为
0111000000000000000000000000000000000000000000000000000000000001=
2^62+2^61+2^60+1
答案为C

考点7

Java对象的初始化方式有（ ）

• A 初始化块
• B 构造器
• C 定义变量时指定初始化值
• D 其它各项都不对

正确答案: ABC

解析

对象的初始化方式

1.new时初始化
2.静态工厂 newInstance；
3.反射Class.forName()；
4.clone方式；
5.反序列化；

考点8

下面关于变量及其范围的陈述哪些是不正确的（）

• A 实例变量是类的成员变量
• B 实例变量用关键字static声明
• C 在方法中定义的局部变量在该方法被执行时创建
• D 局部变量在使用前必须被初始化

正确答案: BC

解析

实例变量属于对象
c选项应该是在线程为该方法创建栈桢时被创建，而不是方法执行时创建

考点1 重载

一个类中，有两个方法名、形参类型、顺序和个数都完全一样，返回值不一样的方法,这种现象叫覆盖。（ ）

• A 正确
• B 错误

解析

考点2 Object类

以下关于Object类的说法正确的是（）

• A Java中所有的类都直接或间接继承自Object，无论是否明确的指明，无论其是否是抽象类。
• B Java中的接口(interface)也继承了Object类
• C 利用“==”比较两个对象时，Java调用继承自Object的equals方法，判断是否相等。
• D 如果类的定义中没有重新定义toString()方法，则该类创建的对象无法使用toStrig()方法。

解析

• A. Java中的所有类都直接或间接继承自Object，无论是否明确的指明，也无论其是否是抽象类。
• B. Java中的接口（interface）并没有继承自Object一个类的子类必然是另一个类，如果interface继承自Object，那么interface也必然是一个类。这和接口的定义矛盾

考点3 try-catch-finally返回值

执行如下代码后输出结果为（ ）

1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

• A return value of getValue(): 1
• B return value of getValue(): 4
• C return value of getValue(): 5
• D 其他几项都不对

解析

考点4 集合Collection List和Set的区别

列表(List)和集合(Set)下面说法正确的是？ ( )

• A Set中至多只能有一个空元素
• B List中至多只能有一个空元素
• C List和Set都可以包含重复元素的有序集合
• D List和Set都是有序集合

解析

• Set 不能有重复的元素，且是无序的，要有空值也就只能有一个。因为它不允许重复。
• List 可以有重复元素，且是有序的，要有空值也可以有多个，因为它可重复

集合中的有序的含义

java里面讲的有序无序，指的是你按照顺序存进去数据，然后再按照顺序取出来，两者是一样的。比如List(0)我放的是“a”，那么我list.get(0)取出来也是“a”。
并不代表我存了打乱顺序存1到10十个数，它会自己给按照升序或者降序给你排好序。

考点5 静态成员变量

关于以下程序代码的说明正确的

1
2
3
4
5
6
7
8
9
10
11
12
13

class HasStatic{
    private static int x = 100;
    public static void main(String args[ ]){
        HasStatic hs1 = new HasStatic();
        hs1.x++;
        HasStatic hs2 = new HasStatic();
        hs2.x++;
        hs1=new HasStatic();
        hs1.x++;
        HasStatic.x--;
        System.out.println( "x=" +x);
    }
}

• A 5行不能通过编译，因为引用了私有静态变量
• B 10行不能通过编译，因为x是私有静态变量
• C 程序通过编译，输出结果为：x=103
• D 程序通过编译，输出结果为：x=102

解析

• 此处是main函数在这个类内部，因而可以访问私有的静态成员。
• 在其他类中的main方法是会显示语法有错

考点6 命令行参数

如下的Java程序

1
2
3
4
5

public class Test { 
    public static void main(String[] args) { 
        System.out.println(args[0]); 
    } 
} 

若采用命令行“java Test one two three”调用，则程序输出的结果为：

• A Test
• B one
• C two
• D java

解析

不要和linux脚本的参数弄混了。

• Linux里$0是程序名，$1以后才是参数
• java里arg[0]就是第一个参数

考点7 前加加和后加加不可同时使用

以下代码段执行后的输出结果为

1
2
3
4
5
6
7

public class Test {
    public static void main(String args[]) {
        int i = -5;
        i =  ++(i++);
        System.out.println(i);
    }
}

• A -7
• B -3
• C 编译错误
• D -5

解析

i++表示先赋值后加1，但前面又有一个++表示先加1再赋值，矛盾，编译器报错。

考点8 JVM规范 java内存区域

以下哪些内存区域属于JVM规范？（　　）

• A 方法区
• B 实例变量
• C 静态变量
• D 程序计数器
• E 虚拟机栈

解析

JVM内存区：

• 程序计数器、
• 虚拟机栈、
• 本地方法栈、
• 堆、
• 方法区（包括常量池）。

不属于JVM内存区：直接内存（Direct Memory），用户I/O操作

考点1 数据库 关系模型和对象模型的匹配关系

一般情况下，以下哪个选项不是关系数据模型与对象模型之间匹配关系？

• A 表对应类
• B 记录对应对象
• C 表的字段对应类的属性
• D 表之间的参考关系对应类之间的依赖关系

解析

一般关系数据模型和对象数据模型之间有以下对应关系：

• 表对应类，
• 记录对应对象，
• 表的字段对应类的属性

目前ORMapping只是规定了数据结构和数据集的映射关系，还没到规定赖关系的阶段

考点2

已知有下列Test类的说明，在该类的main方法内，则下列哪个语句是正确的？（）

1
2
3
4
5
6
7
8
9
10

public class Test
{
    private float f = 1.0f;
    int m = 12;
    static int n = 1;
    public static void main (String args[])
    {
    Test t = new Test();
    }
}

• A t.f;
• B this.n;
• C Test.m
• D Test.f

解析

A的答案中变量虽然为private，但因为main函数在该类中，所以即使private也仍可使用

考点3

下面赋值语句中正确的是（）

• A double d=5.3e12;
• B float f=11.1;
• C int i=0.0;
• D Double oD=3;

正确答案: A

解析

java中整型默认的是int,浮点默认的是double.
A: double类型遵循IEEE754标准（具体自己查一下），约为10^-30810^308和-10^-308-10^308，所以本题在范围里
B: double类型的11.1 转成 float，是需要强制转换的
C: double类型的0.0 转成 int，也是需要强制转换的
D: int 转为 封装类型Double，是无法编译的，int虽可以转换成double，但在类型转换时无法进行自动装箱，故错误

考点4

下列不属于Java语言性特点的是

• A Java致力于检查程序在编译和运行时的错误
• B Java能运行虚拟机实现跨平台
• C Java自己操纵内存减少了内存出错的可能性
• D Java还实现了真数组，避免了覆盖数据类型的可能

正确答案: D

解析

什么是真数组

程序设计语言中，数组元素在内存中是一个接着一个线性存放的，通过第一个元素就能访问随后的元素，这样的数组称之为“真数组”。
实现了真数组为Java语言健壮性的特点之一。

真数组：
1、在内存中连续分配。
2、数组所存在的内存空间为数组专用，避免了数据被覆盖的问题。

是避免数据覆盖，而不是数据类型覆盖

考点5

在java语言中，如果你编写一个多线程序，可以使用的方法是（）

• A 扩展类Thread
• B 实现Runnable接口
• C 扩展类 Runnable
• D 实现接口Thread

正确答案: AB

解析

Java多线程实现方式主要有四种：
1、继承Thread类
2、实现Runnable接口
3、实现Callable接口通过FutureTask包装器来创建Thread线程
4、使用ExecutorService、Callable、Future实现有返回结果的多线程

前两种方式线程执行完后都没有返回值，后两种是带返回值的。

考点6

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

• A int a[][]=new int[][]
• B int b[10][10]=new int[][]
• C int c[][]=new int[10][10]
• D int []d[]=new int[10][10]

正确答案: CD

解析

1. 定义一维数组时，必须显式指明数组的长度；
2. 定义多维数组时，其一维数组的长度必须首先指明，其他维数组长度可以稍后指定；
3. 采用给定值初始化数组时，不必指明长度；
4. “[]” 是数组运算符的意思，在声明一个数组时，数组运算符可以放在数据类型与变量之间，也可以放在变量之后。

一维数组中，[]在变量名arr前还是后，这个写法没有固定的要求，
二维数组中，[][]a这三个元素其实可以作全排列，不论怎么排都不影响最后的编译结果，写法没有固定的要求。
在实际编程中，但最好统一。

考点7

有以下程序段， 则下面正确的选项是（）

1
2
3
4
5
6
7
8
9
10
11
12
13

public class MyThead extends Thread{
    public static void main(String[] args) {
        MyThead t=new MyThead();
        MyThead s=new MyThead();
        t.start();
        System.out.println("one.");
        s.start();
        System.out.println("two.");
    }
    public void run() {
        System.out.println("Thread");
    }
}

• A 编译失败
• B 程序运行可能结果为： one. Thread two. Thread
• C 程序运行可能结果是： one. two. Thread Thread
• D 程序运行结果不稳定

正确答案: BCD

解析

同一个线程中的输出顺序是确定的，main线程中的输出语句确定，也就是，只要one在two前面输出，thread在其后面那个位置输出无所谓。

考点8

java8中，忽略内部接口的情况，不能用来修饰interface里的方法的有（ ）

• A private
• B public
• C protected
• D static

正确答案: AC

解析

java8 接口新特性：可以定义：

• 静态方法（有方法体） 和
• default方法（有方法体

考点9

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

• A 可以获得对任何对象的互斥锁定
• B 通过继承Thread类或实现Runnable接口，可以获得对类中方法的互斥锁定
• C 线程通过使用synchronized关键字可获得对象的互斥锁定
• D 线程调度算法是平台独立的

正确答案: CD

解析

A，“任何对象”锁定，太绝对了，你能锁住你没有权限访问的对象吗？
B，前半句话讲的是创建线程的方式，后半句讲的是锁定，驴头不对马嘴。
C，正确。
D，线程调度分为协同式调度和抢占式调度，Java使用的是抢占式调度，也就是每个线程将由操作系统来分配执行时间，线程的切换不由线程本身来决定（协同式调度）。这就是平台独立的原因。
以上，选CD

考点1

关于容器下面说法正确的是？ ( )

• A 列表(List)和集合(Set)存放的元素都是可重复的。
• B 列表(List)和集合(Set)存放的元素都是不可重复的。
• C 映射(Map)<key,value>中key是可以重复的。
• D 映射(Map)<key,value>中value是可以重复的。

正确答案: D

解析

• List列表的元素是有序的，可重复的
• 集合Set的元素是无序的，不可重复的
• map是使用的是键值对存放，key不重复，value是可重复的

考点2

以下关于继承的叙述正确的是

• A 在Java中类只允许单一继承
• B 在Java中一个类不能同时继承一个类和实现一个接口
• C 在Java中接口只允许单一继承
• D 在Java中一个类只能实现一个接口

正确答案: A

解析

• 类支持单继承，
• 接口支持多继承，一个接口可以有多个父接口，子接口扩展某个父接口，将会获得父接口里定义的所有抽象方法、常量。一个接口继承多个父接口时，多个父接口排在extends关键字之后。

考点3

以下会产生信息丢失的类型转换是( ）

• A float a=10
• B int a=（int）8846.0
• C byte a=10； int b=-a
• D double d=100

正确答案: B

解析

精度丢失只会发生在从大范围到小范围的转换
上面四个选项，只有 B 是从 double 到 int，也就是从大范围到小范围。

float a=10.0; 是把 double 转车 float. 会损失精度. 正确的写法是 float=10.0f;

考点4

java Thread中，run方法和start方法的区别，下面说法错误的是？

• A 通过调用Thread类的start()方法来启动一个线程，这时此线程是处于就绪状态，并没有运行。
• B 他们都可以实现了多线程运行。
• C run方法是thread的一个普通方法调用。
• D 调用start方法后，一旦得到cpu时间片，就开始执行run()方法。

正确答案: B

解析

start方法和run方法的区别

1.start方法

用start方法来启动线程，是真正实现了多线程，
通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法。但要注意的是，此时无需等待run()方法执行完毕，即可继续执行下面的代码。所以run()方法并没有实现多线程。

2.run方法

run()方法只是类的一个普通方法而已，如果直接调用run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码。

考点5

下面哪个选项正确创建socket连接？

• A Socket s = new Socket(8080);
• B Socket s = new Socket(“192.168.1.1”,8080)
• C SocketServer s = new Socket(8080);
• D Socket s = new SocketServer(“192.168.1.1”,8080)

正确答案: B

解析

创建客户端Socket

创建 Socket 肯定要知道服务器ip 和 port 啊
服务器的 ServerSocket 只需要开放端口号就行啦
也就是
服务器端：ServerSocket提供的实例 ServerSocket server = new ServerSocket(端口号)
客户端：Socket提供的实例 Socket client = new Socket(IP地址，端口号)

考点6

变量a是一个64位有符号的整数，初始值用16进制表示为：0x7FFFFFFFFFFFFFFF;变量b是一个64位有符号的整数，初始值用16进制表示为：0x8000000000000000。则a+b的结果用10进制表示为多少？

• A 1
• B -1
• C 2^63+2^62+…+2^2+2^1+2^0
• D –(2^63+2^62+…+2^2+2^1+2^0)

正确答案: B

解析

计算机中是以补码存储并参与运算的，所以题目中的初始值均是补码
（1）a+b的16进制表示为：OxFFFFFFFFFFFFFFF（16位F），转为2进制为111……111（64位1，每个F->4位2）。
（2）有符号数：是针对二进制来讲的。用最高位作为符号位，“0”代表“+”，“1”代表“-”。所以a+b的结果是一个负数。
（3）计算机中负数是以补码的形式保存的，将补码转换成原码的计算方式如下：
①. 对于正数，原码与补码相同。
②.对于负数，将补码除符号位之外，按位取反，末位加1，即得到原码。
（4）a + b = 111……111（64位1）
取反：100……000（1位1，后面63位0）
加一：100……001（中间62位0）
10进制：-1。

考点7

代码片段：

1
2
3
4
5

byte b1=1,b2=2,b3,b6;  
final byte b4=4,b5=6;  
b6=b4+b5;  
b3=(b1+b2);  
System.out.println(b3+b6);

关于上面代码片段叙述正确的是（）

• A 输出结果：13
• B 语句：b6=b4+b5编译出错
• C 语句：b3=b1+b2编译出错
• D 运行期抛出异常

正确答案: C

解析

没有final修饰的byte变量相加后会被自动提升为int型，与目标类型byte不相容，需要强制转换（向下转型）。

表达式的数据类型自动提升规则。

①所有的byte,short,char型的值将被提升为int型；
②如果有一个操作数是long型，计算结果是long型；
③如果有一个操作数是float型，计算结果是float型；
④如果有一个操作数是double型，计算结果是double型；

1
2

final byte b4=4,b5=6;
b6=b4+b5;  

声明b4与b5为final常量，不可改变。
所以b4+b5的结果为byte类型。

1
2

byte b1=1,b2=2;
b3=(b1+b2);  

b1+b2的结果会自动升级为int类型。
int类型赋值给低级别byte的需要强制转换。

考点8

已知如下的命令执行 java MyTest a b c 请问哪个语句是正确的？ ( )

• A args[0] = “MyTest a b c”
• B args[0] = “MyTest”
• C args[0] = “a”
• D args[1]= “b”

正确答案: CD

解析

考点9

对于代码 var a = 10.42; 取出 a 的整数部分，以下代码哪些是正确的？

• A parseInt(a);
• B Math.floor(a);
• C Math.ceil(a);
• D a.split(‘.’)[0];

正确答案: AB

解析

Math的ceil floor round详解

• Math.ceil(); ceiling（天花板） 所以向上取整
• Math.floor();floor（地板）所以向下取整
• Math.round()
  • 对于正数是四舍五入，
  • 对于负数,
    • 小数点后的数<=5都是舍去，
    • 而大于5是减一

关于java 10引入的var

2018年3月20日，Oracle发布java10。java10为java带来了很多新特性，其中包括var关键字的引入。
eg：
public class Example {
public static void main(String[] args) {
var eg = new Example;
eg.emptyFunc();
}
public void emptyFunc() {}
}

java对var的要求

java在var上是有要求的。总结起来，有以下三点很重要：
（1）只能用于局部变量上；
（2）声明时必须初始化；
（3）不能用作方法参数。

考点10

下面关于面向对象的一些理解哪些是错误的( )

• A 面向对象的最重要的特性是支持继承、封装和多态
• B 系统设计应该遵循开闭原则，系统应该稳定不不可修改，但应支持通过继承、组合等方式进行扩展
• C 函数式的语言必然是面向对象的语言
• D 面向对象设计时，每个类的职责应该单一，不要再一个类中引入过多的接口
• E 过程式语言和面向对象的语言各有其优势，过程式语言更加灵活，面向对象语言更加强调抽象和封装
• F Java和C++都是静态类型的面向对象编程语言

正确答案: C

解析

什么是动态类型语言

动态类型语言是指在运行期间才去做数据类型检查的语言，也就是说，在用动态类型的语言编程时，永远也不用给任何变量指定数据类型，该语言会在你第一次赋值给变量时，在内部将数据类型记录下来。

什么是静态类型语言

静态类型语言与动态类型语言刚好相反，它的数据类型是在编译其间检查的，也就是说在写程序时要声明所有变量的数据类型，C/C++是静态类型语言的典型代表，其他的静态类型语言还有C#、JAVA等。

考点1 is-a has-a use-a

在面向对象编程里，经常使用is-a来说明对象之间的继承关系，下列对象中不具备继承关系的是？（）

• A 手机与小米手机
• B 企业家与雷军
• C 编程语言与Java
• D 中国与北京

解析

is-a 的关系：
A：小米手机是一个手机，没毛病
B：雷军是一个企业家，没毛病
C：Java是一门编程语言，没毛病
D：北京是一个中国，不对

use-a has-a is-a

类之间存在以下几种常见的关系

• use-a :是依赖关系
• has-a :一般是组合关系
• is-a : 一般是继承关系

考点2 垃圾收集器

下面关于垃圾收集的描述哪个是错误的？

• A 使用垃圾收集的程序不需要明确释放对象
• B 现代垃圾收集能够处理循环引用问题
• C 垃圾收集能提高程序员效率
• D 使用垃圾收集的语言没有内在泄漏问题

解析

内存泄露

内存泄露(Memory Leak)是指一个不再被使用的对象或者变量还在内存中占有存储空间。
在C/C++语言中，内存泄露出现在开发人员忘记释放已分配的内存就会造成内存泄露。
在java语言中引入垃圾回收机制，有GC负责进行回收不再使用的对象，释放内存。但是还是会存在内存泄露的问题。

内存泄露主要有两种情况

1. 在堆中申请的空间没有释放。
2. 对象已不再被使用(注意：这里的不在被使用是指对程序来说没有用处，如数据库连接使用后没有关。但是还是存在着引用)，但是仍然在内存中保留着。GC机制的引入只能解决第一种情况，对于第2种情况无法保证不再使用的对象会被释放。java语言中的内存泄露主要指第2种情况。

内存泄露的原因

1. 静态集合类。如HashMap和Vector。这些容器是静态的，生命周期和程序的生命周期一致，那么在容器中对象的生命周期也和其一样，对象在程序结束之前将不能被释放，从而会造成内存泄露。
2. 各种连接，如数据库连接，网络连接，IO连接，不再使用时如果连接不释放容易造成内存泄露。
3. 监听器，释放对象时往往没有相应的删除监听器，可能会导致内存泄露。

内存溢出

内存溢出（OOM）是指程序在申请内存时没有足够的内存供使用，进而导致程序崩溃这是结果描述。

内存泄露（Memory Leak）最终会导致内存溢出。

Java的内存分配策略

Java 程序运行时的内存分配策略有三种,分别是
静态分配,栈式分配,和堆式分配，对应的，
三种存储策略使用的内存空间主要分别是静态存储区（也称方法区）、栈区和堆区。

• 静态存储区（方法区）：主要存放静态数据、全局 static 数据和常量。这块内存在程序编译时就已经分配好，并且在程序整个运行期间都存在。
• 栈区：当方法被执行时，方法体内的局部变量（其中包括基础数据类型、对象的引用）都在栈上创建，并在方法执行结束时这些局部变量所持有的内存将会自动被释放。因为栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
• 堆区 ： 又称动态内存分配，通常就是指在程序运行时直接 new 出来的内存，也就是对象的实例（包括该对象其中的所有成员变量）。这部分内存在不使用时将会由 Java 垃圾回收器来负责回收。

Java中的内存管理

Java的内存管理就是对象的分配和释放问题。在 Java 中，程序员需要通过关键字 new 为每个对象申请内存空间 (基本类型除外)，所有的对象都在堆 (Heap)中分配空间。

关于提高效率

对象的释放是由 GC 决定和执行的。在 Java 中，内存的分配是由程序完成的，而内存的释放是由 GC 完成的，这种收支两条线的方法确实简化了程序员的工作。但同时，它也加重了JVM的工作。

关于消除循环引用

Java使用有向图的方式进行内存管理，可以消除引用循环的问题。
例如有三个对象，相互引用，只要它们和根进程不可达的，那么GC也是可以回收它们的。这种方式的优点是管理内存的精度很高，但是效率较低。
另外一种常用的内存管理技术是使用计数器。具体如下：gc清理时的引用计数方式：
当引用连接至新对象时，引用计数+1；
当某个引用离开作用域或被设置为null时，引用计数-1，
GC发现这个计数为0时，就回收其占用的内存。这个开销会在引用程序的整个生命周期发生，并且不能处理循环引用的情况。所以这种方式只是用来说明GC的工作方式，而不会被任何一种Java虚拟机应用。例如COM模型采用计数器方式管理构件，它与有向图相比，精度行低(很难处理循环引用的问题)，但执行效率很高。

什么是内存泄漏

在Java中，内存泄漏就是存在一些被分配的对象，这些对象有下面两个特点，

• 首先，这些对象是可达的，即在有向图中，存在通路可以与其相连；
• 其次，这些对象是无用的，即程序以后不会再使用这些对象。如果对象满足这两个条件，这些对象就可以判定为Java中的内存泄漏，这些对象不会被GC所回收，然而它却占用内存。

有兴趣看引起内存泄漏的原因的可以参考这篇文章http://www.jb51.net/article/92311.htm

考点3 == 比较运算符等于

下面的输出结果是什么？

1
2
3
4
5
6
7
8
9
10
11
12
13

public class Demo {
    public static void main(String args[])
    {
        String str=new String("hello");
        if(str=="hello")
        {
            System.out.println("true");
        }      
        else {
            System.out.println("false");
        }
    }
}

• A true
• B false

解析

这种题烂大街

考点4 类方法 对象方法

类方法中可以直接调用对象变量。（ ）

• A 正确
• B 错误

解析

静态成员不能调用非静态成员

静态方法中不能调用对象的变量，因为静态方法在类加载时就初始化，对象变量需要在新建对象后才能使用

考点5 方法形参传递 Java只有值传递

下列java程序的输出结果为____。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class Example{
    String str=new String("hello");
    char[] ch={'a','b'};
    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]='c';
    }
}

• A hello and ab
• B hello and cb
• C hello and a
• D test ok and ab
• E test ok and cb
• F test ok and c

解析

java中只有值传递，改变形参的地址不影响到实参

考点6 重载 重写

类Parent和Child定义如下：

1
2
3
4
5
6

class  Parent{
    public  float  aFun(float a, float b) { }
}
class  Child  extends  Parent{

}

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

• A float aFun(float a, float b){ }
• B public int aFun(int a, int b) { }
• C public float aFun(float p, float q){ }
• D private int aFun(int a, int b){ }

解析

A.方法重写。子类方法不能缩小父类方法的访问权限，错误。
B.方法重载。参数列表不同，满足重载条件，正确。
C.方法重写。方法声明和父类相同，满足重写条件，正确。
D.方法重载。参数列表不同，满足重载条件，正确。

方法重写 两同两小一大

方法重写要遵循“两同两小一大”规则，

• “两同”即方法名相同、形参列表相同；
• “两小”指的是子类方法返回值类型应比父类方法返回值类型更小或相等，子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等；
• “一大”指的是子类方法的访问权限应比父类方法的访问权限更大或相等。
• 并且，覆盖方法和被覆盖方法要么都是类方法，要么都是实例方法，不能一个是类方法一个是实例方法。

考点7 重载

下面哪几个函数 public void example(){….} 的重载函数？（）

• A public void example(int m){…}
• B public int example(){..}
• C public void example2(){..}
• D public int example(int m,float f){…}

解析

方法重载 两同一不同

同一个类中，方法名相同，形参列表不同
方法重载只用关心两个点：
1.方法名相同
2.参数列表不同（个数不同、顺序不同、类型不同）

考点8 抽象类和接口的区别 JDK1.7

在Jdk1.7中，下述说法中抽象类与接口的区别与联系正确的有哪些？

• A 抽象类中可以有普通成员变量，接口中没有普通成员变量。
• B 抽象类和接口中都可以包含静态成员常量。
• C 一个类可以实现多个接口，但只能继承一个抽象类
• D 抽象类中可以包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法。

解析

考点9 抽象类和接口的区别JDK1.8

jdk1.8中，下面有关java 抽象类和接口的区别，说法错误的是？

• A 抽象类可以有构造方法，接口中不能有构造方法
• B 抽象类中可以包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法
• C 一个类可以实现多个接口，但只能继承一个抽象类
• D 接口中可以有普通成员变量，抽象类中没有普通成员变量

解析

B 的后半句是错误的，java8在接口中允许有方法体，不过必须是静态方法；
接口中不能有普通成员变量，所以D错误

考点10 volatile 多线程

以下哪种JAVA得变量声明方式可以避免程序在多线程竞争情况下读到不正确的值( )

• A volatile
• B static volatile
• C synchronized
• D static

正确答案: AB

解析

synchronized不是修饰变量的 它修饰方法或代码块或对象

考点1 抽象类和接口

关于抽象类和接口叙述正确的是？ ( )

• A 抽象类和接口都能实例化的
• B 抽象类不能实现接口
• C 抽象类方法的访问权限默认都是public
• D 接口方法的访问权限默认都是public

解析

抽象类

如果一个类含有抽象方法那么这个类就是抽象类。
抽象类需要使用关键字abstract来声明。
抽象类中的抽象方法只需要声明，并不需要实现。
抽象类一定具有子类，并且子类必须覆写抽象类中的所有的抽象方法。
在使用abstract定义抽象方法时，抽象方法的权限不能为private，这是因为抽象方法必须被覆写，如果使用private来定义方法的权限，那么该方法无法被子类覆写，会出现错误

普通通类和抽象类的区别

实际上抽象类相比于普通类，只是在类定义的时候多定义了一个抽象方法，除了不能直接进行对象的实例化之外没有其它区别

考点2 合法标识符 合法变量名

下面属于java合法变量定义的是？

• A final
• B 1var1
• C _var2
• D var3&

解析

标识符可以包括这4种字符：

• 字母、数字，下划线、$、
• 开头不能是数字；
• 不能是关键字

A.final 是关键字
B.不能以数字做首写
C.首写字母可以为下划线
D.符号只能使用美元符合下划线，不能使用&

考点3 程序初始化顺序

运行下面代码，输出的结果是（）

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

class A {
    public A() {
        System.out.println("class A");
    }
    { System.out.println("I'm A class"); } 
    static { System.out.println("class A static"); }
}
public class B extends A {
    public B() {
        System.out.println("class B");
    }
    {
        System.out.println("I'm B class"); 
    }
    static { 
        System.out.println("class B static");
    }
    
    public static void main(String[] args) { 
        new B(); 
    }
}

A

1
2
3
4
5
6

class A static
class B static
I'm A class
class A
I'm B class
class B

B

1
2
3
4
5
6

class A static
I'm A class
class A
class B static
I'm B class
class B

C

1
2
3
4
5
6

class A static
class B static
class A
I'm A class
class B
I'm B class

D

1
2
3
4
5
6

class A static
class A
I'm A class
class B static
class B
I'm B class

解析

Java程序初始化顺序：

1. 父类的静态代码块
2. 子类的静态代码块
3. 父类的普通代码块
4. 父类的构造方法
5. 子类的普通代码块
6. 子类的构造方法

考点4 成员变量有默认值 数组有默认值

关于如下程序的描述哪个是正确的？（ ）

1
2
3
4
5
6

public class Person{
    static int arr[] = new int[5];
    public static void main(String a[]){
        System.out.println(arr[0]);
    }
}

• A 编译将产生错误
• B 编译时正确，但运行时将产生错误
• C 正确，输出0
• D 正确，输出 null

解析

数组会自动初始化

数组无论是在定义为实例变量还是局部变量，若没有初始化，都会被自动初始化

• Java中对于整型数组默认初始化0。
• 对字符数组初始化空格。
• 对对象数组初始化为null。

成员变量有默认值

只有类的成员变量才有默认初始值。

局部变量必须手动赋值

局部变量必须手动赋初值，否则编译报错

考点5 JSP分页

JSP分页代码中，哪个步骤次序是正确的？

• A 先取总记录数，得到总页数，最后显示本页的数据。
• B 先取所有的记录，得到总页数，再取总记录数，最后显示本页的数据。
• C 先取总页数，得到总记录数，再取所有的记录，最后显示本页的数据。
• D 先取本页的数据，得到总页数，再取总记录数，最后显示所有的记录。

解析

不足:JSP方面的我还不是很了解
先取总记录数，得到总页数，再取所有的记录，最后显示本页的数据

考点6 编译

下面关于程序编译说法正确的是（）

• A java语言是编译型语言，会把java程序编译成二进制机器指令直接运行
• B java编译出来的目标文件与具体操作系统有关
• C java在运行时才进行翻译指令
• D java编译出来的目标文件，可以运行在任意jvm上

解析

A:java编译成的是字节码，再被各系统的jvm翻译成本系统可以识别的机器码，这就是java一次编程多平台应用的跨平台性
B:java源文件生成的是class文件，与系统无关
C:注意字节码和机器码不是一回事 java程序在运行时字节码才会被jvm翻译成机 器码，所以说java是解释性语言
D:注意jvm的版本，好比人穿裤子，一条裤子能被任何人穿上吗
低版本的jvm没有办法运行高版本的java代码

考点7 线程

下面说法正确的是？（）

• A 调用Thread的sleep()方法会释放锁，调用wait()方法不释放锁
• B 一个线程调用yield方法，可以使具有相同优先级线程获得处理器
• C 在Java中，高优先级的可运行的线程会抢占低优先级线程的资源
• D java中，线程可以调用yield方法使比自己低优先级的线程运行

解析

yield()让当前正在运行的线程回到可运行状态，以允许具有相同优先级的其他线程获得运行的机会。因此，使用yield()的目的是让具有相同优先级的线程之间能够适当的轮换执行。但是，实际中无法保证yield()达到让步的目的，因为，让步的线程可能被线程调度程序再次选中。

参考资料

抽象类和接口的区别

考点1

以下关于计算机病毒的说法，不正确的是（ ）。

• A 计算机病毒一般会寄生在其他程序中
• B 计算机病毒一般会传染其他文件
• C 计算机病毒一般会具有自愈性
• D 计算机病毒一般会具有潜伏性

正确答案: C

解析

计算机病毒实质上是一种特殊的计算机程序，一般具有寄生性、破坏性、传染性、潜伏性和隐蔽性。故正确答案为C选项。

考点2

计算机安全是指计算机资产安全，即（ ）

• A 计算机信息系统资源不受自然有害因素的威胁和危害
• B 信息资源不受自然和人为有害因素的威胁和危害
• C 计算机硬件系统不受人为有害因素的威胁和危害
• D 计算机信息系统资源和信息资源不受自然和人为有害因素的威胁和危害

正确答案: D

解析

我国公安部计算机管理监察司的定义是计算机安全是指计算机资产安全，即计算机信息系统资源和信息资源不受自然和人为有害因素的威胁和危害。

考点3

有一种木马程序，其感染机制与 U 盘病毒的传播机制完全一样，只是感染目标计算机后它会尽量隐藏自己的踪迹，它唯一的动作是扫描系统的文件，发现对其可能有用的敏感文件，就将其悄悄拷贝到 U 盘，一旦这个 U 盘插入到连接互联网的计算机，就会将这些敏感文件自动发送到互联网上指定的计算机中，从而达到窃取的目的。该木马叫做（ ）

• A 网游木马
• B 网银木马
• C 代理木马
• D 摆渡木马

正确答案: D

解析

摆渡木马

摆渡木马是一种特殊的木马，其感染机制与U盘病毒的传播机制完全一样，只是感染目标计算机后，它会尽量隐蔽自己的踪迹，不会出现普通U盘病毒感染后的症状，如更改盘符图标、破坏系统数据、在弹出菜单中添加选项等，它唯一的动作就是扫描系统中的文件数据，利用关键字匹配等手段将敏感文件悄悄写回U盘中，一旦这个U盘再插入到连接互联网的计算机上，就会将这些敏感文件自动发送到互联网上指定的计算机中。
摆渡木马是一种间谍人员定制的木马，隐蔽性、针对性很强，一般只感染特定的计算机，普通杀毒软件和木马查杀工具难以及时发现。故正确答案为D

代理木马

“代理木马”（Troj_Agent）具有自动下载木马病毒的功能，病毒可以根据病毒编者指定的网址下载木马病毒或其他恶意软件，还可以通过网络和移动存储介质传播。

网络木马

网络木马通常采用记录用户键盘输入、Hook游戏进程API函数等方法获取用户的密码和帐号。窃取的信息一般通过发送电子邮件或向远程脚本程序提交的方式发送给木马作者。

网银木马

网银木马是针对网上交易系统编写的木马病毒，其目的是盗取用户的卡号、密码，甚至安全证书。

考点4

下列攻击方式中，哪种不是针对客户端的？

• A cross site script（跨站点脚本）
• B cross site request（跨站点请求）
• C ActiveX buffer overflow（控件缓冲溢出）
• D sql injection（sql注入）

正确答案: D

解析

SQ LInjection：就是通过把SQL命令插入到Web表单递交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。所以SQL injection不是针对客户端的。SQL注入是针对服务器数据库的。

考点5

以下说法不正确的是()

• A Hash算法主要被用来做数字签名、数据校验
• B SHA-224、SHA-256、SHA-384和SHA-512并称为SHA-2
• C 已知明文攻击对 AES算法无效
• D 非对称加密算法，就是加密、解密的密钥分为两组，并且可以互相反推

正确答案: D

解析

非对称加密算法不可逆，不能反推
SHA-2可分为六个不同的算法标准，包括了：SHA-224、SHA-256、SHA-384、SHA-512、SHA-512/224、SHA-512/256。

考点6

流量劫持是网络安全中常见的安全威胁，下列哪些情况可能会造成流量劫持?()

• A MAC地址欺骗
• B DNS劫持
• C 伪造的DHCP服务器
• D 使用https协议

正确答案: ABC

解析

流量劫持：是利用各种恶意软件修改浏览器、锁定主页或不停弹出新窗口，强制用户访问某些网站，从而造成用户流量损失的情形。是一种古老的攻击方式，比如广告弹窗等。
常见的有

• Hub嗅探、
• MAC欺骗、
• MAC冲刷
• ARP攻击、
• DHCP钓鱼、
• DNS劫持、
• CDN入侵、
• 路由器弱口令、
• 路由器CSRF、
• PPPoE钓鱼、
• 蜜罐代理、
• Wifi弱口令、
• 伪热点、
• 强制断线、
• WlAN基站钓鱼。

考点1

虚拟存储器是利用操作系统产生的一个假想的特大存储器，是逻辑上扩充了内存容量，而物理内存的容量并未增加。

• A 正确
• B 错误

正确答案: A

解析

根据程序执行的互斥性和局部性两个特点，我们允许作业装入的时候只装入一部分，另一部分放在磁盘上，当需要的时候再装入到主存，这样以来，在一个小的主存空间就可以运行一个比它大的作业。好像计算机系统具有一个容量很大的主存储器，称为“虚拟存储器”。

考点2

一个进程被唤醒意味着（）

• A 该进程一定马上占有
• B 它的优先权变得最大
• C 其PCB移至等待队列队首
• D 进程变为就绪状态

正确答案: D

解析

考点3

进程和程序的最根本区别在于（ ）。

• A 对资源的占有类型和数量
• B 进程是动态的，而程序是静态的
• C 看它们是否能够并发地在处理机上运行
• D 进程规模较小，程序规模较大

正确答案: B

解析

程序是静态的，进程是动态的，程序相当于一个乐谱，进程相当于一次演奏，程序可以查看，进程不能查看代码，进程可以被创建 运行 撤销

考点4

对进程和线程的描述，以下正确的是？

• A 父进程里的所有线程共享相同的地址空间，父进程的所有子进程共享相同的地址空间
• B 改变进程里面主线程的状态会影响其他线程的行为，改变父进程的状态不会影响其他子进程
• C 多线程会引起死锁，而多进程则不会
• D 以上都不对

正确答案: D

解析

• A错，进程拥有独立的地址空间；
• B错，主线程和子线程是并行关系的时候，并没有依赖关系。父进程和子进程中，子进程是父进程的一个副本，创建子进程后，子进程会有自己的空间，然后把父进程的数据拷贝到子进程的空间里。运行时，谁先运行是不确定的，这由系统决定；
• C错，多线程和多进程都会引起死锁，一般说的死锁指的是进程间的死锁。

考点5

文件系统的主要目的是（ ）

• A 实现对文件的按名存取
• B 实现虚拟存储
• C 提高外存的读取速度
• D 用于存储系统文件

正确答案: A

解析

文件系统是操作系统下用来对文件的命名以及逻辑操作的一些系统。在计算机中，文件系统（file system）是命名文件及放置文件的逻辑存储和恢复的系统。

考点6

在计数器定时查询方式下，若每次计数都从 0 开始，则 （）

• A 设备号小的设备优先级高
• B 设备号大的设备优先级高
• C 每个设备的优先级均等
• D 每个设备的优先级随机变化

正确答案: A

解析

考点7

两个进程合作完成一个任务。在并发执行中，一个进程要等待其合作伙伴发来消息，或者建立某个条件后再向前执行，这种制约性合作关系被称为进程的（ ）。

• A 互斥
• B 同步
• C 调度
• D 伙伴

正确答案: B

解析

同步：进程按照一定规则顺序执行，互斥是同步特例

考点8

分层式 OS 结构是把 OS 的功能模块划分为若干层，每层之间的模块只能单向调用，这样的说法正确吗？

• A 正确
• B 不正确

正确答案: A

解析

所谓的层次结构，就是把操作系统所有的功能模块按照功能调用次序分别排成若干层，各层之间的模块只有单向调用关系(例如，只允许上层或外层模块调用下层或内层模块)。
分层的优点是：
(1)把功能实现的无序性改成有序性，可显著提高设计的准确性。
(2)把模块问的复杂依赖关系改为简单的单向依赖关系，即高层软件依赖于低层软件。

考点9

在操作系统的层次结构中，各层之间是（ ）

• A 互不相关
• B 内外层相互依赖
• C 内层依赖外层
• D 外层依赖内层

正确答案: D

解析

考点10

linux 的索引节点中不包含的内容是（ ）

• A 文件名
• B 文件物理地址
• C 文件存取权限
• D 文件创建时间

正确答案: A

解析

inode包含文件的元信息，具体来说有以下内容：

• 文件的字节数
• 文件拥有者的User ID
• 文件的Group ID
• 文件的读、写、执行权限
• 文件的时间戳，共有三个：
  • ctime指inode上一次变动的时间，
  • mtime指文件内容上一次变动的时间，
  • atime指文件上一次打开的时间。
• 链接数，即有多少文件名指向这个inode
• 文件数据block的位置
  至于为什么没有文件名，是因为由于inode号码与文件名分离，这种机制导致了一些Unix/Linux系统特有的现象。

1. 有时，文件名包含特殊字符，无法正常删除。这时，直接删除inode节点，就能起到删除文件的作用。
2. 移动文件或重命名文件，只是改变文件名，不影响inode号码。
3. 打开一个文件以后，系统就以inode号码来识别这个文件，不再考虑文件名。因此，通常来说，系统无法从inode号码得知文件名。

考点1

水果店店长早晨通知店员，苹果应减10%,中午发现该减价是香蕉而非苹果，便又通知了香蕉减价10%,苹果提价10%,那么苹果是否恢复了原价?()

• A 不能确定
• B 否
• C 是

正确答案: B

解析

原价x元，降价后y=x(1-10%)=0.9x，升价后z=y(1+10%)=1.1y=0.99x。

考点2

如果6个苹果和4根香蕉的价钱是4.6元，7个苹果和9根香蕉的价钱是7.1元，那么一个苹果的价钱是（）元？

• A 0.3
• B 0.4
• C 0.5
• D 0.6

正确答案: C

解析

假设苹果的价格为a,香蕉的价格为b，通过解方程得出苹果的价格为0.5
6a+4b=4.6
7a+9b=7.1

考点3 2,1,2/3,1/2,()

2,1,2/3,1/2,()

• A 0.75
• B 0.25
• C 0.4
• D 0.83

正确答案: C

解析

2/1, 2/2, 2/3, 2/4, 2/5…

考点4

凯物喜欢 225，但不喜欢 224，喜欢 900，但不喜欢 800，喜欢 121，但不喜欢 120，那么请你猜一猜，他会喜欢下面哪个数字?

• A 401
• B 400
• C 501
• D 500

正确答案: B

解析

B，225是25的平方，900是30的平分，121是11的平方，同理，400是20的平方，所以是B