牛客网-java练习

牛客网练习-java

1.编译 Java 源程序文件产生的字节码文件的扩展名为（）

正确答案: B 你的答案: B (正确)
java
class
html
exe

解：
java源文件的后缀名是.java。源文件通过jvm虚拟机编译后会生成二进制字节码文件，后缀是.class

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

正确答案: A 你的答案: A (正确)
带参构造函数
无参构造函数
拷贝构造函数
重载赋值运算

解：
AB ab = new AB(a,5);其实这就是一个类的实例化问题，ab是类AB实例，new一个类的时候就是调用构造方法，而题目中构造方法带参数，可知调用的是带参的构造方法。a和5只是AB类的2个参数

3.Java Application 源程序的主类是指包含有（ ）方法的类。

正确答案: A 你的答案: A (正确)
public static void main方法
toString方法
init方法
actionPerfromed方法

4.Java中基本的编程单元为：

正确答案: A 你的答案: A (正确)
类
函数
变量
数据

解：
java的基本编程单元是类，基本存储单元是变量。

5.关于下面程序 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); 
    		}  
}

正确答案: B 你的答案: B (正确)
11
722
22
程序有编译错误

解：
+号两边如果有一边为字符类型 则为字符串连接
如果变为y+z+x 则等价于xyz 输出722

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

正确答案: D 你的答案: D (正确)
手机与小米手机
企业家与雷军
编程语言与Java
中国与北京

解：
类之间存在以下几种常见的关系
use-a 是依赖关系
has-a 一般是组合关系
is-a 一般是继承关系

7.执行下列程序的输出结果为（ ）

public class Test {
 public static void main(String[] args) {
 String s1 = "HelloWorld";
 String s2 = new String("HelloWorld");
 if (s1 == s2) {
 System.out.println("s1 == s2");
 } else {
 System.out.println("s1 != s2");
 }
 if (s1.equals(s2)) {
 System.out.println("s1 equals s2");
 } else {
 System.out.println("s1 not equals s2");
 }
 }
 }

正确答案: D 你的答案: D (正确)
s1 ==s2
s1 not equals s2

s1 == s2
s1 equals s2

s1 != s2
s1 not equals s2

s1 != s2
s1 equals s2

解：
1.== 和 equals():
(1)==用于比较基本数据类型时比较的是值，用于比较引用类型时比较的是引用指向的地址。
(2)Object 中的equals() 与 “==” 的作用相同，但String类重写了equals()方法，比较的是对象中的内容。

8.正则表达式语法中 \d 匹配的是？（）

正确答案: A 你的答案: A (正确)
数字
非数字
字母
空白字符

解：
\d 匹配一个数字字符。等价于 [0-9]。
\D 匹配一个非数字字符。等价于 [^0-9]。
\f 匹配一个换页符。等价于 \x0c 和 \cL。
\n 匹配一个换行符。等价于 \x0a 和 \cJ。
\r 匹配一个回车符。等价于 \x0d 和 \cM。
\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t 匹配一个制表符。等价于 \x09 和 \cI。
\v 匹配一个垂直制表符。等价于 \x0b 和 \cK。
\w 匹配字母、数字、下划线。等价于’[A-Za-z0-9_]’。
\W 匹配非字母、数字、下划线。等价于 ‘[^A-Za-z0-9_]’。

9.关于Float，下列说法错误的是()

正确答案: C 你的答案: C (正确)
Float是一个类
Float在java.lang包中
Float a=1.0是正确的赋值方法
Float a= new Float(1.0)是正确的赋值方法

解：
Float是类，float不是类.
Byte，Character，Short，Integer，Long，Float，Double，Boolean都在java.lang包中.
Float正确复制方式是Float f=1.0f,若不加f会被识别成double型,double无法向float隐式转换.
Float a= new Float(1.0)是正确的赋值方法

10.以下程序的执行结果是：

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 你的答案: A (正确)
ABDCBDCB
ABCDABCD
编译时出错
运行时抛出异常

解：
for（1循环开始条件；2判断条件；4循环步长件）
3循环体
按照执行顺序依次执行

11.protected访问权限要小于包访问权限。（ ）

正确答案: B 你的答案: B (正确)
正确
错误

解：

12.以下代码的输出的正确结果是

public class Test {
public static void main(String args[]) {
String s = "祝你考出好成绩！";
System.out.println(s.length());
}
}

正确答案: D 你的答案: C (错误)
24
16
15
8

解：
length() 方法返回的就是字符串的长度，
如果想获得占用字节数的话，可以用 s.getBytes(“GBK”).length，最后一个不是空格，是中文下面的 “！”，结果就是 16 了。

13.关于抽象类与最终类，下列说法错误的是？

正确答案: D 你的答案: D (正确)
抽象类能被继承，最终类只能被实例化。
抽象类和最终类都可以被声明使用
抽象类中可以没有抽象方法，最终类中可以没有最终方法
抽象类和最终类被继承时，方法可以被子类覆盖

解：
最终类就是被final修饰的类，最终方法就是被final修饰的方法。最终类不能被继承，最终方法不能被重写。
.
14. 对于abstract声明的类，下面说法正确的是

正确答案: E 你的答案: D (错误)
可以实例化
不可以被继承
子类为abstract
只能被继承
可以被抽象类继承

解：
A,抽象类不能实例化，因为有抽象方法未实现
B,可以被继承。派生类可以实现抽象方法
C，子类可以是抽象的，也可以非抽象的
D，只能被继承说法太肯定，不正确
E，可以被抽象类继承，也可以被非抽象类继承

15.java中下面哪个能创建并启动线程（）

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

正确答案: C 你的答案: A (错误)
new Runnable(MyRunnable).start()
new Thread(MyRunnable).run()
new Thread(new MyRunnable()).start()
new MyRunnable().start()

解：
创建并启动线程的过程为：定义线程—》实例化线程—》启动线程。

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

正确答案: C 你的答案: C (正确)
字节型的类型默认值是0，取值范围是-2^7—27-1
boolean类型默认值是false，取值范围是true\false
字符型类型默认是0，取值范围是-2^15 —2^15-1
long类型默认是0，取值范围是-2^63—263-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.0f -2³¹— -2³¹-1 float f=10.0F

double : 0.0d -2⁶³— -2⁶³-1 double d=10.0;

boolean: false true\false boolean flag=true;

17.下面哪种流可以用于字符输入：

正确答案: C 你的答案: C (正确)
java.io.inputStream
java.io.outputStream
java.io.inputStreamReader
java.io.outputStreamReader

解：
首先B和D排除，题目是要求输入。
A和C之间，inputStream是字节流输入流；而inputStreamReader是对字符流的处理，inputStreamReader将字符流处理成字节流，题目要求是用于处理字符输入c

18.下列哪个选项是正确计算42度（角度）的余弦值？

正确答案: C 你的答案: A (错误)
double d=Math.cos（42）
double d=Math.cosine（42）
double d=Math.cos（Math.toRadians（42））
double d=Math.cos（Math.toDegrees（42））

解：
Math.cos为计算弧度的余弦值，Math.toRadians函数讲角度转换为弧度

19.Given the following code:

public class Test {
    private static int j = 0;

    private static Boolean methodB(int k) {
        j += k;
        return true;
    }

    public static void methodA(int i) {
        boolean b;
        b = i < 10 | methodB(4);
        b = i < 10 || methodB(8);

    }

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

What is the result?

正确答案: B 你的答案: B (正确)
The program prints”0”
The program prints”4”
The program prints”8”
The program prints”12”
The code does not complete.

解：
在main函数中先调用methodA（0）
在methodA中，第二行
1
b = i < 10 | methodB(4); //中间为与计算符，执行完methodB(4)后，j = 4
methodA中，第三行
1
b = i < 10 || methodB(8);//中间为或计算符，因为i < 10 已成立，不需要后续计算
所以最后结果输出为4

20.表达式(short)10/10.2*2运算后结果是什么类型？

正确答案: C 你的答案: C (正确)
short
int
double
float

解：
注意是(short)10/10.22，而不是(short) (10/10.22)，强制类型转换的优先级高于+ - * /，前者只是把10强转为short，又由于式子中存在浮点数，所以会对结果值进行一个自动类型的提升，浮点数默认为double，所以答案是double；后者是把计算完之后值强转short。

21
根据以下代码段，下列说法中正确的是( )。

public class Parent {
    private void m1(){}
    void m2(){}
    protected void m3(){}

