Java练习题集

第001题

Java中所有类的父类是（ ）。
A、Father
B、Dang
C、Exception
D、Object

正确答案: D 我的答案: D (正确)
解释：java中Object是所有类的父亲,所有类的对象都是Class的实例。

第002题

在某个类A中存在一个方法：void set(int x),以下不能作为这个方法的重载的声明的是（）
A、void set(int y)
B、int set(int x，double y)
C、double set(int x,int y)
D、void set(int x,int y)

正确答案: A 我的答案: A (正确)
解释：方法重载满足的条件

同一个类中，方法名相同，参数列表不同的2个或多个方法构成方法的重载 2.参数列表不同指参数的类型，参数的个数，参数的顺序至少一项不同
3.方法的返回值类型，方法的修饰符可以不同。

第003题

关于下面程序 ThisTest .java 运行结果 说法正确的是 ： ( )
public class ThisTest {
	public static void main(String args[]) {
    	String x="7";       
		int y = 2;
    	int z=2;              
        System.out.println(x+y+z); 
	}  
}
A、11		B、722		C、22		D、程序有编译错误

正确答案: B 我的答案: B (正确)
解释：+号两边如果有一边为字符类型则为字符串连接，这里是“7”+2+2—>“72”+2—>722
如果变为y+z+x 则等价于(y+z)+x 输出47

第004题

下面的程序 编译运行后，在屏幕上显示的结果是（）
public class test {
	public static void main(String args[]) {
		int x,y;
		x=5>>2;
		y=x>>>2;
		System.out.println(y);
	}
}
A、0		B、2		C、5		D、80

正确答案: A 我的答案: B (错误)
解释：5的二进制是0101。
x=5>>2 （>>带符号右移）
将0101右移2位，为：0001。
y=x>>>2 （>>>无符号右移，左边空缺补充为0）
将0001右移2位，补0。结果为：0000。
所以得出答案0

Java中的位运算符：
>>表示右移，如果该数为正，则高位补0，若为负数，则高位补1；
>>>表示无符号右移，也叫逻辑右移，即若该数为正，则高位补0，而若该数为负数，则右移后高位同样补0。

第005题

下面的输出结果是什么？
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

正确答案: B 我的答案: A (错误) 重点
解释：= =用来判断两个变量是否相等时，如果两个变量是基本类型变量，且都是数值类型(不要求数据类型严格相同)，则只要两个变量的值相等，就返回true；对于两个引用类型变量，必须指向同一个对象，= =才会返回true。
java中使用new String(“hello”)时，jvm会先使用常量池来管理"hello"常量，再调用String类的构造器创建一个新的String对象，新创建的对象被保存在堆内存中；而直接使用"hello"的字符串直接量，jvm会用常量池来管理这些字符串。故上述程序中str=="hello"返回结果为false

第006题

下面程序的输出结果为（）

public class Demo {
	public static String sRet = "";
	public static void func(int i)
	{
		 try
		 {
		 	if (i%2==0)
		 	{
		 		throw new Exception();
		 	}
		}
		 catch (Exception e)
		 {
			 sRet += "0";
			 return;
		 } 
		 finally
		 {
		 	sRet += "1";
		 }
		 	sRet += "2";
	}
	public static void main(String[] args)
	 {
		func(1);
		func(2);
		System.out.println(sRet);
	 }
}

A、120		B、1201		C、12012		D、101

正确答案: B 我的答案: A (错误)
解释：“1201”
①调用func(1),if不符合，直接进入finally，sRet=“1"
②finally语句中没有返回值，故继续向下执行，sRet=“12”
③调用func(2),if符合，sRet=“120”，此时有返回值!!!
④调用finally语句，sRet=“1201”
⑤因为已经有返回值了，finally之后的语句也不再执行，sRet=“1201”。
错误原因是第二次忽略了finally

第007题

以下哪项不属于java类加载过程？
A、生成java.lang.Class对象
B、int类型对象成员变量赋予默认值
C、执行static块代码
D、类方法解析

正确答案: B 我的答案: D (错误)
解释：不应该选D，而应该选B
类的加载包括：加载，验证，准备，解析，初始化。
选项A：生成java.lang.Class对象是在加载时进行的。生成Class对象作为方法区这个类的各种数据的访问入口。
选项B：既然是对象成员，那么肯定在实例化对象后才有。在类加载的时候会赋予初值的是类变量，而非对象成员。
选项C：这个会调用。可以用反射试验。
选项D：类方法解析发生在解析过程。

第008题

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

public class P {
	public static int abc = 123;
	static{
		System.out.println("P is init");
	}
}
public class S extends P {
	static{
	System.out.println("S is init");
	}
}
public class Test {
	public static void main(String[] args) {
	System.out.println(S.abc);
	}
}

A、P is init
123
B、S is init
P is init
123
C、P is init
S is init
123
D、S is init
123

正确答案: A 我的答案: D (错误)
解释：属于被动引用不会出发子类初始化
1.子类引用父类的静态字段，只会触发子类的加载、父类的初始化，不会导致子类初始化
2.通过数组定义来引用类，不会触发此类的初始化
3.常量在编译阶段会进行常量优化，将常量存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。

第009题

在java中重写方法应遵循规则的包括（）
A、访问修饰符的限制一定要大于被重写方法的访问修饰符
B、可以有不同的访问修饰符
C、参数列表必须完全与被重写的方法相同
D、必须具有不同的参数列表

正确答案: B C 我的答案: B C (正确)
解释：方法的重写（override）两同两小一大原则：
方法名相同，参数类型相同
子类返回类型小于等于父类方法返回类型，
子类抛出异常小于等于父类方法抛出异常，
子类访问权限大于等于父类方法访问权限。

第010题

What is Static Method in Java（）
A、It is a method which belongs to the class and not to the object(instance)
B、A static method can access only static data. It can not access non-static data (instance variables)
C、A static method can call only other static methods and can not call a non-static method from it.
D、A static method can not be accessed directly by the class name and doesn’t need any object

正确答案: A B C 我的答案: A C (错误)
解释：
A：静态方法是一个属于类而不属于对象(实例)的方法。（√）
B：静态方法只能访问静态数据。无法访问非静态数据(实例变量)。（√）
C：静态方法只能调用其他静态方法，不能从中调用非静态方法。（√）
D：静态方法不能通过类名直接访问，也不需要任何对象。（×）静态方法可以直接用类名访问。

第011题

类Test1定义如下:
public class Test1{//1
public float aMethod(float a,float b){}//2 
   //3
}//4
将以下哪种方法插入行3是不合法的。
A、public int aMethod(int a,int b){}
B、private float aMethod(int a,int b,int c){}
C、public float aMethod(float a,float b){}
D、public float aMethod(float a,float b,float c){}f

正确答案: C 我的答案: C (正确)
解释：
重载的概念是：
方法名称相同，参数个数、次序、类型不同
因此重载对返回值没有要求，可以相同，也可以不同
但是如果参数的个数、类型、次序都相同，方法名也相同，仅返回值不同，则无法构成重载。

第012题

J2EE中，当把来自客户机的HTTP请求委托给servlet时，会调用HttpServlet的
（    ）方法
A、service
B、doget
C、dopost
D、init

正确答案: A 我的答案: A (正确)
解释：.首先Servlet通过HttpRequest对象封装http请求信息，然后Servlet容器调用HttpServlet的service方法，它会根据用户请求的方式调用具体的方法。如果请求方式是Get则调用doGet方法，如果请求方式是POST则调用doPost方法，执行完后，通过HttpRespones对象生成相应数据相应客户的请求，一般要重写doGet方法和doPost方法

第013题

When is the text “Hi there”displayed?
public class StaticTest
{
    static
   {
      System.out.println(“Hi there”);
   }
    public void print()
  {
     System.out.println(“Hello”);
  }
  public static void main(String args[])
  {
     StaticTest st1 = new StaticTest();
     st1.print();
	    StaticTest st2 = new StaticTest();
	    st2.print();
  }
}
A、Never.
B、Each time a new object of type StaticTest is created.
C、Once when the class is loaded into the Java virtual machine.
D、Only when the main() method is executed.

正确答案: C 我的答案: D (错误)
解释：静态代码块优先于主方法，且只在类加载时执行一次

第014题

在JAVA中，假设A有构造方法A(int a)，则在类A的其他构造方法中调用该构造方法和语句
式应该为（）
A、this.A(x)
B、this(x)
C、super(x)
D、A(x)

正确答案: B 我的答案: A (错误)
解释：
A.这是调用普通方法的写法
B是调用与类名同名的方法即构造方法
C.这时显示调用父类构造方法
D.调用静态方法

第015题

下列哪一项不属于Swing的顶层容器？（）
A、JApplet
B、JTree
C、JDialog
D、JFrame

正确答案: B 我的答案: B (正确)
解释：
顶层容器是指可以不能被其他容器包含，是容纳其他容器的容器组件，
顶层容器包含JApplet、JDialog、JFrame和JWindow及其子类.
JFrame中就可以放Jtree（树形组件）
所以B不是

第016题

Java 提供的事件处理模型是一种人机交互模型。它有三个基本要素
A、事件源
B、事件对象
C、事件过程
D、事件监听器

正确答案: A B D 我的答案: A B D (正确)
解释：Java 提供的事件处理模型是一种人机交互模型。它有三个基本要素：

事件源（Event Source）：即事件发生的场所，就是指各个组件，如按钮等，点击按钮其实就是组件上发生的一个事件；
事件（Event）：事件封装了组件上发生的事情，比如按钮单击、按钮松开等等；
事件***（Event Listener）：负责监听事件源上发生的特定类型的事件，当事件到来时还必须负责处理相应的事件；

第017题

JDK1.7版本之前，接口和抽象类描述正确的有（ ）
A、抽象类没有构造函数。
B、接口没有构造函数。
C、抽象类不允许多继承。
D、接口中的方法可以有方法体。

正确答案: B C 我的答案: A B C (错误)
解释：
A.抽象类可以有构造方法,只是不能直接创建抽象类的实例对象而已
B.在接口中不可以有构造方法,在接口里写入构造方法时，编译器提示：Interfaces cannot have constructors。
C.Java不允许类多重继承
D.jdk1.8后接口中的方法可以有方法体，jdk1.8之前不可以有方法体

第018题

下面几个关于Java里queue的说法哪些是正确的（）？
A、LinkedBlockingQueue是一个可选有界队列，不允许null值
B、PriorityQueue，LinkedBlockingQueue都是线程不安全的
C、PriorityQueue是一个无界队列，不允许null值，入队和出队的时间复杂度是O（log(n)）
D、PriorityQueue，ConcurrentLinkedQueue都遵循FIFO原则

正确答案: A C 我的答案: 空 (错误)
解释：A、LinkedBlockingQueue是一个基于节点链接的可选是否有界的阻塞队列，不允许null值。
B、LinkedBlockingQueue是一个线程安全的阻塞队列，实现了先进先出等特性。
C、PriorityQueue是一个队列，不允许null值，入队和出队的时间复杂度是O（log(n)）。
D、PriorityQueue是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。ConcurrentLinkedQueue是一个基于链接节点的*线程安全队列，该队列的元素遵循FIFO原则。

第019题

Java程序的种类有（ ）
A、类（Class）
B、Applet
C、Application
D、Servlet
Java程序的种类有：

正确答案: B C D 我的答案: A D (错误)
解释：
Java程序的种类有：
（a）内嵌于Web文件中，由浏览器来观看的_Applet
（b）可独立运行的 Application
（c）服务器端的 Servlets

第020题

有关hashMap跟hashTable的区别，说法正确的是？
A、HashMap和Hashtable都实现了Map接口
B、HashMap是非synchronized，而Hashtable是synchronized
C、HashTable使用Enumeration，HashMap使用Iterator
D、HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。

正确答案: A B C D 我的答案: A B C (错误)
解释：HashTable和HashMap区别（敲黑板！）:
①继承不同。
public class Hashtable extends Dictionary implements Map public class HashMap extends AbstractMap implements Map
②Hashtable 中的方法是同步的，而HashMap中的方法在缺省情况下是非同步的。在多线程并发的环境下，可以直接使用Hashtable，但是要使用HashMap的话就要自己增加同步处理了。
③Hashtable中，key和value都不允许出现null值。
在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。当get()方法返回null值时，即可以表示 HashMap中没有该键，也可以表示该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键，而应该用containsKey()方法来判断。
④两个遍历方式的内部实现上不同。
Hashtable、HashMap都使用了 Iterator。而由于历史原因，Hashtable还使用了Enumeration的方式。
⑤哈希值的使用不同，HashTable直接使用对象的hashCode。而HashMap重新计算hash值。
⑥Hashtable和HashMap它们两个内部实现方式的数组的初始大小和扩容的方式。HashTable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。

第021题

下列程序段执行后t3的结果是（）。
int t1=2, t2=3, t3;
t3=t1


