Java基础学习生疏知识点总结（20）——SE模考错题总结

3 设 int x = 1 , int y = 2 , int z = 3，则表达式 y＋＝z-- / ++x 的值是 _____。

A. 3
B. 3.5
C. 4
D. 5

8 下列说法中，_____是正确的。

A. 子类拥有的成员数目大于父类拥有的成员数目
B. 父类代表的对象范围比子类广
C. 子类要调用父类的方法，必须使用super关键字
D. 一个Java类可以有多个父类

14 下面代码的运行结果为：（）

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 以下对接口描述错误的有 _____。

A. 接口没有提供构造方法
B. 接口中的方法默认使用public、abstract修饰
C. 接口中的属性默认使用public、static、final修饰
D. 接口不允许多继承

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)

21 如下程序打印的结果是什么呢？

（注：答案包括编译失败 或运行异常。请说明结果的同时注明原因，下面同上）
String str1 = “hello”;
String str2 = “he”;
System.out.println(str1.compareTo(str2));

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

}

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

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

}

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

31. 引用类型和基本数据类型有何区别？

【简答题】

32. java中父类中定义的哪些方法没有多态效果，为什么？

【简答题】

33. 如何理解静态上下文无法访问非静态的成员变量和成员方法？

【简答题】

34. 方法重载和方法重写的区别。

【简答题】

35. "=="和equals方法有何异同？

【简答题】

36. 字符流和字节流最主要的区别是什么？如何理解字符流=字节流+编码表？

【简答题】

37. 使用缓冲流是否可以在一定程度改善应用程序的IO的效率？为什么？？

【简答题】

38. 同步和异步有何异同，在什么情况下分别使用他们？

【简答题】

39. Java语言多线程设计中，为什么wait, notify 和 notifyAll这些线程通信的方法不在thread类里面？

【简答题】

40. Java多线程中调用wait() 和 sleep()方法有什么不同？

41. 编程题：

给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
比如，如果数组是[1, 2, 3]则加1之后的结果是[1, 2, 4], 如果数组是[1, 2, 9]加1之后的结果就是[1, 3, 0]

【简答题】

42. 编程题：输入一个整型数组，数组里面有正数也有负数，数组中连续的一个或多个整数组成子数组，每个子数组都有一个和。求所有子数组的和的最大值。例如，输入的数字为：1，-2,3,10，-4,7,2，-5，则和最大的子数组为3,10，-4,7,2和为18。

答案：

3、A
解析：y = (3/2)+2，都是int型，所以结果为3。
8、B
解析：
A:子类拥有的成员数目大于等于父类拥有的成员数目
C:除构造方法和静态方法外，子类要调用父类的方法，不需要使用super关键字
D:一个java类不可以有多个父类，只可以有1个父类。Java类只支持单继承，不支持多继承，所以只可以有1个父类；接口可以多继承，所以接口可以有多个父类。
14、C
由于String s没有初始化，代码不能编译通过。
15、D
接口可以多继承，所以接口可以有多个父类。
18、C
GC确定垃圾方式：引用计数。
当对象o所指向的区域引用计数为0时，才会被确认为垃圾，等待GC回收调度算法进行回收。
所以最早可以被回收的位置是引用计数为0时，选C。
21、输出3。 按照String类compareTo的源码，这两个字符串比较的结果应该是str1.length() - str2.length()的结果。
22、打印结果为0，父类方法被子类覆盖，即使在父类中调用，调用到的也是子类方法，而此时父类对象还在初始化过程中，子类对象更是还未开始初始化，其成员变量的值还是默认值。
23、程序无限循环，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，如此周而复始的打印。
29、正常结束没有任何输出
a. 因为在Thread子类中，没有覆盖父类的run方法，而是覆盖了父类的start()方法
b. 所以，在Thread子类对象上调用的run方法，实际是Thread类中定义的run方法
而根据Thread类的run方法源码，什么都不会输出
30、Stackoverflow error
a. 首先，执行main方法中的创建对象的语句Reluctant b = new Reluctant();
b. 但是，在创建对象的过程中，会执行成员变量的初始化语句private Reluctant internalInstance = new Reluctant(); ，于是又会创建Reluctant对象，于是又执行a，a执行完了，又执行b… 如此周而复始
c. 于是，就出现了一个递归。
31. 基本数据类型包括：byte，short，char， int，long，float，double，boolean
引用数据类型主要包括：类，接口等
基本数据类型的变量存储的是该类型变量的值，而引用数据类型的变量存储的是
地址（比如堆中对象的地址）。
32. 考虑到多态发生的条件是，
1）继承
2）方法覆盖
3）父类引用指向子类实例
所以哪些方法(行为)，实现不了多态效果呢？不能在子类中被覆盖的方法
a. 父类中的private方法(不能被子类覆盖)
b. 父类中的构造方法(不能被子类继承)
c. 父类中的静态方法(不能被子类覆盖)
d. 父类中被final修饰的方法(不能被子类覆盖)
33. 所谓静态上下文不能访问非静态的成员变量或成员方法其实是指，在静态上下文中，无法访问，当前对象this的成员变量，或在当前对象this上调用其非静态的成员方法。因为对于静态上下文而言，静态的东西都是不依赖于对象而存在，所以当静态上下文被访问的时候，当前对象可能并不存在，所以自然无法访问。
34. 方法重载是指在同一个类中定义同名方法，而这些方法名称相同，但方法签名不同。
方法重写，是指在子类中，修改父类中定义的方法的实现。因此，他们发生的范围是不同的，方法重载发生在一个任意类中，而方法重写，发生在子类中，而且发生方法重写和方法覆盖的条件也不相同(这里不再赘述)，同时，方法重载是编译时多态，而方法重写是运行时多态的前提条件之一
35. == 对于基本数据类型的数据而言，比较的是内容，对于引用数据类型的数据而言，比较的引用变量，所指向的内存地址。
equals方法是Object类的方法，其默认实现是比较两个对象的内存地址是否相同，若想：要比较量对象的内容是否相同，则需要在子类中覆盖Object的equals方法
36. 字节流和字符流最主要的区别是，流中数据的逻辑单位不同，字节流中数据的逻辑单位是二进制的字节数据，而字符流中，数据的逻辑单位是单个字符。