    public static void m4(){}

}

正确答案: C 你的答案: D (错误)
子类中一定能够继承和覆盖Parent类的m1方法
子类中一定能够继承和覆盖Parent类的m2方法
子类中一定能够继承和覆盖Parent类的m3方法
子类中一定能够继承和覆盖Parent类的m4方法

解：
通过继承，子类可以拥有所有父类对其可见的方法和域
A.私有方法只能在本类中可见，故不能继承，A错误
B.缺省访问修饰符只在本包中可见，在外包中不可见，B错误
C.保护修饰符凡是继承自该类的子类都能访问，当然可被继承覆盖；C正确
D.static修饰的成员属于类成员，父类字段或方法只能被子类同名字段或方法遮蔽，不能被继承覆盖，D错误

22.对于子类的构造函数说明，下列叙述中错误的是（ ）。

正确答案: D 你的答案: A (错误)
子类不能继承父类的无参构造函数。
子类可以在自己的构造函数中使用super关键字来调用父类的含参数构造函数，但这个调用语句必须是子类构造函数的第一个可执行语句。
在创建子类的对象时，若不含带参构造函数，将先执行父类的无参构造函数，然后再执行自己的无参构造函数。
子类不但可以继承父类的无参构造函数，也可以继承父类的有参构造函数。

解：
构造函数不能被继承，构造方法只能被显式或隐式的调用

23.以下哪个式子有可能在某个进制下成立（）？

正确答案: A 你的答案: B (错误)
1314=204
1234=568
14*14=140
1+1=3

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

正确答案: D 你的答案: B (错误)
ActionForm
ValidatorActionForm
ValidatorForm
DynaValidatorActionForm

解：
DynaValidatorActionForm 动态验证表单
Validation 确认的意思

25.下面哪些接口直接继承自Collection接口（）

正确答案: A C 你的答案: A B (错误)
List
Map
Set
Iterator

解：

26.java中关于继承的描述正确的是（）

正确答案: A C D 你的答案: A B (错误)
一个子类只能继承一个父类
子类可以继承父类的构造方法
继承具有传递性
父类一般具有通用性，子类更具体

解：
在java中，子类构造器会默认调用super()(无论构造器中是否写有super（）),用于初始化父类成员，同时当父类中存在有参构造器时，必须提供无参构造器，子类构造器中并不会自动继承有参构造器，仍然默认调用super()，使用无参构造器。因此，一个类想要被继承必须提供无参构造器。

27.Gadget has-a Sprocket and Gadget has-a Spring and Gadget is-a Widget and Widget has-a
Sprocket 以下哪两段代码可以表示这个关系? (选择两项) ( )

正确答案: A C 你的答案: B D (错误)
class Widget { Sprocket s; }
class Gadget extends Widget { Spring s; }

class Widget { }
class Gadget extends Widget { Spring s1; Sprocket s2; }

class Widget { Sprocket s1; Spring s2; }
class Gadget extends Widget { }

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的接口

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

正确答案: A B C D 你的答案: B D (错误)
ThreadLocal存放的值是线程封闭，线程间互斥的，主要用于线程内共享一些数据，避免通过参数来传递

从线程的角度看，每个线程都保持一个对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal 实例是可访问的；在线程消失之后，其线程局部实例的所有副本都会被垃圾回收

在Thread类中有一个Map，用于存储每一个线程的变量的副本

对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式

解：
ThreadLocal类用于创建一个线程本地变量
在Thread中有一个成员变量ThreadLocals，该变量的类型是ThreadLocalMap,也就是一个Map，它的键是threadLocal，值为就是变量的副本。通过ThreadLocal的get()方法可以获取该线程变量的本地副本，在get方法之前要先set,否则就要重写initialValue()方法。ThreadLocal的缺点时占用了较多的空间。

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

正确答案: A D 你的答案: A D (正确)
新生代串行收集器
老年代串行收集器
并行收集器
新生代并行回收收集器
老年代并行回收收集器
cms收集器

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

30.下列代码片段中，存在编译错误的语句是()

byte b1=1,b2=2,b3,b6,b8;
final byte b4=4,b5=6,b7;
b3=(b1+b2);  /*语句1*/
b6=b4+b5;    /*语句2*/
b8=(b1+b4);  /*语句3*/
b7=(b2+b5);  /*语句4*/
System.out.println(b3+b6);

正确答案: B C D 你的答案: D (错误)
语句2
语句1
语句3
语句4

解：
语句1错误：b3=(b1+b2);自动转为int，所以正确写法为b3=(byte)(b1+b2);或者将b3定义为int；
语句2正确：b6=b4+b5;b4、b5为final类型，不会自动提升，所以和的类型视左边变量类型而定，即b6可以是任意数值类型；
语句3错误：b8=(b1+b4);虽然b4不会自动提升，但b1仍会自动提升，所以结果需要强转，b8=(byte)(b1+b4);
语句4错误：b7=(b2+b5); 同上。同时注意b7是final修饰，即只可赋值一次，便不可再改变。

1.在 Java 中，存放字符串常量的对象属于（ ）类对象。

正确答案: B 你的答案: B (正确)
Character
String
StringBuffer
Vector

解：
Character 字符封装类
String 常量池中字符串
StringBuffer 存放字符数组
Vector 数组

2.以下程序的运行结果是（）

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

正确答案: B 你的答案: B (正确)
666
667
677
676

解：
a++表示先用后+，而++a表示先+后用

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

String s = “hello”;

String t = “hello”;

char c[] = {‘h’,‘e’,‘l’,‘l’,‘o’} ;

正确答案: B 你的答案: B (正确)
s.equals(t);
t.equals©;
s==t;
t.equals(new String(“hello”));

解：
A、D选项是对字符串内容的比较
C选项是对引用地址的比较

4.命令javac-d参数的用途是？（）

正确答案: A 你的答案: A(正确)
指定编译后类层次的根目录
指定编译时需要依赖类的路径
指定编译时的编码
没有这一个参数

解：
-d destination 目的地
-s source 起源地
javac -d 指定放置生成的类文件的位置
javac -s 指定放置生成的源文件的位置

5.Which of the following can be applied to constructors:

正确答案: E 你的答案: C (错误)
final
static
synchronized
native
None of these.

解：
构造方法不能被子类继承，所以用final修饰没有意义。构造方法用于创建一个新的对象，不能作为类的静态方法，所以用static修饰没有意义。此外，Java语言不支持native或synchronized的构造方法。

6.下面关于JAVA的垃圾回收机制，正确的是（ ）

正确答案: B 你的答案: A (错误)
当调用“System.gc()”来强制回收时，系统会立即回收垃圾
垃圾回收不能确定具体的回收时间
程序可明确地标识某个局部变量的引用不再被使用
程序可以显式地立即释放对象占有的内存

解：
java提供了一个系统级的线程，即垃圾回收器线程。用来对每一个分配出去的内存空间进行跟踪。当JVM空闲时，自动回收每块可能被回收的内存，GC是完全自动的，不能被强制执行。程序员最多只能用System.gc()来建议执行垃圾回收器回收内存，但是具体的回收时间，是不可知的。当对象的引用变量被赋值为null，可能被当成垃圾。

7.某程序要求每次输入只能是正整数，并且每次输入的数值要求必须是100的倍数且小于等于500，则下列哪个是正确的无效等价类( )
正确答案: D 你的答案: B (错误)
（0，100）、（100，200）、（200，300）、（300，400）、（400，500）、（500，+∞）;
（500，+∞）
（500，+∞）、任意大于0小于500的非100倍数的整数；
（-∞，100）、（100，200）、（200，300）、（300，400）、（400，500）、（500，+∞）;

解：
无效等价类和有效等价类相反，即不满足程序输入要求或者无效的输入数据构成的集合。
按无效等价类的定义来说，
题目要求输入什么，无效等价类就应该是反着的。
题目要求正整数，那么无效等价类就应该包含负数

8.下列哪一项的实现不可以添加为 TextField 对象的监听器（）

正确答案: C 你的答案: C (正确)
MouseMotionListener
FocusListener
WindowsListener
ActionListener

解：
在单行文本输入区(Textfield)构件上可能发生的事件包括FocusEvent焦点事件，所对应的事件是FocusListener；ActionEvent动作事件，所对应的事件是ActionListener；MouseEvent鼠标事件，所对应的事件***是MouseMotionListener；

9.以下代码将打印出