正确答案: A 我的答案: A (正确)
 解释：三目运算符，
 if(t1 t3=t1;;
 else
 t3=t2+t1;
第022题
下列代码中的错误是（）
public class Test
 {
	public static void main(String [] args)
	{
		int i;
		i+=1;
	}
 }
 A、非法的表达式 i+=1
B、找不到符号i
C、类不应为public
D、尚未初始化变量i

正确答案: D 我的答案: D (正确)
 解释：
 1.方法定义中或者方法声明上。
 2.在内存的栈中。
 3.随方法的调用而存在，随着方法的调用完毕而消失。
 4.没有默认值，必须定义，赋值，然后才能使用
第023题
根据下面的程序代码，哪些选项的值返回true？
public class Square {  
long width;  
public Square(long l) {   
    width = l;  
}  
public static void main(String arg[]) {   
    Square a, b, c;   
    a = new Square(42L);   
    b = new Square(42L);   
    c = b;   
    long s = 42L;  
} 
}
A、a == b				B、s == a
C、b == c				D、a.equals(s)

正确答案: C 我的答案: C (正确)
 解释：
 a = new Square(42L);
 b = new Square(42L);
 这里new了两个对象，所以a,b不是同一个引用a!=b
 s的类型跟a,b不同类型，所以s!=a,s!=b
 c = b;
 这里b，c是同一个对象的引用，所以b==c是true
第024题
java语言中，按照一定格式生成程序的文档的工具是？
A、javac				B、javah
C、javadoc				D、jar

正确答案: C 我的答案: C (正确)
 解释：jar 将许多文件组合成一个jar文件
 javac 编译
 javadoc 它从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档。
 javah 把java代码声明的JNI方法转化成C\C++头文件。
第025题
以下程序的运行结果是：(    )
TreeSet set = new TreeSet();
 TreeSet subSet = new TreeSet();
 for(int i=606;i<613;i++){
 if(i%2==0){
 set.add(i);
 }
 }
 subSet = (TreeSet)set.subSet(608,true,611,true);
set.add(629);
 System.out.println(set+" "+subSet);
 A、编译失败
B、发生运行时异常
C、[606, 608, 610, 612, 629] [608, 610]
D、[606, 608, 610, 612, 629] [608, 610,629]

正确答案: C 我的答案: A (错误)
 解释：subset(form，true，to，true)是Treeset的非静态方法，该方法返回从form元素到to元素的一个set集合，两个boolean类型是确认是否包含边境值用的。
第026题
多重继承的概念在Java中实现是通过如下哪些？（）
I. 扩展两个或多个类
II. 扩展一个类并实现一个或多个接口。
III. 实现两个或更多接口。
A、只有I &II				B、只有II & III
C、只有III					D、都是

正确答案: B 我的答案: B (正确)
 解释：Java只支持单继承，实现多重继承三种方式：
 （1）直接实现多个接口
 （2）扩展(extends)一个类然后实现一个或多个接口
 （3）通过内部类去继承其他类
 所以Ⅰ错误，Ⅱ、Ⅲ正确，
第027题
抽象类方法的访问权限默认都是public。（  ）
A、正确			B、错误

正确答案: B 我的答案: B (正确)
 解释：
 关于抽象类
 JDK 1.8以前，抽象类的方法默认访问权限为protected
 JDK 1.8时，抽象类的方法默认访问权限变为default
 关于接口
 JDK 1.8以前，接口中的方法必须是public的
 JDK 1.8时，接口中的方法可以是public的，也可以是default的
 JDK 1.9时，接口中的方法可以是private的
第028题
以下对继承的描述错误的是（）
A、Java中的继承允许一个子类继承多个父类
B、父类更具有通用性，子类更具体
C、Java中的继承存在着传递性
D、当实例化子类时会调用父类中的构造方法

正确答案: A 我的答案: A (正确)
 解释：jdk1.8后不允许多继承（多继承有违社会常理），所以A错误
第029题
下面哪个行为被打断不会导致InterruptedException：（ ）？
A、Thread.join
B、Thread.sleep
C、Object.wait
D、CyclicBarrier.await
E、Thread.suspend

正确答案: E 我的答案: B (错误)
 解释：
 抛InterruptedException的代表方法有：
 java.lang.Object 类的 wait 方法
 java.lang.Thread 类的 sleep 方法
 java.lang.Thread 类的 join 方法
 关于D选项：
 CyclicBarrier是一个屏障类，它的await方法可以简单的理解为：等待多个线程同时到达之后才能继续进行，在此之前它就是这些线程的屏障，线程不能继续进行，而对于失败的同步尝试，CyclicBarrier 使用了一种要么全部要么全不 (all-or-none) 的破坏模式：如果因为中断、失败或者超时等原因，导致线程过早地离开了屏障点，那么在该屏障点等待的其他所有线程也将通过 BrokenBarrierException（如果它们几乎同时被中断，则用 interruptedException）以反常的方式离开。
第030题
如果Child extends Parent，那么正确的有（）？
A、如果Child是class，且只有一个有参数的构造函数，那么必然会调用Parent中相同参数的构造函数
B、如果Child是interface，那么Parent必然是interface
C、如果Child是interface，那么Child可以同时extends Parent1，Parent2等多个interface
D、如果Child是class，并且没有显示声明任何构造函数，那么此时仍然会调用Parent的构造函数

正确答案: B C D 我的答案: B C D (正确)
 解释:
 A 可以调用父类无参的构造函数，子类的有参构造函数和是否调用父类的有参数的构造函数无必然联系。
 B 接口继承的时候只能继承接口不能继承类，因为如果类可以存在非抽象的成员，如果接口继承了该类，那么接口必定从类中也继承了这些非抽象成员，这就和接口的定义相互矛盾，所以接口继承时只能继承接口。
 C 接口可以多继承可以被多实现，因为接口中的方法都是抽象的，这些方法都被实现的类所实现，即使多个父接口中有同名的方法，在调用这些方法时调用的时子类的中被实现的方法，不存在歧义；同时，接口的中只有静态的常量，但是由于静态变量是在编译期决定调用关系的，即使存在一定的冲突也会在编译时提示出错；而引用静态变量一般直接使用类名或接口名，从而避免产生歧义，因此也不存在多继承的第一个缺点。 对于一个接口继承多个父接口的情况也一样不存在这些缺点。所以接口可以多继承。
 D 子类即使没有显示构造函数，也会有个无参数的默认构造函数，仍然会调用父类的构造函数。
第031题
在类Tester中定义方法如下，
public double max(int x, int y) { // 省略 }
则在该类中定义如下哪个方法头是对上述方法的重载(Overload)?
public int max(int a, int b) {}
public int max(double a, double b) {}
public double max(int x, int y) {}
private double max(int a, int b) {}

正确答案: B 我的答案: B (正确)
 解释：
 Java 重载的规则：

1、必须具有不同的参数列表；
2、可以有不同的返回类型，只要参数列表不同就可以；
3、可以有不同的访问修饰符；
4、可以抛出不同的异常；
5、方法能够在一个类中或者在一个子类中被重载。

方法的重写：

1、在子类中可以根据需要对从基类中继承来的方法进行重写。
2、重写的方法和被重写的方法必须具有相同方法名称、参数列表和返回类型。
3、重写方法不能使用比被重写的方法更严格的访问权限。

总之：重载就是一句话：同名不同参，返回值无关。
 覆盖/重写：同名同参
第032题
关于final说法正确的是？  ( )
final类的方法肯定不能被同一个包的类访问
final类的方法能否被同一个包的类访问不是由final决定
final方法等同于private方法
final对象本身的引用和值都不能改变

正确答案: B 我的答案: B (正确)
 解释：

final 变量：
 final 变量能被显式地初始化并且只能初始化一次。被声明为 final 的对象的引用不能指向不同的对象。但是 final 对象里的数据可以被改变。也就是说 final 对象的引用不能改变，但是里面的值可以改变。
 final 修饰符通常和 static 修饰符一起使用来创建类常量。
final 方法
 类中的 final 方法可以被子类继承，但是不能被子类修改。
 声明 final 方法的主要目的是防止该方法的内容被修改。
final 类
 final 类不能被继承，没有类能够继承 final 类的任何特性。

第033题
以下不是修饰符final的作用的是( )。
修饰常量
修饰不可被继承的类
修饰不可变类
修饰不可覆盖的方法

正确答案: C 我的答案: D (错误)
 final的作用：（上一题的解析）



修饰变量，变量的引用地址不可变，但是地址中的内容可以变。
 


修饰方法，方法不可被重写，但是还是可以重载
 


修饰类，类不可继承。
 

第034题
非抽象类实现接口后，必须实现接口中的所有抽象方法，除了abstract外，方法头必须完
全一致.
A、正确						B、错误

正确答案: B 我的答案: A (错误)
 解释：
 方法头指：修饰符+返回类型 +方法名（形参列表）
 两同两小一大原则

返回值和参数列表相同
返回值类型小于等于父类的返回值类型
异常小于等于父类抛出异常
访问权限大于等于父类

第035题
What will happen when you attempt to compile and run the following code?
public class Test{
static{
   int x=5;
}
static int x,y;
public static void main(String args[]){
   x--;
   myMethod( );
   System.out.println(x+y+ ++x);
}
public static void myMethod( ){
  y=x++ + ++x;
 }
}

A、compiletime error
 B、prints:1
 C、prints:2
 D、prints:3
 E、prints:7
 F、prints:8
 正确答案: D 我的答案: A (错误)
 解释:

1.静态语句块中x为局部变量，不影响静态变量x的值
2.x和y为静态变量，默认初始值为0，属于当前类，其值得改变会影响整个类运行。
3.java中自增操作非原子性的
 main方法中：执行x–后 x=-1
 调用myMethod方法，x执行x++结果为-1(后++)，但x=0，++x结果1，x=1 ，则y=0
 x+y+ ++x,先执行x+y，结果为1，执行++x结果为2，得到最终结果为3

第036题
String与StringBuffer的区别。
A、String是不可变的对象，StringBuffer是可以再编辑的
B、字符串是常量，StringBuffer是变量
C、String是可变的对象，StringBuffer是不可以再编辑的
D、以上说法都不正确

正确答案: A B 我的答案: C (错误)
 解释;String 字符串常量
 StringBuffer 字符串变量（线程安全）
 StringBuilder 字符串变量（非线程安全）
 String 类代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都是String类的对象。字符串是常量；它们的值在创建之后不能改变。所以可以共享它们。StringBuffer是字符串缓存区，它的内容可以被修改，长度也可以改变，StringBuffer类是线程安全的，也就是说多个线程可以安全的访问StringBuffer对象。StringBuilder与StringBuffer类似，都是字符串缓冲区，但StringBuilder不是线程安全的，如果你只是在单线程中使用字符串缓冲区，那么StringBuilder的效率会更高些。值得注意的是StringBuilder是在JDK1.5版本中增加的。以前版本的JDK不能使用该类。
第037题
下列哪个选项是合法的标识符？（）
A、123
B、_name
C、class
D、first

正确答案: B D 我的答案: B (错误)
 解释：
 Java标识符由 数字、字母、下划线(_)、美元符号($) 组成， 首位不能是数字 。并且 Java关键字不能作为标识符 。first不是关键字。
第038题
在 hibernate 开发中，关于 POJO 类对象的状态说法正确的是（）。
A、自由状态（Transient）：实体在内存中自由存在，与数据库中的记录无关
B、持久状态（Persistent）：实体处于由Hibernate框架所管理的状态，对应了数据库中
的一条记录，同时与某个session实例发生了关联
C、游离状态（Detached）：在session 关闭之后,可以使对象从持久状态转换到游离状态。
D、不能将对象从游离状态转换成持久态

正确答案: A B C 我的答案: A B C (正确)
 解释：Hibernate Pojo的三态分别为transient（瞬时态）,persistent（持久态）,detached（游离态）
 三种状态间相互转换关系，及他们在数据库、session中的状态如下：

a.当我们new一个pojo时，它处于瞬时态，此时与session、数据库均无任何关联。
b.此后，我们获得session并开启hibernate事务，调用save(),persist(),saveOrUpdate()方法，将pojo转变为持久态，此时session中存有这个pojo，但直到transaction.commit()被调用时，sql语句才会执行，此后数据库中也才有此条数据。
c.但当commit()并且session.close()执行过后，pojo就变为了游离态，也就是说，数据库中有该记录，但session中不再有。
d.持久化状态的实例，也可以重新变成瞬时态，那就是调用delete()方法。
e.通过get()或load()方法得到的pojo是持久态的。
f.游离态的pojo可以通过update(),saveOrUpdate(),lock()和replicate()方法重新成为持久态。
g.调用merge()方法后，pojo维持原态，但内容会被更新到数据库

第039题
以下代码定义了一个变量，如何输出这个变量的值？
 
A、<% String myBean = 	
	(String)pageContext.getAttribute(“stringBean”,PageContext.PAGE_SCOPE);%>
<%=myBean%>
B、
C、
D、<%=stringBean%>

正确答案: A C D 我的答案: A C (错误)
 解释：

A选项：通过 pageContext（PageContext类的实例，提供对JSP页面所有对象以及命名空间的访问） 获取stringBean 的值，赋给 String 类型的变量 myBean，然后通过 Jsp 表达式 处理该值。
bean:define
 题目中的 Struts 的bean:define 标签定义了一个字符串变量 stringBean ,它的值为 helloworld。
bean:write
 bean:write相当于 <%=request.getAttribute(“something”)%> 其中 something 是属性的名字。所以 B 错，C对。
D选项：
 通过Jsp 表达式 获取变量 stringBean 的值

第040题
以下哪些方法可以取到http请求中的cookie值（）?
A、request.getAttribute
B、request.getHeader
C、request.getParameter
D、request.getCookies

正确答案: B D 我的答案: B D (正确)
 解释：

 1）Cookie[] getCookies()
 返回一个数组，包含客户端发送该请求的所有的 Cookie 对象。
 
 2）Object getAttribute(String name)
 以对象形式返回已命名属性的值，如果没有给定名称的属性存在，则返回 null。
 
 3）String getHeader(String name)
 以字符串形式返回指定的请求头的值。Cookie也是头的一种；
 
 4）String getParameter(String name)
 以字符串形式返回请求参数的值，或者如果参数不存在则返回 null
 

第041题
关于类的叙述正确的是（）。
A、在类中定义的变量称为类的成员变量，在别的类中可以直接使用
B、局部变量的作用范围仅仅在定义它的方法内，或者是在定义它的控制流块中
C、使用别的类的方法仅仅需要引用方法的名字即可
D、只要没有定义不带参数的构造函数，JVM都会为类生成一个默认构造函数

正确答案: B 我的答案: B (正确)
 解释：
 A在类中定义的变量称为类的成员变量，在别的类中不可以直接使用局部变量的
 C使用别的类的方法需要通过该类的对象引用方法的名字
 D只要没有定义任何构造函数，JVM都会为类生成一个默认构造函数
第042题
如下Java语句 double x=2.0; int y=4; x/=++y; 执行后，x的值是（）
A、0.5		B、2.5		C、0.4		D、2.0

正确答案: C 我的答案: B (错误)
 解释：x/=++y 相当于x=x/(++y)，x为2.0 ，++y整体是值为5，但是最终的结果是为double所以是，2.0/5=0.4。（猪脑子算2/5=2.5，啊啊啊啊）
第043题
对于以下代码段，4个输出语句中输出true的个数是(    )。
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

正确答案: C 我的答案: A (错误)
 解释:
 A
 | |
 B C
 |
 D
 D属于B,D属于A,D属于D,D不属于C
 instanceof是判断前者是否可以类型可以转化为后者,可以转化即为true,分为向上转型和向下转型B D都是A的子类向下转型,
第044题
下列描述中，错误的是
A、SQL语言又称为结构化查询语言
B、java中”static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变
量的情况下被访问
C、面向对象开发中，引用传递意味着传递的并不是实际的对象，而是对象的引用，因
此，外部对引用对象所做的改变不会反映到所引用的对象上
D、java是强类型语言，javascript是弱类型语言
E、面向对象的三大特性包括：封装，继承，多态

正确答案: C 我的答案: D (错误)
 解释：
 值传递，传递的是原来值的副本。引用传递，除了一些特殊的（String，包装类属于不可变类），一般的引用类型在进行传递的时候，一开始形参和实参都是指向同一个地址的，这个时候形参对对象的改变会影响到实参。
 特别的是String类型的引用变量，String是被final修饰的，类不可被继承，其值不可被修改；赋值只是将该引用指向了内存中另一个地址，并没有改变原地址中的对象
第045题
以下程序运行的结果为 (   )
public class Example extends Thread{

@Override
 public void run(){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e){
            e.printStackTrace();
        }
        System. out .print( "run" );
    }
    public static void main(String[] args){
        Example example= new Example();
        example.run();
        System. out .print( "main" );
    }
}
A、run main		B、main run		C、main		D、run		E、不能确定

正确答案: A 我的答案: A (正确)
 解释：此题考察的run()方法作为普通方法的调用和通过线程start的启动调用的区别。对象.start()属于对线程的启动调用run()方法。
 题目给出的example.run();是对象对普通方法的调用，所以由上到下依次执行输出：run main。
第046题
java中下面哪个能创建并启动线程（）
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()

正确答案: C 我的答案: C (正确)
 解释：
 创建并启动线程的过程为：定义线程—》实例化线程—》启动线程。

一 、定义线程： 1、扩展java.lang.Thread类。 2、实现java.lang.Runnable接口。
二、实例化线程：

1、如果是扩展java.lang.Thread类的线程，则直接new即可。
2、如果是实现了java.lang.Runnable接口的类，则用Thread的构造方法：
 Thread(Runnable target)
 Thread(Runnable target, String name)
 Thread(ThreadGroup group, Runnable target)
 Thread(ThreadGroup group, Runnable target, String name)
 Thread(ThreadGroup group, Runnable target, String name, long stackSize)
 所以A、D的实例化线程错误。
 
三、启动线程： 在线程的Thread对象上调用start()方法，而不是run()或者别的方法。
 所以B的启动线程方法错误。

第047题
What is the result of compiling and executing the following fragment of code:
Boolean flag = false;
if (flag = true)
{
    System.out.println(“true”);
}
else
{
    System.out.println(“false”);
}
A、The code fails to compile at the “if” statement.
B、An exception is thrown at run-time at the “if” statement.
C、The text“true” is displayed.
D、The text“false”is displayed.
E、Nothing is displayed.

正确答案: C 我的答案: C (正确)
 解释：Boolean修饰的变量为包装类型，初始化值为false,进行赋值时会调用Boolean.valueOf(boolean b)方法自动拆箱为基本数据类型，因此赋值后flag值为true，输出文本true。 如果使用==比较,则输出文本false。if的语句比较，除boolean外的其他类型都不能使用赋值语句，否则会提示无法转成布尔值。
第048题
在java中，下列标识符不合法的有（ ）
A、new
B、$Usdollars
C、1234
D、car.taxi

正确答案: A C D 我的答案: A C D (正确)
 解释：Java标识符由数字，字母和下划线（_），美元符号（$）组成。在Java中是区分大小写的，而且还要求首位不能是数字。最重要的是，Java关键字 不能当作Java标识符。
 A选项是关键字，所以不合法，B选项合法，C选项首位为数字不合法，D中还有“.”，不合法。
第049题
以下关于JAVA语言异常处理描述正确的有？
A、throw关键字可以在方法上声明该方法要抛出的异常。
B、throws用于抛出异常对象。
tC、ry是用于检测被包住的语句块是否出现异常，如果有异常，则抛出异常，并执行catch语句。
D、finally语句块是不管有没有出现异常都要执行的内容。
E、在try块中不可以抛出异常

正确答案: C D 我的答案: A B C D (错误)
 解释：
 Java语言中的异常处理包括声明异常、抛出异常、捕获异常和处理异常四个环节。
 throw用于抛出异常。
 throws关键字可以在方法上声明该方法要抛出的异常，然后在方法内部通过throw抛出异常对象。
 try是用于检测被包住的语句块是否出现异常，如果有异常，则抛出异常，并执行catch语句。
 cacth用于捕获从try中抛出的异常并作出处理。
 finally语句块是不管有没有出现异常都要执行的内容。
第050题
局部内部类可以用哪些修饰符修饰？
A、public
B、private
C、abstract
D、final

正确答案: C D 我的答案: C D (正确)
 解释：局部内部类是放在代码块或方法中的，不能有访问控制修饰符，且不能用static修饰
第051题
java有8种基本类型，请问byte、int、long、char、float、double、boolean各占多少个字
节？
A、1 2 8 2 4 8 1
B、1 4 8 2 4 8 1
C、1 4 4 2 4 4 2
D、1 4 4 2 4 8 2

正确答案: B 我的答案: B (正确)
 解释：



变量名称
字节
位数




byte
1
8


short
2
16


int
4
32


long
8
64


float
4
32


double
8
64


char
2
16


boolean
1
8



第052题
以下程序的运行结果是（）
public class Increment
{
    public static void main(String args[])
    {
        int a;
        a = 6;
        System.out.print(a);
        System.out.print(a++);
        System.out.print(a);
    }
}
A、666		B、667	C、677		D、676

正确答案: B 我的答案: B (正确)
 解释：选B；a++可以理解为当访问a之后再对a进行加一操作
第053题
一个以”.java”为后缀的源文件
A、只能包含一个类，类名必须与文件名相同
B、只能包含与文件名相同的类以及其中的内部类
C、只能有一个与文件名相同的类，可以包含其他类
D、可以包含任意类

正确答案: C 我的答案: C (正确)
 解释：当编写一个java源代码文件时，此文件通常被称为编译单元（有时也被称为转译单元）。每个编译单元都必须有一个后缀名.java，而在编译单元内则可以有一个public类，该类的名称必须与文件的名称相同（包括大小写，但不包括文件的后缀名.java）。每个编译单元只能有一个public类，否则编译器就不会接受。如果在该编译单元之中还有额外的类的话，那么在包之外的世界是无法看见这些类的，这是因为它们不是public类，而且它们主要用来为主public类提供支持。 --《Java 编程思想》
 注：public类不是必须的，但是如果源文件中有一个（只能有一个）public类的话，文件名必须与这个public类同名，原因 是为了方便虚拟机在相应的路径中找到相应的类所对应的字节码文件。所以在没有public类的Java文件中，文件名和类名都没什么联系。
第054题
以下J2EE中常用的名词解释错误的是？
A、EJB容器：Enterprise java bean 容器
B、JNDI：JAVA事务服务。提供各种分布式事务服务。应用程序只需调用其提供的接口即可。
C、JMS：JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。
D、JAF：JAVA安全认证框架。提供一些安全控制方面的框架。

正确答案: B 我的答案: D (错误)
 解释:

EJB容器：Enterprise java bean 容器。更具有行业领域特色。他提供给运行在其中的组件EJB各种管理功能。只要满足J2EE规范的EJB放入该容器，马上就会被容器进行高效率的管理。并且可以通过现成的接口来获得系统级别的服务。例如邮件服务、事务管理。
JNDI：（Java Naming & Directory Interface）JAVA命名目录服务。主要提供的功能是：提供一个目录系，让其它各地的应用程序在其上面留下自己的索引，从而满足快速查找和定位分布式应用程序的功能。
JMS：（Java Message Service）JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。
JTA：（Java Transaction API）JAVA事务服务。提供各种分布式事务服务。应用程序只需调用其提供的接口即可。
JAF：（Java Action FrameWork）JAVA安全认证框架。提供一些安全控制方面的框架。让开发者通过各种部署和自定义实现自己的个性安全控制策略。
RMI/IIOP:（Remote Method Invocation /internet对象请求中介协议）他们主要用于通过远程调用服务。例如，远程有一台计算机上运行一个程序，它提供股票分析服务，我们可以在本地计算机上实现对其直接调用。当然这是要通过一定的规范才能在异构的系统之间进行通信。RMI是JAVA特有的。

第055题
java Thread中，run方法和start方法的区别，下面说法错误的是？
A、通过调用Thread类的start()方法来启动一个线程，这时此线程是处于就绪状态，并没有运行。
B、他们都可以实现了多线程运行。
C、run方法是thread的一个普通方法调用。
D、调用start方法后，一旦得到cpu时间片，就开始执行run()方法。

正确答案: B 我的答案: B (正确)
 解释： 两种方法的区别:

1.start方法
 用 start方法来启动线程，是真正实现了多线程， 通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法。但要注意的是，此时无需等待run()方法执行完毕，即可继续执行下面的代码。所以run()方法并没有实现多线程。
2.run方法
 run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码。

第056题
在java7中，下列不能做switch()的参数类型是？
A、int型
B、枚举类型
C、字符串
D、浮点型

正确答案: D 我的答案: B (错误)
 解释：switch语句后的控制表达式只能是short、char、int、long整数类型和枚举类型，不能是float，double和boolean类型。String类型是java7开始支持。
第057题
下列不属于算法结构的是（）
A、输入数据
B、处理数据
C、存储数据
D、输出结果

正确答案: C 我的答案: C (正确)
 解释：算法=输入（0/n）+过程+输出（1/n）
第058题
下列哪些操作会使线程释放锁资源？
A、sleep()
B、wait()
C、join()
D、yield()

正确答案: B C 我的答案: A B (错误)
 解释：

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

第059题
以下程序执行后，错误的结果是（）
public class Test {
    private String name = "abc";
    public static void main(String[] args) {
        Test test = new Test();
        Test testB = new Test();
        String result = test.equals(testB) + ",";
        result += test.name.equals(testB.name) + ",";
        result += test.name == testB.name;
        System.out.println(result);
    }
}
A、true,true,true
B、true,false,false
C、false,true,false
D、false,true,true

正确答案: A B C 我的答案: A B D (错误)
 解释：

1、首先应该注意到作为成员变量的 name 是使用字面量直接赋值的 （ - privateString name =“abc”; ） 这种赋值的执行过程是先看字符串常量池中有没有 value 数组为 [‘a’, ‘b’, ‘c’] 的 String 对象，如果没有的话就创建一个，有的话就拿到他的一个引用。
2、name 没有被static 修饰，所以每实例化一个对象都会执行 private String name =“abc”; 第一次执行的时候发现字符串常量池没有 value 数组为 [‘a’, ‘b’, ‘c’]的String 对象，所以创建一个，拿到他的一个引用，但是第二次的时候发现已经有了这样的对象了， 所以只是拿到这个拿到这个对象的一个引用而已。
3、执行 test.name == testB.name; 的时候比较的是两个name指向的内存是不是同一个（比较引用本身没有意义），所以 test.name== testB.name; 的结果是true。

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

正确答案: A B C 我的答案: A (错误)
 解释：

1、不管有木有出现异常，finally块中代码都会执行；
2、当try和catch中有return时，finally仍然会执行；
3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；
4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

第061题
下面关于继承的描述正确的是
A、在Java中类只允许单一继承
B、在Java中一个类只能实现一个接口
C、在Java中一个类不能同时继承一个类和实现一个接口
D、Java的单一继承使代码不可靠

正确答案: A 我的答案: A (正确)
 解释：类只支持单继承，接口支持多继承，继承的同时还可以实现接口
第062题
为AB类的一个无形式参数无返回值的方法method书写方法头，可以用AB.method()方式
调用，该方法头的形式为(    )。
A、static void method( )
B、public void method( )
C、final void method( )
D、abstract void method( )

正确答案: A 我的答案: A (正确)
 解释：

首先声明什么是静态方法:

用static修饰的方法
静态方法是使用公共内存空间的，就是说所有对象都可以直接引用，不需要创建对象再使用该方法。
 
其次说明静态方法的使用:

在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。
而实例方法只有后面这种方式。
 也就是说，只有调用静态方法时可以无需创建对象。
 

第063题
ArrayList和LinkList的描述，下面说法错误的是？
A、LinkedeList和ArrayList都实现了List接口
B、ArrayList是可改变大小的数组，而LinkedList是双向链接串列
C、LinkedList不支持高效的随机元素访问
D、在LinkedList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；
	而在ArrayList的中间插入或删除一个元素的开销是固定的

正确答案: D 我的答案: D (正确)
 解释：Arraylist的内存结构是数组，当超出数组大小时创建一个新的数组，吧原数组中元素拷贝过去。其本质是顺序存储的线性表，插入和删除操作会引发后续元素移动，效率低，但是随机访问效率高
 LinkedList的内存结构是用双向链表存储的，链式存储结构插入和删除效率高，不需要移动。但是随机访问效率低，需要从头开始向后依次访问
第064题
下列选项中属于面向对象设计方法主要特征的是（ ）。
A、继承
B、自顶向下
C、模块化
D、逐步求精

正确答案: A 我的答案: A (正确)
 解释：面向对象三大特征：封装、继承、多态
第065题
如下的Java程序 
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

正确答案: B 我的答案: B (正确)
 解释：采用命令行“ java Test one two three ”调用其中Test为调用的方法，而one two three则为Test方法里面main函数的参数；
 System.out.println(args[0]);表示输出第一个元素，故为one；
第066题
下面哪个选项正确创建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 我的答案: B (正确)
第067题
以下 _____ 不是 Object 类的方法
A、clone（）
B、finalize()
C、toString()
D、hasNext()

正确答案: D 我的答案: B (错误)
 解释：
 Object中没有hasNext（） 方式，这个方法是迭代器中的
 Object中的方法

1．clone方法
 保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。
2．getClass方法
 final方法，获得运行时类型。
3．toString方法
 该方法用得比较多，一般子类都有覆盖。
4．finalize方法
 该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。
5．equals方法
 该方法是非常重要的一个方法。一般equals和==是不一样的，但是在Object中两者是一样的。子类一般都要重写这个方法。
6．hashCode方法
 该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。
 一般必须满足obj1.equals(obj2)==true。可以推出obj1.hash- Code()==obj2.hashCode()，但是hashCode相等不一定就满足equals。不过为了提高效率，应该尽量使上面两个条件接近等价。
7．wait方法
 wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。
 调用该方法后当前线程进入睡眠状态，直到以下事件发生。

（1）其他线程调用了该对象的notify方法。
（2）其他线程调用了该对象的notifyAll方法。
（3）其他线程调用了interrupt中断该线程。
（4）时间间隔到了。
 此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。
 
8．notify方法
 该方法唤醒在该对象上等待的某个线程。
 -9．notifyAll方法
 该方法唤醒在该对象上等待的所有线程。

第068题
JSP分页代码中，哪个步骤次序是正确的？
A、先取总记录数，得到总页数，最后显示本页的数据。
B、先取所有的记录，得到总页数，再取总记录数，最后显示本页的数据。
C、先取总页数，得到总记录数，再取所有的记录，最后显示本页的数据。
D、先取本页的数据，得到总页数，再取总记录数，最后显示所有的记录。

正确答案: A 我的答案: B (错误)
 解释：

1、count(*)得到总记录数
2、计算总页数
3、获取所有记录
4、过滤显示本页数据

第069题
java8中，下面哪个类用到了解决哈希冲突的开放定址法 
A、LinkedHashSet
B、HashMap
C、ThreadLocal
D、TreeMap

正确答案: C 我的答案: B (错误)
 解决：ThreadLocalMap使用开放定址法解决hash冲突，HashMap使用链地址法解决hash冲突。
第070题
URL u =new URL("http://www.123.com");。如果www.123.com不存在，则返回______。
A、http://www.123.com
B、””
C、null
D、抛出异常

正确答案: A 我的答案: A (正确)
 解释：new URL()时必须捕获检查异常，但这个异常是由于字符串格式和URL不符导致的，与网址是否存在无关。URL的toString方法返回字符串，无论网址是否存在。
第071题
在委托事件模型中，源生成事件并把它发送给一个或多个监听器，每个监听	器必须向事
件源注册。
A、T					B、F

正确答案: A 我的答案: A (正确)
第072题
下列说法正确的是
A、java中包的主要作用是实现跨平台功能
B、package语句只能放在import语句后面
C、包（package）由一组类（class）和接口（interface）组成
D、可以用#include关键词来标明来自其它包中的类

正确答案: C 我的答案: C (正确)
 解释：
 A: java中"包"的引入的主要原因是java本身跨平台特性的需求。实现跨平台的是JVM。A:
 B： package语句是Java源文件的第一条语句。（若缺省该语句，则指定为无名包。），如果想在另一个类里面引用包里面的类，要把名字写全。（相当用文件的绝对路径访问）或者用import导入。
 D：java中并无#include关键字， 如果想在另一个类里面引用包里面的类，要把名字写全。（相当用文件的绝对路径访问）或者用import导入
第073题
字符界面下接受用户从键盘输入，需要import的包是：（ ）
A、java.lang包
B、java.awt包
C、java.io包
D、java.applet包

正确答案: C 我的答案: A (错误)
 解释：这个问题的前提是字符界面下
 前端用户输入、后台程序获取，都是字符流的传输，因此需要导入java.io包。
 而java.util中的Scanner则是获取控制台的输入。
第074题
AccessViolationException异常触发后，下列程序的输出结果为（      ）
static void Main(string[] args)  
{  
    try  
    {  
        throw new AccessViolationException();  
        Console.WriteLine("error1");  
    }  
    catch (Exception e)  
    {  
        Console.WriteLine("error2");  
    }  
    Console.WriteLine("error3");  
} 
A、error2
	error3
B、error3
C、error2
D、error1

正确答案: A 我的答案: C (错误)
 解释：只要catch语句块中没有return和throw语句，就会继续执行try-catch-finally之外的代码，所谓的遇到异常就不执行了，说的是try语句块中的代码。
第075题
 public void test() {
        int a = 10;
        System.out.println(a++ + a--);
    }
最后输出什么？
A、19		B、20		C、21		D、22

正确答案: C 我的答案: C (正确)
 解释：a++ 先把10赋值给a 再+1 所以左边是10 但此时a=11。右边a-- 也是先赋值 a=11，再-1。10+11=21 此时a=10。
第076题
说明输出结果。
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

正确答案: C 我的答案: A (错误)
 解释：

1.首先 super.getClass() 是父类的getClass（）方法，其父类是Date，它的getClass（）方法是继承自Object类而且没有重写，所以就是调用object的getClass（）方法。
2.在调用getName()方法而getName()是：包名+类名

第077题
下面哪一项不是加载驱动程序的方法？
A、通过DriverManager.getConnection方法加载
B、调用方法 Class.forName
C、通过添加系统的jdbc.drivers属性
D、通过registerDriver方法注册

正确答案: A 我的答案: D (错误)
 解释：DriverManager.getConnection方法返回一个Connection对象，这是加载驱动之后才能进行的
第078题
Java对象的初始化方式有（ ）
A、初始化块
B、构造器
C、定义变量时指定初始化值
D、其它各项都不对

正确答案: A B C 我的答案: A B C (正确)
 解释：
 对象的初始化方式：

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

第079题
Java 中的集合类包括 ArrayList 、 LinkedList 、 HashMap 等，下列关于集合类描述正确
的是？（）
A、ArrayList和LinkedList均实现了List接口
B、ArrayList访问速度比LinkedList快
C、随机添加和删除元素时，ArrayList的表现更加快速
D、HashMap实现Map接口，它允许任何类型的键和值对象，并允许将NULL用作键或值

正确答案: A B D 我的答案: A B D (正确)
 解释：

A、HashMap实现了Map接口的，它的Key和Value都可以是null，但是Hashtable种，Key和Value都不能是null。
B、ArrayList与LinkedList都实现了List接口，继承了AbstractList类。
C、ArrayList底层是动态数组是实现，随机位置添加和删除，都需要移动数组的数据，而LinkedList底层是双向链表，只需要修改Node节点的引用。
D、随机访问数组要比链表块。

ArrayList和LinkedList的区别表：
 
第080题
下面有关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来使用

正确答案: A B C D 我的答案: A B C D (正确)
 解释：

A、Bootstrap ClassLoader/启动类加载器
 主要负责jdk_home/lib目录下的核心 api 或 -Xbootclasspath 选项指定的jar包装入工作.
B、Extension ClassLoader/扩展类加载器
 主要负责jdk_home/lib/ext目录下的jar包或 -Djava.ext.dirs 指定目录下的jar包装入工作
C、System ClassLoader/系统类加载器
 主要负责java -classpath/-Djava.class.path所指的目录下的类与jar包装入工作.D
D、 User Custom ClassLoader/用户自定义类加载器(java.lang.ClassLoader的子类)
 在程序运行期间, 通过java.lang.ClassLoader的子类动态加载class文件, 体现java动态实时类装入特性.

第081题
在程序代码中写的注释太多，会使编译后的程序尺寸变大。
A、对							B、错

正确答案: B 我的答案: B (正确)
 解释:

编译后的程序尺寸即class文件大小
过多注释影响编译效率，影响合作开发效率
注释不会影响class文件的执行效率

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

正确答案: A 我的答案: A (正确)
 解释：所有异常都是Exception的子类。比如用Exception
 因为所有异常都是Exception的子类,如果你把Exception放在前边捕获,后边的catch将永远不会执行
第083题
ResultSet中记录行的第一列索引为？
A、-1		B、0		C、1		D、以上都不是

正确答案: C 我的答案: B (错误)
 解释;ResultSet跟普通的数组不同，索引从1开始而不是从0开始
第084题
在你面前有一个n阶的楼梯，你一步只能上1阶或2阶。请问，当N=11时，你可以采用多
少种不同的方式爬完这个楼梯（）；当N=9时呢？
A、11		B、144		C、55		D、89

正确答案: B C 我的答案: B C (正确)
 解释： 当台阶只有一阶时，只能走一步，只有一种走法。 当两级台阶时，可以走一步，也可以一次走两步，有两种走法。 当三级台阶时，可以走一步，走三次。可以先走一步，再两步。也可以，先两步，再一步。总共三种方法。 可以看到当台阶是3时，第1级台阶选中之后(一种)，剩下可以走的方式恰好是台阶为2时的总数，总的数量为前两个之和，所以是f(3)=f(1)+f(2)。即，f(n)=f(n-2)+f(n-1)，总结起来刚好是一个斐波那契数列。
第085题
Model-View-Controller(MVC) is an architectural pattern that frequently used in web 
applications. Which of the following statement(s) is(are) correct?
A、Models often represent data and the business logics needed to manipulate the data 
	in the application
B、A view is a (visual) representation of its model. It renders the model into a form 
	suitable for interaction, typically a user interface element
C、A controller is the link between a user and the system. It accepts input from the 
	user and instructs the model and a view to perform actions based on that input
D、The common practice of MVC in web applications is, the model receives GET or 
	POST input from user and decides what to do with it, handing over to controller and 
	which hand control to views(HTML-generating components)

正确答案: A B C 我的答案: A B C D (错误)
 翻译：
 MVC是一种在web应用中常用的架构，下列说法正确的是（）
 A. 模型通常代表应用程序中的数据以及用于操纵数据的业务逻辑；
 B. 视图是其对应的模型的可视化呈现，视图 将模型渲染成适合于交互的形式（通常为用户界面元素）；
 C. 控制器是用户与系统之间的纽带，它接受用户输入，并指示模型和视图基于用户输入执行操作（处理数据、展示数据）；
 D. MVC模式在web应用中的常见实践是：模型接受来自于用户的GET或POST请求数据并决定如何处理，模型将用户数据转交给控制器，控制器将控制权转交给视图（视图由HTML生成）；
 E. 以上全不是。
第086题
下面的代码运行的结果是：
class B extends Object
{
    static
    {
        System.out.println("Load B");
    }
    public B()
    {
        System.out.println("Create B");
    }
}
class A extends B
{
    static
    {
        System.out.println("Load A");
    }
    public A()
    {
        System.out.println("Create A");
    }
}

public class Testclass
{
    public static void main(String[] args)
    {
        new A();
    }
}
A、Load B ->Create B->Load A -> Create A
B、Load B -> Load A  ->Create B  ->Create A
C、Load B -> Create B-> Create A -> Load A
D、Create B ->Create A ->Load B ->Load A

正确答案: B 我的答案: A (错误)
 解释：初始化块在构造器执行之前执行，类初始化阶段先执行最顶层父类的静态初始化块，依次向下执行，最后执行当前类的静态初始化块；创建对象时，先调用顶层父类的构造方法，依次向下执行，最后调用本类的构造方法。
 执行顺序：
 父类静态代码块->子类静态代码块 -> 父类构造代码块->父类构造函数->子类构造代码块->子类构造函数
第087题
下列说法正确的是
A、在类方法中可用this来调用本类的类方法
B、在类方法中调用本类的类方法可直接调用
C、在类方法中只能调用本类的类方法
D、在类方法中绝对不能调用实例方法

正确答案: B 我的答案: B (正确)
 解释：类方法（静态方法），属于类而不属于某类的对象

(1) 类方法中不能引用对象变量；
(2) 类方法中不能调用类的对象方法；
(3) 在类方法中不能使用super、this关键字。
(4)类方法不能被覆盖。

第088题
下面有个hibernate延迟加载，说法错误的是？
A、Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）
B、Hibernate3 提供了属性的延迟加载功能
C、get支持延迟加载，load不支持延迟加
D、hibernate使用Java反射机制，而不是字节码增强程序来实现透明性

正确答案: C 我的答案: C (正确)
 Hibernate 中 get()和load() 的区别：

1.get()采用立即加载方式,而load()采用 延迟加载 ; get()方法执行的时候,会立即向数据库发出查询语句, 而load()方法返回的是一个***(此***中只有一个id属性),只有等真正使用该对象属性的时候,才会发出 sql语句
2.如果数据库中没有对应的记录,get()方法返回的是null.而load()方法出现异常ObjectNotFoundException

第089题
对下面Spring声明式事务的配置含义的说明错误的是（）

    
      
 
        PROPAGATION_REQUIRED,readOnly
         PROPAGATION_REQUIRED
     
 

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

正确答案: C 我的答案: A (错误)
 解释：sessionFactory只有使用Hibernate才需要注入，并且是注入到事务管理器的，所以c错误
第090题
以下哪些方法是Object类中的方法
A、clone()
B、toString()
C、wait()
D、finalize()

正确答案: A B C D 我的答案: A B (错误)
 
第091题
已知 声明并初始化二维数组 int a[ ][ ]={{1,2},{3,4},{5,6}} ，则 a[1][1] 的值为（）
A、1		B、2		C、4		D、5

正确答案: C 我的答案: C (正确)
 解释：数组下标是从零开始的!
第092题
以下哪个不是Collection的子接口？
A、List
B、Set
C、SortedSet
D、Map

正确答案: D 我的答案: C (错误)
 
第093题
下面关于Java package的描述，哪个是正确的:（）
I. 包不提供将所有类名分区为更易管理的块的机制.
II. 包提供可见性控制机制.
III. 包的一个重要属性是包内定义的所有类都可以通过该包外的代码访问.
IV. 声明为包的一部分的类的.class文件可以存储在多个目录中.
A、只有I
B、只有II
C、只有III
D、只有IV

正确答案: B 我的答案: D (错误)
第094题
假设如下代码中，若t1线程在t2线程启动之前已经完成启动。代码的输出是（）
public static void main(String[]args)throws Exception {
    final Object obj = new Object();
    Thread t1 = new Thread() {
        public void run() {
            synchronized (obj) {
                try {
                    obj.wait();
                    System.out.println("Thread 1 wake up.");
                } catch (InterruptedException e) {
                }
            }
        }
    };
    t1.start();
    Thread.sleep(1000);//We assume thread 1 must start up within 1 sec.
    Thread t2 = new Thread() {
        public void run() {
            synchronized (obj) {
                obj.notifyAll();
                System.out.println("Thread 2 sent notify.");
            }
        }
    };
    t2.start();
}
A、Thread 1 wake up
	Thread 2 sent notify.
B、Thread 2 sent notify.
	Thread 1 wake up
C、 A、B皆有可能
D、程序无输出卡死

正确答案: B 我的答案: A (错误)
 解释:执行obj.wait();时已释放了锁，所以t2可以再次获得锁，然后发消息通知t1执行，但这时t2还没有释放锁，所以肯定是执行t2，然后释放锁，之后t1才有机会执行。
第095题
当编译并运行下面程序时会发生什么结果（）
public class Bground extends Thread{
    public static void main(String argv[]){
        Bground b = new Bground();
        b.run();
    }
    public void start(){
        for(int i=0;i<10;i++){
            System.out.println("Value of i = "+i);
        }
    }
}
A、编译错误，指明run方法没有定义
B、运行错误，只鞥呢run方法没有定义
C、编译通过并输出0到9
D、编译通过，但无输出
正确答案: D   我的答案: A (错误)
解释·：对于线程而言，start是让线程从new变成runnable。run方法才是执行体的入口。

但是在Thread中，run方法是个空方法，没有具体实现。
 Bground继承了Thread，但是没有重写run方法，那么调用run方法肯定是无输出。
第096题
在java中，在同一包内，类Cat里面有个公有方法sleep()，该方法前有static修饰，则可以
直接用Cat.sleep()。（ ）
A、正确
B、错误

正确答案: A 我的答案: A (正确)
 解释：静态方法可以直接使用 类名.方法.
第097题
下面有关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

正确答案: C 我的答案: C (正确)
 解释:默认值 取值范围 示例
 字节型 ： 0 -2^7—-27-1 byte b=10;
 字符型 ： ‘ \u0000′ 0—-2^16-1 char c=’c’ ;
 short : 0 -2^15—-215-1 short s=10;
 int : 0 -2^31—-231-1 int i=10;
 long : 0 -2^63—-263-1 long o=10L;
 float : 0.0f -2^31—-231-1 float f=10.0F
 double : 0.0d -2^63—-263-1 double d=10.0;
 boolean: false true\false boolean flag=true;
第098题
类A1和类A2在同一包中，类A2有个protected的方法testA2，类A1不是类A2的子类（或
子类的子类），类A1可以访问类A2的方法testA2。（  ）
A、正确
B、错误

正确答案: A 我的答案: B (错误)
 
第099题
如下代码的输出是
package Test;
public class Test {
    private static void test(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            try {
                if (arr[i] % 2 == 0) {
                    throw new NullPointerException();
                } else {
                    System.out.print(i);
                }
            } finally {
                System.out.print("e");
            }
        }
    }

    public static void main(String[]args) {
        try {
            test(new int[] {0, 1, 2, 3, 4, 5});
        } catch (Exception e) {
            System.out.print("E");
        }
    }
}
可以得到的结论是（ ）
A、编译出错
B、eE
C、Ee
D、eE1eE3eE5
E、Ee1Ee3Ee5

