admin管理员组文章数量:1579083
一．单选题(2分 x 20)
【单选题】
- 下列说法正确的是 _B。
A. Java程序经编译后会产生machine code
B. Java程序经编译后会产生byte code
C. Java程序经编译后会产生DLL
D. 以上都不正确
【单选题】 - 下列代码中，哪句代码会报错(C)
A. byte b = 127；
B. byte b = 10; b += 1;
C. byte b = 11; b = b + 1;
D. char c = 97；
【单选题】 - 设 int x = 1 , int y = 2 , int z = 3，则表达式 y＋＝z-- / ++x 的值是 A_。
A. 3
B. 3.5
C. 4
D. 5
【单选题】 - 0.6332的数据类型是 B_。
A. float
B. double
C. Float
D. Double
【单选题】 - 下列说法正确的有 C___。
A. class中的constructor不可省略
B. constructor必须与class同名，但方法不能与class同名
C. constructor在一个对象被创建时执行
D. 一个class只能定义一个constructor
【单选题】 - 以下关于继承的叙述正确的是 _A。
A. 在Java中类只允许单一继承
B. 在Java中一个类只能实现一个接口
C. 在Java中一个类不能同时继承一个类和实现一个接口
D. 在Java中接口只允许单一继承
【单选题】 - 构造方法名必须与__A___相同，它没有返回值，用户不能直接调用它，可以通过new使用。
A. 类名
B. 对象名
C. 包名
D. 变量名
【单选题】 - 下列说法中，__B___是正确的。
A. 子类拥有的成员数目大于父类拥有的成员数目
B. 父类代表的对象范围比子类广
C. 子类要调用父类的方法，必须使用super关键字
D. 一个Java类可以有多个父类
【单选题】 - 下列哪种异常是检查型异常，需要在编写方法时声明 C_。
A. NullPointerException
B. ClassCastException
C. FileNotFoundException
D. IndexOutOfBoundsException
【单选题】 - 下面哪个流类属于面向字符的输入流 D_。
A. BufferedWriter
B. FileInputStream
C. ObjectInputStream
D. InputStreamReader
【单选题】 - 阅读如下代码：
1)class Super{
-
public float getNum(){return 3.0f;} - }
- public class Sub extends Super{
- }
which method, placed at line 6, will cause a compiler error? B
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;}
【单选题】
- 阅读代码
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? B
A. compile fail
B. print out “0”
C. print out “3”
D. compile succeded but exception at line 3
【单选题】 - 下列场景中，_____不会触发类加载过程。 D
A. 创建类的实例
B. Jvm加载子类
C. 访问类的静态成员
D. 访问对象的成员
【单选题】 - 下面代码的运行结果为：（C）
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异常
【单选题】
15. 以下对接口描述错误的有 D。
A. 接口没有提供构造方法
B. 接口中的方法默认使用public、abstract修饰
C. 接口中的属性默认使用public、static、final修饰
D. 接口不允许多继承
【单选题】
16. 关于守护线程的说法，正确的是 A。
A. 所有非守护线程终止，即使存在守护线程，进程运行终止
B. 所有守护线程终止，即使存在非守护线程，进程运行终止
C. 只要有守护线程或者非守护进程其中之一存在，进程就不会终止
D. 只要所有的守护线程和非守护线程终止运行之后，进程才会终止
【单选题】
17. 下列方法被调用后，一定使调用线程改变当前状态的是__C_。
A. notify()
B. run()
C. sleep()
D. isAlive()
【单选题】
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最早可以被垃圾回收器回收的位置是：C
A. After line 4
B. After line 6
C. After line 7
D. After line 9(that is,as the method returns)
【单选题】
19. 下列说法正确的是(D)
A. 所有的Java应用程序运行在同一个JVM中
B. 任意类型的两个引用变量，都可以相互赋值(若编译器不允许，可以强制类型转化)
C. 只要类加载完毕，我们就可以调用类中定义的普通成员方法
D. 所有的缓冲流，都是包装流。
【单选题】
20. 在TCP/IP中，解决计算机到计算机之间通信问题的层次是 B___。
A. 网络接口层
B. 网际层
C. 传输层
D. 应用层
二【读程序题】（2分 x 10）
21如下程序打印的结果是什么呢？
（注：答案包括编译失败 或运行异常。请说明结果的同时注明原因，下面同上）
String str1 = “hello”;
String str2 = “he”;
System.out.println(str1pareTo(str2));
- 输出3。 按照String类compareTo的源码，这两个字符串比较的结果应该是str1.length() - str2.length()的结果
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.如下程序打印的结果是什么呢？
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);
}
}
- 程序无限循环，i的值从Integer.MAX_VALUE-100开始，每次自增1，直到Integer.MAX_VALUE，然后继续自增1变成了Integer.MIN_VALUE(溢出)，接着继续自增，直到Integer.MAX_VALUE，并重复。所以打印的值count，从1开始一直到Integer.MAX_VALUE,然后从Integer.MIN_VALUE到Integer.MAX_VALUE，如此周而复始的打印
- 如下程序打印的结果是什么呢？
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);
}
}
- false 先拼接"Animals are equal: " + pig得到新的字符串，然后在比较==
26.如下程序打印的结果是什么呢？
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.如下程序打印的结果是什么呢？
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语句，结束方法执行，带着存储在栈帧中特殊位置的那个
返回值，返回到方法调用处。
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
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();
}
}
- 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);
}
}
}
- 正常结束没有任何输出
a. 因为在Thread子类中，没有覆盖父类的run方法，而是覆盖了父类的start()方法
b. 所以，在Thread子类对象上调用的run方法，实际是Thread类中定义的run方法
而根据Thread类的run方法源码，什么都不会输出
- 如下程序打印的结果是什么呢？
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
a. 首先，执行main方法中的创建对象的语句Reluctant b = new Reluctant();
b. 但是，在创建对象的过程中，会执行成员变量的初始化语句private Reluctant internalInstance = new Reluctant(); ，于是又会创建Reluctant对象，于是又执行a，a执行完了，又执行b… 如此周而复始
c. 于是，就出现了一个递归。
三【简答题】(2分 x 10)
31. 引用类型和基本数据类型有何区别？
- 基本数据类型包括：byte，short，char， int，long，float，double，boolean
引用数据类型主要包括：类，接口等
基本数据类型的变量存储的是该类型变量的值，而引用数据类型的变量存储的是
地址（比如堆中对象的地址）。
- java中父类中定义的哪些方法没有多态效果，为什么？
- 考虑到多态发生的条件是，
1）继承
2）方法覆盖
3）父类引用指向子类实例
所以哪些方法(行为)，实现不了多态效果呢？不能在子类中被覆盖的方法
a. 父类中的private方法(不能被子类覆盖)
b. 父类中的构造方法(不能被子类继承)
c. 父类中的静态方法(不能被子类覆盖)
d. 父类中被final修饰的方法(不能被子类覆盖)
- 如何理解静态上下文无法访问非静态的成员变量和成员方法？
- 所谓静态上下文不能访问非静态的成员变量或成员方法其实是指，在静态上下文中，无法访问，当前对象this的成员变量，或在当前对象this上调用其非静态的成员方法。因为对于静态上下文而言，静态的东西都是不依赖于对象而存在，所以当静态上下文被访问的时候，当前对象可能并不存在，所以自然无法访问
- 方法重载和方法重写的区别。
- 方法重载是指在同一个类中定义同名方法，而这些方法名称相同，但方法签名不同。
方法重写，是指在子类中，修改父类中定义的方法的实现。因此，他们发生的范围是不同的，方法重载发生在一个任意类中，而方法重写，发生在子类中，而且发生方法重写和方法覆盖的条件也不相同(这里不再赘述)，同时，方法重载是编译时多态，而方法重写是运行时多态的前提条件之一
- "=="和equals方法有何异同？
- == 对于基本数据类型的数据而言，比较的是内容，对于引用数据类型的数据而言，比较的引用变量，所指向的内存地址。
equals方法是Object类的方法，其默认实现是比较两个对象的内存地址是否相同，若想：要比较量对象的内容是否相同，则需要在子类中覆盖Object的equals方法
- 字符流和字节流最主要的区别是什么？如何理解字符流=字节流+编码表？
- 字节流和字符流最主要的区别是，流中数据的逻辑单位不同，字节流中数据的逻辑单位是二进制的字节数据，而字符流中，数据的逻辑单位是单个字符。
a）字符数据在内存中还是以二进制（字符的在编码表中对应的编码值）的形式保存和传输
b）而对于二进制的字节数据的写和读，字节流就已经能够很好的完成了
c） 但为了保证字符流中的数据是一个一个的完整字符，所以字符流在字节流的基础上，添加了编解码器，即在使用底层字节流写数据前，先利用编码器，对字符数据进行编码得到字符数据对应的二进制编码序列，然后利用底层字节流传输它们，同时，在读取数据的时候，先用解码器，将由底层字节流传输的字节数据，解码成一个一个的字符。
所以字符流的功能实现是字节流 + 编码表(基于编码表的编解码操作)
- 使用缓冲流是否可以在一定程度改善应用程序的IO的效率？为什么？？
- 缓冲流可以从一定程度上改善Java程序的IO效率。因为，IO的底层实现，是要依靠操作系统内核的功能来实现的，而我们的java程序每次请求操作系统内核的功能完成IO的时候，都需要付出额外的代价。既然，每次完成IO操作，都需要付出一次通信代价，那么意味着，一次IO操作如果读写的数据越多，那么平均到每个字节(字符)的数据，所付出的额外代价就会越小。
而缓冲流，本身维护了一个较大的缓冲区，能够在和操作系统内核交互的过程中，一次读写较多的字节(字符)数据，从而在整个数据传输过程中，减少java程序和操作系统内核通信的次数。从而减少了，应用程序为了完成功能，所需要付出的额外代价
- 同步和异步有何异同，在什么情况下分别使用他们？
- 异步简单来说就是，线程之间，各自独立运行，互不影响，就好像线程之间“同时”，在各自做自己的事情，简单来说，就是我走你也走
同步和异步相对，同步是指线程之间不能在各自为政，自己运行自己的，而是在某些情况下等待其他线程。简单来说，就是我走你不走
线程天生就是异步执行的，而当多线程异步访问同一个共享数据的时候，为了保证共享数据访问的正确性，必须保证同时只有一个线程，能访问并修改共享变量的值，这意味着，如果一个线程正在，访问某共享变量，则其他所有要访问该共享变量的线程都需要等待，直到，该线程访问完毕。
- Java语言多线程设计中，为什么wait, notify 和 notifyAll这些线程通信的方法不在thread类里面？
- 线程通信，其实是依靠锁对象，来完成的(对于wait方法而言，调用wait方法的对象，首相必须被当前线程，作为锁对象持有)，而java语言中的锁对象，可以是任意对象，因此这些方法被定义在Object中
- Java多线程中调用wait() 和 sleep()方法有什么不同？
- sleep方法的唤醒条件是时间，而wait()方法的唤醒条件是，必须被在同一个锁对象上调用notify()或notifyAll()方法。
sleep方法是Thread类的静态方法，而wait()方法是Object类的方法
sleep方法在导致当前线程休眠时，当前线程不会释放所有有的锁，而wait()方法导致当前线程休眠时，当前线程会释放锁对象
四．【编程题】（10分 x 2）
42. 编程题：
给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
比如，如果数组是[1, 2, 3]则加1之后的结果是[1, 2, 4], 如果数组是[1, 2, 9]加1之后的结果就是[1, 3, 0]
public static int[] arrayAdd(int[] nums){
for(int i = nums.length-1; i >= 0; i++){
nums[i]++;
nums[i] = nums[i] % 10;
if(nums[i] != 0) return nums;
}
int[] res = new int[nums.length + 1];
res[0] = 1;
return res;
}
【简答题】
43. 编程题：输入一个整型数组，数组里面有正数也有负数，数组中连续的一个或多个整数组成子数组，每个子数组都有一个和。求所有子数组的和的最大值。例如，输入的数字为：1，-2,3,10，-4,7,2，-5，则和最大的子数组为3,10，-4,7,2和为18。
public static int arrayAdd(int[] nums){
int sum = nums[0];
int currentSum = nums[0];
for (int i = 1; i < nums.length; i++) {
if(currentSum < 0)
currentSum = nums[i];
else {
currentSum += nums[i];
}
if(currentSum > sum) sum = currentSum;
}
return sum;
}
本文标签： 测试题
版权声明：本文标题：测试题----- 内容由热心网友自发贡献，该文观点仅代表作者本人， 转载请联系作者并注明出处：https://m.elefans.com/xitong/1727846228a1133121.html， 本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。
发表评论