 public static void main (String[] args) { 
    String classFile = "com.jd.". replaceAll(".", "/") + "MyClass.class";
    System.out.println(classFile);
}

正确答案: C 你的答案: B (错误)
com. jd
com/jd/MyClass.class
///MyClass.class
com.jd.MyClass

解：
由于replaceAll方法的第一个参数是一个正则表达式，而"."在正则表达式中表示任何字符，所以会把前面字符串的所有字符都替换成"/"。如果想替换的只是"."，那么久要写成"\.".

10.int，String，*point，union哪些不是 Java 的数据类型？
正确答案: C D 你的答案: C D (正确)
int
String
*point
union

解：
string是C++中定义字符串的类型，java中是String类
*point是指针，java中没有这种类型
union是C系的类型

11.关于Java和C/C++的比较，下列哪个描述是错误的？
正确答案: C D 你的答案: A D (错误)
Java不支持指针，C/C++支持
Java程序不需要显式地关心内存释放，而C/C++需要
Java和C++一样，是纯编译型语言，因此它们的class都是在编译时静态联编(static binding)的
Java数组、字符串不可能溢出，C/C++数组、字符串则有可能溢出边界

解：
Java和C++的区别：

1. Java是解释型语言，所谓的解释型语言，就是源码会先经过一次编译，成为中间码，中间码再被解释器解释成机器码。对于Java而言，中间码就是字节码(.class)，而解释器在JVM中内置了。
2. C++是编译型语言，所谓编译型语言，就是源码一次编译，直接在编译的过程中链接了，形成了机器码。
3. C++比Java执行速度快，但是Java可以利用JVM跨平台。
4. Java是纯面向对象的语言，所有代码（包括函数、变量）都必须在类中定义。而C++中还有面向过程的东西，比如是全局变量和全局函数。
5. C++中有指针，Java中没有，但是有引用。
6. C++支持多继承，Java中类都是单继承的。但是继承都有传递性，同时Java中的接口是多继承，类对接口的实现也是多实现。
7. C++中，开发需要自己去管理内存，但是Java中JVM有自己的GC机制，虽然有自己的GC机制，但是也会出现OOM和内存泄漏的问题。C++中有析构函数，Java中Object的finalize方法
8. C++运算符可以重载，但是Java中不可以。同时C++中支持强制自动转型，Java中不行，会出现ClassCastException（类型不匹配）

12.“先进先出”的容器是：( )

正确答案: B 你的答案: B (正确)
堆栈(Stack)
队列（Queue）
字符串(String)
迭代器(Iterator)

解：
堆栈是具有先进后出的特点;队列具有先进先出的特点。
字符串是一个存储数据的结构，没有严格的出入要求，迭代器的数据读取取决于迭代方式。

13.在 JAVA 编程中， Java 编译器会将 Java 程序转换为（ ）

正确答案: A 你的答案: A (正确)
字节码
可执行代码
机器代码
以上都不对

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

14.下列关于修饰符混用的说法，错误的是( )

正确答案: D 你的答案: D (正确)
abstract不能与final并列修饰同一个类
abstract 类中不建议有private的成员
abstract 方法必须在abstract类或接口中
static方法中能直接处理非static的属性

解：
abstract修饰的类，不可实例化，所以需要子类去继承，然后重写其中的抽象方法。但是final修饰类是不可继承的。两者属性相冲。
看清楚，人家说的是不建议有，不是不能有。
抽象类中可以没有抽象方法，但是抽象方法必须在抽象类中或者接口中
static不可以修饰非static的属性，因为类加载的时候，static属性比非static先初始化，那么一个存在的总不能访问一个没有存在的吧。

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

正确答案: B 你的答案:B (正确)
正确
错误

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

16.给定代码：

public class SwitchTest{//1
	public static void main(String[] args) {//2
		System.out.println("value="+switchit(4));//3
	}//4
	public static int switchit(int x) {
		int j=1;
		switch (x) {
		case 1:j++;
		case 2:j++;
		case 3:j++;
		case 4:j++;
		case 5:j++;
		default:j++;
		}
		return j+x;
	}
}

第三行将输出什么？
正确答案: B 你的答案: B(正确)
value=6
value=8
value=3
value=5
value=4

解：
没有break，从case 4开始一直执行到最后，j自加3次变成了4,结果返回8

17.下面代码的输出结果是什么？

public class ZeroTest {
    public static void main(String[] args) {
     try{
       int i = 100 / 0;
       System.out.print(i);
  }catch(Exception e){
       System.out.print(1);
       throw new RuntimeException();
  }finally{
       System.out.print(2);
  }
      System.out.print(3);
 }
 }

正确答案: D 你的答案: D (正确)
3
123
1
12

解：
inti = 100/ 0; 会出现异常，会抛出异常，System.out.print(i)不会执行，
catch捕捉异常，继续执行System.out.print(1);
当执行 thrownewRuntimeException(); 又会抛出异常，这时，除了会执行finally中的代码，其他地方的代码都不会执行

18.对于子类的构造函数说明，下列叙述中错误的是（ ）。

正确答案: A 你的答案: D (错误)
子类可以继承父类的构造函数。
子类中调用父类构造函数不可以直接书写父类构造函数，而应该用super();。
用new创建子类的对象时，若子类没有带参构造函数，将先执行父类的无参构造函数，然后再执行自己的构造函数。
子类的构造函数中可以调用其他函数。

解：
java继承中对构造函数是不继承的，只是显式或者隐式调用

19.java程序内存泄露的最直接表现是（ ）

正确答案: C 你的答案: C (正确)
频繁FullGc
jvm崩溃
程序抛内存控制的Exception
java进程异常消失

解：
内存异常，最常见的 就是 StackOverFlow ，内存溢出，其实内存泄漏的最终结果就是内存溢出

20.public class contained in a Java program file must have the same name as the file, except for the extension “.java”.

正确答案: A 你的答案: B (错误)
FALSE
TRUE

解：
题目的意思是： 除去扩展名.java的部分，包含在java文件里的Java里的公共类必须与文件的名字相同。
但是公共的内部类是不需要和文件的名字相同的

21.在JAVA中， 下列标识符合法的是（）

正确答案: C 你的答案: C (正确)
3kyou
@163
name
while

解：
JAVA中,标识符, 指用于给变量.类.方法名 等命名的名称. 1,标识以数字,字符,下划线,以及美元$符组成.（不能包括@、%、空格等）,不能以数字开头. 2,不能与JAVA关键字重复 3,严格区分的大小写

22.AWT 中用来表示文本框的类是 ( )

正确答案: A 你的答案: A (正确)
TextField
Menu
Label
List

解：
AWT基本组件
B、Menu表示下拉菜单
C、Label表示标签
D、List表示列表框

public class Test{
    static int cnt = 6;
    static{
        cnt += 9;
    }
public static void main(String[] args）{
    System.out.println（“cnt =” + cnt);
}
static{
    cnt /=3;
    };
}

cnt的值是

正确答案: A 你的答案: A (正确)
cnt=5
cnt=2
cnt=3
cnt=6

解：
静态初始化块，静态变量这两个是属于同一级别的，是按代码写得顺序执行的！
而不是先执行静态变量后执行静态初始化块

24.事务隔离级别是由谁实现的？

正确答案: C 你的答案: A (错误)
Java应用程序
Hibernate
数据库系统
JDBC驱动程序

解：
我们写java程序的时候只是设定事物的隔离级别，而不是去实现它
Hibernate是一个java的数据持久化框架，方便数据库的访问
事物隔离级别由数据库系统实现，是数据库系统本身的一个功能
JDBC是java database connector，也就是java访问数据库的驱动

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

正确答案: A 你的答案: A (正确)
正确
错误

解：
内部类差不多就是类的成员，成员有4种访问权限，内部类也是！
分别为private、protected、public以及默认的访问权限

26.BufferedReader的父类是以下哪个？

正确答案: D 你的答案: D (正确)
FilterReader
InputStreamReader
PipedReader
Reader

解：

27.A 是抽象父类或接口， B ， C 派生自 A ，或实现 A ，现在 Java 源代码中有如下声明：

1. A a0=new A();
2. A a1 =new B();
3. A a2=new C();

问以下哪个说法是正确的？（ ）

正确答案: A 你的答案: C (错误)
第1行不能通过编译
第1、2行能通过编译，但第3行编译出错
第1、2、3行能通过编译，但第2、3行运行时出错
第1行、第2行和第3行的声明都是正确的

解：哎…
抽象类不能实例化.

28.假如某个JAVA进程的JVM参数配置如下：
-Xms1G -Xmx2G -Xmn500M -XX:MaxPermSize=64M -XX:+UseConcMarkSweepGC -XX:SurvivorRatio=3,
请问eden区最终分配的大小是多少？

正确答案: C 你的答案: A (错误)
64M
500M
300M
100M

解：
Xms 起始内存
Xmx 最大内存
Xmn 新生代内存
Xss 栈大小。 就是创建线程后，分配给每一个线程的内存大小
-XX:NewRatio=n:设置年轻代和年老代的比值。如:为3，表示年轻代与年老代比值为1：3，年轻代占整个年轻代年老代和的1/4
-XX:SurvivorRatio=n:年轻代中Eden区与两个Survivor区的比值。注意Survivor区有两个。如：3，表示Eden：Survivor=3：2，一个Survivor区占整个年轻代的1/5
-XX:MaxPermSize=n:设置持久代大小
收集器设置
-XX:+UseSerialGC:设置串行收集器
-XX:+UseParallelGC:设置并行收集器
-XX:+UseParalledlOldGC:设置并行年老代收集器
-XX:+UseConcMarkSweepGC:设置并发收集器
垃圾回收统计信息
-XX:+PrintGC
-XX:+PrintGCDetails
-XX:+PrintGCTimeStamps
-Xloggc:filename
并行收集器设置
-XX:ParallelGCThreads=n:设置并行收集器收集时使用的CPU数。并行收集线程数。
-XX:MaxGCPauseMillis=n:设置并行收集最大暂停时间
-XX:GCTimeRatio=n:设置垃圾回收时间占程序运行时间的百分比。公式为1/(1+n)
并发收集器设置
-XX:+CMSIncrementalMode:设置为增量模式。适用于单CPU情况。
-XX:ParallelGCThreads=n:设置并发收集器年轻代收集方式为并行收集时，使用的CPU数。并行收集线程数

29.以下代码的输出结果是？

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

解：
正确答案: C 你的答案: A (错误)
静态块 构造块 构造块 构造块
构造块 静态块 构造块 构造块
构造块 构造块 静态块 构造块
构造块 构造块 构造块 静态块

解：
不是静态块最先初始化,而是静态域
而静态域中包含静态变量、静态块和静态方法,其中需要初始化的是静态变量和静态块.而他们两个的初始化顺序是靠他们俩的位置决定的!
初始化顺序是 t1 t2 静态块

30.Model-View-Controller(MVC) is an architectural pattern that frequently used in web applications. Which of the following statement(s) is(are) correct?

正确答案: A B C 你的答案: A D E (错误)
Models often represent data and the business logics needed to manipulate the data in the application

A view is a (visual) representation of its model. It renders the model into a form suitable for interaction, typically a user interface element

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

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)