正确答案: B 我的答案: D (错误)
 解释：由于arr[0] =0,所以在进入 test()方法里面会在第一个if 上抛出一个 NullPointerException,接着会执行 finally 的语句, (finally语句先于 return 和 throw语句执行)，输出一个’e，然后回到 main方法中，由于捕捉到异常，所以进入到catch语句中，然后打印一个’E’,所以最终结果为"eE"
第100题
以下各类中哪几个是线程安全的？( )
A、ArrayList
B、Vector
C、Hashtable
D、Stack

正确答案: B C D 我的答案: C D (错误)
 
第101题
 int i = 3;
String result = new String();
switch (i) {
case 1:
result = result + "him ";
case 2:
result = result + "her ";
case 3:
result = result + "it ";
default:
result = result + "me ";
}
System.out.println(result);
请给出最终输出内容。
A、it me
B、him her it me
C、him her
D、me

正确答案: A 我的答案: A (正确)
 解释：没有break，会产生穿透，从满足条件的case开始执行到底
第102题
如下代码，执行结果为：
def f(x):
    if x == 0:
        return 0
    elif x == 1:
        return 1
    else:
        return (x*f(x-1))
print(f(5))
A、120		B、720		C、24		D、64

正确答案: A 你的答案: A (正确)
 解释：递归，54321=120
