玉米迪迪

Java专项练习一（选择题）

每天的学习记录，加油！

- 1、在程序代码中写的注释太多，会使编译后的程序尺寸变大。==错
- 2、StringBuffer类对象创建之后可以再修改和变动。==对==
- 3、假定AB为一个类，则执行 “AB ab = new AB(a,5);”语句时将自动调用该类的。
- 4、假设 A 类有如下定义，设 a 是 A 类的一个实例，下列语句调用哪个是==错误==的?
- 5、下面的代码运行的结果是：（==B==）
- 6、关于抽象类和接口叙述正确的是？
- 7、对于application，主线程main（）方法执行的线索，对于applet，主线程是浏览器加载并执行java小程序。==对==
- 8、在java的一个异常处理中，可以包含多个的语句块是。
- 9、在Java中，HashMap中是用哪些方法来解决哈希冲突的？
- 10、下面有关java的一些细节问题，描述错误的是？（）
- 11、以下多线程对int型变量x的操作,哪个不需要进行同步()
- 167、给定以下JAVA代码，这段代码运行后输出的结果是()
- 168、有如下4条语句：()
- 169、下面关于垃圾收集的说法正确的是
- 170、Java的跨平台特性是指它的源代码可以在多个平台运行。（）
- 171、下面有关jdbc statement的说法错误的是？
- 172、JAVA中，下列语句哪一个正确（）
- 173、下列说法正确的是
- 174、关于Java的抽象类、接口，以下描述错误的是？
- 175、内部类（也叫成员内部类）可以有4种访问权限。（）
- 176、下列代码的执行结果是（）
- 177、用命令方式运行以下代码的运行结果是（）
- 178、以下哪项可能包含菜单条（）
- 179、问这个程序的输出结果。
- 180、假设 a 是一个由线程 1 和线程 2 共享的初始值为 0 的全局变量，则线程 1 和线程 2 同时执行下面的代码，最终 a 的结果不可能是（）
- 181、以下代码的输出结果是？
- 182、检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果
- 183、下面哪些具体实现类可以用于存储键，值对，并且方法调用提供了基本的多线程安全支持：()
- 184、Java1.8版本之前的前提，Java特性中,abstract class和interface有什么区别（）
- 185、Servlet的生命周期可以分为初始化阶段，运行阶段和销毁阶段三个阶段，以下过程属于初始化阶段是（）。
- 186、下面哪项技术可以用在WEB开发中实现会话跟踪实现？
- 187、在Java中下面Class的声明哪些是错误的？
- 188、Model-View-Controller(MVC) is an architectural pattern that frequently used in web applications. Which of the following statement(s) is(are) correct?
- 189、关于Java中的ClassLoader下面的哪些描述是错误的：( )
- 190、下列哪些方法是针对循环优化进行的
- 191、下列不属于类及类成员的访问控制符是：（）
- 192、关于下面程序 ThisTest .java 运行结果说法正确的是： ( )
- 193、如下Java语句 double x=2.0; int y=4; x/=++y; 执行后，x的值是（）
- 194、在java中，已定义两个接口B和C，要定义一个实现这两个接口的类，以下语句正确的是（）
- 195、以下哪个不属于JVM堆内存中的区域（）？
- 196、JVM内存不包含如下哪个部分( )
- 197、下面的程序输出的结果是( )
- 198、ArrayList和Vector主要区别是什么？
- 199、运行下面代码，输出的结果是（）
- 200、观察以下代码：下列哪些针对代码运行结果的描述是正确的？

1、在程序代码中写的注释太多，会使编译后的程序尺寸变大。==错

解析：（注释是给人看的，只是为了方便程序员阅读理解代码，编译器不会读注释，只会读代码程序）

2、StringBuffer类对象创建之后可以再修改和变动。对

解析：（1.String对象不可变、StringBuffer对象可变的含义：举个例子：String str = “aa”; str = “aa”+“bb”; 此时str的值为"aabb"，但是"aabb"不是在开始的字符串"aa"后面直接连接的"bb"，而是又新生成了字符串"aabb"，字符串"aa"一旦被初始化，那么它的值不可能再改变了。 StringBuffer strb = StringBuffer(“aa”); strb.append(“bb”); 此时的strb的值也为"aabb"，但是"aabb"是直接在开始的字符串"aa"后面连接的“bb”，并没有生成新的字符串。）

3、假定AB为一个类，则执行 “AB ab = new AB(a,5);”语句时将自动调用该类的。

A带参构造函数== B无参构造函数 C拷贝构造函数 D重载赋值运算

解析：（类的实例化，创建一个类AB的对象ab，并使用new运算符给类AB中的构造函数中的参数初始化。）

4、假设 A 类有如下定义，设 a 是 A 类的一个实例，下列语句调用哪个是错误的?

public class A
{
public int i;
static String s;
void method1(){}
static void method2(){}
}
A.System.out.println(a.i); B.a.method1();
C.A.method1(); D.A.method2();
解析：( 静态成员和静态方法，可以直接通过类名进行调用，D对，C错；
其他的成员和方法则需要进行实例化成对象之后，通过对象来调用，A,B对)

5、下面的代码运行的结果是：（B）

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
解析：（执行顺序：“静态初始化块 ”先于 “非静态初始化” 先于 “构造函数执行”
父类静态代码块-》子类静态代码块-》父类构造代码块-》父类构造函数-》子类构造代码块-》子类构造函数）

6、关于抽象类和接口叙述正确的是？

A.抽象类和接口都能实例化的 B.抽象类不能实现接口
C.抽象类方法的访问权限默认都是public
D.接口方法的访问权限默认都是public
解析：（抽象类和接口的特点）

7、对于application，主线程main（）方法执行的线索，对于applet，主线程是浏览器加载并执行java小程序。对

8、在java的一个异常处理中，可以包含多个的语句块是。

A.try B.finally C.throws D.catch
解析：考点：异常处理
捕获异常：
try{
//代码块
}catch(异常类型，例如：Exception e){
//需要抛出的异常，例如：e.printStackTrace();
}catch(异常类型){
//需要抛出的异常
}finally{
//必定执行的代码块
}
在一个异常处理中catch语句块是可以多个的，也就是可以抛出多个异常。

9、在Java中，HashMap中是用哪些方法来解决哈希冲突的？

A.开放地址法 B.二次哈希法 C.链地址法 D.建立一个公共溢出区

10、下面有关java的一些细节问题，描述错误的是？（）

A.构造方法不需要同步化
B.一个子类不可以覆盖掉父类的同步方法
C.定义在接口中的方法默认是public的
D.容器保存的是对象的引用

11、以下多线程对int型变量x的操作,哪个不需要进行同步()

A.++x B.x=y C.x++ D.x=1

**12、

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

对于上面这段代码，以下说法正确的是：
A.程序会打出 “Value is 0”
B.程序会抛出 NullPointerException
C.非静态变量不能够被静态方法引用
D.编译器会抛出 "possible reference before assignment"的错误**
解析：（当类加载时，static静态方法随着类加载而初始化，此时实例对象还未被创建，但是非静态成员变量需要等到实例对象创建才会被初始化，故无法被引用。）

13、下列哪项不属于jdk1.6垃圾收集器？
A.Serial收集器
B.parNew收集器
C.CMS收集器
D.G1收集器

14、Integer i = 42;
Long l = 42l;
Double d = 42.0;
下面为true的是
A.(i == l)
B.(i == d)
C.(l == d)
D.i.equals(d)
E.d.equals(l)
F.i.equals(l)
G.l.equals(42L)
解析（包装类的“==”运算在不遇到算术运算的情况下不会自动拆箱
包装类的equals()方法不处理数据转型）

15、以下对继承的描述错误的是（）
A.Java中的继承允许一个子类继承多个父类
B.父类更具有通用性，子类更具体
C.Java中的继承存在着传递性
D.当实例化子类时会调用父类中的构造方法
解析：(java不能执行多继承）

16、java用（）机制实现了进程之间的同步执行
A.监视器
B.虚拟机
C.多个CPU
D.异步调用

17、下列哪一项的实现不可以添加为 TextField 对象的监听器（）
A.MouseMotionListener
B.FocusListener
C.WindowsListener
D.ActionListener

18、 DBMS 中实现事务持久性的子系统是()
A.安全性管理子系统
B.完整性管理子系统
C.并发控制子系统
D.恢复管理子系统

19、下列选项中属于面向对象程序设计语言特征的是（）
A.继承性
B.多态性
C.相似性
D.封装性

20、int，String，*point，union哪些不是 Java 的数据类型？C D
A.int
B.String
C.*point
D.union
引用数据类型，String为字符串类，属于引用数据类型

21、对Collection和Collections描述正确的是
A.Collection是java.util下的类，它包含有各种有关集合操作的静态方法
B.Collection是java.util下的接口，它是各种集合结构的父接口
C.Collections是java.util下的接口，它是各种集合结构的父接口
D.Collections是java.util下的类，它包含有各种有关集合操作的静态方法
解析：（ java.util.Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。
java.util.Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。）

22、下面哪几个函数 public void example(){…} 的重载函数？（）
A.public void example(int m){…}
B.public int example(){…}
C.public void example2(){…}
D.public int example(int m,float f){…}
解析：java重载的时候以参数个数和类型作为区分，方法名相同，返回类型可以相同也可以不同，但不以返回类型作为区分，所以b也是错的，因为b的参数列表和原来的一样。

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

24、下面哪些Java中的流对象是字节流?
A.FileInputStream
B.BufferedInputStream
C.PushbackInputStream
D.ByteArrayInputStream
解析：stream结尾都是字节流，reader和writer结尾都是字符流两者的区别就是读写的时候一个是按字节读写，一个是按字符。实际使用通常差不多。在读写文件需要对内容按行处理，比如比较特定字符，处理某一行数据的时候一般会选择字符流。只是读写文件，和文件内容无关的，一般选择字节流。

25、Gadget has-a Sprocket and Gadget has-a Spring and Gadget is-a Widget and Widget has-a
Sprocket 以下哪两段代码可以表示这个关系? (选择两项) ( )
A.class Widget { Sprocket s; }
class Gadget extends Widget { Spring s; }
B.class Widget { }
class Gadget extends Widget { Spring s1; Sprocket s2; }
C.class Widget { Sprocket s1; Spring s2; }
class Gadget extends Widget { }
D.class Gadget { Spring s; }
class Widget extends Gadget{ Sprocket s; }
解析：
is-a 表示继承：Gadget is-a Widget就表示Gadget 继承 Widget；
has-a表示从属：Gadget has-a Sprocket就表示Gadget中有Sprocket的引用，Sprocket是Gadget的组成部分；
like-a表示组合：如果A like-a B，那么B就是A的接口

26、JAVA反射机制主要提供了以下哪些功能？
A.在运行时判断一个对象所属的类
B.在运行时构造一个类的对象
C.在运行时判断一个类所具有的成员变量和方法
D.在运行时调用一个对象的方法

27、有关静态初始化块说法正确的是？
A.无法直接调用静态初始化块
B.在创建第一个实例前或引用任何静态成员之前，将自动调用静态初始化块来初始化
C.静态初始化块既没有访问修饰符，也没有参数
D.在程序中，用户可以控制合适执行静态初始化块

解析： java对象初始化顺序
父类静态代码块，父类静态成员变量（同级，按代码顺序执行）
子类静态代码块，子类静态成员变量（同级，按代码顺序执行）
父类普通代码块，父类普通成员变量（同级，按代码顺序执行）
父类构造方法
子类普通代码块，子类普通成员变量（同级，按代码顺序执行）
子类构造方法
注意点：
静态内容只在类加载时执行一次，之后不再执行。
默认调用父类的无参构造方法，可以在子类构造方法中利用super指定调用父类的哪个构造方法。

28、判断一块内存空间是否符合垃圾收集器收集的标准有哪些？
A.给对象赋予了空值null,以下再没有调用过
B.对象重新分配了内存空间
C.给对象赋予了空值null
D.给对象赋予了新值

29、有关会话跟踪技术描述正确的是
A.Cookie是Web服务器发送给客户端的一小段信息，客户端请求时，可以读取该信息发送到服务器端
B.关闭浏览器意味着临时会话ID丢失，但所有与原会话关联的会话数据仍保留在服务器上，直至会话过期
C.在禁用Cookie时可以使用URL重写技术跟踪会话
D.隐藏表单域将字段添加到HTML表单并在客户端浏览器中显示

30、character流和byte流的区别不包括
A.每次读入的字节数不同
B.前者带有缓冲，后者没有。
C.前者是字符读入，后者是字节读入。
D.二者没有区别，可以互换。

31 、在使用 interface 声明一个外部接口时，只可以使用（）修饰符修饰该接口。
A.private
B.protected
C.private protected
D.public
解析：接口的方法都是 public abstract 变量都是public static final的

32、下面所示的java代码，运行时，会产生（）类型的异常
int Arry_a[] = new int[10];
System.out.println(Arry_a[10]);
A.ArithmeticException
B.NullPointException
C.IOException
D.ArrayIndexOutOfBoundsException
解析：定义的数组长度为10，角标即为0-9
访问数组角标10会出现数组角标越界异常

33、javac的作用是（）。
A.将源程序编译成字节码
B.将字节码编译成源程序
C.解释执行Java字节码
D.调试Java代码
解析：javac将源程序编译成.class文件，字节码；java将字节码转为机器码，.exe程序

34、执行完以下代码 int [ ] x = new int[10] ；后，以下哪项说明是正确的（）
A.x[9]为0
B.x[9]未定义
C.x[10]为0
D.x[0]为空
解析：数组引用类型的变量的默认值为 null。当数组变量的实例后，如果没有没有显示的为每个元素赋值，Java 就会把该数组的所有元素初始化为其相应类型的默认值。
byte[],short[],int[] ,默认值为0,
boolean[]默认值为false
float[],double[],默认值为0.0
对象类型数组:
默认值为null

35、在Java中，HashMap中是用哪些方法来解决哈希冲突的？
A.开放地址法
B.二次哈希法
C.链地址法
D.建立一个公共溢出区

36、String str =
“”;
System.out.print(str.split(",").length);
A.0
B.1
C.出现异常
解析：String split 这个方法默认返回一个数组，如果没有找到分隔符，会把整个字符串当成一个长度为1的字符串数组返回到结果，所以此处结果就是1 。

37、URL u =new URL(“http://www.123.com”);。如果www.123.com不存在，则返回______。
A.http://www.123.com
B.””
C.null
D.抛出异常
解析：我们在执行URL u =new URL(“http://www.123.com”);这句话的时候确实要抛出异常，但是这个异常属于IOException，不管网址是否存在，最后都会返回该网址的一个连接，打印出来就是该网址。

38、Java创建对象的说法正确的有（）
A.用new语句创建对象，是最常见的创建对象的方法。
B.运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。
C.调用对象的clone()方法。
D.运用反序列化手段，调用java.io.ObjectInputStream对象的 readObject()方法。
解析： Java有5种方式来创建对象：

使用 new 关键字（最常用）： ObjectName obj = new ObjectName();
使用反射的Class类的newInstance()方法： ObjectName obj = ObjectName.class.newInstance(); 
使用反射的Constructor类的newInstance()方法： ObjectName obj = ObjectName.class.getConstructor.newInstance();
使用对象克隆clone()方法： ObjectName obj = obj.clone(); 
使用反序列化（ObjectInputStream）的readObject()方法： try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_NAME))) { ObjectName obj = ois.readObject(); }