None of the above

解：
翻译：
MVC是一种在web应用中常用的架构，下列说法正确的是（）
A. 模型通常代表应用程序中的数据以及用于操纵数据的业务逻辑；
B. 视图是其对应的模型的可视化呈现，视图 将模型渲染成适合于交互的形式（通常为用户界面元素）；
C. 控制器是用户与系统之间的纽带，它接受用户输入，并指示模型和视图基于用户输入执行操作（处理数据、展示数据）；
D. MVC模式在web应用中的常见实践是：模型接受来自于用户的GET或POST请求数据并决定如何处理，模型将用户数据转交给控制器，控制器将控制权转交给视图（视图由HTML生成）；
E. 以上全不是。首先排除…

1.在Web应用程序的文件与目录结构中，web.xml是放置在( )中。

正确答案: A 你的答案: A (正确)
WEB-INF目录
conf目录
lib目录
classes目录

解：
web.xml文件是用来初始化配置信息，web.xml是放置在WEB-INF目录中

2.在运行时，由java解释器自动引入，而不用import语句引入的包是()。

正确答案: A 你的答案: B (错误)
java.lang
java.system
java.io
java.util

解:java.lang包是java语言的核心包，lang是language的缩写
java.lang包定义了一些基本的类型，包括Integer,String之类的，是java程序必备的包，有解释器自动引入，无需手动导入

3.下面代码的运行结果是（）

public static void main(String[] args){
    String s;
    System.out.println("s="+s);
}

正确答案: C 你的答案: B (错误)
代码编程成功，并输出”s=”
代码编译成功，并输出”s=null”
由于String s没有初始化，代码不能编译通过。
代码编译成功，但捕获到NullPointException异常

解:局部变量没有默认值

4.以下哪一项正则能正确的匹配网址: http://www.bilibili.com/video/av21061574 （）
正确答案: B 你的答案: B (正确)
/^(https?/😕/)?([a-zA-Z\d]+).bilibili.com/?video/av(\D{1,8})/?KaTeX parse error: Undefined control sequence: \/ at position 11: / /^(http:\̲/̲\/)?(\w+)\.bili…/
/^(https?😕/)?(\w+).bilibili.com/?\w*KaTeX parse error: Undefined control sequence: \/ at position 11: / /^(http:\̲/̲\/)?([a-zA-Z\d]…/

5.在try的括号里面有return一个值，那在哪里执行finally里的代码？
正确答案: B 你的答案: B (正确)
不执行finally代码
return前执行
return后执行

6.以下代码的输出的正确结果是

public class Test {
public static void main(String args[]) {
String s = "祝你考出好成绩！";
System.out.println(s.length());
}
}

解:正确答案: D 你的答案: D (正确)
24
16
15
8

解:
length得到的是字符，不是字节

7.下面哪一项不属于优化Hibernate所鼓励的？
正确答案: A 你的答案: D (错误)
使用单向一对多关联，不使用双向一对多
不用一对一，用多对一取代
配置对象缓存，不使用集合缓存
继承类使用显式多态

解:
优化Hibernate所鼓励的7大措施：
1.尽量使用many-to-one，避免使用单项one-to-many
2.灵活使用单向one-to-many
3.不用一对一，使用多对一代替一对一
4.配置对象缓存，不使用集合缓存
5.一对多使用Bag 多对一使用Set
6.继承使用显示多态 HQL:from object polymorphism=“exlicit” 避免查处所有对象
7.消除大表，使用二级缓存

8.以下代码可以使用的修饰符是：（）

public interface Status {
 /*INSERT CODE HERE*/  int MY_VALUE=10;
 }

正确答案: A B D 你的答案: A C D (错误)
final
static
abstract
public

解:abstract只能修饰类和方法 不能修饰字段

9.关于下面的一段代码，以下哪些说法是正确的：

public static void main(String[] args) {
    String a = new String("myString");
    String b = "myString";
    String c = "my" + "String";
    String d = c;
    System.out.print(a == b);
    System.out.print(a == c);
    System.out.print(b == c);
    System.out.print(b == d);
}

正确答案: A D 你的答案: A C (错误)
System.out.print(a == b)打印出来的是false
System.out.print(a == c)打印出来的是true
System.out.print(b == c)打印出来的是false
System.out.print(b == d)打印出来的是true

解:
A：a指向堆内存，b指向常量池，因此地址不相等，false
B：java有常量优化机制，c也指向常量池，且与b指向同一个，则a与c地址不相等,false；
C：b与c地址相等，true
D：d是c的副本，地址相同，所以b与d地址相等，true

10.下列选项中是正确的方法声明的是？（）

正确答案: A B C D 你的答案: A B D (错误)
protected abstract void f1();
public final void f1() {}
static final void fq(){}
private void f1() {}

解:
A：抽象方法只可以被public 和 protected修饰；
B：final可以修饰类、方法、变量，分别表示：该类不可继承、该方法不能重写、该变量是常量
C：static final 可以表达在一起来修饰方法，表示是该方法是静态的不可重写的方法
D：private 修饰方法（这太常见的）表示私有方法，本类可以访问，外界不能访问

11.关于Java语言的内存回收机制，下列选项中最正确的一项是

正确答案: C 你的答案: B (错误)
Java程序要求用户必须手工创建一个线程来释放内存
Java程序允许用户使用指针来释放内存
内存回收线程负责释放无用内存
内存回收线程不能释放内存对象

解:
A，java的内存回收是自动的，Gc在后台运行，不需要用户手动操作
B，java中不允许使用指针
D，内存回收线程可以释放无用的对象内存

12.以下说法错误的是

正确答案: C 你的答案: D (错误)
数组是一个对象
数组不是一种原生类
数组的大小可以任意改变
在Java中，数组存储在堆中连续内存空间里

解: 在java中,数组是一个对象, 不是一种原生类,对象所以存放在堆中,又因为数组特性,是连续的,只有C不对

13.给定以下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");
    }
}

