[Java知识库]Java小题精炼训练营(篇七)

1、下面叙述错误的是 ( )

一个类可以有多个构造方法

最终类不能派生子类，最终方法不能被覆盖

如果一个类中没有定义构造方法，则Java在生成这个类的实例时不会调用构造方法。

数组一旦创建之后，就不能再改变其长度

A.一个类可以有多个构造方法，实际上就是方法的重载，正确

B.用final修饰的类不能被继承，方法不能被覆盖，正确

C.如果没有构造方法，编译器会自动添加一个空参构造方法，错误

D.由源码可知，数组内部采用字符数组存储，该字符数组用final修饰，长度一旦确定不可再变，正确

C

2、一个类中，有两个方法名、形参类型、顺序和个数都完全一样，返回值不一样的方法,这种现象叫覆盖。（ ）

正确

错误

重载（overload）和重写（override）的区别： 重载就是同一个类中，有多个方法名相同，但参数列表不同（包括参数个数和参数类型），与返回值无关，与权限修饰符也无关。调用重载的方法时通过传递给它们不同的参数个数和参数类型来决定具体使用哪个方法，这叫多态。 重写就是子类重写基类的方法，方法名，参数列表和返回值都必须相同，否则就不是重写而是重载。权限修饰符不能小于被重写方法的修饰符。重写方法不能抛出新的异常或者是比被重写方法声明更加宽泛的检查型异常。

B

3、若所用变量都已正确定义，以下选项中，非法的表达式是（）

a!= 4||b==1

’a’ % 3

’a’ = 1/3

’A’ + 32

'a'是个常数，不能赋值

C

4、以下程序的运行结果是？

foobar

barfoo

foobar或者barfoo都有可能

Bar

调用start（）后，线程会被放到等待队列，等待CPU调度，并不一定要马上开始执行，只是将这个线程置于可动行状态。然后通过JVM，线程Thread会调用run（）方法，执行本线程的线程体。
1.start（）方法来启动线程，真正实现了多线程运行。这时无需等待run方法体代码执行完毕，可以直接继续执行下面的代码；
2.run（）方法当作普通方法的方式调用。程序还是要顺序执行，要等待run方法体执行完毕后，才可继续执行下面的代码， 这样就没有达到写线程的目的。

A

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

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

i=0

i=10

程序有编译错误

i=true

在接口里面的变量默认都是public static final 的，它们是公共的,静态的,最终的常量.相当于全局常量，可以直接省略修饰符。

实现类可以直接访问接口中的变量

C

6、列表(List)和集合(Set)下面说法正确的是？ ?(?)

Set中至多只能有一个空元素

List中至多只能有一个空元素

List和Set都可以包含重复元素的有序集合

List和Set都是有序集合

list有序有重；set无序无重

A