第103题
以下代码执行的结果显示是多少（）？
 public class Demo{
 public static void main(String[] args){
 System.out.print(getNumber(0));
 System.out.print(getNumber(1));
 System.out.print(getNumber(2));
 System.out.print(getNumber(4));
 }
    public static int getNumber(int num){
        try{
            int result = 2 / num;
            return result;
        }catch (Exception exception){
            return 0;
        }finally{
            if(num == 0){
                return -1;
            }
            if(num == 1){
                return 1;
            }
        }
    }
}
A、0110		B、-1110		C、0211		D、-1211

正确答案: B 我的答案: C (错误)
 解释：finally一定会在return之前执行，但是如果finally使用了return或者throw语句，将会使trycatch中的return或者throw失效
第104题
class Foo {
final int i;
    int j;
    public void doSomething() {
        System.out.println(++j + i);
    }
}
的输出是？
A、0		B、1		C、2		D、不能执行，因为编译有错

正确答案: D 我的答案: B (错误)
 解释：final类型的变量一定要初始化，因为final的变量不可更改。
第105题
在Java中，以下关于方法重载和方法重写描述正确的是？
A、方法重载和方法的重写实现的功能相同
B、方法重载出现在父子关系中，方法重写是在同一类中
C、方法重载的返回值类型必须一致，参数项必须不同
D、方法重写的返回值类型必须相同或相容。（或是其子类）

正确答案: D 我的答案: D (正确)
 解释：方法重载的返回值的类型可以不同，因为判断方法重载的方法主要是根据方法的参数不同来判定；方法重写的返回值类型需要相同，重写就是子类继承了父类的方法，并在此方法上重写属于自己的特征，既然是继承过来的，那么它的返回值类型就必须要相同
第106题
以下哪项可能包含菜单条（ ）
A、Panel
B、Frame
C、Applet
D、Dialog

正确答案: B 我的答案: B (正确)
 解释：Frame是Window的直接子类，一个Frame对象就是一个有标题有边界的顶层窗口；
 Panel是Container的直接子类，一个Panel对象用来添加组件和其他Panel对象的容器。
第107题
假定Base b = new Derived（）; 调用执行b.methodOne（）后，输出结果是什么？
public class Base
{
   public void methodOne()
   {
      System.out.print("A");
      methodTwo();
   }

   public void methodTwo()
   {
      System.out.print("B");
   }
}

public class Derived extends Base
{
   public void methodOne()
   {
      super.methodOne();
      System.out.print("C");
   }

   public void methodTwo()
   {
      super.methodTwo();
      System.out.print("D");
   }
}
A、ABDC
B、AB
C、ABCD
D、ABC

正确答案: A 我的答案: D (错误)
 解释：只要是被子类重写的方法，不被super调用都是调用子类方法，所以这里调用的子类的方法
第108题
下面代码的运行结果为：（）
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异常

正确答案: C 我的答案: B D (错误)
 解释：局部变量可以先申明不用必须初始化，但使用到了一定要先初始化
第109题
有关静态初始化块说法正确的是？
A、无法直接调用静态初始化块
B、在创建第一个实例前或引用任何静态成员之前，将自动调用静态初始化块来初始化
C、静态初始化块既没有访问修饰符，也没有参数
D、在程序中，用户可以控制合适执行静态初始化块

正确答案: A B C 我的答案: A B C D (错误)
 解释：
 java对象初始化顺序

父类静态代码块，父类静态成员变量（同级，按代码顺序执行）
子类静态代码块，子类静态成员变量（同级，按代码顺序执行）
父类普通代码块，父类普通成员变量（同级，按代码顺序执行）
父类构造方法
子类普通代码块，子类普通成员变量（同级，按代码顺序执行）
子类构造方法
注意点：

静态内容只在类加载时执行一次，之后不再执行。
默认调用父类的无参构造方法，可以在子类构造方法中利用super指定调用父类的哪个构造方法。
 

第110题
jvm中垃圾回收分为scanvenge gc和full GC，其中full GC触发的条件可能有哪些
A、栈空间满
B、年轻代空间满
C、老年代满
D、持久代满
E、System.gc()

正确答案: C D E 我的答案: A B C D (错误)
 解释：

1，新生代：

(1）所有对象创建在新生代的Eden区，当Eden区满后触发新生代的Minor GC，将Eden区和非空闲Survivor区存活的对象复制到另外一个空闲的Survivor区中。
（2）保证一个Survivor区是空的，新生代Minor GC就是在两个Survivor区之间相互复制存活对象，直到Survivor区满为止。
 
2，老年代：当Survivor区也满了之后就通过Minor GC将对象复制到老年代。老年代也满了的话，就将触发Full GC，针对整个堆（包括新生代、老年代、持久代）进行垃圾回收。
3，持久代：持久代如果满了，将触发Full GC。

第111题
Java Applet在被浏览器加载的时候首先被执行且在applet整个生命周期中被运行一次的
方法是（）
A、init()
B、stop()
C、opreationcrawl()
D、reader()

正确答案: A 我的答案: A (正确)
 解释;Applet运行之前，先调用 Init() 方法，然后调用 start() 方法，最后调用 paint() 方法。
第112题
在 JAVA 编程中， Java 编译器会将 Java 程序转换为（ ）
A、字节码
B、可执行代码
C、机器代码
D、以上都不对

正确答案: A 我的答案: A (正确)
 解释：

编译器将Java源代码编译成字节码class文件
类加载到JVM里面后，执行引擎把字节码转为可执行代码
执行的过程，再把可执行代码转为机器码，由底层的操作系统完成执行。

第113题
Java 语言用以下哪个类来把基本类型数据封装为对象（）
A、包装类
B、Class
C、Math
D、Object

正确答案: A 我的答案: A (正确)
 八种基本类型： byte short int long float double char boolean
 对应的包装类 ： Byte Short Integer Long Float Double Character Boolean
第114题
Java中只有整型才能使用的运算符为？
A、*		B、/		C、%		D、+

正确答案: C 我的答案: C (正确)
 ABD选项的操作符都可用于float和double
 只有%取余操作，只适用于整型
第115题
下面哪个Set类是排序的？
A、LinkedHashSet
B、TreeSet
C、HashSet
D、AbstractSet

正确答案: B 我的答案: A (错误)
 解释：TreeSet自然排序，LinkedHashSet按添加顺序排序
第116题
It is an important feature of the Java language that it always provides a default 
constructor to a class.
A、FALSE
B、TRUE

正确答案: A 我的答案: A (正确)
 解释：只有在不显示声明构造方法时，系统才提供默认无参构造方法
第117题
在Java中，对于不再使用的内存资源，如调用完成的方法，“垃圾回收器”会自动将其释
放。（  ）
A、正确
B、错误

正确答案: B 我的答案: A (错误)
 解释：方法调用时，会创建栈帧在栈中，调用完是程序自动出栈释放，而不是gc释放
第118题
Choose the correct  ones from the following statements:
A、A class can implement more than one interfaces
B、A class can extend more than one class
C、An interface has at least one method declared.
D、An abstract class which has no abstract methods declared is legal

正确答案: A D 我的答案: A C D (错误)
 解释：

1、一个类可以有多个接口；
2、一个类只能继承一个父类；
3、接口中可以不声明任何方法，和成员变量
4、抽象类可以不包含抽象方法，但有抽象方法的类一定要声明为抽象类

第119题
关于下面这段Java程序，哪些描述是正确的：（ ）
public class ThreadTest extends Thread {
public void run() {
System.out.println("In run");
yield();
System.out.println("Leaving run");
}
public static void main(String []argv) {
(new ThreadTest()).start();
}
}
A、程序运行输出只有In run
B、程序运行输出只有Leaving run
C、程序运行输出先有In run后有Leaving run
D、程序运行输出先有Leaving run后有In run
E、程序没有任何输出就退出了
F、程序将被挂起，只能强制退出

正确答案: C 我的答案: C (正确)
 解释：Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。
第120题
有关线程的叙述正确的是()
A、可以获得对任何对象的互斥锁定
B、通过继承Thread类或实现Runnable接口，可以获得对类中方法的互斥锁定
C、线程通过使用synchronized关键字可获得对象的互斥锁定
D、线程调度算法是平台独立的

正确答案: C D 我的答案: B C (错误)
 解释：线程的互斥锁机制：synchronized，lock，condition
第121题
下列符号中可以在 java 程序里表示单行注释的是（ ）
A、--
B、/* ……*/
C、//
D、/** ……*/

正确答案: C 我的答案: C (正确)

1、单行(single-line)–短注释：//……
 注释格式：/* 注释内容 */
2、块(block)–块注释：/……/
 /*

注释内容
 */
 
3、文档注释：/……*/
 注释若干行，并写入javadoc文档。每个文档注释都会被置于注释定界符
 /…*/之中

第122题
Which is not Java primitive types?
A、short
B、Boolean
C、byte
D、float

正确答案: B 我的答案: B (正确)
 解释：
 java规定类名首字母必须大写，这里可以直观的看出来Boolean是一个引用类型，不是基本数据类型。
 java中的基本数据类型都对应一个引用类型，如Float是float的引用类型，Integer是int的引用类型
第123题
下面属于java合法变量定义的是？
A、final
B、1var1
C、_var2
D、var3&

正确答案: C 我的答案: C (正确)
 解释：A.final 是关键字
 B.不能以数字做首写
 C.首写字母可以为下划线
 D.不能与&相组合来命名
第124题
有如下一段程序：
public class Test{ 
    private static int i=1;
    public int getNext(){ 
         return i++;
    } 
    public static void main(String [] args){ 
        Test test=new Test(); 
        Test testObject=new Test(); 
        test.getNext(); 
        testObject.getNext(); 
        System.out.println(testObject.getNext()); 
    } 
}
请问最后打印出来的是什么？（）
A、2		B、3		C、4		D、5

正确答案: B 我的答案: B (正确)
 解释：return i++, 先返回i，然后i+1；
 第一次调用getNext()方法时，返回的是1，但此时i=2；
 第二次调用 getNext()方法时，返回的是2，但此时i=3；
 第三次调用 getNext()方法时，返回的是3，但此时i=4；
第125题
定义有StringBuffer s1=new StringBuffer(10);s1.append(“1234”)则s1.length()和s1.capacity()分别
是多少?
A、4   10
B、4   4
C、10  10
D、10  4

正确答案: A 我的答案: A (正确)
 解释：length 返回当前长度
 如果字符串长度没有初始化长度大，capacity返回初始化的长度
 如果append后的字符串长度超过初始化长度，capacity返回增长后的长度
第126题
下列程序test 类中的变量c 的最后结果为
public class Test {
	public static void main(String args[]) {
	int a = 10;
	int b;
	int c;
	if (a > 50) {
	b = 9;
	}
	c = b + a;
	}
}
A、10
B、0
C、19
D、编译出错

正确答案: D 我的答案: A (错误)
 解释：方法内定义的变量没有初始值，必须要进行初始化。 类中定义的变量可以不需要赋予初始值，默认初始值为0。
第127题
运行代码，结果正确的是：
Boolean flag = false;
if(flag = true){
System.out.println("true");
}else{

System.out.println("false");
}
A、编译错误
B、TRUE
C、FALSE
D、什么也没有输出

正确答案: B 我的答案: B (正确)
 解释： if(flag = true)的时候flag已经是true了，所以输出true；
 要是为if(flag == true)输出才为false
第128题
以下哪个类包含方法flush()？（）
 A、InputStream
 B、OutputStream
 C、A 和B 选项都包含
 D、A 和B 选项都不包含
 正确答案: B 我的答案: C (错误)
 解释：flush（）函数强制将缓冲区中的字符流、字节流等输出，目的是如果输出流输出到缓冲区完成后，缓冲区并没有填满，那么缓冲区将会一直等待被填满。所以在关闭输出流之前要调用flush（）。
第129题
Test.main()函数执行后的输出是（ ）
class Test {
    public static void main(String[] args) {
        System.out.println(new B().getValue());
    }
    static class A {
        protected int value;
        public A (int v) {
            setValue(v);
        }
        public void setValue(int value) {
            this.value= value;
        }
        public int getValue() {
            try {
                value ++;
                return value;
            } finally {
                this.setValue(value);
                System.out.println(value);
            }
        }
    }
    static class B extends A {
        public B () {
            super(5);
            setValue(getValue()- 3);
        }
        public void setValue(int value) {
            super.setValue(2 * value);
        }
    }
}
A、6 7 7
B、22 34 17
C、22 74 74
D、11 17 34

正确答案: B 我的答案: A (错误)
 
 
第130题
以下哪些继承自 Collection 接口（）
 A、List
 B、Set
 C、Map
 D、Array
 正确答案: A B 我的答案: A B C D (错误)
 
第131题
以下哪项是类实例化的语句？
A、varName ClassName=new varName();
B、ClassName varName=new ClassName(new ClassName);
C、ClassName varName=ClassName();
D、ClassName varName=new ClassName();

正确答案: D 我的答案: D (正确)
 解释：classname说的是类名，varName说的是变量名，这里不是考察类名首字母要大写，毕竟类名首字母不大写也是可以的。
第132题
进行Java基本的GUI设计需要用到的包是（）
A、java.io
B、java.sql
C、java.awt
D、java.rmi

正确答案: C 我的答案: C (正确)
 解释：

java.io提供了全面的IO接口。包括：文件读写、标准设备输出等。
java.sql 提供使用 Java 编程语言访问并处理存储在数据源中的数据的 API。此 API 包括一个框架，凭借此框架可以动态地安装不同驱动程序来访问不同数据源。
java.awt是一个软件包，包含用于创建用户界面和绘制图形图像的所有分类。功能：包含用于创建用户界面和绘制图形图像的所有类。
java.rmi 提供 RMI 包。RMI 指的是远程方法调用 (Remote Method Invocation)。它是一种机制，能够让在某个 Java虚拟机上的对象调用另一个 Java 虚拟机中的对象上的方法。

第133题
下列关于继承的描述正确的是（）
A、在Java中允许定义一个子类的引用，指向父类的对象。
B、在Java中一个子类可以继承多个抽象类，在extends关键字后依次列出，用逗号隔开。
C、在Java中继承是通过extends关键字来描述的，而且只允许继承自一个直接父类。
D、在Java中抽象类之间不允许出现继承关系，所有的抽象类都相互独立。

正确答案: C 我的答案: C (正确)
 解释;
 A、说反了。父类引用指向子类对象
 B、类都是单继承。
 D、抽象类也可以继承。
第134题
下列说法正确的是
A、java中包的主要作用是实现跨平台功能
B、package语句只能放在import语句后面
C、包（package）由一组类（class）和接口（interface）组成
D、可以用#include关键词来标明来自其它包中的类

正确答案: C 我的答案: C (正确)
 包的作用:

1 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
3 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
 package必须放在import的前面

引用包用的是import
第135题
关于Java以下描述正确的有(      )
A、native关键字表名修饰的方法是由其它非Java语言编写的
B、能够出现在import语句前的只有注释语句
C、接口中定义的方法只能是public
D、构造方法只能被修饰为public或者default

正确答案: A 我的答案: D (错误)

A：native是由调用本地方法库（如操作系统底层函数），可以由C，C++实现，A正确
B：import是用于导包语句，其前面可以出现package，用来声明包的，B错误
C：接口方法的修饰符可以是：public，abstract，default，static（后两者需要有{}），C正确
D：构造方法可以用private，protected，default，private，D错误

第136题
如下代码的输出是
package Test;
public class Test {
    private static void test(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            try {
                if (arr[i] % 2 == 0) {
                    throw new NullPointerException();
                } else {
                    System.out.print(i);
                }
            } finally {
                System.out.print("e");
            }
        }
    }	
    public static void main(String[]args) {
        try {
            test(new int[] {0, 1, 2, 3, 4, 5});
        } catch (Exception e) {
            System.out.print("E");
        }
    }
}
可以得到的结论是（ ）
A、编译出错
B、eE
C、Ee
D、eE1eE3eE5
E、Ee1Ee3Ee5