39、以下哪些jvm的垃圾回收方式采用的是复制算法回收
A.新生代串行收集器
B.老年代串行收集器
C.并行收集器
D.新生代并行回收收集器
E.老年代并行回收收集器
F.cms收集器

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

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

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

41、在基本JAVA类型中，如果不明确指定，整数型的默认是什么类型？带小数的默认是什么类型？
A.int float
B.int double
C.long float
D.long double
解析：在常量中，整型常量默认int类型，小数常量默认是double类型。
布尔类型，如果是单一变量的话，在JVM中true被认为是1 false被认为是0 所以是4字节存。如果是布尔类型数组的话，在JVM中true和false被认为是byte类型 1字节。

42、ArrayList和LinkList的描述，下面说法错误的是？
A.LinkedeList和ArrayList都实现了List接口
B.ArrayList是可改变大小的数组，而LinkedList是双向链接串列
C.LinkedList不支持高效的随机元素访问
D.在LinkedList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在ArrayList的中间插入或删除一个元素的开销是固定的
解析： LinkedList是基于双链表的，增加是在尾部增加，增加和删除都只需要修改指针，不需要移动元素。
ArrayList插入或删除一个元素的开销不是固定的。在插入时，如果索引正确，容量够，则直接插入，插入位置之后的都需要移动，如果容易不够，还得扩充容量，开销当然不一样。删除操作同理。
所以，D错误，相当于说反了。

43、有时为了避免某些未识别的异常抛给更高的上层应用，在某些接口实现中我们通常需要捕获编译运行期所有的异常， catch 下述哪个类的实例才能达到目的：（）
A.Error
B.Exception
C.RuntimeException
D.Throwable
解析：error是系统出错
catch是无法处理的，难以修复的
RuntimeException不需要程序员进行捕获处理
error和exception都是throwable的子类，我们只需要对exception的实例进行捕获即可

44、下面属于java合法变量定义的是？
A.final
B.1var1
C._var2
D.var3&
解析：变量命名规则：1、变量名首字母必须为字母(a-z A-Z)，下划线或者美元符号开始。
2、变量名只能是字母(a-z A-Z)，数字(0-9)，下划线(_)的组合，并且之间不能包含空格，数字不能放在变量名首位。
3、变量名不能使用编程语言的保留字。

45、下列选项中符合Java命名规则的标识符是（）
A.2japro
B.&Class
C.const
D._123
解析：同44

46、在JAVA中，假设A有构造方法A(int a)，则在类A的其他构造方法中调用该构造方法和语句格式应该为（）
A.this.A(x)
B.this(x)
C.super(x)
D.A(x)
解析：this的作用其中一个就是在一个构造方法中调用另一个构造方法，格式为this(参数)；

47、下列有关Servlet的生命周期，说法不正确的是？
A.在创建自己的Servlet时候，应该在初始化方法init()方法中创建Servlet实例
B.在Servlet生命周期的服务阶段，执行service()方法，根据用户请求的方法，执行相应的doGet()或是doPost()方法
C.在销毁阶段，执行destroy()方法后会释放Servlet 占用的资源
D.destroy()方法仅执行一次，即在服务器停止且卸载Servlet时执行该方法
解析：
Servlet的生命周期分为5个阶段：加载、创建、初始化、处理客户请求、卸载。
(1)加载：容器通过类加载器使用servlet类对应的文件加载servlet
(2)创建：通过调用servlet构造函数创建一个servlet对象
(3)初始化：调用init方法初始化
(4)处理客户请求：每当有一个客户请求，容器会创建一个线程来处理客户请求
(5)卸载：调用destroy方法让servlet自己释放其占用的资源

48、关于匿名内部类叙述正确的是？ ( )
A.匿名内部类可以继承一个基类，不可以实现一个接口
B.匿名内部类不可以定义构造器
C.匿名内部类不能用于形参
D.以上说法都不正确
解析：由于构造器的名字必须与类名相同，而匿名类没有类名，所以匿名类不能有构造器。

49、下列说法错误的有（）
A.Java面向对象语言容许单独的过程与函数存在
B.Java面向对象语言容许单独的方法存在
C.Java语言中的非静态方法属于类中的成员（member）
D.Java语言中的方法必定隶属于某一类（对象），调用方法与C语言的过程或C++语言的函数相同
解析：做这题其实要区分:C的过程，C++的函数，Java的方法。

50、关于Java中的ClassLoader下面的哪些描述是错误的：( )
A.默认情况下，Java应用启动过程涉及三个ClassLoader: Boostrap, Extension, System
B.一般的情况不同ClassLoader装载的类是不相同的，但接口类例外，对于同一接口所有类装载器装载所获得的类是相同的
C.类装载器需要保证类装载过程的线程安全
D.ClassLoader的loadClass在装载一个类时，如果该类不存在它将返回null
E.ClassLoader的父子结构中，默认装载采用了父优先
F.所有ClassLoader装载的类都来自CLASSPATH环境指定的路径
解析：
A、java中类的加载有5个过程，加载、验证、准备、解析、初始化；这便是类加载的5个过程，而类加载器的任务是根据一个类的全限定名来读取此类的二进制字节流到JVM中，然后转换为一个与目标类对应的java.lang.Class对象实例，在虚拟机提供了3种类加载器，引导（Bootstrap）类加载器、扩展（Extension）类加载器、系统（System）类加载器（也称应用类加载器）。A正确
B、一个类，由不同的类加载器实例加载的话，会在方法区产生两个不同的类，彼此不可见，并且在堆中生成不同Class实例。所以B前面部分是正确的，后面接口的部分真的没有尝试过，等一个大佬的讲解吧；
C、类加载器是肯定要保证线程安全的；C正确
D、装载一个不存在的类的时候，因为采用的双亲加载模式，所以强制加载会直接报错，D错误
java.lang.SecurityException: Prohibited package name: java.lang
E、双亲委派模式是在Java 1.2后引入的，其工作原理的是，如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式，即每个儿子都很懒，每次有活就丢给父亲去干，直到父亲说这件事我也干不了时，儿子自己想办法去完成，所以默认是父装载，E正确
F、自定义类加载器实现继承ClassLoader后重写了findClass方法加载指定路径上的class，F错误

51、 main 方法是 Java Application 程序执行的入口点，以下描述哪项是合法的（）。
A.public static void main（）
B.public static void main（ String args[] ）
C.public static int main（String [] arg ）
D.public void main（String arg[] ）
解析：
java中的main方法，必须满足以下要求：
方法的名字必须是main，方法必须是public static void 类型的，方法必须接收一个字符串数组的参数string[] args 和string args[]相同。

52、以下定义一维数组的语句中，正确的是：（）
A.int a [10]
B.int a []=new [10]
C.int a[]
int a []=new int [10]
D.int a []={1,2,3,4,5}
解析：
Java一维数组有两种初始化方法
1、静态初始化
int array[] = new int[]{1,2,3,4,5}
或者
int array[] = {1,2,3,4,5}
需要注意的是，写成如下形式也是错误的
int array[] = new int[5]{1,2,3,4,5}
2、动态初始化
int array[] = new int[5];
array[0] = 1;
array[1] = 2;
array[2] = 3;
array[3] = 4;
array[4] = 5;
静态与动态初始化的区别就在于，前者是声明的时候就初始化，后者是先声明，再动态初始化。

53、下列关于计算机系统和Java编程语言的说法，正确的是（）
A.计算机是由硬件、操作系统和软件组成，操作系统是缺一不可的组成部分。
B.Java语言编写的程序源代码可以不需要编译直接在硬件上运行。
C.在程序中书写注释不会影响程序的执行，可以在必要的地方多写一些注释。
D.Java的集成开发环境（IDE），如Eclipse，是开发Java语言必需的软件工具。
解析：
A计算机是由硬件和软件组成，操作系统是软件部分。

54、面代码的运行结果是（）
public static void main(String[] args){
String s;
System.out.println(“s=”+s);
}
A.代码编程成功，并输出”s=”
B.代码编译成功，并输出”s=null”
C.由于String s没有初始化，代码不能编译通过。
D.代码编译成功，但捕获到NullPointException异常
解析：局部变量没有默认值

55、下面有关SPRING的事务传播特性，说法错误的是？
A.PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行
B.PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就抛出异常
C.PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起
D.PROPAGATION_NESTED：支持当前事务，新增Savepoint点，与当前事务同步提交或回滚
解析：
Spring的API设计很不错，基本上根据英文翻译就能知道作用:Required:必须的。说明必须要有事物，没有就新建事物。supports:支持。说明仅仅是支持事务，没有事务就非事务方式执行。mandatory:强制的。说明一定要有事务，没有事务就抛出异常。required_new:必须新建事物。如果当前存在事物就挂起。not_supported:不支持事物，如果存在事物就挂起。never:绝不有事务。如果存在事物就抛出异常

56、在java7中,下列哪个说法是正确的:
A.ConcurrentHashMap使用synchronized关键字保证线程安全
B.HashMap实现了Collection接口
C.Arrays.asList方法返回java.util.ArrayList对象
D.SimpleDateFormat对象是线程不安全的
解析：hashMap在单线程中使用大大提高效率，在多线程的情况下使用hashTable来确保安全。hashTable中使用synchronized关键字来实现安全机制，但是synchronized是对整张hash表进行锁定即让线程独享整张hash表，在安全同时造成了浪费。concurrentHashMap采用分段加锁的机制来确保安全