正确答案: B 你的答案: D (错误)
exception in main finished
finally finished
exception in main finally
finally exception in main finished

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

14.关于Java以下描述正确的有( )
正确答案: A 你的答案: B (错误)
native关键字表名修饰的方法是由其它非Java语言编写的
能够出现在import语句前的只有注释语句
接口中定义的方法只能是public
构造方法只能被修饰为public或者default

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

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

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

正确答案: D 你的答案: B (错误)
循环体一次也不执行 循环体执行一次 是无限循环 有限次循环 循环结束判断条件不合法 运行出错
循环体执行一次 是无限循环
有限次循环
循环结束判断条件不合法

解:for 循环的结束判定条件 是 boolean型 n = 0 是 int 类型 会有编译异常

16.类Parent和Child定义如下：

1 ．class Parent{
2. public float aFun(float a, float b) { }
3 ．}
4 ．class Child extends Parent{
5 ．
6 ．}

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

正确答案: A 你的答案: A (正确)
float aFun(float a, float b){ }
public int aFun(int a, int b) { }
public float aFun(float p, float q){ }
private int aFun(int a, int b){ }

解:子类方法不能缩小父类方法的访问权限

17.在各自最优条件下,对N个数进行排序,哪个算法复杂度最低的是? （）

正确答案: A 你的答案: A (正确)
插入排序
快速排序
堆排序
归并排序

解:

18.以下代码的运行结果是什么( )

class Supper{     
 public int get()    
  {          
System.out.println("Supper");         
 return 5;     
 }    
 }     
public class Sub{     
 public int get()    
 {         
 System.out.println("Sub");        
 return new Integer("5");          }      
 public static void main(String args[]) {          
 new Supper().get();        
   new Sub().get();          }   
  }

正确答案: A 你的答案: B (错误)
Supper Sub
Supper 5 Sub
Supper 5 5 Sub
Supper Sub 5 5

解:newSupper().get()和newSub().get()只调用了get()方法，又没有打印输出get()返回的数值，所以肯定没有5

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

正确答案: A B D 你的答案: A B D (正确)
事件源
事件对象
事件过程
事件监听器

解:
面向对象的语言里没有“过程”
面向过程的语言里没有“对象”

20.面向对象程序设计方法的优点包含：
正确答案: A B C 你的答案: A B C (正确)
可重用性
可扩展性
易于管理和维护
简单易懂

解:实际上就是面向对象的三大特性 A.多态 B.继承 C.封装

21.队列(Queue)是先进先出的。（ ）

正确答案: A 你的答案: A (正确)
正确
错误

解:队列先进先出，栈先进后出

22.下列关于功能性注释不正确的说法是()
正确答案: B 你的答案: B (正确)
功能性注释嵌在源程序中，用于说明程序段或语句的功能以及数据的状态
注释用来说明程序段，需要在每一行都要加注释
可使用空行或缩进，以便很容易区分注释和程序
修改程序也应修改注释

23.一个以". java"为后缀的源文件，哪些说法是正确的？
正确答案: C 你的答案: C (正确)
只能包含一个类，类名必须与文件名相同
只能包含与文件名相同的类，以及其中的内部类
只能有一个与文件名相同的类，可以包含其他类
可以包含任意类

解:一个与文件名相同的public的类敏感词类可随意多个

24.关于Float，下列说法错误的是()
正确答案: C 你的答案: C (正确)
Float是一个类
Float在java.lang包中
Float a=1.0是正确的赋值方法
Float a= new Float(1.0)是正确的赋值方法

解:
Float是类，float不是类.
查看JDK源码就可以发现Byte，Character，Short，Integer，Long，Float，Double，Boolean都在java.lang包中.
Float正确复制方式是Float f=1.0f,若不加f会被识别成double型,double无法向float隐式转换.
Float a= new Float(1.0)是正确的赋值方法，但是在1.5及以上版本引入自动装箱拆箱后，会提示这是不必要的装箱的警告，通常直接使用Float f=1.0f.

25./…/中可以嵌套//注释，也能嵌套/…/注释。
正确答案: B 你的答案: B (正确)
正确
错误

解:在Java中规定，多行注释可以嵌套单行注释，但是不能嵌套多行注

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

正确答案: A 你的答案: C (错误)
Set中至多只能有一个空元素
List中至多只能有一个空元素
List和Set都可以包含重复元素的有序集合
List和Set都是有序集合

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

27.What will be printed when you execute the following code?

class C {
    C() {
        System.out.print("C");
    }
}

class A {
    C c = new C();

    A() {
        this("A");
        System.out.print("A");
    }

    A(String s) {
        System.out.print(s);
    }
}

class Test extends A {
    Test() {
        super("B");
        System.out.print("B");
    }

    public static void main(String[] args) {
        new Test();
    }
}

正确答案: B 你的答案: A (错误)
BB
CBB
BAB
None of the above

解:
初始化过程是这样的：
1.首先，初始化父类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；
2.然后，初始化子类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；
3.其次，初始化父类的普通成员变量和代码块，在执行父类的构造方法；
4.最后，初始化子类的普通成员变量和代码块，在执行子类的构造方法；

（1）初始化父类的普通成员变量和代码块，执行 C c = new C(); 输出C
（2）super(“B”); 表示调用父类的构造方法，不调用父类的无参构造函数，输出B
（3） System.out.print(“B”);
所以输出CBB

28.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”);
}

正确答案: C 你的答案: D (错误)
The code fails to compile at the “if” statement.
An exception is thrown at run-time at the “if” statement.
The text“true” is displayed.
The text“false”is displayed.

解:Boolean修饰的变量为包装类型，初始化值为false,进行赋值时会调用Boolean.valueOf(boolean b)方法自动拆箱为基本数据类型，因此赋值后flag值为true，输出文本true。 如果使用==比较,则输出文本false。if的语句比较，除boolean外的其他类型都不能使用赋值语句，否则会提示无法转成布尔值

29.面向对象方法的多态性是指（）
正确答案: C 你的答案: C (正确)
一个类可以派生出多个特殊类
一个对象在不同的运行环境中可以有不同的变体
针对一消息，不同的对象可以以适合自身的方式加以响应
一个对象可以是由多个其他对象组合而成的

30.Servlet的生命周期可以分为初始化阶段，运行阶段和销毁阶段三个阶段，以下过程属于初始化阶段是（）。
正确答案: A C D 你的答案: B D (错误)
加载Servlet类及.class对应的数据
创建servletRequest和servletResponse对象
创建ServletConfig对象
创建Servlet对象

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

1. 加载Servlet类及.class对应的数据
2. 创建ServletConfig对象
3. 创建Servlet对象

1.定义：String s1 = “uml”; String s2 = “uml”; String s3= new String(“uml”); String s4= new String(“uml”);那么，s1==s2；s3 == s4；s1.equals(s3); 判断正确与否
正确答案: A 你的答案: A (正确)
T，F，T
F，T，F

解：
该题考察的是String类创建的对象在JVM中的内存分配和“equals”与“”的区别。
“”比较的是地址和值。
“equals”比较的是值。

s1==s2，比较的是比较的是地址和值，由上图得知两个引用指向的是同一个地址，所以返回true.
s3 == s4，比较的是两个new出来开辟的空间对象地址，所以值相同，但地址不同，返回false.
s1.equals(s3)，比较的是内容,返回true。

2.以下哪项不是java基础类型（）

正确答案: C 你的答案: C (正确)
int
boolean
String
float

解：Java中基本数据类型大体分为两类 数字类型（byte,short,int,long,float,double,char）,布尔类型（boolean）; 备注：由于char可以和数字间转换，也可认为大的范围是数字类型的

3.在 Java 中，存放字符串常量的对象属于（ ）类对象。
正确答案: B 你的答案: B (正确)
Character
String
StringBuffer
Vector

解：Character 字符封装类
String 常量池中字符串
StringBuffer 存放字符数组
Vector 数组

4.“先进先出”的容器是：( )

正确答案: B 你的答案: B (正确)
堆栈(Stack)
队列（Queue）
字符串(String)
迭代器(Iterator)

5.下面所示的java代码，运行时，会产生（）类型的异常

int Arry_a[] = new int[10];
System.out.println(Arry_a[10]);

正确答案: D 你的答案: D (正确)
ArithmeticException
NullPointException
IOException
ArrayIndexOutOfBoundsException