正确答案: B 我的答案: B (正确)
 解释：
 这题主要是2点:

1.finally中的语句一定会执行(如果之前没有retrun)。
2.是catch捕获到异常后程序结束。

第137题
设有下面两个赋值语句：
a = Integer.parseInt("1024");
b = Integer.valueOf("1024").intValue();
下述说法正确的是（）
A、a是整数类型变量，b是整数类对象。
B、a是整数类对象，b是整数类型变量。
C、a和b都是整数类对象并且它们的值相等。
D、a和b都是整数类型变量并且它们的值相等。

正确答案: D 我的答案: D (正确)
 解释：ntValue()是把Integer对象类型变成int的基础数据类型；
 parseInt()是把String 变成int的基础数据类型；
 Valueof()是把String 转化成Integer对象类型；（现在JDK版本支持自动装箱拆箱了。）
 本题：parseInt得到的是基础数据类型int，valueof得到的是装箱数据类型Integer，然后再通过valueInt转换成int，所以选择D
第138题
当编译并运行下面程序时会发生什么结果（）
public class Bground extends Thread{
    public static void main(String argv[]){
        Bground b = new Bground();
        b.run();
    }
    public void start(){
        for(int i=0;i<10;i++){
            System.out.println("Value of i = "+i);
        }
    }
}
A\、编译错误，指明run方法没有定义
B、运行错误，只鞥呢run方法没有定义
C、编译通过并输出0到9
D、编译通过，但无输出

正确答案: D 我的答案: D (正确)
 解释;对于线程而言，start是让线程从new变成runnable。run方法才是执行体的入口。
 但是在Thread中，run方法是个空方法，没有具体实现。
 Bground继承了Thread，但是没有重写run方法，那么调用run方法肯定是无输出。
第139题
以下哪些方法是Object类中的方法
A、clone()
B、toString()
C、wait()
D、finalize()

正确答案: A B C D 我的答案: A D (错误)
 
第140题
以下关于Histroy对象的属性或方法描述正确的是（）
A、bcak回到浏览器载入历史URL地址列表的当前URL的前一个URL
B、go表示刷新当前页面
C、length保存历史URL地址列表的长度信息
D、forward转到浏览器载入历史URL地址列表的当前URL的下一个URL。

正确答案: A D 我的答案: A B C D (错误)
 解释：选A、D。考察的是浏览器的内置对象管理模型，简称BOM(Browser Object Model)中的Histroy属性和方法。

length 返回浏览器历史列表中的URL数量。所以C中表述的长度信息是错误的。
back() 加载 history列表中的前一个URL。
forward() 加载 history 列表中的下一个URL。
go() 加载history列表中的某个具体页面。所以B的表述刷新当前页面是错误的。

第141题
以下有关构造方法的说法，正确的是：（）
A、一个类的构造方法可以有多个
B、构造方法在类定义时被调用
C、构造方法只能由对象中的其他方法调用
D、构造方法可以和类同名，也可以和类名不同

正确答案: A 我的答案: A (正确)
 解释：A一个类有多个构造方法便是重载的表现。重载参数列表不同。所以A是正确的。
 B构造方法是在对象创建时就被调用，用于初始化。
 C构造方法是给与之对应的对象进行初始化，初始化的动作只执行一次。
 D构造方法必须与所在类的名称同名。
第142题
以下多线程对int型变量x的操作，哪几个不需要进行同步（    ）
A、x=y;
B、x++;
C、++x;
D、x=1;

正确答案: D 我的答案: D (正确)
 解释：A.由于y的值不确定，所以要加锁；
 B,C 两个在多线程情况下是必须要加锁的，因为他们是先被读入寄存器，然后再进行+1操作，如果没有加锁，那么可能会出现数据异常；
 D 原子操作，所以不需要加锁
第143题
应用程序的main方法中有以下语句，则输出的结果( )
String s1=new String（ ” xyz ” ）;
String s2=new String（ ” xyz ” ）;
Boolean b1=s1.equals(s2);
Boolean b2=(s1==s2);
System .out.print(b1+ ” ” +b2); 
A、true false
B、false  true
C、true true
D、false  false

正确答案: A 我的答案: A (正确)
 解释：比较s1和s2两个对象的存储地址是否相等，明显两者分别存储在不同的地址，所以返回：false
第144题
下面哪个不是标准Statement类？
A、Statement
B、PreparedStatement
C、CallableStatement
D、BatchedStatement

正确答案: D 我的答案: D (正确)
 解释：

A，Statement是最基本的用法，采用字符串拼接的方式，存在注入漏洞
B，PreparedStatement对Statement中的SQL语句进行预编译，同时检查合法性，效率高
C，CallableStatement接口扩展 PreparedStatement，用来调用存储过程,它提供了对输出和输入/输出参数的支持。CallableStatement 接口还具有对 PreparedStatement 接口提供的输入参数的支持。
D，不是标准的Statement类

第145题
在开发中使用泛型取代非泛型的数据类型（比如用ArrayList取代ArrayList），程序的运
行时性能会变得更好。（） 
A、正确			B、错误

正确答案: B 我的答案: A (错误)
 解释：泛型仅仅是java的语法糖，它不会影响java虚拟机生成的汇编代码，在编译阶段，虚拟机就会把泛型的类型擦除，还原成没有泛型的代码，顶多编译速度稍微慢一些，执行速度是完全没有什么区别的.
第146题
有以下一个对象：
public class DataObject implements Serializable{
    private static int i=0;
    private String word=" ";
    public void setWord(String word){
        this.word=word;
    }
    public void setI(int i){
        Data0bject. i=I;
     }
}
创建一个如下方式的DataObject:
DataObject object=new Data0bject ( );
object. setWord("123");
object. setI(2); 
将此对象序列化为文件，并在另外一个JVM中读取文件，进行反序列化，请问此时读出的
Data0bject对象中的word和i的值分别为：
A、"", 0
B、"", 2
C、"123", 2
D、"123", 0

正确答案: D 我的答案: C (错误)
 解释：序列化保存的是对象的状态，静态变量属于类的状态，因此，序列化并不保存静态变量。所以i是没有改变的
第147题
下列选项中是正确的方法声明的是？（）
A、protected abstract void f1();
B、public final void f1() {}
C、static final void fq(){}
D、private void f1() {}

正确答案: A B C D 我的答案: A B C D (正确)
 注意：抽象方法只可以被public 和 protected修饰；
第148题
如下哪些是 java 中有效的关键字（）
A、native		B、NULL		C、false		D、this

正确答案: A D 我的答案: D (错误)
第149题
final、finally和finalize的区别中，下述说法正确的有
A、final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
B、finally是异常处理语句结构的一部分，表示总是执行。
C、finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以
	覆盖此方法提供垃圾收集时的其他资源的回收，例如关闭文件等。
D、引用变量被final修饰之后，不能再指向其他对象，它指向的对象的内容也是不可变的。

正确答案: A B 我的答案: A B (正确)
 解释：使用 final 关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。
第150题
Servlet的生命周期可以分为初始化阶段，运行阶段和销毁阶段三个阶段，以下过程属于初始化阶
段是（）。
A、加载Servlet类及.class对应的数据
B、创建servletRequest和servletResponse对象
C、创建ServletConfig对象
D、创建Servlet对象

正确答案: A C D 我的答案: A B D (错误)
 解释：Servlet的生命周期一般可以用三个方法来表示：

init()：仅执行一次，负责在装载Servlet时初始化Servlet对象
service() ：核心方法，一般HttpServlet中会有get,post两种处理方式。在调用doGet和doPost方法时会构造servletRequest和servletResponse请求和响应对象作为参数。
destory()：在停止并且卸载Servlet时执行，负责释放资源
 初始化阶段：Servlet启动，会读取配置文件中的信息，构造指定的Servlet对象，创建ServletConfig对象，将ServletConfig作为参数来调用init()方法。所以选ACD。B是在调用service方法时才构造的

第151题
Which is the return type of the method main()?
A、int
B、void
C、Boolean
D、static

正确答案: B 我的答案: B (正确)
 解释：主方法是无返回值类型的，所以要用void修饰。
第152题
下列叙述错误的是（ ）
A、在接口中定义的方法除了default和static关键字修饰的方法拥有方法体，其他方法都应是没有
	方法体的抽象方法（JDK1.8以后）
B、一个java类只能有一个父类,但可以实现多个接口
C、在类声明中,用implements关键字声明该类实现的接口
D、定义接口时使用implements关键字。

正确答案: D 我的答案: D (正确)
 解释：

A、JDK8开始，接口中可以定义有方法体的方法，方法必须被default和static修饰。除此之外，其他方法都是抽象方法。
B、Java的语法是单继承，但是继承可以传递。其实B更准确一点是只能有一个直接父类。
C、继承用extends，实现用implements。先继承后实现。
D、类是class，接口是interface。

第153题
下面程序的输出是:()
String x="fmn";
x.toUpperCase();
String y=x.replace('f','F');
y=y+"wxy";
System.out.println(y);
A、FmNwxy
B、fmnwxy
C、wxyfmn
D、Fmnwxy

正确答案: D 我的答案: D (正确)
 解释：String x=“fmn”; “fmn”是在常量池里的不可变对象。
 x.toUpperCase(); 在堆中new一个"FMN"对象，但无任何引用指向它。
 String y=x.replace(‘f’,‘F’); 在堆中 new一个"Fmn"对象，y指向它。
 y=y+“wxy”; 在堆中 重新new一个"Fmnwxy"对象， 修改y指向，现在y指向它。
第154题
有如下4条语句：()
Integer i01=59;
int i02=59;
Integer i03=Integer.valueOf(59);
Integer i04=new Integer(59);
以下输出结果为false的是:
A、System.out.println(i01==i02);
B、System.out.println(i01==i03);
C、System.out.println(i03==i04);
D、System.out.println(i02==i04);

正确答案: C 我的答案: D (错误)
 
第155题
关于以下application,说法正确是什么？
public class Test {
	static int x=10;
	static {x+=5;}
	public static void main(String[] args) //4
        {
		System.out.println("x="+x);
	}
	static{x/=3;};
}//9
A、4行与9行不能通过编译，因为缺少方法名和返回类型
B、编译通过，执行结果是：x=5
C、编译通过，执行结果是：x=3
D、9行不能通过编译，因为只能有一个静态初始化器

正确答案: B 我的答案: D (错误)
 解释：父类静态代码块–>子类静态代码块–>父类普通代码块–>父类构造方法–>子类代码块–>子类构造方法；
第156题
下列不正确的 Java 语言标识符是（ ）
A、Sky
B、$Computer
C、for
D、NULL

正确答案: C 你的答案: B (错误)
 Java标识符命名规范是：

1）只能包含字母a-zA-Z，数字0-9，下划线_和美元符号$；
2）首字母不能为数字；
3）关键字和保留字不能作为标识符。
null是关键字，NULL不是关键字，java区分大小写。这题答案D是标识符，但C是错的，for是关键字。

第157题
给定includel.isp文件代码片段，如下：
  <% pageContext.setAttribute(“User”,”HAHA”);%>
______ // 此处填写代码
  给定include2.jsp文件代码片段如下：
  <%=pageContext.getAttribute(“User”)%>
  要求运行include1.jsp时，浏览器上输出：HAHA
  A、
B、<%@include file=”include2.jsp”%>
C、
D、<% response.sendRedirect(“include2.jsp”); %>

正确答案: B 我的答案: B (正确)
 解释：B选项是静态包含，相当于不include2.jsp页面内容拷贝到此处，因此可以输出User属性值
 D选项是转发重定向，转发的时候pageContent内的属性值不能被传递，因此得不到User属性值
第158题
常用的servlet包的名称是？
A、java.servlet
B、javax.servlet
C、servlet.http
D、javax.servlet.http

正确答案: B D 我的答案: A B C D (错误)
 解释：JEE5.0中的Servlet相关的就下面这几个包:
 javax.servlet
 javax.servlet.jsp
 java.servlet.jsp.el
 java.servlet.jsp.tagext
 而最用得多的就是
 javax.servlet
 javax.servlet.http
第159题
以下说法中正确的有？
A、StringBuilder是 线程不安全的
B、Java类可以同时用 abstract和final声明
C、HashMap中，使用 get(key)==null可以 判断这个Hasmap是否包含这个key
D、volatile关键字不保证对变量操作的原子性

正确答案: A D 我的答案: A B C (错误)
 解释：abstract修饰的类是抽象类，是可以继承的，而final修饰的类表示不能再被继承，故肯定不能共同使用。故B错。
 HashMap中提供的get(key)获取的是变量，无法判断是否存在key。所以C是错的
 volatile关键字是一种轻量级的同步机制，只保证数据的可见性，而不保证数据的原子性。故D对
第160题
关于下面一段代码，以下说法正确的是： ()
public class Test {
    private synchronized void a() {
    }
    private void b() {
        synchronized (this) {
        }
    }
    private synchronized static void c() {
    }
    private void d() {
        synchronized (Test.class) {
        }
    }
}
A、同一个对象，分别调用方法a和b，锁住的是同一个对象
B、同一个对象，分别调用方法a和c，锁住的是同一个对象
C、同一个对象，分别调用方法b和c，锁住的不是同一个对象
D、同一个对象，分别调用方法a、b、c，锁住的不是同一个对象

正确答案: A C 我的答案: B (错误)
 解释：修饰非静态方法 锁的是this 对象
 修饰静态方法 锁的是class对象
第161题
若在某一个类定义中定义有如下的方法： abstract void performDial( ); 该方法属于（）
A、本地方法
B、最终方法
C、解态方法
D、抽象方法

正确答案: D 我的答案: D (正确)
 解释;含有abstract关键字的方法是抽象方法
第162题
以下那个数据结构是适用于"数据必须以相反的顺序存储然后检索" ? （）
A、Stack
B、Queue
C、List
D、Liink List

正确答案: A 我的答案: A (正确)
 解释;栈-先进后出
第163题
public class Test
{
    static boolean foo(char c)
    {
        System.out.print(c);
        return true;
    }
    public static void main( String[] argv )
    {
        int i = 0;
        for ( foo('A'); foo('B') && (i < 2); foo('C'))
        {
            i++ ;
            foo('D');
        }
    }
}
What is the result?
A、ABDCBDCB
B、ABCDABCD
C、Compilation fails.
D、An exception is thrown at runtime.

正确答案: A 我的答案: A (正确)
 解释：考for循环的执行顺序，1.先执行初始化条件，2.执行判断条件，3.如果满足2的条件，执行循环体中代码；4.执行foo(‘c’), 5.初始化条件不在执行，友从2开始执行
第164题
如果一个list初始化为{5，3，1}，执行以下代码后，其结果为（）？
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]

正确答案: B 我的答案: B (正确)
 解释：
 nums.add(6);//把6添加到list中，变为｛5,3,1,6｝
 nums.add(0,4);//在list的第0个位置添加4，list变为｛4,5,3,1,6｝
 nums.remove(1);//移除list的第一个元素，list变为｛4,3,1,6｝
第165题
public void getCustomerInfo() {
        try {
            // do something that may cause an Exception
        } catch (java.io.FileNotFoundException ex) {
            System.out.print("FileNotFoundException!");
        } catch (java.io.IOException ex) {
            System.out.print("IOException!");
        } catch (java.lang.Exception ex) {
            System.out.print("Exception!");
        }
    }
A、IOException!
B、IOException!Exception!
C、FileNotFoundException!IOException!
D、FileNotFoundException!IOException!Exception!

正确答案: A 我的答案: A (正确)
 解释：
 1.如果抛出一个FileNotFoundException(或其子类)，那么最终结果就打印FileNotFoundException
 2.如果抛出一个IOException,或者IOException的子类(不包含FileNotFoundException及其子类)，那么最终结果就打印IOException
 3.如果抛出一个Exception(不包含IOException及其子类),那么最终结果就打印Exception.
 以上，所以3个皆有可能.但是，不管是哪一种情况，只会输出其中之一。
 从答案上来看，B,C，D的输出情况是不存在的。因此选A
第166题
下面哪些标识符是正确的？
A、MyWorld
B、parseXML
C、–value
D、&maybe

正确答案: A B 我的答案: A B (正确)
 Java中标识符有字母、数字、美元符号$、下划线4种，不能以数字开头，不能用保留字和关键字
第167题
Java是一门支持反射的语言,基于反射为Java提供了丰富的动态性支持，下面关于Java反射的描
	述，哪些是错误的：(          )
A、Java反射主要涉及的类如Class, Method, Filed,等，他们都在java.lang.reflet包下
B、通过反射可以动态的实现一个接口，形成一个新的类，并可以用这个类创建对象，调用对象
	方法
C、通过反射，可以突破Java语言提供的对象成员、类成员的保护机制，访问一般方式不能访问
	的成员
D、Java反射机制提供了字节码修改的技术，可以动态的修剪一个类
E、Java的反射机制会给内存带来额外的开销。例如对永生堆的要求比不通过反射要求的更多
F、Java反射机制一般会带来效率问题，效率问题主要发生在查找类的方法和字段对象，因此通
	过缓存需要反射类的字段和方法就能达到与之间调用类的方法和访问类的字段一样的效率