a）字符数据在内存中还是以二进制（字符的在编码表中对应的编码值）的形式保存和传输
b）而对于二进制的字节数据的写和读，字节流就已经能够很好的完成了
c） 但为了保证字符流中的数据是一个一个的完整字符，所以字符流在字节流的基础上，添加了编解码器，即在使用底层字节流写数据前，先利用编码器，对字符数据进行编码得到字符数据对应的二进制编码序列，然后利用底层字节流传输它们，同时，在读取数据的时候，先用解码器，将由底层字节流传输的字节数据，解码成一个一个的字符。
所以字符流的功能实现是字节流 + 编码表(基于编码表的编解码操作)
37. 缓冲流可以从一定程度上改善Java程序的IO效率。因为，IO的底层实现，是要依靠操作系统内核的功能来实现的，而我们的java程序每次请求操作系统内核的功能完成IO的时候，都需要付出额外的代价。既然，每次完成IO操作，都需要付出一次通信代价，那么意味着，一次IO操作如果读写的数据越多，那么平均到每个字节(字符)的数据，所付出的额外代价就会越小。
而缓冲流，本身维护了一个较大的缓冲区，能够在和操作系统内核交互的过程中，一次读写较多的字节(字符)数据，从而在整个数据传输过程中，减少java程序和操作系统内核通信的次数。从而减少了，应用程序为了完成功能，所需要付出的额外代价
38. 异步简单来说就是，线程之间，各自独立运行，互不影响，就好像线程之间“同时”，在各自做自己的事情，简单来说，就是我走你也走
同步和异步相对，同步是指线程之间不能在各自为政，自己运行自己的，而是在某些情况下等待其他线程。简单来说，就是我走你不走

线程天生就是异步执行的，而当多线程异步访问同一个共享数据的时候，为了保证共享数据访问的正确性，必须保证同时只有一个线程，能访问并修改共享变量的值，这意味着，如果一个线程正在，访问某共享变量，则其他所有要访问该共享变量的线程都需要等待，直到，该线程访问完毕。
39. 线程通信，其实是依靠锁对象，来完成的(对于wait方法而言，调用wait方法的对象，首相必须被当前线程，作为锁对象持有)，而java语言中的锁对象，可以是任意对象，因此这些方法被定义在Object中
40. sleep方法的唤醒条件是时间，而wait()方法的唤醒条件是，必须被在同一个锁对象上调用notify()或notifyAll()方法。
sleep方法是Thread类的静态方法，而wait()方法是Object类的方法
sleep方法在导致当前线程休眠时，当前线程不会释放所有有的锁，而wait()方法导致当前线程休眠时，当前线程会释放锁对象
41

42 该题目，其实有对应的o(n)时间复杂度的实现，即一次遍历，得到结果