考点1 数组声明

Which of the following statements are valid array declaration?
(A) int number();
(B) float average[];
(C) double[] marks;
(D) counter int[];

• A (B) & (C)
• B (A)
• C (A) & (C)
• D (D)

解析

valid有效的

考点2 异常处理

try块后必须有catch块。()

• A 正确
• B 错误

解析

try的形式有如下三种:

• try-catch
• try-finally
• try-catch-finally

但catch和finally语句不能同时省略

考点3 异常继承树

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

• A Error
• B Exception
• C RuntimeException
• D Throwable

解析

error是系统出错,catch是无法处理的,难以修复的,RuntimeException不需要程序员进行捕获处理,
error和exception都是throwable的子类,我们只需要对exception的实例进行捕获即可

考点4 数据表述范围 值传递

如下代码,执行test()函数后,屏幕打印结果为()

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

public class Test2
{
    public void add(Byte b)
    {
        b = b++;
    }
    public void test()
    {
        Byte a = 127;
        Byte b = 127;
        add(++a);
        System.out.print(a + " ");
        add(b);
        System.out.print(b + "");
    }
}

• A 127 127
• B 128 127
• C 129 128
• D 以上都不对

解析

• A 127 127
• B 128 127
• C 129 128
• D 以上都不对

解析

Byte类型值大小为-128~127之间。
add(++a);这里++a会越界，a的值变为-128
add(b); 前面说了，add不起任何作用，b还是127
add()方法里面的修改值并不会起作用，而add(++a)会使a数值越界成-128，所以输出为-128 127

考点5 设计模式 单例模式

单例模式中,两个基本要点是

• A 构造函数私有
• B 静态工厂方法
• C 以上都不对
• D 唯一实例

解析

懒汉单例模式

1.懒汉方式。指全局的单例实例在第一次被使用时构建。

1
2
3
4
5
6
7
8
9
10
11

public class Singleton2 {
    private static Singleton2 INSTANCE=null;
    private Singleton2(){
    }
    public static Singleton2 getInstance(){
        if(INSTANCE!=null){
            INSTANCE = new Singleton2();
        }
        return INSTANCE;
    }
}

饿汉单例模式

2.饿汉方式。指全局的单例实例在类装载时构建。

1
2
3
4
5
6
7
8