7、以下对选择语句描述错误的是(）

根据某一条件重复执行一部分代码直到满足终止条件为止

可以根据条件控制程序流程，改变程序执行的顺序

选择语句可以嵌套使用

当条件满足时就会执行相应的语句

A答案说的是循环语句

java的4类流程控制语句

1. 循环语句：while，for，do while
2. 选择语句（分支语句）：if,switch
3. 跳转语句：break,continue,break,label
4. 异常处理语句：try catch finally，throw、

A

8、有时为了避免某些未识别的异常抛给更高的上层应用，在某些接口实现中我们通常需要捕获编译运行期所有的异常，?catch?下述哪个类的实例才能达到目的：（）

Error

Exception

RuntimeException

Throwable

因为error是系统出错，catch是无法处理的，难以修复的，RuntimeException不需要程序员进行捕获处理，error和exception都是throwable的子类，我们只需要对exception的实例进行捕获即可

9、默认类型等价表示是哪一项:

public interface IService {String NAME="default";}

public String NAME="default";

public static String NAME="default";

public static final String NAME="default";

private String NAME="default";

接口中的变量默认是public static final 的，方法默认是public abstract 的。接口中的成员包括：全局常量和抽象方法。接口中的成员都有固定的修饰符， 成员变量：public static final 成员方法：public abstract 接口中的成员的访问权限都是公共的，接口中可以隐藏不写这些固定的修饰符。接口不可以实例化，只有子类重写了接口中的所有方法后，子类才可以实例化，否则子类还是一个抽象类。子类重写方法的访问权限都是public的。

C

10、如果一个接口Cow有个方法drink()，有个类Calf实现接口Cow，则在类Calf中正确的是？ ?(?)

void drink() { …}

protected void drink() { …}

public void drink() { …}

以上语句都可以用在类Calf中

子类重写父类方法时，方法的访问权限不能小于原访问权限，在接口中，方法的默认权限就是public，所以子类重写后只能是public

1、接口是一种约束和规范，是一种更加更高级的抽象类，抽象类的方法必须是公开的，因为要给人继承和使用啊，不用public，别人怎么看得到，所以在接口实现时，定义的方法修饰符必须是public；因此子类在实现接口重写方法时的修饰符必须是public。

2、另外再扩展一下，接口中没有变量（既然是约束和规范，怎么能够定义一个大家都可以改的东西呢？），只能是常量，接口中定义常量默认的修饰符为public static final。

C

11、java如何返回request范围内存在的对象？

request.getRequestURL()

request.getAttribute()

request.getParameter()

request.getWriter()

request.getParameter()方法传递的数据，会从Web客户端传到Web服务器端，代表HTTP请求数据；request.setAttribute()和getAttribute()方法传递的数据只会存在于Web容器内部，在具有转发关系的Web组件之间共享。

request域代表一次请求处理的过程，就是从客户端到服务端的一次请求的过程。?request.getParameter()获取HTTP提交过来的数据。

而request.getAttribute()方法返回reques，sessiont范围内存在的对象。

B

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

一旦一个对象成为垃圾，就立刻被收集掉。

对象空间被收集掉之后，会执行该对象的finalize方法

finalize方法和C++的析构函数是完全一回事情

一个对象成为垃圾是因为不再有引用指着它，但是线程并非如此

1、在java中，对象的内存在哪个时刻回收，取决于垃圾回收器何时运行。

2、一旦垃圾回收器准备好释放对象占用的存储空间，将首先调用其finalize()方法， 并且在下一次垃圾回收动作发生时，才会真正的回收对象占用的内存（《java 编程思想》）

3、在C++中，对象的内存在哪个时刻被回收，是可以确定的，在C++中，析构函数和资源的释放息息相关，能不能正确处理析构函数，关乎能否正确回收对象内存资源。

在java中，对象的内存在哪个时刻回收，取决于垃圾回收器何时运行，在java中，所有的对象，包括对象中包含的其他对象，它们所占的内存的回收都依靠垃圾回收器，因此不需要一个函数如C++析构函数那样来做必要的垃圾回收工作。当然存在本地方法时需要finalize()方法来清理本地对象。在《java编程思想》中提及，finalize()方法的一个作用是用来回收“本地方法”中的本地对象

4、?线程的释放是在run()方法结束以后，此时线程的引用可能并未释放。

D

13、假定str0,...,str4后序代码都是只读引用。Java 7中，以上述代码为基础，在发生过一次FullGC后，上述代码在Heap空间（不包括PermGen）保留的字符数为（）

static String str0="0123456789";
static String str1="0123456789";
String str2=str1.substring(5);
String str3=new String(str2);
String str4=new String(str3.toCharArray());
str0=null;

5

10

15

20

这是一个关于java的垃圾回收机制的题目。垃圾回收主要针对的是堆区的回收，因为栈区的内存是随着线程而释放的。堆区分为三个区：年轻代（Young Generation）、年老代（Old Generation）、永久代（Permanent Generation，也就是方法区）。

?年轻代：对象被创建时（new）的对象通常被放在Young（除了一些占据内存比较大的对象）,经过一定的Minor GC（针对年轻代的内存回收）还活着的对象会被移动到年老代（一些具体的移动细节省略）。

年老代：就是上述年轻代移动过来的和一些比较大的对象。Minor GC(FullGC)是针对年老代的回收

永久代：存储的是final常量，static变量，常量池。

str3,str4都是直接new的对象，而substring的源代码其实也是new一个string对象返回，

经过fullgc之后，年老区的内存回收，则年轻区的占了15个，不算PermGen

C

14、假设?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);
}

-1

-2

0

1

不管怎样线程对a的操作就是+1后-2

1.线程1执行完再线程2执行，1-2+1-2=-2

2.线程1和2同时+1，再-2不同时，1-2-2=-3

3.线程1和2不同时+1，同时-2，1+1-2=0

4.线程1和2既同时+1又同时-2，1-2=-1

没有结果为1的情况

D

15、在java中重写方法应遵循规则的包括（）

访问修饰符的限制一定要大于被重写方法的访问修饰符

可以有不同的访问修饰符

参数列表必须完全与被重写的方法相同

必须具有不同的参数列表

方法的重写（override）两同两小一大原则：

方法名相同，参数类型相同

子类返回类型小于等于父类方法返回类型，

子类抛出异常小于等于父类方法抛出异常，

子类访问权限大于等于父类方法访问权限。

BC

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

新生代串行收集器

老年代串行收集器

并行收集器

新生代并行回收收集器

老年代并行回收收集器

cms收集器

两个最基本的java回收算法：复制算法和标记清理算法

复制算法：两个区域A和B，初始对象在A，继续存活的对象被转移到B。此为新生代最常用的算法

标记清理：一块区域，标记可达对象（可达性分析），然后回收不可达对象，会出现碎片，那么引出

标记-整理算法：多了碎片整理，整理出更大的内存放更大的对象

两个概念：新生代和年老代

新生代：初始对象，生命周期短的

永久代：长时间存在的对象

整个java的垃圾回收是新生代和年老代的协作，这种叫做分代回收。

P.S：Serial New收集器是针对新生代的收集器，采用的是复制算法

Parallel New（并行）收集器，新生代采用复制算法，老年代采用标记整理

Parallel?Scavenge（并行）收集器，针对新生代，采用复制收集算法

Serial Old（串行）收集器，新生代采用复制，老年代采用标记整理

Parallel?Old（并行）收集器，针对老年代，标记整理

CMS收集器，基于标记清理

G1收集器：整体上是基于标记?整理?，局部采用复制

综上：新生代基本采用复制算法，老年代采用标记整理算法。cms采用标记清理。

AD