一、单选题(1分 x 20)
1、下列说法正确的是 _____。
A. JVM只根据文件类型后缀判断一个文件是否是字节码文件
B. 编译器已经对java语言做了语法检查，所以JVM在运行字节码的时候不会再做检查
C. 每一个字节码文件开头的4个字节的数据都相同
D. 以上都不正确
在这里插入代码片
2、设 int x = 1 , int y = 2 , int z = 3，则表达式 y %＝z-- / ++x 的值是 _____。
A. 0
B. 3
C. 4
D. 5
在这里插入代码片
3、0.6332 + 0.3668的结果的数据类型是 _____。
A. int
B. double
C. Integer
D. Double
在这里插入代码片
4、 下列说法正确的有 _____。
A. 可以有一个类没有constructor
B. constructor必须与class同名，但方法不能与class同名
C. constructor在创建对象的时候执行
D. 定义一个constructor只需，让其方法名与类名相同即可
在这里插入代码片
5、以下关于继承的叙述正确的是 _____。
A. 子类类型的引用变量，一定可以赋值给父类类型的引用变量
B. 父类类型的引用变量，一定可以赋值给子类类型的引用变量
C. 父类类型的引用变量，可以赋值给子类类型的引用变量
D. 子类类型的引用变量，不可以赋值给父类类型的引用变量
在这里插入代码片
6、构造方法名必须与_____相同，它没有返回值，用户不能直接调用它，只能通过new使用。
A. 类名
B. 对象名
C. 包名
D. 变量名
在这里插入代码片
7、下列说法中，_____是正确的。
A. 子类拥有的成员数目大于父类拥有的成员数目
B. 父类代表的对象范围比子类广
C. 子类要调用父类的方法，必须使用super关键字
D. 一个Java类可以继承多个父类
在这里插入代码片
8、下列哪种异常出现在方法的异常列表中，会影响该方法的方法覆盖条件 _____。
A. NullPointerException
B. ClassCastException
C. FileNotFoundException
D. IndexOutOfBoundsException
在这里插入代码片
9、下面哪个流类属于面向字符的输入流 _____。
A. BufferedWriter
B. FileInputStream
C. ObjectInputStream
D. InputStreamReader
在这里插入代码片
10、阅读如下代码：
1)class Super{
2) public float getNum(){
return 3.0f;
}
3) }
4)
5) public class Sub extends Super{
6)
7) }
which method, placed at line 6, will cause a compiler error?
A. public float getNum(){return 4.0f;}
B. public void getNum(){}
C. public void getNum(double d){}
D. public double getNum(float d){return 4.0d;}
11、阅读代码
public class Equals{
public static void add3(Integer i){
int val = i.intValue();
val += 3;
i = new Integer(val);
}
public static void main(String args[]){
Integer i=new Integer(0);
add3(i);
System.out.println(i.intValue());
}
}
what is the result?
A. compile fail
B. print out "0"
C. print out “3”
D. compile succeded but exception at line 3
12、下列场景中，_____一定会触发类加载过程。
A. 创建类的实例
B. 用java命令运行java程序
C. 访问类的字面值常量(即类名.class)
D. 正确执行Class.forName方法
在这里插入代码片
13、下面代码的运行结果为：（）
import java.io.*;
import java.util.*;
public class foo{
public static void main (String[] args){
String s;
System.out.println("s=" + s);
}
}
A. 代码得到编译，并输出“s=”
B. 代码得到编译，并输出“s=null”
C. 由于String s没有初始化，代码不能编译通过
D. 代码得到编译，但捕获到 NullPointException异常
String s = null;
14、以下对接口描述错误的有 _____。
A. 接口没有提供构造方法
B. 接口中的方法默认使用public、abstract修饰
C. 接口中的属性默认使用public、static、final修饰
D. 接口中的方法不能有方法体
在这里插入代码片
15、下面有关JVM内存，说法错误 _____。
A. 程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行到了第几行，是线程隔离的
B. Java方法执行内存模型（stack），用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的
C. 方法区用于存储JVM加载的类信息、常量、静态变量、即使编译器编译后的代码等数据，是线程隔离的
D. 原则上讲，所有new出来的对象都在堆区上分配内存，是线程之间共享的
在这里插入代码片
16、关于守护线程的说法，正确的是 _____。
A. 所有非守护线程终止，即使存在守护线程，进程运行终止
B. 所有守护线程终止，即使存在非守护线程，进程运行终止
C. 只要有守护线程或者非守护进程其中之一存在，进程就不会终止
D. 只要所有的守护线程和非守护线程终止运行之后，进程才会终止
在这里插入代码片
17、下列方法被调用后，一定使调用线程改变当前状态的是_____。
A. notify()
B. run()
C. sleep()
D. notifyAll()
在这里插入代码片
18、有如下程序
1)public class X{
2) public Object m(){
3) Object o=new Float(3.14F);
4) Object[] oa=new Object[1];
5) oa[0]=o;
6) o=null;
7) oa[0]=null;
8) System.out.println(oa[0]);
9) }
10) }
对象o最早可以被垃圾回收器回收的位置是：
A. After line 4
B. After line 6
C. After line 7
D. After line 9(that is,as the method returns)
在这里插入代码片
19、JAVA语言对象状态的持久化是通过_____实现的。
A. 文件
B. 管道
C. 序列化
D. 过滤器
在这里插入代码片
20、 在TCP/IP中，解决进程到进程之间通信问题的层次是 _____。
A. 网络接口层
B. 网际层
C. 传输层
D. 应用层
在这里插入代码片
二、读程序题（4分 x 10）
要求：除了要写出结果，还要解释为什么。
21、如下程序打印的结果是什么呢？（注：答案包括编译失败 或运行异常。请说明结果的同时注明原因，下面同上）
public class InTheLoop {
public static final int END = Integer.MAX_VALUE;
public static final int START = END - 100;
public static void main(String[] args) {
int count = 0;
for (int i = START; i <= END; i++) {
count++;
}
System.out.println(count);
}
}
程序无限循环，先打印出从Integer.MAX_VALUE-100到Integer.MAX_VALUE的这100个数，
然后，从Integer.MIN_VALUE开始接着打印，直到Integer.MAX_VALUE，并重复
=======================================================================================================
将输出放在for循环外面
System.out.println("count的值为：" + count);
count的值为：101（加了101次）
Integer.MIN_VALUE，int的最小值-2147483648
整数在计算机中以补码的形式存在，所以最大值 + 1 = 最小值
22、如下程序打印的结果是什么呢？（多态）
如果在同包的某个main方法中运行Father father = new Son(1000)，程序的输出结果是什么?
class Father {
int i = 10;
public Father() {
System.out.println(getI());
}
public int getI() {
return i;
}
}
class Son extends Father {
int i = 100;
public Son(int i) {
this.i = i;
}
public int getI() {
return i;
}
}
打印结果为0
父类方法被子类覆盖，即使在父类中调用，调用到的也是子类方法
而此时父类对象还在初始化过程中，子类对象更是还未开始初始化，其成员变量的值还是默认值。
23. 如下程序打印的结果是什么呢？（String类，字符串）
public class AnimalFarm{
public static void main(String[] args){
final String pig = "length: 10";
final String dog = "length: " + pig.length();
System.out. println("Animals are equal: " + pig == dog);
}
}
System.out. println("Animals are equal: " + pig == dog); 这一句有问题
3.false
先拼接"Animals are equal: " + pig得到新的字符串，然后在比较==
24. 如下程序打印的结果是什么呢？（String类，字符串）
String str1 = "hello";
String str2 = "he" + new String("llo");
System.err.println(str1 == str2);
False
Str2 和 str1所指向的是两个不同的字符串对象，
一个是字符串常量池中的”hello”对应的字符串对象，一个是堆上的一个新的字符串对象
String str1= "hello", String str2="he"+"llo";之所以str1==str2返回true
是因为两者都是在字符串常量池中（由于初始化就会在此区域分布内存）
但是String str3= "he"+a;String a="llo";时str1==str3返回的为false
是因为：str1指向的hello在编译期一如既往的还是分配在常量区内，a指向的llo也在常量区，虽然str3也是初始化但是编译器
无法判断a这货到底是什么个情况，进而不会将str3的等号右侧声明在常量区内，而是在通过构造时在堆区中的非常量池外的内存中声明
至此str3与str1不止是分配内存的时期不同（一个在编译期，一个在运行期）而且在内存空间的区域也不同。
25. 如下程序打印的结果是什么呢？（静态方法不能被重写 / 覆盖）
class Dog {
public static void bark() {
System.out.print("woof ");
}
}
class Basenji extends Dog {
public static void bark() {
}
}
public class Bark {
public static void main(String args[]) {
Dog woofer = new Dog();
Dog nipper = new Basenji();
woofer.bark();
nipper.bark();
}
}
woof woof
静态方法不能被覆盖，
所以两次方法调用实际上调用的都是父类，Dog类中定义的静态方法，所以输出两次woof
因此，通过一个指向子类对象的父类引用变量 来调用父子同名的静态方法时，只会调用父类的静态方法
26. 如下程序打印的结果是什么呢？（try-catch-finally执行与返回值问题）
public class Indecisive {
public static void main(String[] args) {
System.out.println(decision());
}
static boolean decision() {
try {
return true;
} finally {
return false;
}
}
}
False
a.执行第一条return语句的时候，首先将待返回的结果，复制到该方法栈帧中的一个特 殊位置。
b.紧接着，执行finally代码块中的return语句，又将该return语句待返回的值，放到栈帧中，
用来存放方法返回值的那个特殊位置(将第一个return语句存放的待返回结果覆盖掉)
C.然后继续执行第二个return语句，结束方法执行，带着存储在栈帧中特殊位置的那个 返回值，返回到方法调用处。
参考博客：
一、执行顺序
1、执行try块；
2、如果try块中有异常，则执行catch块；
3、无论有无异常，都会执行finally块;
4、但是要注意，如果在try块或者catch块中添加了System.exit(0)，程序会退出，finally不会执行。
二、返回值问题-return
1、无论try-catch中有无异常，如果finally块中有return语句，最后返回的是finally的return值；
2、如果finally中没有return语句，若try中有异常，则返回catch中的return值，反之，则返回try中return值。
在这种情况下，return语句是在finally之后执行的。
27. 如下程序打印的结果是什么呢？（异常）
public class Test{
public static void main(String[]args) {
int[]x={
0，1，2，3};
for(int i=0;i<3;i+=2) {
try{
system.out.println(x[i+2]/x[i]+x[i+1]);
}catch(ArithmeticException e){
System.out.println("errorl");
}catch(Exception e){
System.out.println("error2");
}
}
}
}
error1
error2
a.当i值为0时，执行第一次for循环，此时try块中输出语句中输出的计算表达式是在 求 2 / 0 + 1,很显然，发生除0异常，输出error1
b.紧接着执行第二次循环，此时i值为2，try块的输出语句中计算的是 x[4] / x[2] + x[3], 此时x[4]数组越界，于是输出error2
异常体系结构还熟悉吗？
ArithmeticException
Exception
28. 如下程序打印的结果是什么呢？（好题：构造代码块可放回 构造方法的第一行）（不熟悉，突然间有点晕哦）
public class TestMain {
这里是静态代码块
static {
System.out.println("C");
}
这里是构造代码块
{
System.out.println("B");
}
这里是构造方法
public TestMain(){
System.out.println("A");
}
public static void main(String[] args) {
TestMain testMain = new TestMain(); new 对象
}
}
C
B
A
静态代码块先于构造代码块，构造代码块先于构造方法
29. 如下程序打印的结果是什么呢？
public class Bground extends Thread{
public static void main(String[] args){
Bground bground=new Bground();
bground.run();
}
public void start(){
for (int i = 0; i < 10; i++) {
System.out.println("B ground.start()"+i);
}
}
}
正常结束没有任何输出（答案简略描述为：子类没有覆盖父类的run方法，实际调用的是Thread子类中的run方法，所以什么都不会输出）
a.因为在Thread子类中，没有覆盖父类的run方法，而是覆盖了父类的start()方法
b.所以，在Thread子类对象上调用的run方法，实际是Thread类中定义的run方法
而根据Thread类的run方法源码，什么都不会输出
30. 如下程序打印的结果是什么呢？
public class Reluctant {
private Reluctant internalInstance = new Reluctant();
public Reluctant() throws Exception {
throw new Exception("I'm not coming out");
}
public static void main(String[] args) {
try {
Reluctant b = new Reluctant();
System.out.println("Surprise!");
} catch (Exception ex) {
System.out.println("I told you so");
}
}
}
Stackoverflow error （在创建对象的过程中，会执行成员变量的初始化语句，于是又会创建Reluctant对象，出现了一个递归）
a.首先，执行main方法中的创建对象的语句Reluctant b = new Reluctant();
b.但是，在创建对象的过程中，会执行成员变量的初始化语句private Reluctant internalInstance = new Reluctant();
于是又会创建Reluctant对象，于是又执行a，a执行完了，又执行b... 如此周而复始
c.于是，就出现了一个递归。
三、简答题(2分 x 10)
31、引用类型和原始类型有何区别？基本数据类型有哪些（共8种）？
基本数据类型包括：byte，short，char， int，long，float，double，boolean
引用数据类型主要包括：类，接口等
基本数据类型的变量存储的是该类型变量的值，而引用数据类型的变量存储的是
地址（比如堆中对象的地址）
32、notify 和 notifyAll什么情况下会造成虚假唤醒？为什么？怎么解决？
虚假唤醒：唤醒了本不该唤醒的线程。当使用notifyAll方法的时候，会唤醒在此对象上等待的所有线程，就会有不该唤醒的线程被唤醒
所以要在生产者消费者每次执行之前，判断此时是否满足消费者或者生产者的执行条件，
不满足满足条件，就继续wait阻止自己
满足条件，才执行，这样一来，即使出现了虚假唤醒，也能保证生产者和消费者之间正确的协作
33、方法重载和方法重写的区别。注解的保留级别分别有哪些，每种保留级别有什么含义？
方法重载是指在同一个类中定义同名方法，而这些方法名称相同，但方法签名不同。
方法重写，是指在子类中，定义和父类“一模一样”的方法，来修改父类中定义的方法的实现。
a. 他们发生的范围是不同的，方法重载发生在一个任意类中，而方法重写，发生在子类中
b. 而且发生方法重写和方法覆盖的条件也不相同(这里不再赘述)
c. 同时，方法重载是编译时多态，而方法重写是运行时多态的前提条件之一
注解中的保留级别，
SOURCE：注解将被编译器丢弃(class文件中没有)
CLASS：注解在class文件中可用，但会被JVM丢弃(内存没有)
RUNTIME：JVM在运行时，也会保留注解信息，注解默认情况下的保留级别是CLASS。
34、字符流和字节流最主要的区别是什么？如何理解字符流=字节流+编码表？
字节流和字符流最主要的区别是，流中数据的逻辑单位不同
字节流中数据的逻辑单位是二进制的字节数据，而字符流中，数据的逻辑单位是单个字符
a）字符数据在内存中还是以二进制（字符的在编码表中对应的编码值）的形式保存和传输
b）而对于二进制的字节数据的写和读，字节流就已经能够很好的完成了
即在使用底层字节流写数据前，先利用编码器，对字符数据进行编码得到字符数据对应的二进制编码序列，然后利用底层字节流传输它们
同时，在读取数据的时候，先用解码器，将由底层字节流传输的字节数据，解码成一个一个的字符
35、同步异步单词怎么拼写？静态同步方法和非静态的同步方法的锁对象相同吗？分别哪个锁对象？
同步synchronized 与 异步asynchronized
非静态的同步方法的锁对象是this，
静态同步方法的锁对象是字节码文件对象
36、"=="和equals方法有何异同？
== 对于基本数据类型的数据而言，比较的是内容，对于引用数据类型的数据而言，比较的引用变量，所指向的内存地址
equals方法是Object类的方法，其默认实现是比较两个对象的内存地址是否相同，若想：要比较量对象的内容是否相同，则需要在子类中覆盖Object的equals方法
37、 写深度克隆的clone()方法时，该方法题通常都有一行代码，是什么？
super.clone()
因为该方法其实是在调用Object的clone方法，首先实现对该对象自身的浅克隆，然后在针对，该对象的引用变量做进一步的处理
38、java中实现运行时多态的前提条件有哪些？哪些方法不会有多态效果？
java中实现运行时多态，有3个前提条件: 继承，方法覆盖，父类引用指向子类实例
不能在子类中被覆盖的方法
a. 父类中的private方法(不能被子类覆盖)
b. 父类中的构造方法(不能被子类继承)
c. 父类中的静态方法(不能被子类覆盖)
d. 父类中被final修饰的方法(不能被子类覆盖)
39、Java多线程中调用wait() 和 sleep()方法有什么不同？【考试题】
唤醒条件不同：sleep方法的唤醒条件是时间，而wait()方法的唤醒条件是，必须被在同一个锁对象上调用notify()或notifyAll()方法。
所属不同：sleep方法是Thread类的静态方法，而wait()方法是Object类的方法
对于锁对象的持有不同：sleep方法在导致当前线程休眠时，当前线程不会释放所有的锁，而wait()方法导致当前线程休眠时，
当前线程会释放锁对象
使用条件不同: wait方法必须在锁对象上调用才能正确执行
40、使用缓冲流是否可以在一定程度改善应用程序的IO的效率？为什么？？缓冲流的默认缓冲区大小是多少？是否可以修改？
默认缓冲区大小：如果是缓冲字节流8KB，如果是缓冲字符流16KB(因为一个字符两个字节), 可以通过构造函数去修改默认缓冲区大小。
四、编程题（10分 x 2）
41、编程题：给你一个整数数组 nums，请你返回其中位数为 偶数 的数字的个数。
比如，对于数组nums = [12,345,2,6,7896]
12 是 2 位数字（位数为偶数)，345 是 3 位数字（位数为奇数），2 是 1 位数字（位数为奇数），6 是 1 位数字 位数为奇数），
7896 是 4 位数字（位数为偶数）
因此只有 12 和 7896 是位数为偶数的数字，结果为2，注意，其中1 <= nums[i] <= 10^5。
42、编程题：给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字），
并返回该子数组所对应的乘积。
例如，输入的数字为：[2,3,-2,4]，结果是6，子数组 [2,3] 有最大乘积 6
[-2,0,-1]结果是0，结果不能为 2, 因为 [-2,-1] 不是子数组。