正确答案: A D F 我的答案: A B C D F (错误)
 A：Class类在java.lang包下，错；
 B：动态代理可以通过接口与类实现，通过反射形成新的代理类，这个代理类增强了原来类的方法。对；
 C：反射可以强制访问private类型的成员，对；
 D：反射并不能对类进行修改，只能对类进行访问，错；
 E：反射机制对永生堆要求较多，对；
 F：即使使用换成，反射的效率也比调用类的方法低，错；
第168题
下面关于面向对象的一些理解哪些是错误的(    )
A、面向对象的最重要的特性是支持继承、封装和多态
B、系统设计应该遵循开闭原则，系统应该稳定不不可修改，但应支持通过继承、组合等方式进
	行扩展
C、函数式的语言必然是面向对象的语言
D、面向对象设计时，每个类的职责应该单一，不要再一个类中引入过多的接口
E、过程式语言和面向对象的语言各有其优势，过程式语言更加灵活，面向对象语言更加强调抽
	象和封装
F、Java和C++都是静态类型的面向对象编程语言

正确答案: C 我的答案: A D E F (错误)
 解释：动态类型语言是指在运行期间才去做数据类型检查的语言，也就是说，在用动态类型的语言编程时，永远也不用给任何变量指定数据类型，该语言会在你第一次赋值给变量时，在内部将数据类型记录下来。静态类型语言与动态类型语言刚好相反，它的数据类型是在编译其间检查的，也就是说在写程序时要声明所有变量的数据类型，C/C++是静态类型语言的典型代表，其他的静态类型语言还有C#、JAVA等。
第169题
关于java中的数组，下面的一些描述，哪些描述是准确的：（）
A、数组是一个对象，不同类型的数组具有不同的类
B、数组长度是可以动态调整的
C、数组是一个连续的存储结构
D、一个固定长度的数组可类似这样定义：int array[100]
E、两个数组用Object 里equals方法比较时，会逐个遍历其中的元素，对每个元素进行比较
F、java中不存在 int *a这样的东西做数组的形参

正确答案: A C F 我的答案: C D E F (错误)
第170题
以下JAVA程序的运行结果是什么(  )
public static void main(String[] args) {
Object o1 = true ? new Integer(1) : new Double(2.0);
Object o2;
if (true) {
             o2 = new Integer(1);
} else {
o2 = new Double(2.0);
}
System.out.print(o1);
System.out.print(" ");         
System.out.print(o2);
}
A、1 		1
B、1.0		1.0
C、1 		1.0
D、1.0 		1

正确答案: D 我的答案: A (错误)
 三元操作符类型的转换规则：
 1.若两个操作数不可转换，则不做转换，返回值为Object类型
 2.若两个操作数是明确类型的表达式（比如变量），则按照正常的二进制数字来转换，int类型转换为long类型，long类型转换为float类型等。
 3.若两个操作数中有一个是数字S,另外一个是表达式，且其类型标示为T，那么，若数字S在T的范围内，则转换为T类型；若S超出了T类型的范围，则T转换为S类型。
 4.若两个操作数都是直接量数字，则返回值类型为范围较大者
第171题
客户端要获取一个socket对象通过实例化，而服务器获得一个socket对象则通过什么方法的返回
值？
A、getRemoteSocketAddress()
B、getInputStream()
C、getOutputStream()

正确答案: A 我的答案: A (正确)
 解释：



通过建立一个SocketAddress对象，可以在多次连接同一个服务器时使用这个SocketAddress对象。
 


在Socket类中提供了两个方法：getRemoteSocketAddress和getLocalSocketAddress，通过这两个方法可以得到服务器和本机的网络地址。而且所得到的网络地址在相应的Socket对象关闭后任然可以使用。
 

第172题
protected访问权限要小于包访问权限。（  ）
A、正确
B、错误

正确答案: B 我的答案: B (正确)
 
第173题
用命令方式运行以下代码的运行结果是（）
public class f{
    public static void main(String[] args){
        String foo1 = args[1];
        String foo2 = args[2];
        String foo3 = args[3];
    }
}
命令:  java f a b c
A、程序编译错误
B、a b c
C、程序运行错误
D、f

正确答案: C 我的答案: B (错误)
第174题
以下哪些内存区域属于JVM规范？（　　）
A、方法区
B、实例变量
C、静态变量
D、程序计数器
E、虚拟机栈

正确答案: A D E 我的答案: A B C E (错误)
 JVM内存区：程序计数器、虚拟机栈、本地方法栈、堆、方法区（包括常量池）。
 不属于JVM内存区：直接内存（Direct Memory），用户I/O操作
第175题
下面哪几个语句正确的声明一个整型的二维数组（）
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]

正确答案: C D 我的答案: C D (正确)
 解释：

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

第176题
在java中，无论在何处调用，使用静态属性必须以类名做前缀。
A、正确
B、错误

正确答案: B 我的答案: A (错误)

1如果是本类使用，可以直接就用静态变量名。
2如果是其他类使用，可以使用类名来调用，也可以创建一个实例对象来调用。
3如果静态变量所在的类是静态类，那么不管在本类里或者在其他外部类，都可以直接使用静态变量名。

第177题
下面有关java实例变量,局部变量,类变量和final变量的说法，错误的是？
A、实例变量指的是类中定义的变量，即成员变量，如果没有初始化，会有默认值。
B、局部变量指的是在方法中定义的变量，如果没有初始化，会有默认值
C、类变量指的是用static修饰的属性
D、final变量指的是用final 修饰的变量

正确答案: B 我的答案: D (错误)
 解释：局部变量必须有初始值。
第178题
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"))

正确答案: A 我的答案: B (错误)
 byte [ ] String.getBytes(String charsetName); 得到的是以charsetName编码得到的byte数组；
 String的构造函数有： String (byte[] bytes, String charsetName);
第179题
以下哪个事件会导致线程销毁？（）
A、调用方法sleep()
B、调用方法wait()
C、start()方法的执行结束
D、run()方法的执行结束

正确答案: D 我的答案: A (错误)
 

A. 调用sleep()方***让线程进入睡眠状态—睡眠指定的时间后再次执行；
B. 调用wait()方***让线程进入等待状态 ----等待别的线程执行notify()或notifyAll()唤醒后继续执行；
C.调用start()方***让线程进入就绪状态—得到CPU时间就执行线程；
D.run()方法是线程的具体逻辑方法，执行完，线程就结束。

第180题
ArrayList list = new ArrayList(20);中的list扩充几次
A、0		B、1		C、2		D、3

正确答案: A 我的答案: B (错误)
 解释：Arraylist默认数组大小是10，扩容后的大小是扩容前的1.5倍，最大值小于Integer 的最大值减8，如果新创建的集合有带初始值，默认就是传入的大小，也就不会扩容
第181题
Java 语言中创建一个对象使用的关键字是（）
A、class
B、interface
C、new
D、create

正确答案: C 我的答案: C (正确)
 没有对象怎么办，new一个对象
第182题
以下代码的循环次数是
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、无限次

正确答案: D 我的答案: D (正确)
 解释：每次-2， 减三次1 减第四次－1 等不到0，理论一直做
第183题
以下对选择语句描述错误的是(）
A、根据某一条件重复执行一部分代码直到满足终止条件为止
B、可以根据条件控制程序流程，改变程序执行的顺序
C、选择语句可以嵌套使用
D、当条件满足时就会执行相应的语句

正确答案: A 我的答案: A (正确)
 流程控制语句分类：
 顺序结构
 选择结构:if语句、switch语句
 循环结构:while语句、for语句
第184题
关于访问权限说法正确 的是 ？ ( )
A、外部类前面可以修饰public,protected和private
B、成员内部类前面可以修饰public,protected和private
C、局部内部类前面可以修饰public,protected和private
D、以上说法都不正确

正确答案: B 我的答案: A (错误)
 （ 1 ）对于外部类而言，它也可以使用访问控制符修饰，但外部类只能有两种访问控制级别： public 和默认。因为外部类没有处于任何类的内部，也就没有其所在类的内部、所在类的子类两个范围，因此 private 和 protected 访问控制符对外部类没有意义。
（ 2 ）内部类的上一级程序单元是外部类，它具有 4 个作用域：同一个类（ private ）、同一个包（ protected ）和任何位置（ public ）。
（ 3 ） 因为局部成员的作用域是所在方法，其他程序单元永远不可能访问另一个方法中的局部变量，所以所有的局部成员都不能使用访问控制修饰符修饰。
第185题
JavaWEB中有一个类，当会话种邦定了属性或者删除了属性时，他会得到通知，这个类是：(    )
A、HttpSessionAttributeListener
B、HttpSessionBindingListener
C、HttpSessionObjectListener
D、HttpSessionListener;
E、HttpSession
F、HttpSessionActivationListener

正确答案: A 我的答案: D F (错误)

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

第186题
关于Java语言的内存回收机制，下列选项中最正确的一项是
A、Java程序要求用户必须手工创建一个线程来释放内存
B、Java程序允许用户使用指针来释放内存
C、内存回收线程负责释放无用内存
D、内存回收线程不能释放内存对象

正确答案: C 我的答案: C (正确)
 java的内存回收是自动的，Gc在后台运行，不需要用户手动操作
 java中不允许使用指针
 内存回收线程可以释放无用的对象内存
第187题
Web客户端的编程语言JavaScript源自Java，其功能是Java SE的子集。
A、对
B、错

正确答案: B 我的答案: B (正确)
第188题
在try的括号里面有return一个值，那在哪里执行finally里的代码？
A、不执行finally代码
B、return前执行
C、return后执行

正确答案: B 我的答案: A (错误)
第189题
执行以下程序，最终输出可能是：
 
 A、010 2123012 3434
 B、01201 340124 2334
 C、0012314 01223344**（"*"代表空格）
 D、12345 12345 12345
 正确答案: C 我的答案: D (错误)
 每个线程输出0，1，2，3，4，’空格， 输出空格前必有线程输出了0-4，所以选C、（三个线程并发执行）
第190题
下列哪些操作会使线程释放锁资源？
A、sleep()
B、wait()
C、join()
D、yield()

正确答案: B C 我的答案: A C (错误)

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

第191题
关于protected 修饰的成员变量，以下说法正确的是
A、可以被该类自身、与它在同一个包中的其它类、在其它包中的该类的子类所访问
B、只能被该类本身和该类的所有的子类访问
C、只能被该类自身所访问
D、只能被同一个包中的类访问

正确答案: A 我的答案: A (正确)
 
第192题
事务隔离级别是由谁实现的？
A、Java应用程序
B、Hibernate
C、数据库系统
D、JDBC驱动程序

正确答案: C 我的答案: A (错误)
 A，我们写java程序的时候只是设定事物的隔离级别，而不是去实现它
 B，Hibernate是一个java的数据持久化框架，方便数据库的访问
 C，事物隔离级别由数据库系统实现，是数据库系统本身的一个功能
 D，JDBC是java database connector，也就是java访问数据库的驱动
第193题
int  i, sum=0;
for(i=0;i<10;++i,sum+=i); i 的最终结果是？
A、10
B、9
C、11
D、以上答案都不正确

正确答案: A 我的答案: D (错误)
 解释：问的是i的最终结果，不是sum的
第194题
在 main() 方法中给出的整型数组，如果将其写到一个文件中，需要（ ）。
A、System.out.print (buffer[i]);
B、DataOutputStream dout = new DataOutputStream(new FileOutputStream(this.filename));
C、DataInputStream din = new DataInputStream(new FileInputStream(this.filename));。
D、System.in.read(buffer)。

正确答案: B 我的答案: C (错误)
 解释：input和output指的是对于程序而言。input是从文件读取进来，output是输出到文件。
第195题
下列在Java语言中关于数据类型和包装类的说法，正确的是（）
A、基本（简单）数据类型是包装类的简写形式，可以用包装类替代基本（简单）数据类型
B、long和double都占了64位（64bit）的存储空间。
C、默认的整数数据类型是int，默认的浮点数据类型是float。
D、和包装类一样，基本（简单）数据类型声明的变量中也具有静态方法，用来完成进制转化等。

正确答案: B 我的答案: B (正确)
 A，包装和基本类型不是同一个概念
 B，long和double都占了64位（64bit）的存储空间
 C，默认的浮点数据类型是double，如果要指明使用float，则需要在后面加f
 D，基本数据类型是没有静态方法的，但是基本数据类型的包装类却有
第196题
有程序片段如下，以下表达式结果为 true 的是（ ）
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)

正确答案: B 我的答案: B (正确)
 解释：Float的==比较的是地址，只有同一个类才会返回true，但是equals不是，Float的equals被重写了，只校验类型是不是Float以及值是否相同即可
第197题
面向对象方法的多态性是指（）
A、一个类可以派生出多个特殊类
B、一个对象在不同的运行环境中可以有不同的变体
C、针对一消息，不同的对象可以以适合自身的方式加以响应
D、一个对象可以是由多个其他对象组合而成的

正确答案: C 我的答案: C (正确)
 解释：多态，意味着一个对象有着多重特征，可以在特定的情况下，表现不同的状态，从而对应着不同的属性和方法。 动态绑定，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。 作用消除类型之间的耦合关系。
第198题
正则表达式中，表示匹配非数字字符的字符是（）？
A、\b		B、\d		C、\B		D、\D

正确答案: D 我的答案: A (错误)
 解释：大写表示“非”，d表示digit数字。非数字就是\D, w表示word，非单词就是\W
第199题
下面哪些具体实现类可以用于存储键，值对，并且方法调用提供了基本的多线程安全支持：(  )
A、java.util.ConcurrentHashMap
B、java.util.Map
C、java.util.TreeMap
D、java.util.SortMap
E、java.util.Hashtable
F、java.util.HashMap

正确答案: A E 我的答案: A B C D E F (错误)
 线程安全的类有hashtable concurrentHashMap synchronizedMap
第200题
在JAVA中，下列哪些是Object类的方法（）
A、synchronized()
B、wait()
C、notify()
D、notifyAll()
E、sleep()

正确答案: B C D 我的答案: B C D E (错误)
 Object中包含以下方法：

clone();
equals();
finalize();
getClass();
notify(),notifyAll();
hashCode();
toString();
wait();

第201题
以下代码执行后输出结果为（ ）
public class ExceptionTest
{
    public void method()
    {
        try
        {
            System.out.println("进入到try块");
        }
        catch (Exception e)
        {
             System.out.println("异常发生了！");
        }
        finally
        {
            System.out.println("进入到finally块");
        }
            System.out.println("后续代码");
 }
     public static void main(String[] args)
     {
         ExceptionTest test = new ExceptionTest();
         test.method();
     }
 }
A、 进入到try块  异常发生了！  进入到finally块  后续代码
B、进入到try块  进入到finally块  后续代码
C、进入到try块  后续代码
D、异常发生了！  后续代码

正确答案: B 我的答案: B (正确)
 解释：若try-catch语言中有return，则保存return的值，执行finally，若finally中无return，则返回之前保存的return值，若finally中有return，则用finally中的return覆盖try-catch中的return
第202题
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

正确答案: B 我的答案: A (错误)
 解释：Integer类型在-128–>127范围之间是被缓存了的，也就是每个对象的内存地址是相同的，赋值就直接从缓存中取，不会有新的对象产生，而大于这个范围，将会重新创建一个Integer对象，也就是new一个对象出来，当然地址就不同了，也就！=；
第203题
关于C++/JAVA类中static 成员和对象成员的说法正确的是？
A、static 成员变量在对象构造时生成
B、static 成员函数在对象成员函数中无法调用
C、虚成员函数不可能是static 成员函数
D、static 成员函数不能访问static 成员变量

正确答案: C 我的答案: C (正确)
 解释：static成员变量是在类加载的时候生成的
 static成员函数既可以通过类名直接调用，也可以通过对象名进行调用
 虚函数是C++中的，虚函数不可能是static的
 static成员函数可以访问static成员变量
第204题
下列语句正确的是：
A、形式参数可被字段修饰符修饰
B、形式参数不可以是对象
C、形式参数为方法被调用时真正被传递的参数
D、形式参数可被视为local variable

正确答案: D 我的答案: D (正确)
 A：形式参数只能被final修饰
 B：形式参数可以是对象
 C：形式参数被调用时被传递的是实际参数的拷贝
 D：local variable：局部变量
第205题
下面哪一项不属于优化Hibernate所鼓励的？
A、使用单向一对多关联，不使用双向一对多
B、不用一对一，用多对一取代
C、配置对象缓存，不使用集合缓存
D、继承类使用显式多态

正确答案: A 我的答案: A (正确)
 优化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.消除大表，使用二级缓存

第206题
与InputStream流相对应的Java系统的“标准输入对象”是（）
A、System.in
B、System.out
C、System.err
D、System.exit()

正确答案: A 我的答案: A (正确)
 A.标准输入 B.标准输出 C.错误输出 D.结束程序
第207题
我们在程序中经常使用“System.out.println()”来输出信息，语句中的System是包名，out是类名，
println是方法名。
A、对
B、错

正确答案: B 我的答案: A (错误)
 解释：System是java.lang中的一个类，out是System内的一个成员变量，这个变量是一个java.io.PrintStream类的对象，println呢就是一个方法了。
第208题
以下哪项陈述是正确的？
A、垃圾回收线程的优先级很高，以保证不再 使用的内存将被及时回收
B、垃圾收集允许程序开发者明确指定释放 哪一个对象
C、垃圾回收机制保证了JAVA程序不会出现 内存溢出
D、进入”Dead”状态的线程将被垃圾回收器回收
E、以上都不对

正确答案: E 我的答案: A (错误)
 A: 垃圾回收在jvm中优先级相当相当低。
 B：垃圾收集器（GC）程序开发者只能推荐JVM进行回收，但何时回收，回收哪些，程序员不能控制。
 C：垃圾回收机制只是回收不再使用的JVM内存，如果程序有严重BUG，照样内存溢出。
 D：进入DEAD的线程，它还可以恢复，GC不会回收
第209题
以下 b 的值是： byte b = (byte)129;
A、-126
B、-127
C、-128
D、-129

正确答案: B 我的答案: B (正确)
 129 int类型（4个字节）二进制： 00000000 00000000 00000000 10000001
 在计算机系统中，数值一律用补码来表示（存储），正数的补码和源码相同。
 int -> byte(1个字节),截取： 10000001
 补码转反码：1开始则为负数，负数得到反码是末位-1： 10000000
 负数的反码转原码（最高位即符号位不变）：11111111
 转换为十进制：-（27-1）=-127
第210题
下面有关servlet的层级结构和常用的类，说法正确的有?
A、GenericServlet类：抽象类，定义一个通用的、独立于底层协议的Servlet。
B、大多数Servlet通过从GenericServlet或HttpServlet类进行扩展来实现
C、ServletConfig接口定义了在Servlet初始化的过程中由Servlet容器传递给Servlet得配置信息对
	象