57、下面有关maven和ant的描述，描述错误的是？
A.Ant 没有正式的约定如一个一般项目的目录结构，你必须明确的告诉 Ant 哪里去找源代码
B.Maven 拥有约定，因为你遵循了约定，它已经知道你的源代码在哪里
C.maven和ant都有“生命周期”的概念，当你输入一个命令后，maven或者ant会执行一系列的有序的步骤，直到到达你指定的生命周期
D.Ant构建文件默认命名为build.xml，Maven默认构建文件为pom.xml
解析：
Ant和Maven都是基于Java的构建(build)工具。理论上来说，有些类似于（Unix）C中的make ，但没有make的缺陷。Ant是软件构建工具，Maven的定位是软件项目管理和理解工具。
Ant特点
没有一个约定的目录结构 ›必须明确让ant做什么，什么时候做，然后编译，打包 ›没有生命周期，必须定义目标及其实现的任务序列 ›没有集成依赖管理
Maven特点
拥有约定，知道你的代码在哪里，放到哪里去 ›拥有一个生命周期，例如执行 mvn install 就可以自动执行编译，测试，打包等构建过程 ›只需要定义一个pom.xml,然后把源码放到默认的目录，Maven帮你处理其他事情 ›拥有依赖管理，仓库管理

58、下面这段程序的输出结果是（）

public class Main {
    public static void main(String[] args) {
        split(12);
    }
    public static int split(int number) {
        if (number > 1) {
            if (number % 2 != 0) System.out.print(split((number + 1) / 2));
                System.out.print(split(number / 2));
            }
        return number;
       }
}

A.12136
B.63121
C.61213
D.11236
解析：考察方法进栈与出栈的顺序。先进后出
有个知识点，方法在出栈的时候，执行的是return语句。因为出栈就意味着方法结束并消费，如果没有return语句，那么方法出栈的时候什么都不执行，就直接销毁。

59、下面代码的输出是什么？

public class Base
{
    private String baseName = "base";
    public Base()
    {
        callName();
    }

    public void callName()
    {
        System. out. println(baseName);
    }

    static class Sub extends Base
    {
        private String baseName = "sub";
        public void callName()
        {
            System. out. println (baseName) ;
        }
    }
    public static void main(String[] args)
    {
        Base b = new Sub();
    }
}

A.null
B.sub
C.base

60、以下关于final关键字说法错误的是（）
A.final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性
B.final修饰的类肯定不能被继承
C.final修饰的方法不能被重载
D.final修饰的变量不允许被再次赋值
解析： final修饰类、方法、属性！不能修饰抽象类，因为抽象类一般都是需要被继承的，final修饰后就不能继承了。
final修饰的方法不能被重写而不是重载！
final修饰属性，此属性就是一个常量，不能被再次赋值！

61、使用mvc模式设计的web应用程序具有以下优点,除了？
A.可维护行强
B.可扩展性强
C.代码重复少
D.大大减少代码量
解析：MVC全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。MVC被独特的发展起来用于映射传统的输入、处理和输出功能在一个逻辑的图形化用户界面的结构中。
MVC只是将分管不同功能的逻辑代码进行了隔离，增强了可维护和可扩展性，增强代码复用性，因此可以减少代码重复。但是不保证减少代码量，多层次的调用模式还有可能增加代码量。

62、下面有关java基本类型的默认值和取值范围，说法错误的是？
A.字节型的类型默认值是0，取值范围是-2⁷—2⁷-1
B.boolean类型默认值是false，取值范围是true\false
C.字符型类型默认是0，取值范围是-2¹⁵ —2¹⁵-1
D.long类型默认是0，取值范围是-2⁶³—2⁶³-1
解析：

数据类型	默认值	取值范围	例子
字节型	0	-2⁷—-2⁷-1	byte b=10
字符型	‘ \u0000′	0—-2^16-1	char c=’c’
short	0	-2¹⁵—-2¹⁵-1	short s=10
int	0	-2³¹—-2³¹-1	int i=10
long	0	-2⁶³—-2⁶³-1	long o=10L
float	0.0	f -2³¹—-2³¹-1	float f=10.0F
double	0.0d	-2⁶³—-2⁶³-1	double d=10.0
boolean	false	true\false	boolean flag=true

63、下面字段声明中哪一个在interface主体内是合法的? （）
A.private final static int answer = 42;
B.public static int answer = 42;
C.final static answer = 42;
D.int answer;
解析：
在接口中，属性都是默认public static final修饰的，所以：
A（错误）：不能用private修饰；
B（正确）：在接口中，属性默认public static final，这三个关键字可以省略；
C（错误）：没写属性的类型；
D（错误）：final修饰的属性必须赋值；