public class Singleton {
    private final static Singleton INSTANCE = new Singleton();
    private Singleton(){
    }
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

考点6 final关键字 异常处理

下列有关JAVA异常处理的叙述中正确的是()

• A finally是为确保一段代码不管是否捕获异常都会被执行的一段代码
• B throws是用来声明一个成员方法可能抛出的各种非运行异常情况
• C final用于可以声明属性和方法,分别表示属性的不可变及方法的不可继承
• D throw是用来明确地抛出一个异常情况

解析

throws用于在方法上声明该方法不需要处理的异常类型,用在方法上后面跟异常类名 可以是多个异常类
throw用于抛出具体异常类的对象,用在方法内 后面跟异常对象只能是一个异常类型实体.
try块必须和catch块或和finally同在,不能单独存在,二者必须出现一个.
finally块总会执行,不论是否有错误出现.但是若try语句块或会执行的catch语句块使用了JVM系统退出语句,finally块就不会被执行了.
一般我们把关闭资源的代码放在finally里面 保证资源总是能关闭
然后再看这一题 A肯定对了，C根本就跟异常处理没有关系，所以不选。就算有关系也错了
final用于声明属性、方法、类。分别表示

• 属性不可更改、
• 方法不能被覆盖、
• 类不能被继承。

所以C选项说final方法不能被继承是错误的,final方法可以继承,但是不能覆盖,

考点7 循环 等差数列

下面是findSum(int m.int n)方法的定义,方法调用findSum(1,5)的返回结果是( )

1
2
3
4
5
6
7

int findSum(int m, int n){
    int sum=0;
    for(int i=m;i<=n;i++){
        sum+=i;
    }
    return sum;
}

• A 1
• B 5
• C 10
• D 15

解析

1+2+3+4+5=(1+5)×5÷2=15

考点8 JVM内存分类

JVM内存不包含如下哪个部分( )

• A Stacks
• B PC寄存器
• C Heap
• D Heap Frame

解析

JVM内存五大区域

栈有帧堆没帧
方法区 堆 pc计数器 本地方法栈 虚拟机栈

考点9

如果一个list初始化为{5,3,1},执行以下代码后,其结果为()？

1
2
3

nums.add(6);
nums.add(0,4);
nums.remove(1);

• A [5, 3, 1, 6]
• B [4, 3, 1, 6]
• C [4, 3, 6]
• D [5, 3, 6]

解析

list{5,3,1}
nums.add(6); //往后边加一个6，{5，3，1，6}
nums.add(0,4);//往下标为0的数加一个4，{4，5，3，1，6}
nums.remove(1); // 移除下标为1 的元素，{4，3，1，6}

考点10 JVM堆内存

以下哪个不属于JVM堆内存中的区域()？

• A survivor区
• B 常量池
• C eden区
• D old区

解析

堆中的内存可以为了新生代和老年代,新生代由可以分为一个Survivor和两个Eden(From,To),默认比例8:1:1。
其实这个题有问题,从JDK7开始,常量池就从方法区中被移了到了堆(Hotspot叫做永久代),JDK8的时候,永久代被元空间代替。但是这个字符串常量池可是一直都在堆中的。
这里先说一下,方法区和永久代只是针对于HotSpot而言,在JDK7之前是一个概念,对于别的虚拟机而言,可没有什么永久代,只有方法区。
为什么HotSpot把永久代取消了呢,主要是因为这块地方的GC机制和堆邦定在一起,但是因为它不是堆,所以每一个GC收集器都需要有很大一部分代码去专门实现这个区域的垃圾,其次,每次一开始为永久代分配内存的时候,因为无法估量对象的大小,所以总是很难分配合适的内存,还容易出现OOM,所以取代成了元空间。元空间的话相当于一个内地内存,所以基本不会出现什么OOM,但是内存泄漏还是有的。

考点11 Hibernate

下面哪一项不属于优化Hibernate所鼓励的？

• A 使用单向一对多关联,不使用双向一对多
• B 不用一对一,用多对一取代
• C 配置对象缓存,不使用集合缓存
• D 继承类使用显式多态

解析

优化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.消除大表，使用二级缓存

1、什么是延迟加载？
定义：延迟加载(lazy load)是Hibernate3 关联关系对象默认的加载方式，延迟加载机制是为了避免一些无谓的性能开销而提出来的。就是只有当真正需要数据时，才真正的执行数据加载操作。延迟加载是 hibernate 中用于提高查询效率的一种措施，它的对立面是 立即加载。
2、如何实现延迟加载？
Hibernate 2 实现延迟加载有 2 种方式：
实体对象
集合
Hibernate 3 又引入了一种新的加载方式：属性的延迟加载
一般使用load()的方法来实现延迟加载：
当调用load方法加载对象时，返回***对象，等到真正用到对象的内容时才发出sql语句
3、Hibernate 其他介绍
Hibernate 使用 Java 反射机制，而不是字节码增强程序来实现透明性
Hibernate 的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。
4、优化 Hibernate 所鼓励的 7 大措施
1.尽量使用多对一，避免使用单项一对多
2.灵活使用单向一对多
3.不用一对一，使用多对一代替一对一
4.配置对象缓存，不使用集合缓存
5.一对多使用Bag ，多对一使用Set
6.继承使用显示多态 HQL:from object polymorphism=”exlicit” 避免查处所有对象
7.消除大表，使用二级缓存

考点12 Struts

在Struts框架中如果要使用Validation作验证的话,需要使用以下哪个Form？

• A ActionForm
• B ValidatorActionForm
• C ValidatorForm
• D DynaValidatorActionForm

解析

有空了解一下
DynaValidatorActionForm 动态验证表单 Validation 确认的意思

考点13 hibernate POJO

在 hibernate 开发中,关于 POJO 类对象的状态说法正确的是()。

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

解析

有空了解一下

考点1 异常处理 catch顺序

下列类在多重catch中同时出现时,哪一个异常类应最后一个列出()

• A ArithmeticException
• B NumberFormatException
• C Exception
• D ArrayIndexOutOfBoundException

解析

这是多重catch块的顺序问题，由于异常处理系统就近寻找匹配异常处理程序，应先子类后父类。

考点2 JSP编码

通过HttpServletRequest. getParameter获取的参数.

• A 总是采用UTF-8编码
• B 总是采用lS08859-1编码
• C 由客户端浏览器和Web容器配置共同决定编码
• D 由服务器所在的操作系统决定编码

解析

编码格式由浏览器决定，浏览器根据html中指定的编码格式进行编码，tomcat根据指定的格式进行解码，另外get请求和post请求对编码格式的处理也是不同的

考点3 异常处理 finally返回值会覆盖try的返回值

以下代码执行后输出结果为( )
public class Test {
public static void main(String[] args) {
System.out.println(“return value of getValue(): “ +
getValue());
}
public static int getValue() {
try {
return 0;
} finally {
return 1;
}
}
}

• A return value of getValue(): 1
• B return value of getValue(): 0
• C return value of getValue(): 0return value of getValue(): 1
• D return value of getValue(): 1return value of getValue(): 0

解析

根据官方的JVM规范：
如果try语句里有return，返回的是try语句块中变量值。
详细执行过程如下：

• 如果try语句块有返回值，就把try的返回值保存到局部变量中；
• 执行jsr指令跳到finally语句里执行；执行完finally语句后，
  • 如果finally语句没有返回值，则返回之前保存在局部变量表里的值。
  • 如果finally语句里有return，忽略try的return，而使用finally的return.

考点4 重写要求

根据以下接口和类的定义,要使代码没有语法错误,则类Hero中应该定义方法( )。
interface Action{
void fly();
}
class Hero implements Action{ //…… }

• A private void fly(){}
• B void fly(){}
• C protected void fly(){}
• D public void fly(){}

解析

继承中方法重写要求

• 两同 参数列表相同，方法名相同
• 两小 抛出异常子类小，子类返回值和父类返回值相同或比父类小
• 一大 访问控制权限子类比父类大或相等

接口中的方法默认public abstract修饰 故子类重写时只能用public作为访问控制权限修饰符

考点5 网络编程socket

socket编程中,以下哪个socket的操作是不属于服务端操作的()？

• A accept
• B listen
• C connect
• D close

解析

图片

考点6 Integer缓存

下面的代码返回结果为:

1
2
3
4

Integer a = 1;
Integer b = 1;
Integer c = 500;
Integer d = 500;

System.out.print(a == b);
System.out.print(c == d);

• A true、true
• B true、false
• C false、true
• D false、false

解析

Interger的缓存[-128,127]这个范围内的Interger对象，创建在这个范围内的Integer对象时，不会创建新的Interger对象，而是返回缓存好了的对象，所以
在[-128,127]范围内比较相等返回为true，
超过范围返回false

考点7 queue的实现类

下面几个关于Java里queue的说法哪些是正确的()？

• A LinkedBlockingQueue是一个可选有界队列,不允许null值
• B PriorityQueue,LinkedBlockingQueue都是线程不安全的
• C PriorityQueue是一个无界队列,不允许null值,入队和出队的时间复杂度是O(log(n))
• D PriorityQueue,ConcurrentLinkedQueue都遵循FIFO原则

解析

有空了解一下

考点8 反射

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

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

解析

A选项错误:
类Class在java.lang包下，
类Method、Filed在java.lang.reflet包下
D选项错误:反射的本质就是从字节码中查找，动态获取类的整容结构，包括属性，构造器，动态调用对象的方法，而不是修剪类，
F选项错误:使用了反射的效率都会降低，就算加了缓存

考点1

假设一个 list初始化为{2,9,5,4,8,1}。 在第一次冒泡排序后,list变成了()?

• A 2, 9, 5, 4, 8, 1
• B 2, 9, 5, 4, 1, 8
• C 2, 5, 9, 4, 8, 1
• D 2, 5, 4, 8, 1, 9

解析

冒泡排序：将最大值放到末尾，一直缩小范围到第一位
第一次排序后最大的数,转移到数组最后

考点2

要求匹配以下16进制颜色值，正则表达式可以为： #ffbbad #Fc01DF #FFF #ffE

• A /#([0-9a-f]{6}|[0-9a-fA-F]{3})/g
• B /#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})/g
• C /#([0-9a-fA-F]{3}|[0-9a-f]{6})/g
• D /#([0-9A-F]{3}|[0-9a-fA-F]{6})/g

解析

考点3

对于如下代码段

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

class A{
    public A foo(){return this;}
}
class B extends A{
    public A foo(){
        return this;
    }
}
class C extends B
{
    _______
}

可以放入到横线位置,使程序正确编译运行,而且不产生错误的选项是( )

• A public void foo(){}
• B public int foo(){return 1;}
• C public A foo(B b){return b;}
• D public A foo(){return A;}

解析

重写 要求

两同两小一大原则，

• 方法名相同，
• 参数列表相同，
• 子类返回类型小于等于父类方法返回类型，
• 子类抛出异常小于等于父类方法抛出异常，
• 子类访问权限大于等于父类方法访问权限。

［注意：这里的返回类型必须要在有继承关系的前提下比较］

重载

两同一不同

• 同一个类中
• 方法名必须相同，
• 参数类型必须不同，

再来说说这道题 A B 都是方法名和参数相同，是重写，但是返回类型没与父类返回类型有继承关系，

D语法错误，要返回一个对象，不能返回一个类

c的参数类型与父类不同，所以不是重写，可以理解为广义上的重载访问权限小于父类，都会显示错误

虽然题目没点明一定要重载或者重写，但是当你的方法名与参数类型与父类相同时，已经是重写了，这时候如果返回类型或者异常类型比父类大，或者访问权限比父类小都会编译错误

考点4

URL u =new URL(“http://www.123.com");。如果www.123.com不存在,则返回______。

• A http://www.123.com
• B “”
• C null
• D 抛出异常

解析

new URL()时必须捕获检查异常，但这个异常是由于字符串格式和URL不符导致的，与网址是否存在无关。URL的toString方法返回字符串，无论网址是否存在
有空了解一下

考点5 考点:子类构造器调用父类构造器 已提供构造器则系统不提供默认无参构造器

以下程序的输出结果为

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

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

• A BD
• B DB
• C C
• D 编译错误

解析

子类构造方法在调用时必须先调用父类的构造器，由于父类没有无参构造构造器，必须在子类中显式调用，修改子类构造方法如下即可：

1
2
3
4

public Derived(String s){
    super("s");
    System.out.print("D");
}

考点6

以下哪些jvm的垃圾回收方式采用的是复制算法回收

• A 新生代串行收集器
• B 老年代串行收集器
• C 并行收集器
• D 新生代并行回收收集器
• E 老年代并行回收收集器
• F cms收集器

解析

有空了解一下
两个最基本的java回收算法：复制算法和标记清理算法
复制算法：两个区域A和B，初始对象在A，继续存活的对象被转移到B。此为新生代最常用的算法
标记清理：一块区域，标记可达对象（可达性分析），然后回收不可达对象，会出现碎片，那么引出
标记-整理算法：多了碎片整理，整理出更大的内存放更大的对象
两个概念：新生代和年老代
新生代：初始对象，生命周期短的
永久代：长时间存在的对象
整个java的垃圾回收是新生代和年老代的协作，这种叫做分代回收。
P.S：Serial New收集器是针对新生代的收集器，采用的是复制算法
Parallel New（并行）收集器，新生代采用复制算法，老年代采用标记整理
Parallel Scavenge（并行）收集器，针对新生代，采用复制收集算法
Serial Old（串行）收集器，新生代采用复制，老年代采用标记整理
Parallel Old（并行）收集器，针对老年代，标记整理
CMS收集器，基于标记清理
G1收集器：整体上是基于标记 整理 ，局部采用复制

综上：新生代基本采用复制算法，老年代采用标记整理算法。cms采用标记清理。

有空了解一下

考点1

下列程序段的输出结果是:( )

1
2
3
4
5
6

 public void complicatedexpression_r(){
    int x=20, y=30;
    boolean b;
    b = x > 50 && y > 60 || x > 50 && y < -60 || x < -50 && y > 60 || x < -50 && y < -60;
    System.out.println(b);
}

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

解析

&&的优先级大于|| 而不是相等 所以原式=(x>50&&y>60)||(x>50&&y<-60)||(x<-50&&y>60)||(x<-50&&y<-60);

考点2

函数()把文件位置重定位到文件中的指定位置

• A fseek
• B fread
• C fopen
• D fgets

解析

这是c语言的题

考点3

关于struts框架,下面那些说法是正确的？

• A Struts中无法完成上传功能
• B Struts框架基于MVC模式
• C Struts框架容易引起流程复杂、结构不清晰等问题
• D Struts可以有效地降低项目的类文件数目

解析

有空了解一下

考点4

有关hashMap跟hashTable的区别,说法正确的是？

• A HashMap和Hashtable都实现了Map接口
• B HashMap是非synchronized,而Hashtable是synchronized
• C HashTable使用Enumeration,HashMap使用Iterator
• D HashMap允许将 null 作为一个 entry 的 key 或者 value,而 Hashtable 不允许。

解析

考点6

下面哪些类可以被继承？ Java.lang.Thread、java.lang.Number、java.lang.Double、java.lang.Math、 java.lang.ClassLoader

• A Thread
• B Number
• C Double
• D Math
• E ClassLoader

解析

• A，Thread可以被继承，用于创建新的线程
• B，Number类可以被继承，Integer，Float，Double等都继承自Number类
• C，Double类的声明为

  1	public final class Double extends Number implements Comparable

  final生明的类不能被继承
• D，Math类的声明为

  1	public final class Math extends Object

  不能被继承
• E，ClassLoader可以被继承，用户可以自定义类加载器

考点7

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

• A ThreadLocal继承自Thread
• B ThreadLocal实现了Runnable接口
• C ThreadLocal重要作用在于多线程间的数据共享
• D ThreadLocal是采用哈希表的方式来为每个线程都提供一个变量的副本
• E ThreadLocal保证各个线程间数据安全,每个线程的数据不会被另外线程访问和破坏

解析

1、ThreadLocal的类声明：

1

public class ThreadLocal<T>

可以看出ThreadLocal并没有继承自Thread，也没有实现Runnable接口。所以AB都不对。
2、ThreadLocal类为每一个线程都维护了自己独有的变量拷贝。每个线程都拥有了自己独立的一个变量。
所以ThreadLocal重要作用并不在于多线程间的数据共享，而是数据的独立，C选项错。
由于每个线程在访问该变量时，读取和修改的，都是自己独有的那一份变量拷贝，不会被其他线程访问，
变量被彻底封闭在每个访问的线程中。所以E对。
3、ThreadLocal中定义了一个哈希表用于为每个线程都提供一个变量的副本：

ThreadLocal继承Object，相当于没继承任何特殊的。
ThreadLocal没有实现任何接口。
ThreadLocal并不是一个Thread，而是Thread的局部变量。

考点1

关于依赖注入,下列选项中说法错误的是()

• A 依赖注入能够独立开发各组件,然后根据组件间关系进行组装
• B 依赖注入使组件之间相互依赖,相互制约
• C 依赖注入提供使用接口编程
• D 依赖注入指对象在使用时动态注入

解析

依赖注入是相互依赖(减少耦合)，使开发更加简洁

考点2

如果一个接口Cup有个方法use(),有个类SmallCup实现接口Cup,则在类SmallCup中正确的是？ ( )

• A void use() { …}
• B protected void use() { …}
• C public void use() { …}
• D 以上语句都可以用在类SmallCup中

解析

• 接口中的常量修饰符是public static final，
• 接口中的方法修饰符是public abstract
• 两头两小一大

考点3

使用mvc模式设计的web应用程序具有以下优点,除了？

• A 可维护行强
• B 可扩展性强
• C 代码重复少
• D 大大减少代码量

解析

考点4

关于ASCII码和ANSI码,以下说法不正确的是()？

• A 标准ASCII只使用7个bit
• B 在简体中文的Windows系统中,ANSI就是GB2312
• C ASCII码是ANSI码的子集
• D ASCII码都是可打印字符

解析

A、标准ASCII只使用7个bit，扩展的ASCII使用8个bit。
B、ANSI通常使用 0x000x7f 范围的1 个字节来表示 1 个英文字符。超出此范围的使用0x800xFFFF来编码，即扩展的ASCII编码。不同 ANSI 编码之间互不兼容。在简体中文Windows操作系统中，ANSI 编码代表 GBK 编码；在繁体中文Windows操作系统中，ANSI编码代表Big5；在日文Windows操作系统中，ANSI 编码代表 Shift_JIS 编码。
C、ANSI通常使用 0x00~0x7f 范围的1 个字节来表示 1 个英文字符，即ASCII码
D、ASCII码包含一些特殊空字符，这些特殊的空字符无法打印。

考点5

在开发中使用泛型取代非泛型的数据类型(比如用ArrayList取代ArrayList),程序的运行时性能会变得更好。()

• A 正确
• B 错误

解析

泛型仅仅是java的语法糖，它不会影响java虚拟机生成的汇编代码，在编译阶段，虚拟机就会把泛型的类型擦除，还原成没有泛型的代码，顶多编译速度稍微慢一些，执行速度是完全没有什么区别的.

考点6

java中将ISO8859-1字符串转成GB2312编码,语句为 ？

• A new String("ISO8859-1".getBytes("ISO8859-1"),"GB2312")
• B new String(String.getBytes("GB2312"), ISO8859-1)
• C new String(String.getBytes("ISO8859-1"))
• D new String(String.getBytes("GB2312"))

解析

得到的是以charsetName编码得到的byte数组;

1

byte [  ]  String.getBytes(String charsetName);

String的构造函数有:

1

String(byte[] bytes, String charsetName);

考点7

对于以下代码段,4个输出语句中输出true的个数是( )。

1
2
3
4
5
6
7
8
9

class A{}
class B extends A{}
class C extends A{}
class D extends B{}
A obj = new D();
System.out.println(obj instanceof B);
System.out.println(obj instanceof C);
System.out.println(obj instanceof D);
System.out.println(obj instanceof A);

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

解析

a instanceof A；表示的是a指向的实际对象，是否是A类或者A的子类的实例。

1

A obj = new D();

这里obj指向的实际对象类型为D

1

obj instanceof B

obj是B的子类D的实例，true

1

obj instanceof D

obj是D对象的实例，true

1

obj instanceof A

obj是A类的子类B的子类D的实例，true

总结可以从obj的实际类型D开始，依次向上查找父类，如果在继承链中找到这个类，则返回true。

考点8

关于异常的编程,以下描述错误的是:( )

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

解析

除零异常是运行时异常，不需要显示处理
Java的异常分为两种，一种是运行时异常（RuntimeException），一种是非运行异常也叫检查式异常（CheckedException）。

1、运行时异常不需要程序员去处理，当异常出现时，JVM会帮助处理。常见的运行时异常有：

• ClassCastException(类转换异常)
• ClassNotFoundException
• IndexOutOfBoundsException(数组越界异常)
• NullPointerException(空指针异常)
• ArrayStoreException(数组存储异常，即数组存储类型不一致)
• 除零异常
• 还有IO操作的BufferOverflowException异常

2、非运行异常需要程序员手动去捕获或者抛出异常进行显示的处理，因为Java认为Checked异常都是可以被修复的异常。常见的异常有：

• IOException
• SqlException

考点9

关于java集合下列说法不正确的有哪些()

• A HashSet 它是线程安全的,不允许存储相同的对象
• B ConcurrentHashMap 它是线程安全的,其中存储的键对象可以重复,值对象不能重复
• C Collection接口是List接口和Set接口的父接口,通常情况下不被直接使用
• D ArrayList线程安全的,允许存放重复对象

解析

线程安全(Thread-safe)的集合对象：

• Vector 线程安全：
• HashTable 线程安全：

非线程安全的集合对象：

• ArrayList
• LinkedList
• HashMap
• HashSet
• TreeMap
• TreeSet

StringBuffer线程安全
StringBulider线程不安全

考点1

下面有关maven和ant的描述,描述错误的是？

• A Ant 没有正式的约定如一个一般项目的目录结构,你必须明确的告诉 Ant 哪里去找源代码
• B Maven 拥有约定,因为你遵循了约定,它已经知道你的源代码在哪里
• C maven和ant都有”生命周期”的概念,当你输入一个命令后,maven或者ant会执行一系列的有序的步骤,直到到达你指定的生命周期
• D Ant构建文件默认命名为build.xml,Maven默认构建文件为pom.xml

解析

Ant没有生命周期，你必须定义目标和目标之间的依赖。你必须手工为每个目标附上一个任务序列。
有空了解一下
Ant的作用：是一种基于Java的build工具

能够用ant编译java类。生成class文件
ant能够自己定义标签、配置文件，用于构建。
ant能够把相关层构建成jar包 。
ant把整个项目生成web包。并公布到Tomcat
Ant的长处：

跨平台性：Ant是纯Java语言编写的，因此具有非常好的跨平台性。
操作简单：Ant是由一个内置任务和可选任务组成的。Ant执行时须要一个XML文件(构建文件)。
Ant通过调用target树，就能够运行各种task：每一个task实现了特定接口对象。因为Ant构建文件时XML格式的文件。所以非常easy维护和书写，并且结构非常清晰。
Ant能够集成到开发环境中：因为Ant的跨平台性和操作简单的特点。它非常easy集成到一些开发环境中去。
Maven的作用： 除了以程序构建能力为特色之外，还提供高级项目管理工具。
Maven除了具备Ant的功能外。还添加了下面基本的功能：
使用Project Object Model来对软件项目管理。
内置了很多其它的隐式规则，使得构建文件更加简单。
内置依赖管理和Repository来实现依赖的管理和统一存储；
内置了软件构建的生命周期；
Maven的长处：
拥有约定，知道你的代码在哪里，放到哪里去
拥有一个生命周期，比如运行 mvn install就能够自己主动运行编译，測试。打包等构建过程
仅仅须要定义一个pom.xml,然后把源代码放到默认的文件夹，Maven帮你处理其它事情
拥有依赖管理。仓库管理
总体的比較：
Ant将提供了非常多能够重用的task，比如 copy, move, delete以及junit单元測试Maven则提供了非常多能够重用的过程。

考点2

有一个源代码,只包含import java.util.* ; 这一个import语句,下面叙述正确的是？ ( )

• A 只能写在源代码的第一句
• B 可以访问java/util目录下及其子目录下的所有类
• C 能访问java/util目录下的所有类,不能访问java/util子目录下的所有类
• D 编译错误

解析

导入java.util.*不能读取其子目录的类，因为如果java.util里面有个a类，java.util.regex里面也有个a类，我们若是要调用a类的方法或属性时，应该使用哪个a类呢。所以也应该选C

考点3

下面代码的输出结果为:
String str =
“”;
System.out.print(str.split(“,”).length);

• A 0
• B 1
• C 出现异常

解析

String的 split 方法默认返回一个数组， 如果没有找到分隔符， 会把整个字符串当成一个长度为1的字符串数组返回到结果， 所以此处结果就是1

考点4

局部内部类可以用哪些修饰符修饰？

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

解析

局部内部类定义在方法中，可以看成局部变量，局部本身就是访问权限修饰，不能有public，protected，public修饰，另外，普通方法中不能定义static内部类。

成员内部类定义在类中，是类的成员，类的成员可以有public，protected，public，static修饰。

考点5

在socket编程中,可以使用方法( )获取本机的ip地址

• A getInetAddress()
• B getLocalAddress()
• C getReuseAddress()
• D getLocalPort()

解析

• getInetAddress获取主机名和IP地址
• getLocalAddress()顾名思义，获取本地IP地址
• getReuseAddress()返回布尔类型，表示复用地址

考点6

以下 b 的值是: byte b = (byte)129;

• A -126
• B -127
• C -128
• D -129

解析

byte型占一个字节，也就是8位，int型4个字节，32位）；二、在计算机系统中，数值一律用补码来表示（存储）
正数：补码=反码=原码（当然以二进制形式表达）
129 int类型（4个字节）二进制：

1

00000000 00000000 00000000 10000001

强制转换byte型后，只有一个字节即

1

1000 0001

（注意这里从二进制角度看，第一位是符号位，即求负数的补码接下来）
只要求出上面原码对应的补码就行了，然后再转换对应的int型数值（因为题干所给的答案都是比较int型）

1

1000 0001

（原码）
对应的反码为

1

1111 1110

又补码等于反码+1，即

1

1111 1111

该二进制转换int型刚好是

1

-127＝(1+2+4+8+16+32+64)

普及一下

• 正数原码，反码，补码相同
• 负数反码除了符号位不变，其他位取反，
• 负数补码=反码+1；

考点7

下列关于包(package)的描述,正确的是()

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

解析

1、为了更好地组织类,Java提供了包机制。包是类的容器,用于分隔类名空间。如果没有指定包名,所有的示例都属于一个默认的无名包。Java中的包一般均包含相关的类,java是跨平台的,所以java中的包和操作系统没有任何关系,java的包是用来组织文件的一种虚拟文件系统。A错
2、import语句并没有将对应的java源文件拷贝到此处仅仅是引入,告诉编译器有使用外部文件,编译的时候要去读取这个外部文件。B错
3、Java提供的包机制与IDE没有关系。C错
4、定义在同一个包(package)内的类可以不经过import而直接相互使用。

考点8

某程序要求每次输入只能是正整数,并且每次输入的数值要求必须是100的倍数且小于等于500,则下列哪个是正确的无效等价类( )

• A (0,100)、(100,200)、(200,300)、(300,400)、(400,500)、(500,+∞);
• B (500,+∞)
• C (500,+∞)、任意大于0小于500的非100倍数的整数;
• D (-∞,100)、(100,200)、(200,300)、(300,400)、(400,500)、(500,+∞);

解析

什么是有效等价类

• 无效等价类是指不满足软件规格说明的输入数据集合，也就是没有意义的、不合理的输入数据集合。
  • 利用无效等价类可以找出程序异常说明情况，检查程序的功能和性能的实现是否有不符合规格说明要求的地方。

什么是无效等价类

• 有效等价类是指输入数据完全满足程序输入的规格说明，是有效、有意义的输入数据所构成的集合。
  • 利用有效等价类可以检验程序是否满足规格说明所规定的功能和性能。

考点9

关于volatile关键字,下列描述不正确的是？

• A 用volatile修饰的变量,每次更新对其他线程都是立即可见的。
• B 对volatile变量的操作是原子性的。
• C 对volatile变量的操作不会造成阻塞。
• D 不依赖其他锁机制,多线程环境下的计数器可用volatile实现。

解析

有空了解一下

考点10

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

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

解析

考点11

对下面Spring声明式事务的配置含义的说明错误的是()

1
2
3
4
5
6
7
8
9
10
11

<bean id="txProxyTemplate" abstract="true"
class=
"org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    <property name="transactionManager" ref="myTransactionManager" />
<property name="transactionAttributes">      
 <props>
        <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
         <prop key="*">PROPAGATION_REQUIRED</prop>
     </props>
</property> 
</bean>

• A 定义了声明式事务的配置模板
• B 对get方法采用只读事务
• C 缺少sessionFactory属性的注入
• D 配置需要事务管理的bean的代理时,通过parent引用这个配置模板,代码如下:

解析

有空了解一下。

考点12

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

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

解析

有空了解一下。

考点1

下面哪段程序能够正确的实现了GBK编码字节流到UTF-8编码字节流的转换:
byte[] src,dst;

• A dst=String.fromBytes(src,"GBK").getBytes("UTF-8")
• B dst=new String(src,"GBK").getBytes("UTF-8")
• C dst=new String("GBK",src).getBytes()
• D dst=String.encode(String.decode(src,"GBK")),"UTF-8" )

解析

先解码再编码

• 用new String(src,"GBK")解码得到字符串
• 用getBytes("UTF-8")得到字符串对应的UTF8编码字节数组

String类没有fromBytes()和encode以及decode方法

考点2

在java7中,下列哪个说法是正确的:

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

解析

ConcurrentHashMap使用ReentrantLock来保证线程安全

ConcurrentHashMap使用segment来分段和管理锁,segment继承自ReentrantLock,因此ConcurrentHashMap使用ReentrantLock来保证线程安全。

Arrays.asList()返回Arrays类的静态内部类

Arrays.asList()将一个数组转化为一个List对象,这个方方法返回一个ArrayList类型的对象, 这个ArrayList类是Arrays类的静态内部类
而不是java.util.ArrayList类,

不能对这个列表进行添加删除更新操作,否则会报UnsupportedOperationException异常。

考点3

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

• A tar -xvf backup.tar
• B tar -tvf backup.tar
• C tar -svf backup.tar
• D none of these

解析

Linux解压缩和压缩命令

有空了解一下
把常用的tar解压命令总结下，当作备忘：
tar
-c: 建立压缩档案
-x：解压
-t：查看内容
-r：向压缩归档文件末尾追加文件
-u：更新原压缩包中的文件
这五个是独立的命令，压缩解压都要用到其中一个，可以和别的命令连用但只能用其中一个。下面的参数是根据需要在压缩或解压档案时可选的。
-z：有gzip属性的
-j：有bz2属性的
-Z：有compress属性的
-v：显示所有过程
-O：将文件解开到标准输出
下面的参数-f是必须的
-f: 使用档案名字，切记，这个参数是最后一个参数，后面只能接档案名。

tar -cf all.tar *.jpg

这条命令是将所有.jpg的文件打成一个名为all.tar的包。-c是表示产生新的包，-f指定包的文件名。

tar -rf all.tar *.gif

这条命令是将所有.gif的文件增加到all.tar的包里面去。-r是表示增加文件的意思。

tar -uf all.tar logo.gif

这条命令是更新原来tar包all.tar中logo.gif文件，-u是表示更新文件的意思。

tar -tf all.tar

这条命令是列出all.tar包中所有文件，-t是列出文件的意思

tar -xf all.tar

这条命令是解出all.tar包中所有文件，-x是解开的意思
压缩
tar –cvf jpg.tar *.jpg 将目录里所有jpg文件打包成tar.jpg
tar –czf jpg.tar.gz *.jpg 将目录里所有jpg文件打包成jpg.tar后，并且将其用gzip压缩，生成一个gzip压缩过的包，命名为jpg.tar.gz
tar –cjf jpg.tar.bz2 *.jpg 将目录里所有jpg文件打包成jpg.tar后，并且将其用bzip2压缩，生成一个bzip2压缩过的包，命名为jpg.tar.bz2
tar –cZf jpg.tar.Z *.jpg 将目录里所有jpg文件打包成jpg.tar后，并且将其用compress压缩，生成一个umcompress压缩过的包，命名为jpg.tar.Z
rar a jpg.rar *.jpg rar格式的压缩，需要先下载rar for linux
zip jpg.zip *.jpg zip格式的压缩，需要先下载zip for linux
解压
tar –xvf file.tar 解压 tar包
tar -xzvf file.tar.gz 解压tar.gz
tar -xjvf file.tar.bz2 解压 tar.bz2
tar –xZvf file.tar.Z 解压tar.Z
unrar e file.rar 解压rar
unzip file.zip 解压zip
总结
*.tar 用 tar –xvf 解压
*.gz 用 gzip -d或者gunzip 解压
.tar.gz和.tgz 用 tar –xzf 解压
*.bz2 用 bzip2 -d或者用bunzip2 解压
*.tar.bz2用tar –xjf 解压
*.Z 用 uncompress 解压
*.tar.Z 用tar –xZf 解压
*.rar 用 unrar e解压
*.zip 用 unzip 解压
linux下最常用的打包程序就是tar了，使用tar程序打出来的包我们常称为tar包，tar包文件的命令通常都是以.tar结尾的。生成tar包后，就可以用其它的程序来进行压缩。
1．命令格式：
tar[必要参数][选择参数][文件]
2．命令功能：
用来压缩和解压文件。tar本身不具有压缩功能。他是调用压缩功能实现的
3．命令参数：
必要参数有如下：
-A 新增压缩文件到已存在的压缩
-B 设置区块大小
-c 建立新的压缩文件
-d 记录文件的差别
-r 添加文件到已经压缩的文件
-u 添加改变了和现有的文件到已经存在的压缩文件
-x 从压缩的文件中提取文件
-t 显示压缩文件的内容
-z 支持gzip解压文件
-j 支持bzip2解压文件
-Z 支持compress解压文件
-v 显示操作过程
-l 文件系统边界设置
-k 保留原有文件不覆盖
-m 保留文件不被覆盖
-W 确认压缩文件的正确性
可选参数如下：
-b 设置区块数目
-C 切换到指定目录
-f 指定压缩文件
–help 显示帮助信息
–version 显示版本信息
4．常见解压/压缩命令
tar
解包：tar xvf FileName.tar
打包：tar cvf FileName.tar DirName
（注：tar是打包，不是压缩！）
.gz
解压1：gunzip FileName.gz
解压2：gzip -d FileName.gz
压缩：gzip FileName
.tar.gz 和 .tgz
解压：tar zxvf FileName.tar.gz
压缩：tar zcvf FileName.tar.gz DirName
.bz2
解压1：bzip2 -d FileName.bz2
解压2：bunzip2 FileName.bz2
压缩： bzip2 -z FileName
.tar.bz2
解压：tar jxvf FileName.tar.bz2
压缩：tar jcvf FileName.tar.bz2 DirName
.bz
解压1：bzip2 -d FileName.bz
解压2：bunzip2 FileName.bz
压缩：未知
.tar.bz
解压：tar jxvf FileName.tar.bz
压缩：未知
.Z
解压：uncompress FileName.Z
压缩：compress FileName
.tar.Z
解压：tar Zxvf FileName.tar.Z
压缩：tar Zcvf FileName.tar.Z DirName
.zip
解压：unzip FileName.zip
压缩：zip FileName.zip DirName
.rar
解压：rar x FileName.rar
压缩：rar a FileName.rar DirName
5．使用实例
实例1：将文件全部打包成tar包
命令：
tar -cvf log.tar log2012.log
tar -zcvf log.tar.gz log2012.log
tar -jcvf log.tar.bz2 log2012.log

考点4

jdk1.8版本之前的前提下,接口和抽象类描述正确的有( )

• A 抽象类没有构造函数
• B 接口没有构造函数
• C 抽象类不允许多继承
• D 接口中的方法可以有方法体

解析

抽象类可以有构造函数。只是不能被实例化！
JDK8以后的默认方法和静态方法可以有方法体，题目的方法应该是指普通方法

考点5

以下选项中,合法的赋值语句是()

• A a>1;
• B i++;
• C a= a+1=5;
• D y = int ( i );

解析

考点6

执行完以下代码 int [ ] x = new int[10] ;后,以下哪项说明是正确的( )

• A x[9]为0
• B x[9]未定义
• C x[10]为0
• D x[0]为空

解析

• 基本类型数组: byte[],short[],int[] ,默认值为0；
• boolean[]默认值为false；
• float[],double[],默认值为0.0；
• 对象类型数组: 默认值为null

考点7

Java的体系结构包含( )。

• A Java编程语言
• B Java类文件格式
• C Java API
• D JVM

解析

考点8

以下代码的循环次数是

1
2
3
4
5
6
7
8
9
10
11

public class Test {
    public static void main(String args[]) {
        int i = 7;
        do {
            System.out.println(--i);
            --i;
        }
         while (i != 0);
        System.out.println(i);
    }
}

• A 0
• B 1
• C 7
• D 无限次

解析

每次循环都减2,7÷2不可能等于0。所以死循环。

考点9

一个Java源程序文件中定义几个类和接口,则编译该文件后生成几个以.class为后缀的字节码文件。

• A 正确
• B 错误

解析

如果类中有内部类，会产生类名$内部类名.class，
如果有匿名类则会产生类名$1.class

有空测试一下

考点10

java8中,下面哪个类用到了解决哈希冲突的开放定址法

• A LinkedHashSet
• B HashMap
• C ThreadLocal
• D TreeMap

解析

• ThreadLocalMap使用开放定址法解决hash冲突，
• HashMap使用链地址法解决hash冲突。

考点11

Java程序的种类有( )

• A 类(Class)
• B Applet
• C Application
• D Servlet

解析

java程序的种类有:
内嵌于web文件中,由浏览器来观看的Applet
可独立运行的Application
服务器端的Servlet

考点12

有这样一段程序:

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

public class Test{ 
    public static void main(String [] args){ 
        List list=new ArrayList(); 
        list.add("a");
        list.add("b");
        list.add("a");
        Set set=new HashSet(); 
        set.add("a"); 
        set.add("b"); 
        set.add("a"); 
        System.out.println(list.size()+","+set.size()); 
    } 
}

请问运行主要的程序会打印出的是什么()

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

解析

list有序可重复，set无序不可重复

考点13

以下程序输出()
public static void main(String[] args) {
int num = 2;
switch (num) {
case 1:
++num;
case 2:
++num;
case 3:
++num;
default:
++num;
break;
}
System.out.println(num);
}
}

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

解析

case遇到break才跳出

• 匹配到case 2 num等于3
• 但是其后没有break,所以继续执行case 3 num等于4、
• 还是没有break，继续匹配到default语句 num等于5

所以答案为 5

考点14

以下代码在编译和运行过程中会出现什么情况

1
2
3
4
5
6
7
8
9
10

public class TestDemo{
    private int count;
    public static void main(String[] args) {
        TestDemo test=new TestDemo(88);
        System.out.println(test.count);
    }
    TestDemo(int a) {
        count=a;
    }
}

• A 编译运行通过,输出结果是88
• B 编译时错误,count变量定义的是私有变量
• C 编译时错误,System.out.println方法被调用时test没有被初始化
• D 编译和执行时没有输出结果

解析

考点1

以下哪个区域不属于新生代？

• A eden区
• B from区
• C 元数据区
• D to区

解析

考点1

下列程序执行后结果为( )

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

class A {
    public int func1(int a, int b) {
        return a - b;
    }
}
class B extends A {
    public int func1(int a, int b) {
        return a + b;
    }
}
public class ChildClass {
    public static void main(String[] args) {
    A a = new B();
    B b = new B();
    System.out.println("Result=" + a.func1(100, 50));
    System.out.println("Result=" + b.func1(100, 50));
    }
}

• A Result=150Result=150
• B Result=100Result=100
• C Result=100Result=150
• D Result=150Result=100

解析

编译看左边 运行看右边

编译时，看左边是否有这个方法。也就是父类引用只能调用父类中声明的方法
运行时，调用右边的方法，也就是调用的是new创建的实际对象的方法，

• 如果重写了该方法，则调用子类重写的方法，
• 如果没有重写该方法，则调用从父类继承来的方法。

静态方法编译看左，运行看左
成员方法编译看左，运行看右
成员变量编译看左，运行看左

考点2

有程序片段如下,以下表达式结果为 true 的是( )

1
2
3

Float  s=new  Float(0.1f);
Float  t=new  Float(0.1f);
Double  u=new  Double(0.1);

• A s==t
• B s.equals(t)
• C u.equals(s)
• D t.equals(u)

解析

Float类和Double类都重写对于的equals方法，在比较之前都会判断是否同属于Float对象或Double对象，如果不是直接返回false，如果是再继续比较对应的数值大小。
JDK1.8的源码如下：
1.Float类重写了equals方法：

1
2
3
4

public boolean equals(Object obj) { 
  return (obj instanceof Float) 
          && (floatToIntBits(((Float)obj).value) == floatToIntBits(value)); 
}

2.Double类重写了equals方法：

1
2
3
4

public boolean equals(Object obj) { 
   return (obj instanceof Double) 
          && (doubleToLongBits(((Double)obj).value) == doubleToLongBits(value)); 
}

考点1

Math.floor(-8.5)=( )

• A (float)-8.0
• B (long)-9
• C (long)-8
• D (double)-9.0

解析

考点3

Math.floor(-8.5)=( )

• A (float)-8.0
• B (long)-9
• C (long)-8
• D (double)-9.0

解析

Math.floor() 表示向下取整，返回double类型 （floor—地板）
Math.ceil() 表示向上取整，返回double类型 （ceil—天花板）
Math.round() 四舍五入，返回int类型

考点4

下面关于volatile的功能说法正确的是哪个

• A 原子性
• B 有序性
• C 可见性
• D 持久性

解析

• synchronized保证三大性，原子性，有序性，可见性，
• volatile保证有序性，可见性，不能保证原子性。

考点5

以下哪几种方式可用来实现线程间通知和唤醒:( )

• A Object.wait/notify/notifyAll
• B ReentrantLock.wait/notify/notifyAll
• C Condition.await/signal/signalAll
• D Thread.wait/notify/notifyAll

解析

wait()、notify()和notifyAll()是Object类中的方法；
Condition是在java1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、 notify()，使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。

考点6

JavaWEB中有一个类,当会话种邦定了属性或者删除了属性时,他会得到通知,这个类是:( )

• A HttpSessionAttributeListener
• B HttpSessionBindingListener
• C HttpSessionObjectListener
• D HttpSessionListener;
• E HttpSession
• F HttpSessionActivationListener

解析

HttpSessionAttributeListener：可以实现此侦听器接口获取此web应用程序中会话属性列表更改的通知；
HttpSessionBindingListener：当该对象从一个会话中被绑定或者解绑时通知该对象，这个对象由HttpSessionBindingEvent对象通知。这可能是servlet程序显式地从会话中解绑定属性的结果，可能是由于会话无效，也可能是由于会话超时；
HttpSessionObjectListener：没有该接口API；
HttpSessionListener：当web应用程序中的活动会话列表发生更改时通知该接口的实现类，为了接收该通知事件，必须在web应用程序的部署描述符中配置实现类；
HttpSessionActivationListener：绑定到会话的对象可以侦听容器事件，通知它们会话将被钝化，会话将被激活。需要一个在虚拟机之间迁移会话或持久会话的容器来通知所有绑定到实现该接口会话的属性。

考点1

下面所示的java代码,运行时,会产生()类型的异常
int Arry_a[] = new int[10];
System.out.println(Arry_a[10]);

• A ArithmeticException
• B NullPointException
• C IOException
• D ArrayIndexOutOfBoundsException

解析

考点2

以下哪个区域不属于新生代？

• A eden区
• B from区
• C 元数据区
• D to区

解析

Java 中的堆是JVM 所管理的最大的一块内存空间,主要用于存放各种类的实例对象。
在Java 中,堆被划分成两个不同的区域:

• 新生代(Young)、
• 老年代(Old)。

新生代(Young)又被划分为三个区域:

• Eden、
• From Survivor、
• To Survivor。

这样划分的目的是为了使 JVM 能够更好的管理堆内存中的对象,包括内存的分配以及回收。
堆的内存模型大致为:
这里有图片
从图中可以看出： 堆大小 = 新生代 + 老年代。其中，堆的大小可以通过参数 –Xms、-Xmx 来指定。
本人使用的是 JDK1.6，以下涉及的 JVM 默认值均以该版本为准。
默认的新生代 ( Young ) 与老年代 ( Old ) 的比例的值为 1:2 ( 该值可以通过参数 –XX:NewRatio 来指定 )，即：

• 新生代 ( Young ) = 1/3 的堆空间大小。
• 老年代 ( Old ) = 2/3 的堆空间大小。

其中，新生代 ( Young ) 被细分为 Eden 和 两个 Survivor 区域，这两个 Survivor 区域分别被命名为 from 和 to，以示区分。
默认的，Edem : from : to = 8 : 1 : 1 ( 可以通过参数 –XX:SurvivorRatio 来设定 )，即：

• Eden = 8/10 的新生代空间大小，
• from = to = 1/10 的新生代空间大小。

JVM 每次只会使用 Eden 和其中的一块 Survivor 区域来为对象服务，所以无论什么时候，总是有一块 Survivor 区域是空闲着的。
因此，新生代实际可用的内存空间为 9/10 ( 即90% )的新生代空间。

考点3

以下JAVA程序代码的输出是

1
2
3

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

• A 12
• B 22
• C 20
• D 1419857

解析

异或运算是一个二进制运算：两者相同为0，两者不同为1

考点4

下面程序的运行结果是

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

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

• A Base SonB
• B Son SonB
• C Base Son SonB
• D 编译不通过

解析

多态 编译看左边 运行看右边

这类多态问题中，无论向上或向下转型，都记住一句话就可以了。
编译看左边，运行看右边

• 意思编译时候，看左边有没有该方法，
• 运行的时候结果看new的对象是谁，就调用谁的方法。

考点5

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

• A 类定义前面可以修饰public,protected和private
• B 内部类前面可以修饰public,protected和private
• C 局部内部类前面可以修饰public,protected和private
• D 以上说法都不正确

解析

内部类分类

在Java中，可以将一个类定义在另一个类里面或者一个方法里边，这样的类称为内部类，广泛意义上的内部类一般包括四种：

• 成员内部类，
• 局部内部类，
• 匿名内部类，
• 静态内部类 。

1.成员内部类

成员内部类中可以访问外部类的所有成员

该类像是外部类的一个成员，可以无条件的访问外部类的所有成员属性和成员方法（包括private成员和静态成员）；

成员内部类的成员会隐藏外部类成员

成员内部类拥有与外部类同名的成员变量时，会发生隐藏现象，即成员内部类中，默认情况下访问的是成员内部类中的成员。如果要访问外部类中的成员，需要以下形式访问：
【外部类.this.成员变量 或 外部类.this.成员方法】；

外部类中要先创建内部类对象才能调用内部类的成员

成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象；
在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问；

内部类可以拥有四种访问权限

内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。

• 如果成员内部类用private修饰，则只能在外部类的内部访问；
• 如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；
• 如果是默认访问权限，则只能在同一个包下访问。
• 如果用public修饰，则任何地方都能访问；

外部类只能有两种访问权限

外部类只能被public和包访问两种权限修饰。

2.局部内部类

局部内部类只在方法或者代码块中可见

局部内部类是定义在一个方法或者一个代码块里面的类
它和成员内部类的区别在于
局部内部类的访问仅限于方法内或者该作用域内；

局部内部类不能用访问修饰符修饰

局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

3.匿名内部类

• 匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。
• 匿名内部类是唯一一种没有构造器的类；
• 匿名内部类是不能有访问修饰符和static修饰符的；
• 一般使用匿名内部类的方法来编写事件监听代码；

  4.内部静态类

• 静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似；
• 静态成员不能访问非静态成员，也就是静态内部类不能使用外部类的非static成员变量或者方法

考点6

下面哪一项不属于优化Hibernate所鼓励的？

• A 使用单向一对多关联,不使用双向一对多
• B 不用一对一,用多对一取代
• C 配置对象缓存,不使用集合缓存
• D 继承类使用显式多态

解析

有空了解一下

优化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.消除大表，使用二级缓存