6.在 main() 方法中给出的字节数组，如果将其显示到控制台上，需要（ ）。

正确答案: A 你的答案: B (错误)
标准输出流System.out.println()。
建立字节输出流。
建立字节输入流。
标准输入流System.in.read()。

解：
out是java.lang.System类中的一个字段，out是“标准“”输出流，public static final PrintStream out，
out是PrintStream类型，PrintStream是包装流，传入什么，他就输出什么

7.下列说法正确的是
正确答案: B 你的答案: B (正确)
在类方法中可用this来调用本类的类方法
在类方法中调用本类的类方法可直接调用
在类方法中只能调用本类的类方法
在类方法中绝对不能调用实例方法

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

8.以下哪个不能用来处理线程安全
正确答案: D 你的答案: A (错误)
synchronized关键字
volatile关键字
Lock类
transient关键字

解：valitale关键字也不能保证线程的安全性，因为它不具备原子性

9.我们在程序中经常使用“System.out.println()”来输出信息，语句中的System是包名，out是类名，println是方法名。
正确答案: B 你的答案: B (正确)
对
错

解：System是java.lang中的一个类，out是System内的一个成员变量，这个变量是一个java.io.PrintStream类的对象，println呢就是一个方法了

10.如下的Java程序
public class Test {
public static void main(String[] args) {
System.out.println(args[0]);
}
}
若采用命令行“java Test one two three”调用，则程序输出的结果为：
正确答案: B 你的答案: B (正确)
Test
one
two
java

解：采用命令行“ java Test one two three ”调用
其中Test为调用的方法，而one two three则为Test方法里面main函数的参数；
System.out.println(args[0]);表示输出第一个元素，故为one

11.JVM内存不包含如下哪个部分( )
正确答案: D 你的答案: A (错误)
Stacks
PC寄存器
Heap
Heap Frame

解：

12.如下代码的 结果是什么 ?

class Base {
    Base() {
    System.out.print("Base"); 
    }
}
public class Alpha extends Base {
    public static void main( String[] args ) {
        new Alpha();
        //调用父类无参的构造方法
        new Base();
    } 
}

正确答案: B 你的答案: B (正确)
Base
BaseBase
编译失败
代码运行但没有输出
运行时抛出异常

解：在执行new Alpha()时，会先执行父类的构造方法，在执行相应的子类的构造方法，所以此处会打印Base，在执行new Base()时，会直接执行Base中无参构造器的代码，再输出Base

以下代码的输出的正确结果是

public class Test {
public static void main(String args[]) {
String s = "祝你考出好成绩！";
System.out.println(s.length());
}
}

正确答案: D 你的答案: D (正确)
24
16
15
8

14.对于Java中异常的描述正确的是（ ）

正确答案: D 你的答案: B (错误)
用throws定义了方法可能抛出的异常，那么调用此方法时一定会抛出此异常。
如果try块中没有抛出异常，finally块中的语句将不会被执行。
抛出异常意味着程序发生运行时错误，需要调试修改
Java中的可不检测（unchecked）异常可能来自RuntimeException类或其子类。

解：
A错 在调用此方法的时候 也可以再次申明以将异常交由更高一级处理。
B错 finally块中的语句一定会被执行。除非catch块中有System.exit(0)。
C错 抛出异常不一定是运行时异常，也有可能是编译时异常。
D对 运行时异常的特点是Java编译器不会检查它。

15.Thread. sleep()是否会抛出checked exception?
正确答案: A 你的答案: B (错误)
会
不会

解：Thread.sleep() 和 Object.wait(),都可以抛出 InterruptedException。这个异常是不能忽略的,因为它是一个检查异常(checked exception)

16.下列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';
    }
}

正确答案: B 你的答案: F (错误)
hello and ab
hello and cb
hello and a
test ok and ab
test ok and cb
test ok and c

解：String类是final类型的，不能继承和修改这个类。str=“tesk ok”，其实是隐含的让Java生成一个新的String对象，那么就与原来的“Hello”没有任何关系，当函数结束，str作用结束，所以输出的还是“Hello”。 char ch[] 是传递引用，修改了原内容

17.正则表达式中，表示匹配非数字字符的字符是（）？
正确答案: D 你的答案: D(正确)
\b
\d
\B
\D

解：大写表示“非”，d表示digit数字。非数字就是\D, w表示word，非单词就是\W

18.对于如下代码段

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

{
    _______

}

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

正确答案: C 你的答案: B (错误)
public void foo(){}
public int foo(){return 1;}
public A foo(B b){return b;}
public A foo(){return A;}

解：
public void foo(){} 方法名相同，返回值不同–>不是重写；而参数列表与父类相同，那么也不是重载。
public int foo(){return 1;} 方法名相同，返回值不同–>不是重写；而参数列表与父类相同，那么也不是重载。
public A foo(B b){return b;} 方法名相同，返回值（无所谓），而参数列表与父类不相同，那么是重载。另：B是A的子类，根据里氏替换原则/自动向上转型，可以这个选项正确。
public A foo(){return A;} 方法名相同，返回值相同，而参数列表也与父类相同，那么也不是重载。

19.尝试编译以下程序会产生怎么样的结果？（）

public class MyClass {
    long var;
    public void MyClass(long param) { var = param; }//(1)
    public static void main(String[] args) {
        MyClass a, b;
        a =new MyClass();//(2)
        b =new MyClass(5);//(3)
    }
}

正确答案: C 你的答案: C (正确)
编译错误将发生在（1），因为构造函数不能指定返回值
编译错误将发生在（2），因为该类没有默认构造函数
编译错误将在（3）处发生，因为该类没有构造函数，该构造函数接受一个int类型的参数
该程序将正确编译和执行

解：MyClass方法并不是构造参数，而是返回类型为void的普通方法，普通方法自然需要实例化对象然后去调用它，所以124不对，第三个是正确的，因为没有带参数的构造器，所以自然不能传一个int进去

20.下面代码将输出什么内容：（）

public class SystemUtil{
    public static boolean isAdmin(String userId){
        return userId.toLowerCase()=="admin";
    }
    public static void main(String[] args){
        System.out.println(isAdmin("Admin"));
    }
}

正确答案: B 你的答案: A (错误)
true
false
1
编译错误

解：在源码中 toLowerCase 是重新 new String()
所以为 == 是比较对象是否是同一个对象，所以为 false 。

21.下面哪一项不是加载驱动程序的方法？
正确答案: A 你的答案: A (正确)
通过DriverManager.getConnection方法加载
调用方法 Class.forName
通过添加系统的jdbc.drivers属性
通过registerDriver方法注册

解：DriverManager.getConnection方法返回一个Connection对象，这是加载驱动之后才能进行的

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

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

正确答案: C 你的答案: D (错误)
堆区、堆区、堆区
堆区、栈区、堆区
堆区、栈区、栈区
堆区、堆区、栈区
静态区、栈区、堆区
静态区、栈区、栈区

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

23.从内存实现或者反射的角度来看，关于继承的说法正确的是（）。
注：此处的继承不代表能调用
正确答案: A 你的答案: C (错误)
子类将继承父类的所有的数据域和方法
子类将继承父类的其可见的数据域和方法
子类只继承父类public方法和数据域
子类只继承父类的方法，而不继承数据域

解：
在一个子类被创建的时候，首先会在内存中创建一个父类对象，然后在父类对象外部放上子类独有的属性，两者合起来形成一个子类的对象。所以所谓的继承使子类拥有父类所有的属性和方法其实可以这样理解，子类对象确实拥有父类对象中所有的属性和方法，但是父类对象中的私有属性和方法，子类是无法访问到的，只是拥有，但不能使用。就像有些东西你可能拥有，但是你并不能使用。所以子类对象是绝对大于父类对象的，所谓的子类对象只能继承父类非私有的属性及方法的说法是错误的。可以继承，只是无法访问

24.以下代码执行的结果显示是多少（）？

正确答案: B 你的答案: A (错误)
num * count = 505000
num * count = 0
运行时错误
num * count = 5050

解：count = count++ 原理是 temp = count； count = count+1 ； count = temp； 因此count始终是0

25.关于 java 的异常处理机制的叙述哪些正确？
正确答案: A B 你的答案: B C (错误)
不论程序是否发生错误及捕捉到异常情况，都会执行finally部分
当try区段的程序发生异常时，才会执行catch区段的程序
catch部分捕捉到异常情况时，才会执行finally部分
其它选项都不正确