D、HttpServletRequest接口扩展ServletRequest接口，为HTTP Servlet提供HTTP请求信息

正确答案: A B C D 我的答案: C D (错误)
 
第211题
在JAVA中， 下列标识符合法的是（）
A、3kyou
B、@163
C、name
D、while

正确答案: C 我的答案: C (正确)
 合法标识符：三不能

1.不能以数字开头
2.不能是关键字
3.不能包含除了$和_以外的其他字符

第212题
For which of these values of a
II.6
III. 8
is the expression
(a != 3 && a != 4 && a != 5 && a != 6)
false?
A、I only
B、II only
C、III only
D、I and II only
E、I， II， and III

正确答案: D 我的答案: C (错误)
 && 运算时出现false时运算结果就判断为false
 a != 3 && a != 4 && a != 5 && a != 6
 a = 4;
 因为a != 4 false 所以 结果false；
 a = 6;
 因为a != 6 false 所以 结果false；
 a = 8;
 因为a != 3 a != 4 a != 5 a != 6都为 ture 所以 结果true
 所以
 答案D
第213题
子类要调用继承自父类的方法，必须使用super关键字。
A、正确
B、错误

正确答案: B 我的答案: B (正确）

1、子类构造函数调用父类构造函数用super
2、子类重写父类方法后，若想调用父类中被重写的方法，用super
3、未被重写的方法可以直接调用。

第214题
假如某个JAVA进程的JVM参数配置如下：
-Xms1G -Xmx2G -Xmn500M -XX:MaxPermSize=64M -XX:+UseConcMarkSweepGC -
XX:SurvivorRatio=3,
请问eden区最终分配的大小是多少？
A、64M
B、500M
C、300M
D、100M

正确答案: C 我的答案: A (错误)
 java -Xmx2G -Xms1G -Xmn500M -Xss128k
 -Xmx2G：设置JVM最大可用内存为2G。
 -Xms1G：设置JVM促使内存为1G。此值可以设置与-Xmx相同，以避免每次垃圾回收完成后JVM重新分配内存。
 -Xmn500M：设置年轻代大小为2G。整个JVM内存大小=年轻代大小 + 年老代大小 + 持久代大小。
 -XX:SurvivorRatio=3:新生代中又会划分为 Eden 区，from Survivor、to Survivor 区。
 其中 Eden 和 Survivor 区的比例默认是 8:1:1，当然也支持参数调整 -XX:SurvivorRatio=3的话就是3:1:1。
 故该题为500*（3/5）=300M.
第215题
以下程序的输出结果为
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、编译错误

正确答案: D 我的答案: B (错误)
 子类构造方法在调用时必须先调用父类的，由于父类没有无参构造，必须在子类中显式调用，修改子类构造方法如下即可：
 public Derived(String s){
 super(“s”);
 System.out.print(“D”);
 }
第216题
 装箱、拆箱操作发生在: ()
 A、类与对象之间
B、对象与对象之间
C、引用类型与值类型之间
D、引用类型与引用类型之间

正确答案: C 我的答案: A (错误)
 通俗的讲，就是基本数据类型和包装类之间的转换。如： int 类型和 Integer 类的转换
 基本数据类型转化成包装类是装箱 (如： int --> Integer)。
 包装类转化成基本数据类型就是拆箱 (如：Integer --> int)。
 包装类就是引用类型，基本数据类型就是值类型。
第217题
使用mvc模式设计的web应用程序具有以下优点,除了？
A、可维护行强
B、可扩展性强
C、代码重复少
D、大大减少代码量

正确答案: D 我的答案: D (正确)
 使用设计模式都会增加代码量。
第218题
关于 Socket 通信编程，以下描述正确的是：（ ）
A、客户端通过new ServerSocket()创建TCP连接对象
B、客户端通过TCP连接对象调用accept()方法创建通信的Socket对象
C、客户端通过new Socket()方法创建通信的Socket对象
D、服务器端通过new ServerSocket()创建通信的Socket对象

正确答案: C 我的答案: C (正确)
 客户端通过new Socket()方法创建通信的Socket对象
 服务器端通过new ServerSocket()创建TCP连接对象 accept接纳客户端请求
第219题
对于构造方法，下列叙述正确的是（ ）。
A、构造方法的优先级一般比代码块低。
B、构造方法的返回类型只能是void型。
C、构造方法的主要作用是完成对类的对象的初始化工作。
D、一般在创建新对象时，系统会自动调用构造方法。

正确答案: A C D 我的答案: A C D (正确)
 java程序初始化顺序
 父类静态变量，父类静态代码块（只执行一次），子类静态变量，子类静态代码块（只执行一次），父类非静态变量，父类非静态代码块，父类构造函数，子类非静态变量，子类非静态代码块，子类构造函数
 构造方法无返回值类型。
第220题
以下哪种JAVA得变量声明方式可以避免程序在多线程竞争情况下读到不正确的值(  )
A、volatile
B、static volatile
C、synchronized
D、static

正确答案: A B 我的答案: C (错误)
 ynchronized不是修饰变量的 它修饰方法或代码块或对象
第221题
代码 
System.out.println(10%3*2);
将打印？
A、1		B、2		C、4		D、6

正确答案: B 我的答案: B (正确)
 解释：%和*是同一个优先级，从左到右运算
第222题
	以下类定义中的错误是什么？（）
	abstract class xy
	{
	    abstract sum (int x, int y) { }
	}
A、没有错误
B、类标题未正确定义
C、方法没有正确定义
D、没有定义构造函数

正确答案: C 我的答案: B (错误)
 1、抽象方法不能有方法体，这是规定
 2、该方法缺少返回值，只有构造没有返回值
第223题
try块后必须有catch块。（）
A、正确
B、错误

正确答案: B 我的答案: A (错误)
 try的形式有三种：
 try-catch
 try-finally
 try-catch-finally
第224题
以下选项中，合法的赋值语句是（）
A、a>1;
B、i++;
C、a= a+1=5;
D、y = int ( i );

正确答案: B 我的答案: D (错误)
 
第225题
关于java编译和运行命令叙述不正确的是？  ( )
A、运行“java Scut.class”
B、运行“java Scut”
C、运行“javac Scut.java”的输出文件是Scut.class
D、java这个命令的运行对象是Scut.class

正确答案: A 我的答案: C (错误)
 A 错误 运行命令是 java + 你的 Java 程序的名字但是不加后缀 所以这道题错在多了 .class这个后缀
 B 正确
 C javac 是编译命令，后跟 你的 Java 程序名字加后缀，也就是 YourClassName.java 所以答案正确
 D JVM （Java 虚拟机）运行的是编译后的字节码文件（以.class为后缀的文件），也就是 YourClassName.class 所以答案正确
第226题
关于Java中参数传递的说法，哪个是错误的？
A、在方法中，修改一个基础类型的参数不会影响原始参数值
B、在方法中，改变一个对象参数的引用不会影响到原始引用
C、在方法中，修改一个对象的属性会影响原始对象参数
D、在方法中，修改集合和Maps的元素不会影响原始集合参数

正确答案: D 我的答案: D (正确)
 A、在方法中，修改一个基础类型的参数永远不会影响原始参数值。
 B、在方法中，改变一个对象参数的引用永远不会影响到原始引用。然而，它会在堆中创建了一个全新的对象。（译者注：指的是包装类和immutable对象）
 C、在方法中，修改一个对象的属性会影响原始对象参数。
 D、在方法中，修改集合和Maps会影响原始集合参数。
第227题
由3 个“1”和 5 个“0”组成的 8 位二进制补码，能表示的最小整数（）
A、-126
B、-125
C、-32
D、-3

正确答案: B 我的答案: B (正确)
 既然求最小整数，那肯定先想到负数，则最高位（符号位）一定为1，原码中肯定是1所在的位数越高，值越小，而补码是由原码取反加1得到的，则在补码中1所在的位数一定要越低，即补码为1000 0011；由补码求得原码：1111 1101=-(64+32+16+8+4+1)=-125;
第228题
在java7中,下列哪个说法是正确的:
A、ConcurrentHashMap使用synchronized关键字保证线程安全
B、HashMap实现了Collection接口
C、Arrays.asList方法返回java.util.ArrayList对象
D、SimpleDateFormat对象是线程不安全的

正确答案: D 我的答案: B (错误)
第229题
一般有两种用于创建线程的方法,一是(),二是()。
A、从Java.lang.Thread类派生一个新的线程类，重写它的runnable()方法
B、从Java.lang.Thread类派生一个新的线程类，重写它的run()方法
C、实现Thread接口，重写Thread接口中的run()方法
D、实现Runnable接口，重写Runnable接口中的run()方法

正确答案: B D 我的答案: B D (正确)
 创建线程对象两种方式：
 1.继承Thread类，重载run方法；
 2.实现Runnable接口，实现run方法
第230题
下面有关java classloader说法正确的是（）？
A、ClassLoader就是用来动态加载class文件到内存当中用的
B、JVM在判定两个class是否相同时，只用判断类名相同即可，和类加载器无关
C、ClassLoader使用的是双亲委托模型来搜索类的
D、Java默认提供的三个ClassLoader是Boostrap ClassLoader，Extension 
ClassLoader，App ClassLoader
E、以上都不正确

正确答案: A C D 我的答案: A B C D (错误)
 JVM根据两个方面判断两个类是否相同:一是类的全称;另一个是类加载器.
 即使类的全称相同,而使用的加载器不同那Class对象也是不同的.
 选项B：错误
第231题
Stack通常是指“先进先出”的容器。（  ）
A、正确
B、错误

正确答案: B 我的答案: A (错误)
 解释：栈，先进后出
第232题
对于application，主线程main（）方法执行的线索，对于applet，主线程是浏览器加载并执行
java小程序。
A、正确
B、错误

正确答案: A 我的答案: B (错误)
 jdk9将废除浏览器插件applet
第233题
下列选项中符合Java命名规则的标识符是（）
A、2japro
B、&Class
C、const
D、_123

正确答案: D 我的答案: D (正确)
第234题
以下程序段的输出结果为：
public class EqualsMethod
{
    public static void main(String[] args)
    {
        Integer n1 = new Integer(47);
        Integer n2 = new Integer(47);
        System.out.print(n1 == n2);
        System.out.print(",");
        System.out.println(n1 != n2);
    }
}
A、false，false
B、false，true
C、true，false
D、true，true

正确答案: B 我的答案: C (错误)
 使用Integer a = 1;或Integer a = Integer.valueOf(1); 在值介于-128至127直接时，作为基本类型。
 使用Integer a = new Integer(1); 时，无论值是多少，都作为对象。
第235题
/*..................*/中可以嵌套//注释，也能嵌套/*..........*/注释。
A、正确
B、错误

正确答案: B 我的答案: B (正确)
 解释： /…/中不能能嵌套/…/注释。
第236题
关于Float，下列说法错误的是()
A、Float是一个类
B、Float在java.lang包中
C、Float a=1.0是正确的赋值方法
D、Float a= new Float(1.0)是正确的赋值方法

正确答案: C 我的答案: C (正确)
 解释：Float是类，float不是类.
第237题
Java数据库连接库JDBC用到哪种设计模式?
A、生成器
B、桥接模式
C、抽象工厂
D、单例模式

正确答案: B 你的答案: D (错误)
第238题
下面有关JAVA swing的描述，说法错误的是？
A、Swing是一个基于Java的跨平台MVC框架。使用单线程模式。
B、Swing 是为了解决 AWT 存在的问题而新开发的包，它以 AWT 为基础的
C、Swing优化了AWT，运行速度比AWT快
D、Swing是一个基于组件的框架，所有的组件都是从javax.swing.JComponent类继承来的

正确答案: C 我的答案: A (错误)
 解释：Swing 是在AWT的基础上构建的一套新的图形界面系统，它提供了AWT 所能够提供的所有功能，并且用纯粹的Java代码对AWT 的功能进行了大幅度的扩充。AWT 是基于本地方法的C/C++程序，其运行速度比较快；Swing是基于AWT 的Java程序，其运行速度比较慢。
第239题
面向对象的基本特征是（）
A、封装
B、继承
C、重载
D、多态

正确答案: A B D 我的答案: A B D (正确)
第240题
对 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 ) ;
 正确答案: C D 我的答案: A D (错误)
 
第241题
下列不属于访问控制符的是（）
A、public
B、private
C、protected
D、static

正确答案: D 你的答案: D (正确)
第242题
下列类定义中哪些是合法的抽象类的定义？（）
 A、abstract Animal{abstract void growl();}
 B、class abstract Animal{abstract void growl();}
 C、abstract class Animal{abstract void growl();}
 D、abstract class Animal{abstract void growl(){System.out.println( “growl”);};}
 正确答案: C 我的答案: C (正确)
第243题
有以下程序片段且Interesting不是内部类，下列哪个选项不能插入到行1。（    ）
public class Interesting{
 // 省略代码
}
A、import java.awt.*;
B、package mypackage;
C、class OtherClass{   }
D、public class MyClass{ }

正确答案: D 我的答案: C (错误)
 解释：在同一个java原文件中，可以有多个class类，但是只有有一个公共的 public class
第244题
如果int x=20, y=5，则语句System.out.println(x+y +""+(x+y)+y);  的输出结果是（）
A、2530
B、55
C、2052055
D、25255

正确答案: D 我的答案: D (正确)
 解释：

1）不论有什么运算，小括号的优先级都是最高的，先计算小括号中的运算，得到x+y +""+25+y
2）任何字符与字符串相加都是字符串，但是是有顺序的，字符串前面的按原来的格式相加，字符串后面的都按字符串相加，得到25+“”+25+5
3）上面的结果按字符串相加得到25255

第245题
off-heap是指那种内存（）
 A、JVM GC能管理的内存
 B、JVM进程管理的内存
 C、在JVM老年代内存区
 D、在JVM新生代内存
 正确答案: B 我的答案: C (错误)
第246题
public class Test
{
    public int x;
    public static void main(String []args)
    {
        System. out. println("Value is" + x);
    }
}
对于上面这段代码，以下说法正确的是：
程序会打出 "Value is 0"

程序会抛出 NullPointerException
 非静态变量不能够被静态方法引用
 编译器会抛出 "possible reference before assignment"的错误
第247题
如何获取ServletContext设置的参数值？
A、context.getParameter()
B、context.getInitParameter()
C、context.getAttribute()
D、context.getRequestDispatcher()

正确答案: B 我的答案: A (错误)
 解释：getParameter()是获取POST/GET传递的参数值；
 getInitParameter获取Tomcat的server.xml中设置Context的初始化参数
 getAttribute()是获取对象容器中的数据值；
 getRequestDispatcher是请求转发。
第248题
Java 多线程有几种实现方法？（ ）
A、继承Thread类
B、实现Runnable接口
C、实现Thread接口
D、以上都不正确

正确答案: A B 我的答案: A B (正确)
第249题
下面属于JSP内置对象的是？
A、out对象
B、response对象
C、application对象
D、page对象

正确答案: A B C D 我的答案: A B C D (正确)
 1、pageContext 表示页容器 EL表达式、 标签 、上传
 2、request 服务器端取得客户端的信息：头信息 、Cookie 、请求参数 ，最大用处在MVC设计模式上
 3、response 服务器端回应客户端信息：Cookie、重定向
 4、session 表示每一个用户，用于登录验证上
 5、application 表示整个服务器
 6、config 取得初始化参数，初始化参数在web.xml文件中配置
 7、exception 表示的是错误页的处理操作
 8、page 如同this一样，代表整个jsp页面自身
 9、out 输出 ，但是尽量使用表达式输出
第250题
关于运行时常量池，下列哪个说法是正确的
A、运行时常量池大小受栈区大小的影响
B、运行时常量池大小受方法区大小的影响
C、存放了编译时期生成的各种字面量
D、存放编译时期生成的符号引用

正确答案: B C D 我的答案: C (错误)
第251题
以下关于继承的叙述正确的是
A、在Java中类只允许单一继承
B、在Java中一个类不能同时继承一个类和实现一个接口
C、在Java中接口只允许单一继承
D、在Java中一个类只能实现一个接口

正确答案: A 我的答案: A (正确)
 解释1）接口可以继承接口，而且可以继承多个接口，但是不能实现接口，因为接口中的方法全部是抽象的，无法实现其他接口；
 2）普通类可以实现接口，并且可以实现多个接口，但是只能继承一个类，这个类可以是抽象类也可以是普通类，如果继承抽象类，必须实现抽象类中的所有抽象方法，否则这个普通类必须设置为抽象类
 3）抽象类可以实现接口，可以继承具体类，可以继承抽象类，也可以继承有构造器的实体类。
第252题
关于下面的程序Test.java说法正确的是(    )。
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);
    }
}
A、3
B、112
C、13
D、程序有编译错误

正确答案: D 我的答案: D (正确)
 解释：被static修饰的变量称为静态变量，静态变量属于整个类，而局部变量属于方法，只在该方法内有效，所以static不能修饰局部变量
第253题
代码片段：
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 我的答案: C (正确)
 解释：被final修饰的变量是常量，这里的b6=b4+b5可以看成是b6=10；在编译时就已经变为b6=10了而b1和b2是byte类型，java中进行计算时候将他们提升为int类型，再进行计算，b1+b2计算后已经是int类型，赋值给b3，b3是byte类型，类型不匹配，编译不会通过，需要进行强制转换。
第254题
在Java中，关于HashMap类的描述，以下正确的是 ()
A、HashMap使用键/值得形式保存数据
B、HashMap 能够保证其中元素的顺序
C、HashMap允许将null用作键
D、HashMap允许将null用作值

正确答案: A C D 我的答案: A C D (正确)
 
第255题
关于ThreadLocal类 以下说法正确的是
A、ThreadLocal继承自Thread
B、ThreadLocal实现了Runnable接口
C、ThreadLocal重要作用在于多线程间的数据共享
D、ThreadLocal是采用哈希表的方式来为每个线程都提供一个变量的副本
E、ThreadLocal保证各个线程间数据安全，每个线程的数据不会被另外线程访问和破坏

正确答案: D E 我的答案: A E (错误)
 1、ThreadLocal的类声明：
 public class ThreadLocal
 可以看出ThreadLocal并没有继承自Thread，也没有实现Runnable接口。所以AB都不对。
 2、ThreadLocal类为每一个线程都维护了自己独有的变量拷贝。每个线程都拥有了自己独立的一个变量。
 所以ThreadLocal重要作用并不在于多线程间的数据共享，而是数据的独立，C选项错。
 由于每个线程在访问该变量时，读取和修改的，都是自己独有的那一份变量拷贝，不会被其他线程访问，
 变量被彻底封闭在每个访问的线程中。所以E对。
 3、ThreadLocal中定义了一个哈希表用于为每个线程都提供一个变量的副本