64、下列程序的运行结果

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!
解析:
try-catch-finally 规则( 异常处理语句的语法规则）

必须在 try 之后添加 catch 或 finally 块。try 块后可同时接 catch 和 finally 块，但至少有一个块。
必须遵循块顺序：若代码同时使用 catch 和 finally 块，则必须将 catch 块放在 try 块之后。
catch 块与相应的异常类的类型相关。
一个 try 块可能有多个 catch 块。若如此，则执行第一个匹配块。即Java虚拟机会把实际抛出的异常对象依次和各个catch代码块声明的异常类型匹配，如果异常对象为某个异常类型或其子类的实例，就执行这个catch代码块，不会再执行其他的 catch代码块。
可嵌套 try-catch-finally 结构。
在 try-catch-finally 结构中，可重新抛出异常。
除了下列情况，总将执行 finally 做为结束： JVM 过早终止（调用 System.exit(int)）；在 finally 块中抛出一个未处理的异常；计算机断电、失火、或遭遇病毒攻击。
由此可以看出，catch只会匹配一个，因为只要匹配了一个，虚拟机就会使整个语句退出

65、关于异常的编程，以下描述错误的是：（）
A.在有除法存在的代码处，为了防止分母为零，必须抛出并捕获异常
B.int i=Integer.parseInt(”123a”);将产生NumberFormatException
C.int a[]=null; a[0]=1; 将产生NullPointerException
D.输入输出流编程中，读和写时都要抛出IOException
解析：

66、ArrayList list = new ArrayList(20);中的list扩充几次
A.0
B.1
C.2
D.3
解析：Arraylist默认数组大小是10，扩容后的大小是扩容前的1.5倍，最大值小于Integer 的最大值减8，如果新创建的集合有带初始值，默认就是传入的大小，也就不会扩容。

67、哪个正确
A.abstract类只能用来派生子类，不能用来创建abstract类的对象。
B.final类不但可以用来派生子类，也可以用来创建final类的对象。
C.abstract不能与final同时修饰一个类。
D.abstract类定义中可以没有abstract方法。
解析：
1、abstract类不能用来创建abstract类的对象；
2、final类不能用来派生子类，因为用final修饰的类不能被继承；
3、如2所述，final不能与abstract同时修饰一个类，abstract类就是被用来继承的；
4、类中有abstract方法必须用abstract修饰，但abstract类中可以没有抽象方法，接口中也可以有abstract方法。

68、下列哪些操作会使线程释放锁资源？
A.sleep()
B.wait()
C.join()
D.yield()
解析：所谓的释放锁资源实际是通知对象内置的monitor对象进行释放，而只有所有对象都有内置的monitor对象才能实现任何对象的锁资源都可以释放。又因为所有类都继承自Object，所以wait(）就成了Object方法，也就是通过wait()来通知对象内置的monitor对象释放，而且事实上因为这涉及对硬件底层的操作，所以wait()方法是native方法，底层是用C写的。
其他都是Thread所有，所以其他3个是没有资格释放资源的
而join()有资格释放资源其实是通过调用wait()来实现的

69、下列流当中，属于处理流的是：（）
A.FilelnputStream
B.lnputStream
C.DatalnputStream
D.BufferedlnputStream
解析：
按照流是否直接与特定的地方（如磁盘、内存、设备等）相连，分为节点流和处理流两类。
节点流：可以从或向一个特定的地方（节点）读写数据。如FileReader.
处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。
JAVA常用的节点流：
文件 FileInputStream FileOutputStrean FileReader FileWriter 文件进行处理的节点流。
字符串 StringReader StringWriter 对字符串进行处理的节点流。
数组 ByteArrayInputStream ByteArrayOutputStreamCharArrayReader CharArrayWriter 对数组进行处理的节点流（对应的不再是文件，而是内存中的一个数组）。
管道 PipedInputStream PipedOutputStream PipedReaderPipedWriter对管道进行处理的节点流。
常用处理流（关闭处理流使用关闭里面的节点流）
缓冲流：BufferedInputStrean BufferedOutputStream BufferedReader BufferedWriter 增加缓冲功能，避免频繁读写硬盘。
转换流：InputStreamReader OutputStreamReader 实现字节流和字符流之间的转换。
数据流 DataInputStream DataOutputStream 等-提供将基础数据类型写入到文件中，或者读取出来.
流的关闭顺序
一般情况下是：先打开的后关闭，后打开的先关闭
另一种情况：看依赖关系，如果流a依赖流b，应该先关闭流a，再关闭流b。例如，处理流a依赖节点流b，应该先关闭处理流a，再关闭节点流b
可以只关闭处理流，不用关闭节点流。处理流关闭的时候，会调用其处理的节点流的关闭方法。

70、有关线程的叙述正确的是()
A.可以获得对任何对象的互斥锁定
B.通过继承Thread类或实现Runnable接口，可以获得对类中方法的互斥锁定
C.线程通过使用synchronized关键字可获得对象的互斥锁定
D.线程调度算法是平台独立的
解析：
A，“任何对象”锁定，太绝对了，你能锁住你没有权限访问的对象吗？
B，前半句话讲的是创建线程的方式，后半句讲的是锁定，驴头不对马嘴。
C，正确。
D，线程调度分为协同式调度和抢占式调度，Java使用的是抢占式调度，也就是每个线程将由操作系统来分配执行时间，线程的切换不由线程本身来决定（协同式调度）。这就是平***立的原因。
以上，选CD

71、类 ABC 定义如下：

1 public  class  ABC{
2 public  double  max( double  a, double  b) {   }
3 
4 }

将以下哪个方法插入行 3 是不合法的。（）
A.public float max(float a, float b, float c){ }
B.public double max (double c, double d){ }
C.public float max(float a, float b){ }
D.private int max(int a, int b, int c){ }
解析：这道题考的是函数重载。函数重载前提必须是同名，和返回值类型无关（返回值类型只和函
数的计算功能相关），和权限也没有关系，和形式参数的名称也无关！只和形式参数的数据类型有关（数量，排列组合）。

72、以下那个数据结构是适用于"数据必须以相反的顺序存储然后检索" ? （）
A.Stack
B.Queue
C.List
D.Liink List
解析：A栈，先进后出（符合题意）B队列，先进先出 C链表，有下标存的顺序与取得的顺序一致 D是队列的子类存的顺序与取得的顺序一致

73、下面有关List接口、Set接口和Map接口的描述，错误的是？
A.他们都继承自Collection接口
B.List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置
C.Set是一种不包含重复的元素的Collection
D.Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value
解析：
Collection
-----List
-----LinkedList 非同步
----ArrayList 非同步，实现了可变大小的元素数组
----Vector 同步
------Stack
-----Set 不允许有相同的元素
Map
-----HashTable 同步，实现一个key–value映射的哈希表
-----HashMap 非同步，
-----WeakHashMap 改进的HashMap，实现了“弱引用”，如果一个key不被引用，则被GC回收

74、如果要建立一个java.scut.computer的包，叙述正确的是？ ( )
A.只需在代码中加入“package java.scut.computer;”一个语句，并且必须放在代码的第一行
B.只需在代码中加入“package java.scut;”一个语句
C.必须在代码中加入“package java.scut;”和“package java.scut.computer;”两个语句
D.在代码中，不一定是第一句，只要是类定义前，加入package语句即可

75、以下代码执行后输出结果为（）

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
解析：静态块：用static申明，JVM加载类时执行，仅执行一次
构造块：类中直接用{}定义，每一次创建对象时执行
执行顺序优先级：静态块>main()>构造块>构造方法
静态块按照申明顺序执行，先执行Test t1 = new Test();
所有先输出blockA，然后执行静态块，输出blockB，最后执行main
方法中的Test t2 = new Test();输出blockA。

76、下列不正确的 Java 语言标识符是（）
A.Sky
B. $ Computer
C.for
D.NULL
解析：Java标识符命名规范是：
1）只能包含字母a-zA-Z，数字0-9，下划线_和美元符号$；
2）首字母不能为数字；
3）关键字和保留字不能作为标识符。
null是关键字，NULL不是关键字，java区分大小写。这题答案D是对的，但C是错的，for是关键字。

77、下面有关JAVA异常类的描述，说法错误的是？
A.异常的继承结构：基类为Throwable，Error和Exception继承Throwable，RuntimeException和IOException等继承Exception
B.非RuntimeException一般是外部错误(非Error)，其必须被 try{}catch语句块所捕获
C.Error类体系描述了Java运行系统中的内部错误以及资源耗尽的情形，Error不需要捕捉
D.RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等，必须被 try{}catch语句块所捕获
解析：运行时异常故名思议就是程序在运行的时候出现异常，隐含的一个前提就是程序在编译时是检测不到异常的存在，作者本人也并不知道是否自己的代码中含有运行时异常，所以根本也不可能提前使用try{}catch{}捕获．

78、下列代码执行结果为（）

public static void main(String args[])throws InterruptedException{
            Thread t=new Thread(new Runnable() {
                public void run() {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.print("2");
                }
            });
            t.start();
             
            t.join();
            System.out.print("1");
        }

A.21
B.12
C.可能为12，也可能为21
D.以上答案都不对
解析： thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。
t.join(); //使调用线程 t 在此之前执行完毕。
t.join(1000); //等待 t 线程，等待时间是1000毫秒

79、以下 json 格式数据，错误的是
A.{company：4399}
B.{“company”:{“name”:[4399,4399,4399]}}
C.{[4399,4399,4399]}
D.{“company”:[4399,4399,4399]}
E.{“company”:{“name”:4399}}
解析：

80、线程安全的map在JDK 1.5及其更高版本环境有哪几种方法可以实现?
A.Map map = new HashMap()
B.Map map = new TreeMap()
C.Map map = new ConcurrentHashMap();
D.Map map = Collections.synchronizedMap(new HashMap());
解析： 1. HashMap,TreeMap 未进行同步考虑，是线程不安全的。
2. HashTable 和 ConcurrentHashMap 都是线程安全的。区别在于他们对加锁的范围不同，HashTable 对整张Hash表进行加锁，而ConcurrentHashMap将Hash表分为16桶(segment)，每次只对需要的桶进行加锁。
3. Collections 类提供了synchronizedXxx()方法，可以将指定的集合包装成线程同步的集合。比如，
List list = Collections.synchronizedList(new ArrayList());
Set set = Collections.synchronizedSet(new HashSet());

81、以下不属于构造方法特征的是（）
A.构造方法名与类名相同
B.构造方法不返回任何值，也没有返回类型
C.构造方法在创建对象时调用，其他地方不能显式地直接调用
D.每一个类只能有一个构造方法
解析：
构造方法的特点：
1.构造方法名与类名相同
2.构造方法不返回任何值，也没有返回类型
3.构造方法在创建对象时调用，其他地方不能显式地直接调用
4.一个类可以有多个构造方法，多个构造方法通过不同参数列表进行重载。

82、若有下列定义，下列哪个表达式返回false？

String s = "hello";
String t = "hello";
char c[] = {'h','e','l','l','o'} ;

A.s.equals(t);
B.t.equals©;
C.s==t;
D.t.equals(new String(“hello”));
解析：
A、D选项是对字符串内容的比较。JVM为了减少字符串对象的重复创建，其维护了一个特殊的内存，这段内存被成为字符串常量池。代码中出现字面量形式创建字符串对象时，JVM首先会对这个字面量进行检查，如果字符串常量池中存在相同内容的字符串对象的引用，则将这个引用返回，否则新的字符串对象被创建，然后将这个引用放入字符串常量池，并返回该引用。所以返回true。
C选项是引用地址的比较，同上也属于常量池的同一个字符串地址，所以相等返回true。

83、关于下面程序，哪些描述是正确的: ( )

 public class While {
public void loop() {
int x= 10;
while ( x )  {
System.out.print("x minus one is " + (x - 1));
x -= 1;
}
}
}

A.行1有语法错误
B.行4有语法错误
C.行5有语法错误
D.行6有语法错误
E.行2有语法错误,loop是关键字
F.程序能够正常编译和运行
解析：while()括号里参数必须是布尔类型，要么true要么false

84、下面的程序编译运行后，在屏幕上显示的结果是（）

 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
解析：5 >> 2 相当于 5除于（2的平方），等于1 ，>>> 表示无符号右移，高位用0 填充，0001 右移两位 0000，所以答案选 A
（<< : 左移运算符，num << 1,相当于num乘以2 ）（>> : 右移运算符，num >> 1,相当于num除以2）（>>> : 无符号右移，忽略符号位，空位都以0补齐）

85、在运行时，由java解释器自动引入，而不用import语句引入的包是()。
A.java.lang
B.java.system
C.java.io
D.java.util
解析：答案：A
java.lang包是java语言的核心包，lang是language的缩写
java.lang包定义了一些基本的类型，包括Integer,String之类的，是java程序必备的包，有解释器自动引入，无需手动导入

86、一般用()创建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
解析：System.in 和 System.out 是java中的标准输入输出流，一般情况下代表从控制台输入和输出到控制台

87、下面赋值语句中正确的是（）
A.double d=5.3e12;
B.float f=11.1;
C.int i=0.0;
D.Double oD=3;
解析：A科学计数法 5.3e12表示5.3乘以10的12次方
Bfloat f=11.1f;
Cint i=0;
D Double d = 3; 错（自动装箱的目标必须严格对应它拆箱后的类型）
Double d = 3.0;对（自动装箱）

88、变量a是一个64位有符号的整数，初始值用16进制表示为：0Xf000000000000000；变量b是一个64位有符号的整数，初始值用16进制表示为：0x7FFFFFFFFFFFFFFF。则a-b的结果用10进制表示为多少？（）
A.1
B.-(2⁶²+2⁶¹+2⁶⁰+1)
C.2⁶²+2⁶¹+2⁶⁰+1
D.2⁵⁹+(2⁵⁵+2⁵⁴+…+2²+2¹+2⁰)
解析：
0Xf000000000000000补码为1111000000000000000000000000000000000000000000000000000000000000
0x7FFFFFFFFFFFFFFF补码为0111111111111111111111111111111111111111111111111111111111111111
a-b=a+(-b)=
1111000000000000000000000000000000000000000000000000000000000000+
1000000000000000000000000000000000000000000000000000000000000001=
10111000000000000000000000000000000000000000000000000000000000001(高位溢出舍去)
则结果为
0111000000000000000000000000000000000000000000000000000000000001=
2⁶²⁺²61+2^60+1

89、指出下列程序运行的结果（）

public class Example{
    String str = new String("good");
    char[ ] ch = { 'a' , 'b' , 'c' };
    public static void main(String args[]){
        Example ex = new Example();
        ex.change(ex.str,ex.ch);
        System.out.print(ex.str + " and ");
        System.out.print(ex.ch);
    }
    public void change(String str,char ch[ ]){
        str = "test ok";
        ch[0] = 'g';
    }
}

A.good and abc
B.good and gbc
C.test ok and abc
D.test ok and gbc
解析：change()函数里，str采用的是传值调用，ch[]采用的是传址调用。传址调用形参不影响实参，如果将参数表里的str改成引用调用或者指针调用就是D选项的结果。

90、如果一个接口Glass有个方法setColor()，有个类BlueGlass实现接口Glass，则在类BlueGlass中正确的是？ ( )
A.protected void setColor() { …}
B.void setColor() { …}
C.public void setColor() { …}
D.以上语句都可以用在类BlueGlass中
解析：JAVA 子类重写继承的方法时,不可以降低方法的访问权限，子类继承父类的访问修饰符要比父类的更大，也就是更加开放，假如我父类是protected修饰的，其子类只能是protected或者public，绝对不能是friendly(默认的访问范围)或者private，当然使用private就不是继承了。还要注意的是，继承当中子类抛出的异常必须是父类抛出的异常的子异常，或者子类抛出的异常要比父类抛出的异常要少。

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

92、以下是java concurrent包下的4个类，选出差别最大的一个
A.Semaphore
B.ReentrantLock
C.Future
D.CountDownLatch
解析：
A、Semaphore：类，控制某个资源可被同时访问的个数;
B、ReentrantLock：类，具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大；
C、 Future：接口，表示异步计算的结果；
D、 CountDownLatch：类，可以用来在一个线程中等待多个线程完成任务的类。

93、下面的输出结果是什么？

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
解析：== 判断的是对象引用地址是否相同

 String str=new String("hello");
这句话new了一个新的String对象，所以地址与"hello"字符串常量的地址不同，答案为false

如果判断字符串是否相等应给用str.equals("hello")方法

94、下列哪个修饰符可以使在一个类中定义的成员变量只能被同一包中的类访问？
A.private
B.无修饰符
C.public
D.protected
解析：无修饰符就是默认权限，也叫包访问权限，只能被同一包内类访问

95、以下哪项陈述是正确的？
A.垃圾回收线程的优先级很高，以保证不再使用的内存将被及时回收
B.垃圾收集允许程序开发者明确指定释放哪一个对象
C.垃圾回收机制保证了JAVA程序不会出现内存溢出
D.进入”Dead”状态的线程将被垃圾回收器回收
E.以上都不对
解析：答案：E
A: 垃圾回收在jvm中优先级相当相当低。
B：垃圾收集器（GC）程序开发者只能推荐JVM进行回收，但何时回收，回收哪些，程序员不能控制。
C：垃圾回收机制只是回收不再使用的JVM内存，如果程序有严重BUG，照样内存溢出。
D：进入DEAD的线程，它还可以恢复，GC不会回收。

96、下列叙述中，错误的是（）
A.File类能够存储文件属性
B.File类能够读写文件
C.File类能够建立文件
D.File类能够获取文件目录信息
解析：File类能操作文件本身，但不能对文件内容进行修改

97、下面有关java object默认的基本方法，说法错误的是？
A.equals(Object obj) 指示某个其他对象是否与此对象“相等”
B.copy() 创建并返回此对象的一个副本
C.wait() 导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法
D.toString() 返回该对象的字符串表示
解析：Object中没有copy方法

98、非抽象类实现接口后，必须实现接口中的所有抽象方法，除了abstract外，方法头必须完全一致.
A.正确
B.错误
解析：
方法名相同，参数类型相同
子类返回类型小于等于父类方法返回类型，
子类抛出异常小于等于父类方法抛出异常，
子类访问权限大于等于父类方法访问权限。

99、实现或继承了Collection接口的是（）
A.Map
B.List
C.Vector
D.Iterator
E.Set
解析：答案：BCE

A，Map接口未实现Collection接口
B，List接口的定义为

public interface Listextends Collection

C，Vector定义为

public class Vectorextends AbstractListimplements List,RandomAccess, Cloneable, Serializable

Vector实现了List接口自然实现了Collection接口

D，Iterator接口未实现Collection接口
E，

public interface Setextends Collection
Set接口继承自Collection接口

100、Which statement declares a variable a which is suitable for referring to an array of 50 string objects?（Java）
A.char a[][];
B.String a[];
C.String[] a;
D.Object a[50];
E.String a[50];
F.Object a[];
解析： BCF
在java 中，声明一个数组时，不能直接限定数组长度，只有在创建实例化对象时，才能对给定数组长度.。
如下，1，2,3可以通过编译，4，5不行。而String是Object的子类，所以上述BCF均可定义一个存放50个String类型对象的数组。

String a[]=new String[50];
String b[];
char c[];
String d[50];
char e[50];

101、为Test类的一个无形式参数无返回值的方法method书写方法头，使得使用类名Test作为前缀就可以调用它，该方法头的形式为( )
A.static void method（）
B.public void method
C.protected void method（）
D.abstract void method（）
解析： A是静态方法，可以通过【类名.方法名】的形式调用，而不必去实例化一个对象进行方法的调用；
B是普通的public方法，必须先new一个对象出来，即实例化类，通过对象来调用方法；
C是protected方法，则只能在子类以及基类中调用该方法，其他的非继承基类的类，是不能有访问权限的；
D是抽象方法，抽象方法必须被抽象类的实现类来实现，这样通过实现类实例化来调用该方法才可以。

102、下列哪个类的声明是正确的？
A.abstract final class HI{}
B.abstract private move(){}
C.protected private number;
D.public abstract class Car{}
解析：类的声明的基本格式：
访问说明符 class 类名 extends 超类名 implements 接口名

A只能有final和abstract的一个，因为final是最终类，不能继承，必须可以创建实例，而abstract是抽象类，只能继承，不有实例。冲突了，所以不对。
B是抽象方法，不能有方法体。所以末尾不是{}而是；才对
C中访问修饰符只能有一个，而且对象没有类型。
D正确，这是抽象类。

103、Java中基本的编程单元为：
A.类
B.函数
C.变量
D.数据
解析：java的基本编程单元是类，基本存储单元是变量。

104、对于同一类中的两个方法 , 在判断它们是不是重载方法时 , 肯定不考虑（）
A.参数个数
B.参数类型
C.返回值类型
D.参数顺序
解析：判断函数重载，只需要看参数类型，参数个数，以及他们的排列组合（即参数类型的顺序）就可以了。

105、下面有关java final的基本规则，描述错误的是？
A.final修饰的类不能被继承
B.final修饰的成员变量只允许赋值一次，且只能在类方法赋值
C.final修饰的局部变量即为常量，只能赋值一次。
D.final修饰的方法不允许被子类覆盖
解析： final修饰的成员变量为基本数据类型是，在赋值之后无法改变。当final修饰的成员变量为引用数据类型时，在赋值后其指向地址无法改变，但是对象内容还是可以改变的。
final修饰的成员变量在赋值时可以有三种方式。1、在声明时直接赋值。2、在构造器中赋值。3、在初始代码块中进行赋值。

106、下列语句哪一个是不正确的（）
A.Log4j支持按分钟为间隔生成新的日志文件
B.Log4j是一个打印日志用的组件
C.Log4j支持按年为间隔生成新的日志文件
D.Log4j的日志打印级别可以在运行时重新设置
解析：日志的级别之间的大小关系如右所示：ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < OFF Log4j建议只使用四个级别，优先级从高到低分别是 ERROR > WARN > INFO > DEBUG。 log4j在运行期间是不可以重新设置的

107、java如何返回request范围内存在的对象？
A.request.getRequestURL()
B.request.getAttribute()
C.request.getParameter()
D.request.getWriter()
解析：request.getAttribute()方法返回request范围内存在的对象，而request.getParameter()方法是获取http提交过来的数据。getAttribute是返回对象,getParameter返回字符串。

108、Given:

public class IfTest{
    public static void main(string[]args){
        int x=3;
        int y=1;
        if(x=y)
            System.out.println(“Not equal”);
        else
            System.out.println(“Equal”);
     }
}

What is the result?
A.The output is “Equal”
B.The output in “Not Equal”
C.An error at line 5 causes compilation to fall.
D.The program executes but does not print a message.
解析：在java中的if…else…选择语句，if（这里只能写布尔类型的判断语句），改为x == y表示判断x与y是否相等，编译便能通过。

109、执行下面的程序段，语句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)
解析：对于for循环执行顺序的考点，当n=1时，执行1次，n=2时，执行1+2次，n=3时，执行1+2+3次，进行规律总结，当为n时，执行n(n+1)/2次。

110、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
解析：题目给出是在AccessViolationException异常触发后，运行的结果，所以应该从catch开始运行，得到error2和error3.
1.若catch(){}块中，如果有throw 语句，则，try{}catch(){} finally{}块之外的代码不执行；否则，执行。 2.try{}中有异常，则异常下面代码不执行。 3.finally{}中代码必执行。

111、关于抽象类与最终类，下列说法错误的是？
A.抽象类能被继承，最终类只能被实例化。
B.抽象类和最终类都可以被声明使用
C.抽象类中可以没有抽象方法，最终类中可以没有最终方法
D.抽象类和最终类被继承时，方法可以被子类覆盖
解析：

1，抽象类中可以有抽象方法，也可以没有抽象方法。
2，抽象类当然可以被继承，因为它就是用来继承的，
3，继承抽象类，若有抽象方法，则子类必须将其抽象方法实现，
4，抽象类中的非抽象方法可以被重写。

最终类和抽象类正好相反
5，加上final的类就叫最终类，加上final的方法就叫最终方法，
6，最终类中可以有最终方法也可以没有
7，最终类不能有子类，最终方法不能被重写

112、在一个基于分布式的游戏服务器系统中，不同的服务器之间，哪种通信方式是不可行的（）？
A.管道
B.消息队列
C.高速缓存数据库
D.套接字
解析：对于管道，有下面这几种类型：
①普通管道（PIPE）：通常有两种限制，一是单工，即只能单向传输；二是血缘，即常用于父子进程间（或有血缘关系的进程间）。
②流管道（s_pipe）：去除了上述的第一种限制，实现了双向传输。
③命名管道（name_pipe）：去除了上述的第二种限制，实现了无血缘关系的不同进程间通信。
显然，要求是对于不同的服务器之间的通信，是要要求全双工形式的，而管道只能是半双工，虽然可以双向，但是同一时间只能有一个方向传输，全双工和半双工的区别可以如下图示理解：

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

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

A.-7
B.-3
C.编译错误
D.-5
解析： 1.先执行括号中的i++ 在执行i++的时候 Java会将i先存放到一个临时变量中去并返回该临时变量的值（假设为temp）
2.所以这句可以拆成 temp = i （值为-5）并返回temp的值然后 i自加1 此时 i 的值为-4 但是之后执行就会出现问题由于返回了temp的值继续执行的表达式为 i = ++(-5); 单目运算符无法后跟一个字面量所以在IDEA编辑器中提示Variable expected（此处应为变量）故选择C选项

114、给定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选项是静态包含，相当于不include2.jsp页面内容拷贝到此处，因此可以输出User属性值
D选项是转发重定向，转发的时候pageContent内的属性值不能被传递，因此得不到User属性值

115、What is displayed when the following is executed;

double d1=-0.5;
System.out.println("Ceil d1="+Math.ceil(d1));
System.out.println("floor d1="+Math.floor(d1));

A.Ceil d1=-0.0
floor d1=-1.0
B.Ceil d1=0.0
floor d1=-1.0
C.Ceil d1=-0.0
floor d1=-0.0
D.Ceil d1=0.0
floor d1=0.0
E.Ceil d1=0
floor d1=-1
解析：Math.ceil(d1):大于等于 x，并且与它最接近的整数。
ceil 方法上有这么一段注释：如果参数小于0且大于-1.0，结果为 -0。
1Math.floor(d1)：小于等于 x，且与 x 最接近的整数。
ceil 和 floor 方法上都有一句话：意思为：如果参数是 NaN、无穷、正 0、负 0，那么结果与参数相同，如果是 -0.0，那么其结果是 -0.0 。

116、在创建派生类对象，构造函数的执行顺序（）
A.基类构造函数，派生类对象成员构造函数，派生类本身的构造函数
B.派生类本身的构造函数，基类构造函数，对象成员构造函数
C.基类构造函数，派生类本身的构造函数，派生类对象成员构造函数
D.对象成员构造函数，基类构造函数，派生类本身的构造函数
解析：类的初始化过程也就是方法执行的过程。
父类的静态域----子类的静态域父类的非静态域----父类的构造函数子类的非静态域----子类的构造函数
规律就是父类先于子类静态的先于非静态的
其中静态域包含静态代码块与静态方法，这个谁在前面，则先执行谁。
非静态域同理

117、 Java 多线程有几种实现方法？（）
A.继承Thread类
B.实现Runnable接口
C.实现Thread接口
D.以上都不正确
解析：
实现多线程的方法：
1.继承Thread类
2.实现Runnable接口
3.实现Callable接口,然后使用 FutureTask包装，因为Callable接口没有实现Runnable接口不能做为Thread的target，而FutureTask是在Java程序中可以取消的异步运算，有可以开始，取消运算，查询运算是否结束，获得查询结果的功能，特别注意的是，如果查询结果时，运算还没完成则会阻塞线程。
4.使用，java.util.current.ThreadPoolExecutor来获取线程，执行多线程

118、在java中重写方法应遵循规则的包括（）
A.访问修饰符的限制一定要大于被重写方法的访问修饰符
B.可以有不同的访问修饰符
C.参数列表必须完全与被重写的方法相同
D.必须具有不同的参数列表
解析：
方法重写要注意的事项：
1.方法重写时，方法名与形参列表必须一致。
2.方法重写时，子类的权限修饰符必须要大于或者等于父类的权限修饰符。
3.方法重写时，子类的返回值类型必须要小于或者等于父类的返回值类型。
4.方法重写时，子类抛出的异常类型要小于或者等于父类抛出的异常类型。
Exception(大)
RuntimeException(小)

119、 Hashtable 和 HashMap 的区别是：
A.Hashtable 是一个哈希表，该类继承了 AbstractMap，实现了 Map 接口
B.HashMap 是内部基于哈希表实现，该类继承AbstractMap，实现Map接口
C.Hashtable 线程安全的，而 HashMap 是线程不安全的
D.Properties 类继承了 Hashtable 类，而 Hashtable 类则继承Dictionary 类
E.HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。
解析： Hashtable：
（1）Hashtable 是一个散列表，它存储的内容是键值对(key-value)映射。
（2）Hashtable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为null。
（3）HashTable直接使用对象的hashCode。
HashMap：
（1）由数组+链表组成的，基于哈希表的Map实现，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的。
（2）不是线程安全的，HashMap可以接受为null的键(key)和值(value)。
（3）HashMap重新计算hash值

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

121、下面关于继承的描述正确的是
A.在Java中类只允许单一继承
B.在Java中一个类只能实现一个接1D
C.在Java中一个类不能同时继承一个类和实现一个接口.
D.Java的单一继承使代码不可靠
解析：
A. 类支持单根继承，接口支持多继承
B.类可以实现多接口
C.一个类能同时继承一个类和实现一个接口
D.单一继承使得代码更可靠

122、现有一变量声明为 boolean aa; 下面赋值语句中正确的是（）
A、aa=false;
B、aa=False;
C、aa=“true”;
D、aa=0;
解析：boolean类型的变量的默认值是false

123、在 Java 中，存放字符串常量的对象属于（）类对象。
A、Character
B、String
C、StringBuffer
D、Vector
解析：
Character 字符封装类
String 常量池中字符串
StringBuffer 存放字符数组
Vector 数组

124、对于java类型变量char c,short s,float f,double d,表达式c*s+f+d的结果类型为（）
A、float
B、char
C、short
D、double
解析:
自动类型转换遵循下面的规则：
1.若参与运算的数据类型不同，则先转换成同一类型，然后进行运算。
2.转换按数据长度增加的方向进行，以保证精度不降低。例如int型和long型运算时，先把int量转成long型后再进行运算。
3.所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算。
4.char型和short型参与运算时，必须先转换成int型。
5.在赋值运算中，赋值号两边的数据类型不同时，需要把右边表达式的类型将转换为左边变量的类型。如果右边表达式的数据类型长度比左边长时，将丢失一部分数据，这样会降低精度。
往精度高的转

125、下列代码编译和运行的结果是：（）

public class Threads4{
 public static void main(String[] args){
 new Threads4().go();
 }
 public void go(){
 Runnable r=new Runnable(){
 public void run(){
 System.out.print("foo");
 }
 };
 Thread t=new Thread(r);
 t.start();
 }
 }

A、编译错误
B、抛出运行时异常
C、输出：foo
D、代码正常运行，但是无输出

解析：
在java多线程中实现多线程的方式有两种①extends Thread ②implements Runnable。这两种情况是我们最常见的，还有一种是由第二种变形而来的直接new Runnable(){}，我们都知道java的接口是不可以实例化的，但代码中的new Runnable(){xxx}确是实例化了，为什么？接口和抽象类不可以实例化是对的，这个是java语法规范来的，而new Runnable(){}其实不是实例化Runnable接口来的，实际上一种内部类的一种简写 在这里：
①首先构造了一个”implements Runnable “的无名local内部类(方法内的内部类)
②然后构造了这个无名local内部类的一个实例
③然后用Runnable来表示这个无名local内部类的type(OO多态)。例如上面这段代码编译后你会看到其实是编译了两个类来的，如下：
其中Text2$1就是无名local内部内类，这个也就很好地解释了为什么在main（）方法中new Runnable(){xxx}里面的调用main()方法中的变量的时候要用final关键字来修饰

126、在try的括号里面有return一个值，那在哪里执行finally里的代码？
A、不执行finally代码
B、return前执行
C、return后执行
解析：
https://www.ibm.com/developerworks/cn/java/j-lo-finally/
关于 try return finally 的详细解释文档

127、以下程序的执行结果是：

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

A、ABDCBDCB
B、ABCDABCD
C、编译时出错
D、运行时抛出异常
解析：for循环的考察，调用foo函数，打印相应的值然后并返回ture,执行顺序为:foo(‘A’),foo("B)&&(i<2),{i++;foo(‘D’)},foo(‘C’),(第一遍循环后，i = 1);
foo("B)&&(i<2),{i++;foo(‘D’)},foo(‘C’)(第二遍循环后，i = 2);
foo("B)&&(i<2),i !< 2,跳出循环。
结果为：ABDCBDCB

128、下面哪个方法与Applet的显示无关？
A、draw
B、paint
C、repaint
D、update
解析：
这题，应该选draw。
Applet显示相关的方法主要有3个。

paint(Graphicsg)方法，具体执行Applet的绘制。
update(Graphicsg)()方法，主要用于更新Applet的显示。
repaint()方法，主要用于Applet的重新显示，它调用update()方法实现对Applet的更新。
而draw()方法与显示无关，故选A draw

129、java8中，下面哪个类用到了解决哈希冲突的开放定址法
A、LinkedHashSet
B、HashMap
C、ThreadLocal
D、TreeMap
解析：
threadlocalmap使用开放定址法解决hash冲突，hashmap使用链地址法解决hash冲突

130、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
解析：java多态。执行对象实例化过程中遵循多态特性 ==> 调用的方法都是将要实例化的子类中的重写方法，只有明确调用了super.xxx关键词或者是子类中没有该方法时，才会去调用父类相同的同名方法。
（重点理解）

131、在 hibernate 开发中，关于 POJO 类对象的状态说法正确的是（）。
A、自由状态（Transient）：实体在内存中自由存在，与数据库中的记录无关
B、持久状态（Persistent）：实体处于由Hibernate框架所管理的状态，对应了数据库中的一条记录，同时与某个session实例发生了关联
C、游离状态（Detached）：在session 关闭之后,可以使对象从持久状态转换到游离状态。
D、不能将对象从游离状态转换成持久态

解析：
Hibernate Pojo的三态分别为transient（瞬时态）,persistent（持久态）,detached（游离态）

1、官方给出的三态与Session的关系如下：
transient: never persistent, not associated with any Session
persistent: associated with a unique Session
detached: previously persistent, not associated with any Session

2、三种状态间相互转换关系，及他们在数据库、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维持原态，但内容会被更新到数据库

132、用户不能调用构造方法，只能通过new关键字自动调用。（）
A、正确
B、错误
解析：
选B。

在类内部可以用户可以使用关键字this.(args)调用（参数决定调用的是本类对应的构造方法）
在子类中用户可以通过关键字super.(args)调用（参数决定调用的是父类对应的构造方法）。
反射机制对于任意一个类，都能够知道这个类的所有属性和方法，包括类的构造方法。

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

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。
包的作用

1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

134、表达式(short)10/10.2*2运算后结果是什么类型？
A、short
B、int
C、double
D、float
解析：
强制类型转换的优先级高于+ - * /
首先，要注意是(short)10/10.22，而不是(short) (10/10.22)，前者只是把10强转为short，又由于式子中存在浮点数，所以会对结果值进行一个自动类型的提升，浮点数默认为double，所以答案是double；后者是把计算完之后值强转short。

135、以下程序的输出结果为

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、编译错误
解析：子类构造方法在调用时必须先调用父类的，由于父类没有无参构造，必须在子类中显式调用，修改子类构造方法如下即可：

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

136、以下哪种JAVA的变量表达式使得变量a和变量b具有相同的内存引用地址( )
A、String a = “hello”; String b = “hello”;
B、Integer a; Integer b = a;
C、int a = 1; Integer b = new Integer(1);
D、int a = 1; Integer b = 1;
解析：
内存引用地址，是指栈中存放的地址，来指向堆中的某个位置。
int 是基本类型，数据直接存放在栈中，不存在内存引用地址的说法
A对指向常量池里的"hello"。
B对题中没说声明的a是局部变量。
C错 int a =1;并不指向堆中，它只有值，没有引用地址，Integer b =new Integer(1);指向堆中地址为1的位置。
D错原因同C

137、ArrayLists和LinkedList的区别，下述说法正确的有？
A、ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
B、对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
C、对于新增和删除操作add和remove，LinkedList比较占优势，因为ArrayList要移动数据。
D、ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间。

138、Java.Thread的方法resume()负责重新开始被以下哪个方法中断的线程的执行（）。
A、stop
B、sleep
C、wait
D、suspend
解析：
suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的 resume() 被调用，才能使得线程重新进入可执行状态。

139、 Given the following code:
import EnclosingOne.InsideOne

1.class Enclosingone
2.{
3.    public class InsideOne {}
4.
5.}
6.public class inertest
7.{
8.    public static void main(string[]args)
9.    {
10.        EnclosingOne eo = new EnclosingOne();
11.        //insert code here
12.    }
13.
14.}

Which statement at line 11 constructs an instance of the inner class?
A、InsideOne ei=eo.new InsideOne();
B、eo.InsideOne ei=eo.new InsideOne();
C、InsideOne ei=EnclosingOne.new InsideOne();
D、EnclosingOne.InsideOne ei=eo.new InsideOne();
解析：
对于A答案主要在开头添加 import EnclosingOne.Insider这一句，不然的话A肯定是错误，其他类不能够直接引用内部类的

140、下面哪些类可以被继承？ Java.lang.Thread、java.lang.Number、java.lang.Double、java.lang.Math、 java.lang.ClassLoader
A、Thread
B、Number
C、Double
D、Math
E、ClassLoader
解析：
答案：ABE
A，Thread可以被继承，用于创建新的线程
B，Number类可以被继承，Integer，Float，Double等都继承自Number类
C，Double类的声明为
public final class Doubleextends Numberimplements Comparable
final生明的类不能被继承
D，Math类的声明为
public final class Mathextends Object
不能被继承
E，ClassLoader可以被继承，用户可以自定义类加载器

141、下列对接口的说法，正确的是( )
A、接口与抽象类是相同的概念
B、若要实现一个接口为普通类则必须实现接口的所有抽象方法
C、接口之间不能有继承关系
D、一个类只能实现一个接口
解析：
A 接口与抽象类是不同的概念。抽象类是用于捕捉子类的通用特性，接口是抽象方法的集合；
B 实现接口必须实现接口的所有方法；
C 接口可以继承一个或多个接口，抽象类只能继承一个类或者实现多个接口；
D 一个类只能继承一个类，但是可以实现多个接口。

142、以下关于Integer与int的区别错误的是
A、int是java提供的8种原始数据类型之一
B、Integer是java为int提供的封装类
C、int的默认值为0
D、Integer的默认值为1
解析：
int 是八大基本数据类型之一（byte,char,short,int,long,float,double,boolean）
Integer 是 int 包装类;
int是基本数据类型，默认值为0,
Integer 是类，默认值为null；
Integer 表示的是对象，用一个引用指向这个对象,
int是基本数据类型，直接存储数值。

143、下列外部类定义中，不正确的是：（）
A、class x { … }
B、class x extends y { … }
C、static class x implements y1,y2 { … }
D、public class x extends Applet { … }
解析：static修饰的为类成员,会随着类的加载而加载,比如静态代码块,静态成员,静态方法(这里只是加载,并没有调用)等等,可以想象一下,如果把一个Class文件中的外部类设为static,目的难道是让这个类随着应用的启动而加载吗？如果在这次使用过程中根本没有使用过这个类,那么是不是就会浪费内存。这样来说设计不合理,总而言之,设计不合理的地方,Java是不会让它存在的。
而为什么内部类可以使用static修饰呢,因为内部类算是类的成员了,如果没有使用静态来修饰,那么在创建内部类的时候就需要先有一个外部类的对象,如果我们一直在使用内部类,那么内存中就会一直存在外部类的引用,而我们有时候只需要使用内部类,不需要外部类,那么还是会浪费内存,甚至会造成内存溢出。使用static修饰内部类之后,内部类在创建对象时就不需要有外部类对象的引用了。
最终结论就是:static可以用来修饰内部类,但是不可以用来修饰外部类

144、关于Float，下列说法错误的是()
A、Float是一个类
B、Float在java.lang包中
C、Float a=1.0是正确的赋值方法
D、Float a= new Float(1.0)是正确的赋值方法
解析： Float a = new Float(1.0); 这个的东西能存在，是因为Float类中有形参是float和double的两个构造器。
Double d = new Double(1.0F);这个能成立的原因是float向上转型了。
Float a = 1.0；这个东西不成立是因为浮点型的默认类型是double，而double不会自动转成float，然后再装箱。
Double d = 1.0f；不成立的原因是因为Double类中的装箱方法，只有valueOf(String s)和valueOf(double d)；装箱本身可不会自动向上转型啊。

145、选项中哪一行代码可以替换 //add code here 而不产生编译错误

public abstract class MyClass {
     public int constInt = 5;
     //add code here
     public void method() {
     }

A、public abstract void method(int a);
B、consInt=constInt+5;
C、public int method();
D、public abstract void anotherMethod(){}
解析： A是抽象方法，抽象类可以包含抽象方法，也可以不包含，实现重载。（√）
B 在类中不能constInt = constInt + 5（×）
C 返回值不能作为重载的依据（×）
D 有方法体的不能作为抽象函数（×）

146、如果一个接口Cup有个方法use()，有个类SmallCup实现接口Cup，则在类SmallCup中正确的是？ ( )
A、void use() { …}
B、protected void use() { …}
C、public void use() { …}
D、以上语句都可以用在类SmallCup中
解析：既然是实现接口，就要实现接口的所以方法，相当于重写方法，方法的重写需要满足：三同一大一小（方法名、返回值类型、形参相同；访问权限>=重写前；抛出异常<=重写前）

147、当编译并运行下面程序时会发生什么结果（）

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

对于线程而言，start是让线程从new变成runnable。run方法才是执行体的入口。
但是在Thread中，run方法是个空方法，没有具体实现。
Bground继承了Thread，但是没有重写run方法，那么调用run方法肯定是无输出。

148、下列在Java语言中关于数据类型和包装类的说法，正确的是（）
A、基本（简单）数据类型是包装类的简写形式，可以用包装类替代基本（简单）数据类型
B、long和double都占了64位（64bit）的存储空间。
C、默认的整数数据类型是int，默认的浮点数据类型是float。
D、和包装类一样，基本（简单）数据类型声明的变量中也具有静态方法，用来完成进制转化等。
解析：
A，包装和基本类型不是同一个概念
B，
long和double都占了64位（64bit）的存储空间
C，默认的浮点数据类型是double，如果要指明使用float，则需要在后面加f
D，基本数据类型是没有静态方法的，但是基本数据类型的包装类却有

149、下列代码输出结果为（）

class Animal{
    public void move(){
        System.out.println("动物可以移动");
    }
}
class Dog extends Animal{
    public void move(){
        System.out.println("狗可以跑和走");
    }
    public void bark(){
        System.out.println("狗可以吠叫");
    }
}
public class TestDog{
    public static void main(String args[]){
        Animal a = new Animal();
        Animal b = new Dog(); 
        a.move();
        b.move();
        b.bark();
    }
}

A、动物可以移动
狗可以跑和走
狗可以吠叫
B、动物可以移动
动物可以移动
狗可以吠叫
C、运行错误
D、编译错误
解析：编译看左边，运行看右边。父类型引用指向子类型对象，无法调用只在子类型里定义的方法

150、关于java中的数组，下面的一些描述，哪些描述是准确的：（）
A、数组是一个对象，不同类型的数组具有不同的类
B、数组长度是可以动态调整的
C、数组是一个连续的存储结构
D、一个固定长度的数组可类似这样定义：int array[100]
E、两个数组用Object 里equals方法比较时，会逐个遍历其中的元素，对每个元素进行比较
F、java中不存在 int *a这样的东西做数组的形参
解析：数组a.equals(数组b)，调用的equals方法为Object的，比较的是地址，相当于==，Arrays的equals方法是逐个元素比较。Arrays的equals方法只对基本数据类型逐个比较，其余类型需要重写

151、以下类定义中的错误是什么？（）

abstract class xy
{
    abstract sum (int x, int y) { }
}

A、没有错误
B、类标题未正确定义
C、方法没有正确定义
D、没有定义构造函数
解析：
1、抽象方法不能有方法体，这是规定
2、该方法缺少返回值，只有构造没有返回值

152、给定以下方法声明，调用执行mystery（1234）的输出结果？

//precondition:  x >=0
public void mystery (int x)
{
System.out.print(x % 10);

if ((x / 10) != 0)
{
mystery(x / 10);
}
System.out.print(x % 10);
}

A、1441
B、43211234
C、3443
D、12344321
解析：
这个题目是考递归，总共调用了4次mystery方法，注意：程序是从上往下执行的，所以当一个方法，调用另一个或本方法时，程序会等调用完毕以后在接着执行
1.第一次调用mystery方法，此时参数（x）为1234,进入第四行，x不变为x=1234，1234%10=4,输出 4

2.接着进入if语句，1234/10=123 !=0,进入if语句，此时x还是1234,接着第二次调用mystery方法（此时第一次调用的方法不会继续执行，会等第二次（本次）调用的方法执行完毕后继续执行），mystery(x/10),传入的参数(x)为123,然后第四行123%10=3,参数还是不变为123，输出 3

3.接着进入if语句，第三次调用mystery()方法（此时第二次调用的方法不会继续执行，会等第三次（本次）调用的方法执行完毕后继续执行），传入参数为123/10=12, x=12,接着第四行12%10=2，传入的参数值不会变，输出 2

4.然后进入if语句12/10!=0,第四次调用mystery()方法（此时第三次调用的方法不会继续执行，会等第四次调用的方法（本次）执行完毕后继续执行），传入的参数（x=1）为1，进入第四行1%10，输出 1

5.然后进入if语句1/10=0不满足if语句x/10 != 0,所以本次不会继续调用mystery方法，然后程序继续执行调用下面的输出参数为1，1%10，输出 1
6.然后第四次调用的方法执行结束然后返回第三次调用的方法继续执行，调用下面的输出，参数为12,x%10=2，输出 2

7.然后第三次调用的方法执行结束然后返回第二次调用的方法继续执行，此时调用下面的输出，参数为123,x%10=3,输出 3

8.最后第二次调用的方法执行结束然后回第一次调用的方法继续执行，此时调用下面的输出，参数为1234,x%10=4,输出 4

9.第一次调用方法结束

153、执行如下代码段后，变量s1引用的字符串值是( )。

 String s1 = "ABCD";

String s2 = "1234";

System.out.println(s1 + s2);

A、ABCD
B、1234
C、ABCD1234
D、1234ABCD
解析：
String 是不可变类型，是存储在常量字符区的，所以答案是ABCD。
System.out.println(s1 + s2)是创建了一个新的字符串。

154、命令javac-d参数的用途是？（）
A、指定编译后类层次的根目录
B、指定编译时需要依赖类的路径
C、指定编译时的编码
D、没有这一个参数
解析：
155、程序读入用户输入的一个值，要求创建一个自定义的异常，如果输入值大于 10 ，使用 throw 语句显式地引发异常，异常输出信息为 ”something’swrong!” ，语句为（）
A、if(i>10)throw new Exception(“something’swrong!”);
B、if(i>10)throw Exception e(“something’swrong!”);
C、if(i>10) throw new Exception e(“something’swrong!”);
D、if(i>10)throw Exception( “something’swrong!”);

解析：throw是语句抛出异常，有两种用法: //***抛出异常e实例或新的Exception实例1.catch中的throw e; 2.方法体中的throw new Exception(); 区别如下: throw e是将已经catch到的e重新抛出，而throw new Exception()是重新生成一个Exception类的对象并抛出。有两点重要区别，第一e中记录了原异常的信息，如除零异常的信息，而new Exception()是一个新对象，当中不包含任何有用的信息；第二e可能存在向上转型，即e的实际类型可能是Exception的子类，而new Exception()就是Exception类的对象。

156、设m和都是int类型,那么以下for循环语句的执行情况是( )

for (m = 0, n = -1; n = 0; m++, n++)
n++;

A、循环体一次也不执行循环体执行一次是无限循环有限次循环循环结束判断条件不合法运行出错
B、循环体执行一次是无限循环
C、有限次循环
D、循环结束判断条件不合法
解析：for 循环的结束判定条件是 boolean型 n = 0 是 int 类型会有编译异常

157、What results from the following code fragment?

int i = 5;
int j = 10;
System.out.println(i + ~j);

A、Compilation error because”~”doesn’t operate on integers
B、-5
C、-6
D、15
解析：公式-n= ~ n+1可推出 ~ n=-n-1，所以~10=-11再加5结果为-6

158、what is the result of the following code?

enum AccountType
{
    SAVING, FIXED, CURRENT;
    private AccountType()
    {
        System.out.println(“It is a account type”);
    }
}
class EnumOne
{
    public static void main(String[]args)
    {
        System.out.println(AccountType.FIXED);
    }
}

A、Compiles fine and output is prints”It is a account type”once followed by”FIXED”
B、Compiles fine and output is prints”It is a account type”twice followed by”FIXED”
C、Compiles fine and output is prints”It is a account type”thrice followed by”FIXED”
D、Compiles fine and output is prints”It is a account type”four times followed by”FIXED”
解析：枚举类有三个实例，故调用三次构造方法，打印三次It is a account type

159、在Java中，对于不再使用的内存资源，如调用完成的方法，“垃圾回收器”会自动将其释放。（）
A、正确
B、错误
解析：
JVM 内存可简单分为三个区：

1、堆区（heap）：用于存放所有对象，是线程共享的（注：数组也属于对象）

2、栈区（stack）：用于存放基本数据类型的数据和对象的引用，是线程私有的（分为：虚拟机栈和本地方法栈）

3、方法区（method）：用于存放类信息、常量、静态变量、编译后的字节码等，是线程共享的（也被称为非堆，即 None-Heap）

Java 的垃圾回收器（GC）主要针对堆区

160、下面几个关于Java里queue的说法哪些是正确的（）？
A、LinkedBlockingQueue是一个可选有界队列，不允许null值
B、PriorityQueue，LinkedBlockingQueue都是线程不安全的
C、PriorityQueue是一个无界队列，不允许null值，入队和出队的时间复杂度是O（log(n)）
D、PriorityQueue，ConcurrentLinkedQueue都遵循FIFO原则
解析：A、LinkedBlockingQueue是一个基于节点链接的可选是否有界的阻塞队列，不允许null值。
B、LinkedBlockingQueue是一个线程安全的阻塞队列，实现了先进先出等特性。
C、PriorityQueue是一个队列，不允许null值，入队和出队的时间复杂度是O（log(n)）。
D、PriorityQueue是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。ConcurrentLinkedQueue是一个基于链接节点的线程安全队列，该队列的元素遵循FIFO原则。

161、 java7后关键字 switch 支不支持字符串作为条件：（）
A、支持
B、不支持
解析： switch(exp)，在JDK7之前，只能是byte、short、char、int或者对应的包装类，或者枚举常量（内部也是由整型或字符类型实现）。
为什么必须是这些呢，因为其实exp只是对int型支持的，其他都是因为可以自动拆卸或者自动向上转型到int，所以才可以。
到了JDK7的时候，String被引入了，为什么String能被引入呢？
其实本质上还是对int类型值得匹配。
原理如下，通过对case后面得String对象调用hashCode方法，得到一个int类型得hash值，然后用这个hash值来唯一标识这个case。那么当匹配时，首先调用exp的hashCode，得到exp的hash值，用这个hash值来匹配所有case，如果没有匹配成功，就说明不存在；如果匹配成功了，接着会调用字符串的equals方法进行匹配。（hash值一致，equals可不一定返回的就是true）。
所以，exp不能为null，cas子句使用的字符串也不能为null，不然会出现空指针异常。

162、以下哪项不是java基础类型（）
A、int
B、boolean
C、String
D、float
解析：String是类

163、下面的输出结果是:


	
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、我是父类
我是父类
我是父类

164、假设一个 list初始化为{2，9，5，4，8，1}。在第一次冒泡排序后，list变成了（）?
A、2, 9, 5, 4, 8, 1
B、2, 9, 5, 4, 1, 8
C、2, 5, 9, 4, 8, 1
D、2, 5, 4, 8, 1, 9
解析：冒泡排序：相邻两个元素进行比较，如果第i - 1个大于第i个，则将第i - 1 个与第 i 个交换位置。

165、HashMap的数据结构是怎样的？
A、数组
B、链表
C、数组+链表
D、二叉树
解析：HashMap 由数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的。JDK8及其以后版本，HashMap的数据结构是数组+链表/红黑树

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

public class Example{
    String str=new String("hello");
    char[]ch={'a','b'};
    public static void main(String args[]){
        Example ex=new Example();
        ex.change(ex.str,ex.ch);
        System.out.print(ex.str+" and ");
        System.out.print(ex.ch);
    }
    public void change(String str,char ch[]){
        str="test ok";
        ch[0]='c';
    }
}

A、hello and ab
B、hello and cb
C、hello and a
D、test ok and ab
E、test ok and cb
F、test ok and c
解析：String类不可改变，change函数中对形参str进行值传递，相当于新创建了一个字符串对象，并没有改变实参的值。

167、给定以下JAVA代码，这段代码运行后输出的结果是()

public class Test
{
    public static int aMethod(int i)throws Exception
    {
        try{
            return i / 10;
        }
        catch (Exception ex)
        {
            throw new Exception("exception in a Method");
        } finally{
            System.out.printf("finally");
        }
    }

    public static void main(String [] args)
    {
        try
        {
            aMethod(0);
        }
        catch (Exception ex)
        {
            System.out.printf("exception in main");
        }
        System.out.printf("finished");
    }
}

A、exception in main finished
B、finally finished
C、exception in main finally
D、finally exception in main finished
解析： i / 10;无论i是多少，永远不会抛出异常，所以catch语句不会执行。
而finally语句是必定执行的语句。
所以先指向aMathod()的finally代码块，输出finally
然后执行main()方法的最后一条输出语句，输出finished

168、有如下4条语句：()

Integer i01=59;
int i02=59;
Integer i03=Integer.valueOf(59);
Integer i04=new Integer(59);

以下输出结果为false的是:
A、System.out.println(i01i02);
B、System.out.println(i01i03);
C、System.out.println(i03i04);==
D、System.out.println(i02==i04);
解析：

169、下面关于垃圾收集的说法正确的是

A、一旦一个对象成为垃圾，就立刻被收集掉。
B、对象空间被收集掉之后，会执行该对象的finalize方法
C、finalize方法和C++的析构函数是完全一回事情
D、一个对象成为垃圾是因为不再有引用指着它，但是线程并非如此
解析：

170、Java的跨平台特性是指它的源代码可以在多个平台运行。（）

A、正确
B、错误
解析：java的跨平台特性是因为JVM的存在，它可以执行.class字节码文件，而不是.java源代码

171、下面有关jdbc statement的说法错误的是？

A、JDBC提供了Statement、PreparedStatement 和 CallableStatement三种方式来执行查询语句，其中 Statement 用于通用查询， PreparedStatement 用于执行参数化查询，而 CallableStatement则是用于存储过程
B、对于PreparedStatement来说，数据库可以使用已经编译过及定义好的执行计划，由于 PreparedStatement 对象已预编译过，所以其执行速度要快于 Statement 对象”
C、PreparedStatement中，“?” 叫做占位符，一个占位符可以有一个或者多个值
D、PreparedStatement可以阻止常见的SQL注入式攻击
解析：

172、JAVA中，下列语句哪一个正确（）

A、class中的constructor不可省略
B、constructor必须与class同名，但方法不能与class同名
C、constructor在一个对象被new时执行
D、一个class只能定义一个constructor

解析： A 省略构造函数,编译器会自动生成。
D 构造函数可以重载
B 方法是可以和类名同名的，和构造方法唯一的区别就是，构造方法没有返回值。

173、下列说法正确的是

A、在类方法中可用this来调用本类的类方法
B、在类方法中调用本类的类方法可直接调用
C、在类方法中只能调用本类的类方法
D、在类方法中绝对不能调用实例方法
解析：

在类方法中调用本类的类方法可直接调用。实例方法也叫做对象方法。

类方法是属于整个类的，而实例方法是属于类的某个对象的。
由于类方法是属于整个类的，并不属于类的哪个对象，所以类方法的方法体中不能有与类的对象有关的内容。即类方法体有如下限制：
(1) 类方法中不能引用对象变量；
(2) 类方法中不能调用类的对象方法；
(3) 在类方法中不能使用super、this关键字。
(4)类方法不能被覆盖。
如果违反这些限制，就会导致程序编译错误。
与类方法相比，对象方法几乎没有什么限制：
(1) 对象方法中可以引用对象变量，也可以引用类变量；
(2) 对象方法中可以调用类方法；
(3) 对象方法中可以使用super、this关键字。

174、关于Java的抽象类、接口，以下描述错误的是？

A、抽象类不一定含有抽象方法，接口中的方法都是抽象方法
B、一个类只能继承一个抽象类，但可以实现多个接口；一个接口可以继承多个接口
C、抽象类和接口中的方法都没有方法体
D、抽象类可以含有私有成员变量，接口不含有私有成员变量
解析：
A----------抽象类不一定含有抽象方法，接口中的方法都是抽象方法。
接口中的方法默认修饰符有public abstract。
B----------一个类只能继承一个一个抽象类，但可以实现多个接口；一个接口可以继承多个接口。
Java里类是单继承的，接口是可以多继承的，用关键字extends。
C----------抽象类和接口中的方法都没有方法体。
抽象类中的方法是可以有方法体的。JDK1.8之后，接口中的方法也可以有方法体，用default关键字修饰方法。
D----------抽象类可以含有私有成员变量，接口不含有私有成员变量。
接口中的成员变量都是public static final的，一般用作常量。

175、内部类（也叫成员内部类）可以有4种访问权限。（）

A、正确
B、错误

解析：

176、下列代码的执行结果是（）

public class Test {

    public static int a = 1;

    public static void main(String[] args) {

        int a = 10;

        a++; Test.a++;

        Test t=new Test();

        System.out.println("a=" + a + " t.a=" + t.a);

    }

}

A、a=10 t.a=3
B、a=11 t.a=2
C、a=12 t.a=1
D、a=11 t.a=1
解析：值为1的a属于类变量也叫作成员变量，值为10的a是局部变量首先a＋＋时就近原则，用局部变量10来加，Text.a直接用类名调用成员变量的情况，只能是static 修饰的成员变量1来加，然后又实例化了对象，在输出中第一个a＝用就近原则输出11，第二个t.a 对象只能调用类变量输出2

177、用命令方式运行以下代码的运行结果是（）

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
解析：运行java命令,没有T11对应的类,会报找不到或者无法加载主类。

178、以下哪项可能包含菜单条（）

A、Panel
B、Frame
C、Applet
D、Dialog
解析：
Frame是Window的直接子类，一个Frame对象就是一个有标题有边界的顶层窗口；
Panel是Container的直接子类，一个Panel对象用来添加组件和其他Panel对象的容器。

179、问这个程序的输出结果。

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、编译不通过
解析：
Base base = new Son();
这句new 了一个派生类，赋值给基类，所以下面的操作编译器认为base对象就是Base类型的
Base类中不存在methodB()方法，所以编译不通过

180、假设 a 是一个由线程 1 和线程 2 共享的初始值为 0 的全局变量，则线程 1 和线程 2 同时执行下面的代码，最终 a 的结果不可能是（）

boolean isOdd = false;
for(int i=1;i<=2;++i)
{
if（i%2==1）isOdd = true；
else isOdd = false；
a+=i*(isOdd?1:-1)；
}

A、-1
B、-2
C、0
D、1
解析：线程问题。

181、以下代码的输出结果是？

public class B
{
    public static B t1 = new B();
    public static B t2 = new B();
    {
        System.out.println("构造块");
    }
    static
    {
        System.out.println("静态块");
    }
    public static void main(String[] args)
    {
        B t = new B();
    }
}

A、静态块构造块构造块构造块
B、构造块静态块构造块构造块
C、构造块构造块静态块构造块
D、构造块构造块构造块静态块
解析：

182、检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果

package algorithms.com.guan.javajicu;  
public class Inc {  
    public static void main(String[] args) {  
       Inc inc = new Inc();  
       int i = 0;  
       inc.fermin(i);  
       i= i ++;  
       System.out.println(i); 
   
    }  
    void fermin(int i){  
       i++;  
    }  
}

A、0
B、1
C、2
D、3
解析：

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

A、java.util.ConcurrentHashMap
B、java.util.Map
C、java.util.TreeMap
D、java.util.SortMap
E、java.util.Hashtable
F、java.util.HashMap
解析：

先说HashMap和HashTable的区别
最开始的时候只有HashMap和HashTable，他们最重要的区别就是HashMap不是线程安全的，而HashTable是线程安全的；他们的具体区别如下：
①:他们的继承是不同的，HashMap继承的是 AbstractMap，而HashTable继承的是Dictionary 类；
②:他们存储的键值对有些区别；HashMap的键能有一个为null，而他的值只能有任意多个是null；
由于它的键可以是为空的，所以，所以我们不能用get（key）判断是否有这个键，而应该用containsKey（）这个方法来判断是否有这个键；而HashTable中键值对都不能为空；
③:他们的扩容方式是不一样的；HashMap默认的初始大小是16，装载因子是0.75，并且扩容的大小一定是2的指数；而HashTable的默认初始大小是11，扩容的方式是 2*old+1；
④:哈希值的使用是不同的，HashTable的hash值是直接使用对象中的hashCode方法，而HashMap则是重新计算对象的HashCode；并且用与代替求模；
⑤:两个遍历方式的内部实现上不同。
Hashtable、HashMap都使用了 Iterator。而由于历史原因，Hashtable还使用了Enumeration的方式。

2.再看CurrentHashMap和HashMap
上面已经知道HashMap是线程不安全的了，后来在jdk1.5的时候就出来了CurrentHashMap来弥补HashMap的线程不安全的特性；CurrentHashMap，是将HashMap分成了很多个片（一般默认是16片），引入了分段锁的概念，然后对每一片加锁，具体可以理解成一把大的Map分解成N个小的HashTable，根据key.hashCode（）来决定放到哪一个片上；

3.三者效率的比较：
由于安全机制的原因，HashMap的效率比HashTable，CurrentHashMap的效率高；但是由于CurrentHashMap加锁的高效性,HashTable是整个加锁，他的效率比HashTable高；总的来说 HashMap>CurrentHashMap>HashTable;

184、Java1.8版本之前的前提，Java特性中,abstract class和interface有什么区别（）

A、抽象类可以有构造方法，接口中不能有构造方法
B、抽象类中可以有普通成员变量，接口中没有普通成员变量
C、抽象类中不可以包含静态方法，接口中可以包含静态方法
D、一个类可以实现多个接口，但只能继承一个抽象类。
解析：

185、Servlet的生命周期可以分为初始化阶段，运行阶段和销毁阶段三个阶段，以下过程属于初始化阶段是（）。

A、加载Servlet类及.class对应的数据
B、创建servletRequest和servletResponse对象
C、创建ServletConfig对象
D、创建Servlet对象
解析：
Servlet的生命周期一般可以用三个方法来表示：
1、init()：仅执行一次，负责在装载Servlet时初始化Servlet对象
2、service() ：核心方法，一般HttpServlet中会有get,post两种处理方式。在调用doGet和doPost方法时会构造servletRequest和servletResponse请求和响应对象作为参数。
3、destory()：在停止并且卸载Servlet时执行，负责释放资源
初始化阶段：Servlet启动，会读取配置文件中的信息，构造指定的Servlet对象，创建ServletConfig对象，将ServletConfig作为参数来调用init()方法。所以选ACD。B是在调用service方法时才构造的

186、下面哪项技术可以用在WEB开发中实现会话跟踪实现？

A、session
B、Cookie
C、地址重写
D、隐藏域
解析：会话跟踪是一种灵活、轻便的机制，它使Web上的状态编程变为可能。
HTTP是一种无状态协议，每当用户发出请求时，服务器就会做出响应，客户端与服务器之间的联系是离散的、非连续的。当用户在同一网站的多个页面之间转换时，根本无法确定是否是同一个客户，会话跟踪技术就可以解决这个问题。当一个客户在多个页面间切换时，服务器会保存该用户的信息。
有四种方法可以实现会话跟踪技术：URL重写、隐藏表单域、Cookie、Session。
1）.隐藏表单域：，非常适合步需要大量数据存储的会话应用。
2）.URL 重写:URL 可以在后面附加参数，和服务器的请求一起发送，这些参数为名字/值对。
3）.Cookie:一个 Cookie 是一个小的，已命名数据元素。服务器使用 SET-Cookie 头标将它作为 HTTP
响应的一部分传送到客户端，客户端被请求保存 Cookie 值，在对同一服务器的后续请求使用一个
Cookie 头标将之返回到服务器。与其它技术比较，Cookie 的一个优点是在浏览器会话结束后，甚至
在客户端计算机重启后它仍可以保留其值
4）.Session：使用 setAttribute(String str,Object obj)方法将对象捆绑到一个会话

187、在Java中下面Class的声明哪些是错误的？

A、public abstract final class Test {
abstract void method();
}
B、public abstract class Test {
abstract final void method();
}
C、public abstract class Test {
abstract void method() {
}
}
D、public class Test {
final void method() {
}
}
解析： A、final修饰的类为终态类，不能被继承，而抽象类是必须被继承的才有其意义的，因此，final是不能用来修饰抽象类的。
B、 final修饰的方法为终态方法，不能被重写。而继承抽象类，必须重写其方法。
C、抽象方法是仅声明，并不做实现的方法。

188、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)
E、None of the above
解析：

翻译：
MVC是一种在web应用中常用的架构，下列说法正确的是（）

A. 模型通常代表应用程序中的数据以及用于操纵数据的业务逻辑；

B. 视图是其对应的模型的可视化呈现，视图将模型渲染成适合于交互的形式（通常为用户界面元素）；

C. 控制器是用户与系统之间的纽带，它接受用户输入，并指示模型和视图基于用户输入执行操作（处理数据、展示数据）；

D. MVC模式在web应用中的常见实践是：模型接受来自于用户的GET或POST请求数据并决定如何处理，模型将用户数据转交给控制器，控制器将控制权转交给视图（视图由HTML生成）；

E. 以上全不是。

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

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

解析：

190、下列哪些方法是针对循环优化进行的

A、强度削弱
B、删除归纳变量
C、删除多余运算
D、代码外提
解析：

191、下列不属于类及类成员的访问控制符是：（）

A、public
B、private
C、static
D、protected
解析：

192、关于下面程序 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、程序有编译错误
解析：

193、如下Java语句 double x=2.0; int y=4; x/=++y; 执行后，x的值是（）

A、0.5
B、2.5
C、0.4
D、2.0
解析：x/=++y等价于x = x / ++y; ++y = 5; x = 2.0 / 5 = 0.4

194、在java中，已定义两个接口B和C，要定义一个实现这两个接口的类，以下语句正确的是（）

A、interface A extends B，C
B、interface A eimplements B，C
C、class A implements B，C
D、class A implements B，implements C
解析：类实现多个接口的时候，只需要一个implements，多个接口通过逗号进行隔开，先继承类再实现接口

195、以下哪个不属于JVM堆内存中的区域（）？

A、survivor区
B、常量池
C、eden区
D、old区
解析： jvm堆分为：新生代（一般是一个Eden区，两个Survivor区），老年代（old区）。
常量池属于 PermGen（方法区）

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

A、Stacks
B、PC寄存器
C、Heap
D、Heap Frame
解析：

197、下面的程序输出的结果是( )

 public class A implements B{
public static void main(String args[]){
    int i;
    A a1=new  A();
    i =a1.k;
    System.out.println("i="+i);
    }
}
interface B{

    int k=10；

}

A、i=0
B、i=10
C、程序有编译错误
D、i=true
解析：

198、ArrayList和Vector主要区别是什么？

A、Vector与ArrayList一样，也是通过数组实现的，不同的是Vector支持线程的同步
B、Vector与ArrayList一样，也是通过数组实现的，不同的是ArrayList支持线程的同步
C、Vector是通过链表结构存储数据，ArrayList是通过数组存储数据
D、上述说法都不正确
解析： Vector支持线程的同步，也就是内部加锁的
但是效率低，因此在新版jdk中加入线程不安全的Arraylist

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

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

A、
class A static
class B static
I’m A class
class A
I’m B class
class B
B、
class A static
I’m A class
class A
class B static
I’m B class
class B
C、
class A static
class B static
class A
I’m A class
class B
I’m B class
D、
class A static
class A
I’m A class
class B static
class B
I’m B class
解析：

200、观察以下代码：下列哪些针对代码运行结果的描述是正确的？

class Car extends Vehicle
{
    public static void main (String[] args)
    {
        new  Car(). run();
    }
    private final void run()
    {
        System. out. println ("Car");
    }
}
class Vehicle
{
    private final void run()
    {
        System. out. println("Vehicle");
    }
}

A、Car
B、Vehicle
C、Compiler error at line 3
D、Compiler error at line 5
E、Exception thrown at runtime
解析：首先final声明的方法是不能被覆盖的，但是这里并不错误，因为方法是private的，也就是子类没有继承父类的run方法，因此子类的run方法跟父类的run方法无关，并不是覆盖。new Car().run()也是调用子类的run方法。

Java专项练习二（选择题）
https://blog.csdn.net/weixin_46041230/article/details/113871006?spm=1001.2014.3001.5501