在Java中，关于HashMap类的描述，以下正确的是 ()
正确答案: A C D 你的答案: A B (错误)
HashMap使用键/值得形式保存数据
HashMap 能够保证其中元素的顺序
HashMap允许将null用作键
HashMap允许将null用作值

解：HashMap 不按插入顺序排序，按照哈希值排序。所以无序。
但是不增删改键的情况下，输出是按照一定顺序不变的

27.下面哪些类实现或者继承了Collection接口？
正确答案: B C 你的答案: B C D (错误)
HashMap
ArrayList
Vector
Iterator

解：

28.关于Java以下描述正确的有( )
正确答案: C D 你的答案: B D (错误)
Class类是Object类的超类
Object类是一个final类
String类是一个final类
Class类可以装载其它类

解：每个类都使用Object类作为超类，而final修饰的类不能被继承
Class类中的forName()方法返回与带有给定字符串名的类或接口相关联的Class对象（装载其他类）

29.下面的Java赋值语句哪些是有错误的 （）
正确答案: B F 你的答案: D F (正确)
int i =1000;
float f = 45.0;
char s = ‘\u0639’;
Object o = ‘f’;
String s = “hello,world\0”;
Double d = 100;

解：
b：小数如果不加 f 后缀，默认是double类型。double转成float向下转换，意味着精度丢失，所以要进行强制类型转换。
c：是使用unicode表示的字符。
d：‘f’ 字符会自动装箱成包装类，就可以向上转型成Object了。
f：整数默认是int类型，int类型不能转型为Double，最多通过自动装箱变为Integer但是Integer与Double没有继承关系，也没法进行转型。

30.下列哪些方法是针对循环优化进行的
正确答案: A B D 你的答案: B C D (错误)
强度削弱
删除归纳变量
删除多余运算
代码外提

解：
代码优化也可分为局部优化、 循环优化和全局优化：
局部优化指的是在只有一个入口、 一个出口的基本程序块上进行的优化。
循环优化是对循环中的代码进行的优化，在一个程序运行时，相当多的一部分时间会花在循环上，因此，基于循环的优化非常重要。
全局优化是在整个程序范围内进行的优化。
删除多余运算
使生成的目标代码减少而执行速度较快
也叫删除公共子表达式
循环优化：对循环中的代码段，可以进行代码外提、强度削弱和删除归纳变量等优化。
删除多余运算应该不是专门针对循环优化的。

1.将类的成员的访问权限设置为默认的，则该成员能被( )

正确答案: A 你的答案: A (正确)
同一包中的类访问
其它包中的类访问
所有的类访问
所有的类的子类访问

解：public：可以被所有其他类所访问;

protected：自身、子类及同一个包中类可以访问;

default：同一包中的类可以访问;
private：只能被自己访问和修改。
public>protcted>default>priavte

2.下面程序的输出是:()

String x="fmn";
x.toUpperCase();
String y=x.replace('f','F');
y=y+"wxy";
System.out.println(y);

正确答案: D 你的答案: A (错误)
FmNwxy
fmnwxy
wxyfmn
Fmnwxy

解：String x=“fmn”; “fmn”是在常量池里的不可变对象。
x.toUpperCase(); 在堆中new一个"FMN"对象，但无任何引用指向它。
String y=x.replace(‘f’,‘F’); 在堆中 new一个"Fmn"对象，y指向它。
y=y+“wxy”; 在堆中 重新new一个"Fmnwxy"对象， 修改y指向，现在y指向它。

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

String s1 = “ABCD”;

String s2 = “1234”;

System.out.println(s1 + s2);

正确答案: A 你的答案: A (正确)
ABCD
1234
ABCD1234
1234ABCD

4.java用（）机制实现了线程之间的同步执行
正确答案: A 你的答案: A (正确)
监视器
虚拟机
多个CPU
异步调用

5.以下哪一个不是赋值符号？
正确答案: C 你的答案: A (错误)
+=
<<=
<<<=
.> >>=

解：
A.很明显是赋值符号
B.<<=左移赋值
C.不是
D.>>>= 右移赋值，左边空出的位以0填充

6.Java 多线程有几种实现方法？（ ）

正确答案: A B 你的答案: B C (错误)
继承Thread类
实现Runnable接口
实现Thread接口
以上都不正确

解：实现多线程的方法：
1.继承Thread类
2.实现Runnable接口
3.实现Callable接口

7.下面有关servlet的层级结构和常用的类，说法正确的有?
正确答案: A B C D 你的答案: B D (错误)
GenericServlet类：抽象类，定义一个通用的、独立于底层协议的Servlet。
大多数Servlet通过从GenericServlet或HttpServlet类进行扩展来实现
ServletConfig接口定义了在Servlet初始化的过程中由Servlet容器传递给Servlet得配置信息对象
HttpServletRequest接口扩展ServletRequest接口，为HTTP Servlet提供HTTP请求信息

解：
Servlet
GenericServlet
HttpServlet
自己的servlet
ServletRequest
HttpServletRequest
ServletResponse
HttpServletResponse

8.不能用来修饰interface的有（ ）（仅限外部接口）
正确答案: A C D 你的答案: A C D (正确)
private
public
protected
static

9.关于Java的一些概念，下面哪些描述是正确的：( )
正确答案: B F 你的答案: B E (错误)
所有的Java异常和错误的基类都是java.lang.Exception, 包括java.lang.RuntimeException

通过try … catch … finally语句，finally中的语句部分无论发生什么异常都会得到执行

java中所有的数据都是对象

Java通过垃圾回收回收不再引用的变量，垃圾回收时对象的finallize方法一定会得到执行

Java是跨平台的语言，无论通过哪个版本的Java编写的程序都能在所有的Java运行平台中运行

Java通过synchronized进行访问的同步，synchronized作用非静态成员方法和静态成员方法上同步的目标是不同的

解：
B：基本数据类型不是对象，不能用new的方法获取，但是每个基本数据类型都对应着封装类型，这些封装类型为了解决基本数据类型面向对象用的。
F.Synchronized修饰非静态方法，实际上是对调用该方法的对象加锁，俗称“对象锁”
Synchronized修饰静态方法，实际上是对该类对象加锁，俗称“类锁”。

10.下面哪个语句是创建数组的正确语句？( )
正确答案: A B D E 你的答案:A D E (错误)
float f[][] = new float[6][6];
float []f[] = new float[6][6];
float f[][] = new float[][6];
float [][]f = new float[6][6];
float [][]f = new float[6][];

解：长见识了…

11.假设 A 类有如下定义，设 a 是 A 类同一个包下的一个实例，下列语句调用哪个是错误的？（）
class A{
int i;

static String s;

void method1() { }

static void method2() { }

}

正确答案: C 你的答案: C (正确)
System.out.println(a.i)；
a.method1();
A.method1();
A.method2()

解：
非静态方法只能通过实例对象来调用，不能直接通过类名调用。静态方法（static）才能通过类名直接调用.

12.下列哪个对访问修饰符作用范围由大到小排列是正确的？
正确答案: D 你的答案: D (正确)
private>default>protected>public
public>default>protected>private
private>protected>default>public
public>protected>default>private

解：
D public可以被当前类，子类，包，其他包，访问，
protected 可以被当前类，子类，包访问
default可以被可以被当前类，包内访问；
private只能被当前类访问

13.以下代码输出的是：

public class SendValue{
    public String str="6";
    public static void main(String[] args) {
        SendValue sv=new SendValue();
        sv.change(sv.str);
        System.out.println(sv.str);
    }
    public void change(String str) {
        str="10";
    }
}

正确答案: A 你的答案: B (错误)
6
10
都不对
16

解：
Java中String类型变量是immutable（不可变的）。
尽管 change()方法中的str与sv.str都是新的对象实例成员变量值"6"的引用， 由于String类型的 不可变 性，change()方法中的str="10"语句实际上是将传入的str副本引用指向了一个值为“10”的新的内存地址，但 原数据引用 sv.str的引用值（也就是“6”的内存地址） 并没有发生改变，因此sv.str指向的值仍旧为6.

14.以下程序段的输出结果为：

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

正确答案: B 你的答案: B (正确)
false，false
false，true
true，false
true，true

解：= =可用于基本类型和引用类型：当用于基本类型时候，是比较值是否相同；当用于引用类型的时候，是比较对象是否相同。
"==“和”!="比较的是地址 指第一个new()c出来的地址
所以因为两次new() 分出的内存也不同
所以System.out.print(n1 == n2);返回 false
！=就返回true