第256题
现有一变量声明为 boolean aa; 下面赋值语句中正确的是 （ ）
A、aa=false;
B、aa=False;
C、aa="true";
D、aa=0;

正确答案: A 我的答案: A (正确)
 解释：boolean的值要不是true，要不就是false。
第257题
以下关于Integer与int的区别错误的是
A、int是java提供的8种原始数据类型之一
B、Integer是java为int提供的封装类
C、int的默认值为0
D、Integer的默认值为1

正确答案: D 我的答案: D (正确)
 int 是八大基本数据类型之一（byte,char,short,int,long,float,double,boolean）
 Integer 是 int 包装类;
 int是基本数据类型，默认值为0,
 Integer 是类，默认值为null；
 Integer 表示的是对象，用一个引用指向这个对象,
 int是基本数据类型，直接存储数值。
第258题
Java1.8之后，Java接口的修饰符可以为（）
A、private
B、protected
C、final
D、abstract

正确答案: D 我的答案: C (错误)
 接口是一种特殊的抽象类
第259题
对于JVM内存配置参数：
-Xmx10240m -Xms10240m -Xmn5120m -XXSurvivorRatio=3
,其最小内存值和Survivor区总大小分别是（）
A、5120m，1024m
B、5120m，2048m
C、10240m，1024m
D、10240m，2048m

正确答案: D 我的答案: B (错误)
 -Xmx：最大堆大小
 -Xms：初始堆大小
 -Xmn:年轻代大小
 -XXSurvivorRatio=3：代表Eden:Survivor = 3 根据Generation-Collection算法(目前大部分JVM采用的算法)，一般根据对象的生存周期将堆内存分为若干不同的区域，一般情况将新生代分为Eden ，两块Survivor； 计算Survivor大小， Eden:Survivor = 3，总大小为5120,3x+x+x=5120 x=1024，两块就是2048m。
第260题
在 myjsp.jsp 中，关于下面的代码说法错误的是： (  )   
<%@ page language="java" import="java.util.*" errorPage="error.jsp" isErrorPage="false" %> 
A、该页面可以使用 exception 对象
B、该页面发生异常会转向 error.jsp
C、存在 errorPage 属性时，isErrorPage 是默认为 false
D、error.jsp 页面一定要有isErrorPage 属性且值为 true

正确答案: A 我的答案: A (正确)
 exception是JSP九大内置对象之一，其实例代表其他页面的异常和错误。只有当页面是错误处理页面时，即isErroePage为 true时，该对象才可以使用。对于C项，errorPage的实质就是JSP的异常处理机制,发生异常时才会跳转到 errorPage指定的页面，没必要给errorPage再设置一个errorPage。所以当errorPage属性存在时， isErrorPage属性值为false
第261题
java7后关键字 switch 支不支持字符串作为条件：（）
A、支持
B、不支持

正确答案: A 我的答案: B (错误)
 解释：在Java7之前，switch只能支持 byte、short、char、int或者其对应的封装类以及Enum类型。在Java7中，呼吁很久的String支持也终于被加上了。
第262题
下面的输出结果是:
public class Test { public static void main(String[] args) {
    Father a = new Father();
    Father b = new Child();
  }
} class Father { public Father() {
    System.out.println("我是父类");
  }
} class Child extends Father { public Child() {
    System.out.println("我是子类");
  }
}
A、我是父类
   我是父类
   我是子类
B、我是父类
   我是子类
   我是子类
C、我是父类
   我是父类
D、我是父类
   我是父类
   我是父类

正确答案: A 我的答案: A (正确)
 解释：创建子类的对象时要调用父类的构造函数
第263题
下面关于垃圾收集的说法正确的是
A、一旦一个对象成为垃圾，就立刻被收集掉。
B、对象空间被收集掉之后，会执行该对象的finalize方法
C、finalize方法和C++的析构函数是完全一回事情
D、一个对象成为垃圾是因为不再有引用指着它，但是线程并非如此

正确答案: D 我的答案: D (正确)
 解释：在java中，对象的内存在哪个时刻回收，取决于垃圾回收器何时运行，
第264题
下列关于修饰符混用的说法，错误的是( )
A、abstract不能与final并列修饰同一个类
B、abstract类中不应该有private的成员
C、abstract方法必须在abstract类或接口中
D、static方法中能直接调用类里的非static的属性

正确答案: D 我的答案: D (正确)
 解释：

abstract不能与final并列修饰同一个类 对的。
abstract类中不应该有private的成员 对的 ：abstract类中可以有private 但是不应该有。
abstract方法必须在abstract类或接口中 对的 ： 若类中方法有abstract修饰的，该类必须abstract修改。接口方法默认public abstract。
static方法中能处理非static的属性 错误 ：在JVM中static方法在静态区，静态区无法调用非静态区属性。

第265题
要使某个类能被同一个包中的其他类访问，但不能被这个包以外的类访问，可以( )
A、让该类不使用任何关键字
B、使用private关键字
C、使用protected关键字
D、使用void关键字

正确答案: A 我的答案: C (错误)
 
第266题
以下代码段执行后的输出结果为
public class Test {
public static void main(String args[]) {
int x = -5;
int y = -12;
System.out.println(y % x);
}
}
A、-1		B、2		C、1		D、-2

正确答案: D 我的答案: D (正确)
 解释：取模运算，余数的符号跟被除数符号相同
第267题
执行下面的程序段，语句3的执行次数为（）
for   （i=0; i<=n-1; i++)   (1)
for  (j=n; j>i; j--）           (2)
state;                      (3)
A、n(n+2)/2
B、(n-1)(n+2)/2
C、n(n+1)/2
D、(n-1)(n+2)

正确答案: C 我的答案: C (正确)
 解释：外循环有n次，当i=0,内循环为n次,当i=1,内循环为n-1次,当i=2时，内循环为n-2次，以此类推，总次数为n+(n-1)+(n-2)+…+2+1,就是个等差数列，等于n(n+1)/2。
第268题
如下代码的输出结果是什么？
public class Test { 
    public int aMethod(){
        static int i = 0;
        i++; 
        return i;
    } 
public static void main(String args[]){
    Test test = new Test(); 
    test.aMethod(); 
    int j = test.aMethod();
    System.out.println(j);
    } 
}
A、0
B、1
C、2
D、编译失败

正确答案: D 我的答案: C (错误)
 解释：静态变量只能在类主体中定义，不能在方法中定义
第269题
在jdk1.5之后，下列 java 程序输出结果为______。
int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));
A、true,false
B、true,true
C、false,true
D、false,false
E、对于不同的环境结果不同
F、程序无法执行

正确答案: B 我的答案: C (错误)
 解释：

基本型和基本型封装型进行'=='运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；
两个Integer类型进行“==”比较，如果其值在-128至127，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关
两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true
基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。

第270题
关于身份证号，以下正确的正则表达式为（      ）
A、isIDCard=/^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$/;
B、isIDCard=/^[1-9]\d{7}((9\d)|(1[0-2]))(([0|1|2]\d)|3[9-1])\d{3}$/;
C、isIDCard=/^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{4}$/;
D、isIDCard=/^[1-9]\d{5}[1-9]\d{3}((9\d)|(1[9-2]))(([0|1|2]\d)|3[9-1])\d{4}$/;

正确答案: A C 我的答案: B (错误)
 ^{：起始符号，}x表示以x开头
  $： 结 束 符 号 ， x$ 表示以x结尾
 [n-m]：表示从n到m的数字
 \d：表示数字，等同于[0-9]
 X{m}：表示由m个X字符构成，\d{4}表示4位数字
 15位身份证的构成：六位出生地区码+六位出身日期码+三位顺序码
 18位身份证的构成：六位出生地区码+八位出生日期码+三位顺序码+一位校验码
第271题
以下说法错误的是（）
A、数组是一个对象
B、数组不是一种原生类
C、数组的大小可以任意改变
D、在Java中，数组存储在堆中连续内存空间里

正确答案: C 我的答案: C (正确)
 解释：Java中数组是对象，不是基本数据类型（原生类），大小不可变且连续存储，因为是对象所以存在堆中。
第272题
下列关于修饰符混用的说法，错误的是( )
A、abstract不能与final并列修饰同一个类
B、abstract 类中不建议有private的成员
C、abstract 方法必须在abstract类或接口中
D、static方法中能直接处理非static的属性

正确答案: D 我的答案: D (正确)
 A、abstract修饰的类，不可实例化，所以需要子类去继承，然后重写其中的抽象方法。但是final修饰类是不可继承的。两者属性相冲。
 B、看清楚，是不建议有，不是不能有。
 C、抽象类中可以没有抽象方法，但是抽象方法必须在抽象类中或者接口中
 D、static不可以修饰非static的属性，因为类加载的时候，static属性比非static先初始化，那么一个存在的总不能访问一个没有存在的吧。
第273题
下列关于计算机系统和Java编程语言的说法，正确的是（）
A、计算机是由硬件、操作系统和软件组成，操作系统是缺一不可的组成部分。
B、Java语言编写的程序源代码可以不需要编译直接在硬件上运行。
C、在程序中书写注释不会影响程序的执行，可以在必要的地方多写一些注释。
D、Java的集成开发环境（IDE），如Eclipse，是开发Java语言必需的软件工具。

正确答案: C 我的答案: D (错误)
第274题
假设有以下代码String s = "hello"；String t = "hello"；char c [ ] = {'h','e','l','l','o'}；下列选项中返回
false的语句是？
A、s.equals (t)；
B、t.equals (c)；
C、s==t；
D、t.equals (new String ("hello"))；

正确答案: B 我的答案: B (正确)

首先==与equals是有明显区别的。
 ==强调栈中的比较，可以理解为地址比较
 equals强调对象的内容比较


String s=“hello”；会在栈中生成hello字符串，并存入字符串常量池中。
String t=“hello” ；创建时，会在字符串常量池中寻找，当找到需要的hello时，不进行字符串的创建，引用已有的。 所以，s==t返回true，s.equals(t)也是true。
char c[]={‘h’,‘e’,‘l’,‘l’,‘o’}; c==s这个是不存在的，==两边类型不同
 t.equals©这个语句在anObject instanceof String这步判断不会通过，也就是cha[] 压根不能与String相比较，类型不是相同的。返回false

第275题
下面有关jsp中静态include和动态include的区别，说法错误的是？  
A、动态INCLUDE:用jsp:include动作实现 
B、静态INCLUDE:用include伪码实现，定不会检查所含文件的变化，适用于包含静态页面<%@ 
	include file="included.htm" %>
C、静态include的结果是把其他jsp引入当前jsp，两者合为一体;动态include的结构是两者独立，
	直到输出时才合并
D、静态include和动态include都可以允许变量同名的冲突.页面设置也可以借用主文件的

正确答案: D 我的答案: C (错误)

动态 INCLUDE 用 jsp:include 动作实现  它总是会检查所含文件中的变化 , 适合用于包含动态页面 , 并且可以带参数。各个文件分别先编译，然后组合成一个文件。
静态 INCLUDE 用 include 伪码实现 , 定不会检查所含文件的变化 , 适用于包含静态页面 <%@ include file=“included.htm” %> 。先将文件的代码被原封不动地加入到了主页面从而合成一个文件，然后再进行翻译，此时不允许有相同的变量。

第276题
以下代码执行后输出结果为（ ）
public class Test
{
    public static Test t1 = new Test();
    {
         System.out.println("blockA");
    }
    static
    {
        System.out.println("blockB");
    }
    public static void main(String[] args)
    {
        Test t2 = new Test();
    }
 }
A、blockAblockBblockA
B、blockAblockAblockB
C、blockBblockBblockA
D、blockBblockAblockB

正确答案: A 我的答案: C (错误)
 解释：执行顺序优先级：静态域,main(),构造代码块,构造方法。

静态域 ：首先执行，第一个静态域是一个静态变量 public static Test t1 = new Test(); 创建了Test 对象，会执行构造块代码，所以输出blockA。然后执行第二个静态域（即静态代码块）输出blockB。
main():Test t2 = new Test()执行，创建Test类对象，只会执行构造代码块（创建对象时执行），输出blockA。
构造代码块只会在创建对象时执行，没创建任何对象了，所以没输出
构造函数：使用默认构造函数，没任何输出

第277题
以下程序段执行后将有（）个字节被写入到文件afile.txt中。
try {
    FileOutputStream fos = new FileOutputStream("afile.txt");
    DataOutputStream dos = new DataOutputStream(fos);
    dos.writeInt(3);
    dos.writeChar(1);
    dos.close();
    fos.close();
} catch (IOException e) {}
A、3				B、5
C、6				D、不确定，与软硬件环境相关

正确答案: C 我的答案: C (正确)
 byte 1个字节
 short 2个字节
 int 4个字节
 long 8个字节
 float 4个字节
 double 8个字节
 char 2个字节
 boolean 1个字节或4个字节，在java规范2中，如果boolean用于声明一个基本类型变量时占4个字节，如果声明一个数组类型的时候，那么数组中的每个元素占1个字节。
第278题
下列描述错误的是?
A、类只能继承一个父类，但是可以实现多个接口
B、抽象类自身可以定义成员而接口不可以
C、抽象类和接口都不能被实例化(忽略匿名内部类)
D、一个类可以有多个父类和多个基接口

正确答案: B D 我的答案: B D (正确)
 A、java为单继承，多实现。可以实现多个接口。
 B、接口允许定义成员，但必须是常量。
 C、抽象类和接口类的无法实例化，任何编译器中直接使用new会报错。
 D、同A，单继承，多实现。
第279题
下面有关Java的说法正确的是（         ）
A、一个类可以实现多个接口
B、抽象类必须有抽象方法
C、protected成员在子类可见性可以修改
D、通过super可以调用父类构造函数
E、final的成员方法实现中只能读取类的成员变量
F、String是不可修改的，且java运行环境中对string对象有一个对象池保存

正确答案: A C D F 我的答案: A D F (错误)
 A对：java类单继承，多实现
 B错：被abstract修饰的类就是抽象类，有没有抽象方法无所谓
 C错：描述有问题。protected成员在子类的可见性，我最初理解是子类（不继承父类protected成员方法）获取父类被protected修饰的成员属性或方法，可见性是不可能变的，因为修饰符protected就是描述可见性的。 这道题应该是要考察子类继承父类，并重写父类的protected成员方法，该方法的可见性可以修改，这是对的，因为子类继承父类的方法，访问权限可以相同或往大了改
 D对。
 E错：final修饰的方法只是不能重写，static修饰的方法只能访问类的成员变量
 F对。
第280题
以下可以正确获取结果集的有
A、Statement sta=con.createStatement();
ResultSet rst=sta.executeQuery(“select * from 
	book”);
B、Statement sta=con.createStatement(“select * from book”); ResultSet rst=sta.executeQuery();
C、PreparedStatement pst=con.prepareStatement();
	ResultSet rst=pst.executeQuery(“select * from book”);
D、PreparedStatement pst=con.prepareStatement(“select * from book”);
	ResultSet rst=pst.executeQuery();

正确答案: A D 我的答案: A B C D (错误)
 解释：创建Statement是不传参的，PreparedStatement是需要传入sql语句
第281题
在某个类A中存在一个方法：void set(int x),以下不能作为这个方法的重载的声明的是（）
A、void set(int y)
B、int set(int x，double y)
C、double set(int x,int y)
D、void set(int x,int y)

正确答案: A 我的答案: A (正确)
 解释：方法重载：方法名称相同，参数列表不同（可以是参数的类型，个数，顺序不同）
第282题
关于下面代码 int[] x=new int[25]; 描述正确的是（）
A、x[25]存放了数据“\0”。
B、x[24] 存放了数据“\0”。
C、若访问x[25]，程序将抛出异常。
D、x[1]访问此数组的第一个元素。

正确答案: C 我的答案: C (正确)
 A:不存在x[25] 索引从0开始到length-1
 B:x[24] 存的是默认值0(java中没有’\0’这一说)
 C:超出内存 正确
 D:第二元素
第283题
以下代码段执行后的输出结果为
public class Test {
	public static void main(String args[]) {
	int x = -5;
	int y = -12;
	System.out.println(y % x);
	}
}
A、-1		B、2		C、1		D、-2

正确答案: D 我的答案: D (正确)
 解释：取模运算，结果的符号和被除数符号一致
第284题
一般用()创建InputStream对象,表示从标准输入中获取数据,用()创建OutputStream对象，表示输出
到标准输出设备中。
A、System.in System.out
B、System.out System.in
C、System.io.in System.io.out
D、System.io.out System.io.in

正确答案: A 我的答案: C (错误)
 解释：System.in 和 System.out 是java中的标准输入输出流，一般情况下代表从控制台输入和输出到控制台
第285题
以下哪个区域不属于新生代？
A、eden区
B、from区
C、元数据区
D、to区

正确答案: C 我的答案: A (错误)
 解释：在 Java 中，堆被划分成两个不同的区域：新生代 ( Young )、老年代 ( Old )。新生代 ( Young ) 又被划分为三个区域：Eden、From Survivor、To Survivor。
第286题
关于protected 修饰的成员变量，以下说法正确的是
A、可以被该类自身、与它在同一个包中的其它类、在其它包中的该类的子类所访问
B、只能被该类本身和该类的所有的子类访问
C、只能被该类自身所访问
D、只能被同一个包中的类访问

正确答案: A 我的答案: B (错误)
 
第287题
java语言的下面几种数组复制方法中，哪个效率最高？
A、for 循环逐一复制
B、System.arraycopy
C、Array.copyOf
D、使用clone方法

正确答案: B 我的答案: D (错误)
 从速度上看：System.arraycopy > clone > Arrays.copyOf > for
第288题
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、编译不通过

正确答案: D 我的答案: B (错误)
 解释;这句new 了一个派生类，赋值给基类，所以下面的操作编译器认为base对象就是Base类型的,Base类中不存在methodB()方法，所以编译不通过
第289题
下面哪些具体实现类可以用于存储键，值对，并且方法调用提供了基本的多线程安全支持：(  )
A、java.util.ConcurrentHashMap
B、java.util.Map
C、java.util.TreeMap
D、java.util.SortMap
E、java.util.Hashtable
F、java.util.HashMap

正确答案: A E 我的答案: A C E (错误)
 线程安全的类有hashtable concurrentHashMap synchronizedMap
第290题
下列关于while循环、do-while循环和for循环说法错误的是
A、while循环先执行条件判断，do-while循环执行循环体
B、do-while循环结束的条件是关键字while后的条件表达式成立
C、for循环结构中的3个表达式缺一不可
D、while循环能够实现的操作，for循环也能实现

正确答案: B C 我的答案: B C (正确)

变量名称	字节	位数
byte	1	8
short	2	16
int	4	32
long	8	64
float	4	32
double	8	64
char	2	16
boolean	1	8