15.1
2
3
Integer i = 42;
Long l = 42l;
Double d = 42.0;
下面为true的是
正确答案: G 你的答案: G (正确)
(i == l)
(i == d)
(l == d)
i.equals(d)
d.equals(l)
i.equals(l)
l.equals(42L)

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

解：创建线程对象两种方式：
1.继承Thread类，重载run方法；
2.实现Runnable接口，实现run方法

17.下面关于volatile的功能说法正确的是哪个
正确答案: B C 你的答案: B C D (错误)
原子性
有序性
可见性
持久性

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

18.实现或继承了Collection接口的是（）
正确答案: B C E 你的答案: B D (错误)
Map
List
Vector
Iterator
Set

解：

19.关于下面这段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();
}
}

正确答案: C 你的答案: E F (错误)
程序运行输出只有In run
程序运行输出只有Leaving run
程序运行输出先有In run后有Leaving run
程序运行输出先有Leaving run后有In run
程序没有任何输出就退出了
程序将被挂起，只能强制退出

解：
Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。
yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。
结论：yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

20.class A {}
class B extends A {}
class C extends A {}
class D extends B {}
Which four statements are true ?
正确答案: A C D G 你的答案: A (错误)
The type Listis assignable to List.
The type Listis assignable to List.
The type Listis assignable to List<?>.
The type Listis assignable to List<?extends B>.
The type List<?extends A>is assignable to List.
The type Listis assignable to any List reference.
The type List<?extends B>is assignable to List<?extends A>.

解：

1. 只看尖括号里边的！！明确点和范围两个概念
2. 如果尖括号里的是一个类，那么尖括号里的就是一个点，比如List,List,List
3. 如果尖括号里面带有问号，那么代表一个范围，<? extends A> 代表小于等于A的范围，<? super A>代表大于等于A的范围，<?>代表全部范围
4. 尖括号里的所有点之间互相赋值都是错，除非是俩相同的点
5. 尖括号小范围赋值给大范围，对，大范围赋值给小范围，错。如果某点包含在某个范围里，那么可以赋值，否则，不能赋值
6. List<?>和List 是相等的，都代表最大范围
   7.补充：List既是点也是范围，当表示范围时，表示最大范围

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

手机与小米手机
企业家与雷军
编程语言与Java
中国与北京

解：
A：小米手机是一个手机，没毛病
B：雷军是一个企业家，没毛病
C：Java是一门编程语言，没毛病
D：北京是一个中国？！中国是一个北京？？错

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

正确
错误

解：Java的跨平台特性是因为JVM的存在， 它可以执行.class字节码文件，而不是.java源代码

3.下面有关java的一些细节问题，描述错误的是？

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

解：构造方法每次都是构造出新的对象，不存在多个线程同时读写同一对象中的属性的问题，所以不需要同步 。
如果父类中的某个方法使用了 synchronized关键字，而子类中也覆盖了这个方法，默认情况下子类中的这个方法并不是同步的，必须显示的在子类的这个方法中加上 synchronized关键字才可。当然，也可以在子类中调用父类中相应的方法，这样虽然子类中的方法并不是同步的，但子类调用了父类中的同步方法，也就相当子类方法也同步了。
接口里面的变量为常量，其实际是 public static final ；
接口里面的方法为抽象方法，其实际是public abstract。

4.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?

The output is “Equal”
The output in “Not Equal”
An error at line 5 causes compilation to fall.
The program executes but does not print a message.

解：
1、Java中，赋值是有返回值的 ，赋什么值，就返回什么值。x=y，返回y的值，所以括号里的值是1。
2、Java跟C的区别，C中赋值后会与0进行比较，如果大于0，就认为是true；而Java不会与0比较，而是直接把赋值后的结果放入括号。但是int类型，不能转换为boolean，所以会报错：“ Type mismatch: cannot convert from int to boolean ”

5.关于protected 修饰的成员变量，以下说法正确的是

可以被该类自身、与它在同一个包中的其它类、在其它包中的该类的子类所访问
只能被该类本身和该类的所有的子类访问
只能被该类自身所访问
只能被同一个包中的类访问

6.关于Java中参数传递的说法，哪个是错误的？

在方法中，修改一个基础类型的参数不会影响原始参数值
在方法中，改变一个对象参数的引用不会影响到原始引用
在方法中，修改一个对象的属性会影响原始对象参数
在方法中，修改集合和Maps的元素不会影响原始集合参数

解析: 注意!Java中方法的参数传递都是值传递
A. 在方法中，修改一个基础类型的参数不会影响原始参数值

public static void main(String []args){
    int i = 5;   
    func(i);
    System.out.println(i);
}
static void func(int j){
    j = 10;
}
//输出结果
5

在主方法调用func(int j) 时 , 参数i是实际参数 , 值为5 , 参数j是形式参数 , 值是i给的 , 也是5 , i和j没有任何关系 , 是两个独立的参数 , 所以修改j的值时与i没有关系 , 仍然输出5。

B. 在方法中，改变一个对象参数的引用不会影响到原始引用

public static void main(String []args){
    User rabbiter = new User();
    rabbiter.setName("rabbiter");
    func(rabbiter);
    System.out.println(rabbiter.getName());
}
static void func(User user){
    user = new User();
    user.setName("zhangsan");
}
 
//输出结果
rabbiter

在主方法调用func(User user) 时 , 对象rabbiter保存的是一个地址值 , 本质上就是把rabbiter的地址值给了形参user , 所以此时实参rabbiter和形参user指向在堆中的同一个对象 , 他们的地址值相同 , 只是指向的对象一致 , 所以并不违反值传递的理论。
此时 , 如果修改形参user , new一个新的对象并让user指向它 , 修改的只是形参保存的地址 , 与实参rabbiter无关 , rabbiter指向的对象仍然是之前的那个对象。

C. 在方法中，修改一个对象的属性会影响原始对象参数

public static void main(String []args){
    User rabbiter = new User();
    rabbiter.setName("rabbiter");
    func(rabbiter);
    System.out.println(rabbiter.getName());
}
static void func(User user){
    user.setName("zhangsan");
}
 
//输出结果
zhangsan

在主方法调用func(User user) 时 , 对象rabbiter保存的是一个地址值 , 本质上就是把rabbiter的地址值给了形参user , 所以此时实参rabbiter和形参user指向在堆中的同一个对象 , 他们的地址值相同 , 指向的对象一致 , 所以并不违反值传递的理论。
那么user对其指向的对象的属性name进行修改 , rabbiter指向的对象的name属性也就被修改了。

D. 在方法中，修改集合和Maps的元素不会影响原始集合参数
集合和Maps都是对象 , 所以此项跟C选项的解析一致。

有以下一个对象：

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的值分别为：

“”, 0
“”, 2
“123”, 2
“123”, 0

解：这道题的答案应该是: D,序列化保存的是对象的状态，静态变量属于类的状态，因此，序列化并不保存静态变量。所以i是没有改变的

8.有如下一段代码，请选择其运行结果（）

public class StringDemo{
  private static final String MESSAGE="taobao";
  public static void main(String [] args) {
    String a ="tao"+"bao";
    String b="tao";
    String c="bao";
    System.out.println(a==MESSAGE);
    System.out.println((b+c)==MESSAGE);
  }
}

true true
false false
true false
false true

解：
1，字符串在java中存储在字符串常量区中
2，/ == 判断的是对象引用是否是同一个引用，判断字符串相等要用equals方法
首先判断a ==MESSAGE 同一份字符串常量在内存中只有一份，因此是同一地址，返回true
再次比较(b+c)==MESSAGE 这相当于 new String(b+c)==MESSAGE 这里new了一个String对象，所以返回false

9.Java语言中，方法的重写（Overriding）和重载（Overloading）是多态性的不同表现。下边哪些说法是对的？

重写是父类与子类之间多态性的一种表现
重写是一个类中多态性的一种表现
重载是一个类中多态性的一种表现
重载是父类与子类之间多态性的一种表现

解：重写(Overriding)是父类与子类之间多态性的一种表现，类的不同实现可以重写父类方法，实现同方法名，同参数，同返回类型，不同的实现。重载(Overloading)最典型的就是一个类的不同构造函数，方法名相同，参数个数不同，返回类型也可以不同，重载是一个类中多态性的一种表现。

10.下面哪个流类不属于面向字符的流（）

BufferedWriter
FileInputStream
ObjectInputStream
InputStreamReader