Java基础题(五)

87 阅读 0 评论 58 点赞

我是靠谱客的博主单身日记本，最近开发中收集的这篇文章主要介绍Java基础题(五)，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

1.javac将源程序编译成.class字节码文件；java将字节码转为机器码，.exe程序

2. package语句必须作为源文件的第一条非注释性语句，一个源文件只能指定一个包，只能包含一条package语句

3. 在java中，无论在何处调用，使用静态属性必须以类名做前缀。(错)
解析：
1如果是本类使用，可以直接就用静态变量名。
2如果是其他类使用，可以使用类名来调用，也可以创建一个实例对象来调用。
3如果静态变量所在的类是静态类，那么不管在本类里或者在其他外部类，都可以直接使用静态变量名。

4. 一个类的构造器不能调用这个类中的其他构造器。（错）
解析：
this(x)，这种形式的调用就ok

5.
1.接口必须为public abstract，因为接口是高度抽象的类，它的存在就是被其他类实现。
2.接口中声明的变量必须为 public static final。
3.接口中定义的方法必须为public abstract，且没有方法体。

6. 事务隔离级别是由谁实现的？（C）
A. Java应用程序
B. Hibernate
C. 数据库系统
D. JDBC驱动程序
解析：
A，我们写java程序的时候只是设定事物的隔离级别，而不是去实现它
B，Hibernate是一个java的数据持久化框架，方便数据库的访问
C，事物隔离级别由数据库系统实现，是数据库系统本身的一个功能
D，JDBC是java database connector，也就是java访问数据库的驱动

7. 下面的方法，当输入为2的时候返回值是多少?()

public static int getValue(int i) {
int result = 0;
switch (i) {
case 1:
result = result + i;
case 2:
result = result + i * 2;
case 3:
result = result + i * 3;
}
return result;
}

解析：
switch结构中没有break的话，匹配完不会跳出，会继续匹配下一个case直到整个结构结束
所以：case 2结束时result=4；case3结束时result=10；

8. 有以下类定义,运行后为(B)：：

abstract class Animal{
abstract void say();
}
public class Cat extends Animal{
public Cat(){
System.out.printf("I am a cat");
}
public static void main(String[] args) {
Cat cat=new Cat();
}
}

A. I am a cat
B. Animal能编译，Cat不能编译
C. Animal不能编译，Cat能编译
D. 编译能通过，但是没有输出结果

解析：
当一个实体类继承一个抽象类时，有两种解决方法：
1实现抽象类中的全部抽象方法；
2用abstract修饰子类，不实现抽象方法，方法的实现交由别的类实现。

9. 在java7中,下列哪个说法是正确的(D)
A. ConcurrentHashMap使用synchronized关键字保证线程安全
B. HashMap实现了Collection接口
C. Arrays.asList方法返回java.util.ArrayList对象
D. SimpleDateFormat对象是线程不安全的
解析：
A项：hashMap在单线程中使用大大提高效率，在多线程的情况下使用hashTable来确保安全。hashTable中使用synchronized关键字来实现安全机制，但是synchronized是对整张hash表进行锁定即让线程独享整张hash表，在安全同时造成了浪费。concurrentHashMap采用分段加锁的机制来确保安全
B项：HashMap继承了AbstractMap类，实现的是Map接口
C项：Arrays.asList()
将一个数组转化为一个List对象，这个方法会返回一个ArrayList类型的对象，这个ArrayList类并非java.util.ArrayList类，而是Arrays类的静态内部类！用这个对象对列表进行添加删除更新操作，就会报UnsupportedOperationException异常。

10. 下面哪段程序能够正确的实现了GBK编码字节流到UTF-8编码字节流的转换：（B）
byte[] src,dst;
A. dst=String.frombytes(src,”GBK”).getbytes(“UTF-8”)
B. dst=new String (src,”GBK”).getbytes(“UTF-8”)
C. dst=new String (”GBK”, src,) getbytes()
D. dst=String.encode(String.decode(src,”GBK”)), “UTF-8”)

解析：
String (byte[] bytes, String charsetName) 通过使用指定的 charset 解码指定的 byte 数组，构造一个新的String
String.getBytes(Charset charset) 使用给定的 charset 将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组

11. 以下声明合法的是(B)
A. default String s
B. public final static native int w( )
C. abstract double d
D. abstract final double hyperbolicCosine( )

解析：
A：java的访问权限有public、protected、private和default的，default不能修饰变量
C：普通变量不能用abstract修饰，abstract一般修饰方法和类
D：被定义为abstract的类需要被子类继承，但是被修饰为final的类是不能被继承和改写的

12.
原子性-事务管理子系统
一致性-完整子系统
隔离性-并发控制子系统
持久性-恢复管理子系统

13. 以下程序的输出结果为(D)

class Base{
public Base(String s){
System.out.print("B");
}
}
public class Derived extends Base{
public Derived (String s) {
System.out.print("D");
}
public static void main(String[] args){
new Derived("C");
}
}

A. BD
B.DB
C.C
D. 编译错误

解析：
在调用子类构造器之前，会先调用父类构造器，当子类构造器中没有使用"super(参数或无参数)"指定调用父类构造器时，是默认调用父类的无参构造器，如果父类中包含有参构造器，却没有无参构造器，则在子类构造器中一定要使用“super(参数)”指定调用父类的有参构造器，不然就会报错。

14. 匿名内部类的创建格式为：
new 父类构造器（参数列表）|实现接口（）{
//匿名内部类的类体实现
}
1.使用匿名内部类时，必须继承一个类或实现一个接口
2.匿名内部类由于没有名字，因此不能定义构造函数
3.匿名内部类中不能含有静态成员变量和静态方法

Mark：在使用匿名内部类的过程中，我们需要注意如下几点：
1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。
2、匿名内部类中是不能定义构造函数的。
3、匿名内部类中不能存在任何的静态成员变量和静态方法。
4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。
5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

15. You have the following code.Which numbers will cause “Test2” to be printed?（BCD）
switch (x)
{
case 1: System.out.println(“Test1”);
case 2:
case 3:
System.out.println(“Test2”);
break;
default:
System.out.println(“Test3”);
break;
}
A.0
B.1
C.2
D.3
E.4

16. 下面代码在main()方法中第八行后可以正常使用的是（AD ）
public class Test
{
private int a=10;
int b=20;
static int c=1;
public static void main(String arg[])
{
Test t = new Test();
}
}
A. t.a
B. this.c
C. Test.b
D. Test.c

解析：
A : 在private 修饰不能在外部类中调用，main 方法属于Test类的方法，所以对象 t 可以在他自己的类方法中调用它的private
B ： static 方法中没有this 这么一说
C: b不是static变量
D: 合理

17. JDK提供的用于并发编程的同步器有哪些？(ABC)
A. Semaphore
B. CyclicBarrier
C. CountDownLatch
D. Counter
解析：
A，Java 并发库的Semaphore 可以很轻松完成信号量控制，Semaphore可以控制某个资源可被同时访问的个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。
B，CyclicBarrier 主要的方法就是一个：await()。await() 方法每被调用一次，计数便会减少1，并阻塞住当前线程。当计数减至0时，阻塞解除，所有在此 CyclicBarrier 上面阻塞的线程开始运行。
C，直译过来就是倒计数(CountDown)门闩(Latch)。倒计数不用说，门闩的意思顾名思义就是阻止前进。在这里就是指 CountDownLatch.await() 方法在倒计数为0之前会阻塞当前线程。
D，Counter不是并发编程的同步器

18.

public class NameList
{
private List names = new ArrayList();
public synchronized void add(String name)
{
names.add(name);
}
public synchronized void printAll()
{
for (int i = 0; i < names.size(); i++)
{
System.out.print(names.get(i) + ””);
}
}
public static void main(String[]args)
{
final NameList sl = new NameList();
for (int i = 0; i < 2; i++)
{
new Thread()
{
public void run()
{
sl.add(“A”);
sl.add(“B”);
sl.add(“C”);
sl.printAll();
}
} .start();
}
}
}

Which two statements are true if this class is compiled and run?（EG）
A. n exception may be thrown at runtime.
B. The code may run with no output, without exiting.
C. The code may run with no output, exiting normally(正常地).
D. The code may rum with output “A B A B C C “, then exit.
E. The code may rum with output “A B C A B C A B C “, then exit.
F The code may ruin with output “A A A B C A B C C “, then exit.
G The code may ruin with output “A B C A A B C A B C “, then exit.

解析：
在每个线程中都是顺序执行的，所以sl.printAll();必须在前三句执行之后执行，也就是输出的内容必有（连续或非连续的）ABC。
而线程之间是穿插执行的，所以一个线程执行 sl.printAll();之前可能有另一个线程执行了前三句的前几句。
E答案相当于线程1顺序执行完然后线程2顺序执行完。
G答案则是线程1执行完前三句add之后线程2插一脚执行了一句add然后线程1再执行 sl.printAll();输出ABCA。接着线程2顺序执行完输出ABCABC
输出加起来即为ABCAABCABC

19. Which lines of the following will produce an error?（）

1. byte a1 = 2, a2 = 4, a3;
2. short s = 16;
3. a2 = s;
4. a3 = a1 * a2;

A. Line 3 and Line 4
B. Line 1 only
C. Line 3 only
D. Line 4 only

解析：
低级向高级是隐式类型转换
高级向低级必须强制类型转换
byte<char<short<int<long<float<double
Line3：short类型转为byte类型出错
Line4：a1*a2结果为int类型，转为byte类型出错

20. 下列选项中是正确的方法声明的是？（ABCD）
A.protected abstract void f1();
B. static final void fq(){}
C. public final void f1() {}
D. private void f1() {}

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

21. 下面的程序编译运行后，在屏幕上显示的结果是（A）

public class test {
public static void main(String args[]) {
int x,y;
x=5>>2;
y=x>>>2;
System.out.println(y);
}
}

A.0
B.2
C.5
D.80
解析：
5的二进制是0101。
x=5>>2 （>>带符号右移）
将0101右移2位，为：0001。
y=x>>>2 （>>>无符号右移，左边空缺补充为0）
将0001右移2位，补0。结果为：0000。
所以得出答案0

22. Test.main()函数执行后的输出是（ B）

class Test {
public static void main(String[] args) {
System.out.println(new B().getValue());
}
static class A {
protected int value;
public A (int v) {
setValue(v);
}
public void setValue(int value) {
this.value= value;
}
public int getValue() {
try {
value ++;
return value;
} finally {
this.setValue(value);
System.out.println(value);
}
}
}
static class B extends A {
public B () {
super(5);
setValue(getValue()- 3);
}
public void setValue(int value) {
super.setValue(2 * value);
}
}
}

A. 6 7 7
B. 22 34 17
C. 22 74 74
D. 11 17 34
解析：
new B() ->[super(5)(显示调用父类)->setValue(5)->(调用子类重写的的setValue(5)->super.setValue(10)-> this.value= 10)
->[setValue(getValue()-3){setValue([getValue()(调用父类的方法) value++(value = 11,return value = 11),执行finally{
this.setValue(11)调用子类的setValue(11)->(super.setValue(22) Sysout.system.out(22))
->[ setValue(11-3)(return 的是11)]setValue(8) ->super.setValue(2 * 8) )->super.setValue(16) this.value = 16;
(new B()).getValue())->value +±>return value ;return value值(value=17 )->finally (this.setValue(17 *2)System.out.print(34))
->System.out.print(new B().getValue));System.out.print(17)

23. 下面程序的输出是什么？（B）

package algorithms.com.guan.javajicu;
public class TestDemo
{
public static String output = ””;
public static void foo(inti)
{
try
{
if (i == 1)
{
throw new Exception();
}
}
catch (Exception e)
{
output += “2”;
return ;
} finally
{
output += “3”;
}
output += “4”;
}
public static void main(String[] args)
{
foo(0);
foo(1);
System.out.println(output);
}
}

A. 342
B. 3423
C. 34234
D. 323

解析：
首先是foo(0),在try代码块中未抛出异常，finally是无论是否抛出异常必定执行的语句，
所以 output += “3”;然后是 output += “4”;
执行foo(1)的时候，try代码块抛出异常，进入catch代码块，output += “2”;
前面说过finally是必执行的，即使return也会执行output += “3”
由于catch代码块中有return语句，最后一个output += “4”不会执行。
所以结果是3423

24. What results from the following code fragment?©

int i = 5;
int j = 10;
System.out.println(i + ~j);

A. Compilation error because”~”doesn’t operate on integers
B.-5
C.-6
D.15
解析：
方法一：公式-n=_n+1可推出n=-n-1，所以~10=-11再加5结果为-6
**方法二：**计算机本身储存的就是补码
10的补码就是10的原码：0000 0000 0000 1010——这是补码，因为现在是计算机在计算
~10的补码就是：1111 1111 1111 0101
~10的反码就是：1111 1111 1111 0100——补码减1
~10的原码就是：1000 0000 0000 1011——反码取反：这个才是正常二进制数，换算为整数为-11
即结果5-11=-6

25. 给定以下JAVA代码，这段代码运行后输出的结果是（B）

public class Test
{
public static int aMethod(int i)throws Exception
{
try{
return i/10;
}
catch (Exception ex)
{
throw new Exception("exception in a aMethod");
}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");
}
}

A. exception in main finished
B. finally finished
C. exception in main finally
D. finally exception in main finally

解析：
进入main方法->try->aMethod(0)->return 0/10;这里注意并没有出现异常所以执行finally打印finally，返回的时候也并没有异常，所以不会打印exception in main然后按照顺序执行然后打印finished

26. jvm中垃圾回收分为scanvenge gc和full GC，其中full GC触发的条件可能有哪些（CDE）
A. 栈空间满
B. 年轻代空间满
C. 老年代满
D. 持久代满
E. System.gc()
解析：
1，新生代：（1）所有对象创建在新生代的Eden区，当Eden区满后触发新生代的Minor GC，将Eden区和非空闲Survivor区存活的对象复制到另外一个空闲的Survivor区中。（2）保证一个Survivor区是空的，新生代Minor GC就是在两个Survivor区之间相互复制存活对象，直到Survivor区满为止。
2，老年代：当Survivor区也满了之后就通过Minor GC将对象复制到老年代。老年代也满了的话，就将触发Full GC，针对整个堆（包括新生代、老年代、持久代）进行垃圾回收。
3，持久代：持久代如果满了，将触发Full GC。

27. 下列哪些语句关于 java 内存回收的说明是正确的？(B)
A. 程序员必须创建一个线程来释放内存
B. 内存回收程序负责释放无用内存
C. 内存回收程序允许程序员直接释放内存
D. 内存回收程序可以在指定的时间释放内存对象
解析：
A：垃圾回收程序是一般是在堆上分配空间不够的时候会自己进行一次GC，程序员不需要也不能主动释放内存。
B：Java的内存释放由垃圾回收程序来进行释放
C：在Java里，内存的释放由垃圾回收程序进行管理，程序员不能直接进行释放。
D：程序员可以调用System.gc()运行垃圾回收器，但是不能指定时间。

28. 在（函数代码小，频繁调用）情况下适宜采用内联函数。

29. 代码的运行结果是（编译错误）

package com.sunline.java;
public class A implements B extends C{
public static void main(String args[]){
System.out.println("hello sunline!");
}
}

解析：先继承再实现

30.
在java中一个unicode占2个字节（byte）。
一个字节等于8比特位（bit）。
所以每个Unicode码占用16个比特位。

31. 在Struts框架中如果要使用Validation作验证的话，需要使用以下哪个Form？
（DynaValidatorActionForm）动态验证表单

32. 存根（Stub）与以下哪种技术有关(B)
A.交换
B. 动态链接
C. 动态加载
D. 磁盘调度
MARK:
存根类是一个类，它实现了一个接口，它的作用是：如果一个接口有很多方法，如果要实现这个接口，就要实现所有的方法。但是一个类从业务来说，可能只需要其中一两个方法。如果直接去实现这个接口，除了实现所需的方法，还要实现其他所有的无关方法。而如果通过继承存根类就实现接口，就免去了这种麻烦。
RMI 采用stubs 和 skeletons 来进行远程对象(remote object)的通讯。stub 充当远程对象的客户端代理，有着和远程对象相同的远程接口，远程对象的调用实际是通过调用该对象的客户端代理对象stub来完成的。
每个远程对象都包含一个代理对象stub，当运行在本地Java虚拟机上的程序调用运行在远程Java虚拟机上的对象方法时，它首先在本地创建该对象的代理对象stub, 然后调用代理对象上匹配的方法。每一个远程对象同时也包含一个skeleton对象，skeleton运行在远程对象所在的虚拟机上，接受来自stub对象的调用。这种方式符合等到程序要运行时将目标文件动态进行链接的思想

enum AccountType
{
SAVING, FIXED, CURRENT;
private AccountType()
{
System.out.println(“It is a account type”);
}
}
class EnumOne
{
public static void main(String[]args)
{
System.out.println(AccountType.FIXED);
}
}

A．Compiles fine and output is prints”It is a account type”once followed by”FIXED”
B．Compiles fine and output is prints”It is a account type”twice followed by”FIXED”
C. Compiles fine and output is prints”It is a account type”thrice followed by”FIXED”
D. Compiles fine and output is prints”It is a account type”four times followed by”FIXED”
E. Compilation fails

解析：
枚举类有多少个实例，就会调用多少次构造方法(枚举类有三个实例，故调用三次构造方法，打印三次It is a account type
)
枚举类构造方法只能加private修饰符(或不加）,因为枚举类本身已经是构造好的，不允许再被外部构造

34. jre 判断程序是否执行结束的标准是（所有的前台线程执行完毕）
MARK: main()函数即主函数，是一个前台线程，前台进程是程序中必须执行完成的，而后台线程则是java中所有前台结束后结束，不管有没有完成，后台线程主要用与内存分配等方面
前台线程和后台线程的区别和联系：
1、后台线程不会阻止进程的终止。属于某个进程的所有前台线程都终止后，该进程就会被终止。所有剩余的后台线程都会停止且不会完成。
2、可以在任何时候将前台线程修改为后台线程，方式是设置Thread.IsBackground 属性。
3、不管是前台线程还是后台线程，如果线程内出现了异常，都会导致进程的终止。

4、托管线程池中的线程都是后台线程，使用new Thread方式创建的线程默认都是前台线程。
说明：
应用程序的主线程以及使用Thread构造的线程都默认为前台线程
使用Thread建立的线程默认情况下是前台线程，在进程中，只要有一个前台线程未退出，进程就不会终止。主线程就是一个前台线程。而后台线程不管线程是否结束，只要所有的前台线程都退出（包括正常退出和异常退出）后，进程就会自动终止。一般后台线程用于处理时间较短的任务，如在一个Web服务器中可以利用后台线程来处理客户端发过来的请求信息。而前台线程一般用于处理需要长时间等待的任务，如在Web服务器中的监听客户端请求的程序，或是定时对某些系统资源进行扫描的程序

35. 以下代码的输出结果是？（）

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

A. 静态块构造块构造块构造块
B. 构造块静态块构造块构造块
C. 构造块构造块静态块构造块
D. 构造块构造块构造块静态块

解析：
静态块：用static申明，JVM加载类时执行，仅执行一次
构造块：类中直接用{}定义，每一次创建对象时执行
执行顺序优先级：静态块>main()>构造块>构造方法
静态域中包含静态变量、静态块和静态方法,
静态块和静态属性是优先级别相同的，所以按先后顺序执行

36. What will happen when you attempt to compile and run the following code?(D)

public class Test{
static{
int x=5;
}
static int x,y;
public static void main(String args[]){
x--;
myMethod( );
System.out.println(x+y+ ++x);
}
public static void myMethod( ){
y=x++ + ++x;
}
}

A. compiletime error
B. prints:1
C. prints:2
D. prints:3

解析：
1.静态语句块中x为局部变量，不影响静态变量x的值
2.x和y为静态变量，默认初始值为0，属于当前类，其值得改变会影响整个类运行。
3.java中自增操作非原子性的
main方法中：
• 执行x–后 x=-1
• 调用myMethod方法，x执行x++结果为-1(后++)，但x=0，++x结果1，x=1 ，则y=0
• x+y+ ++x,先执行x+y，结果为1，执行++x结果为2，得到最终结果为3
局部变量，静态块外部不能直接调用；静态块一般用在一些初始化操作

37. 下面的对象创建方法中哪些会调用构造方法（AC）？
A.new语句创建对象
B. 调用Java.io.ObjectInputStream的readObject方法
C. java反射机制使用java.lang.Class或java.lang.reflect.Constructor的newInstance()方法
D. 调用对象的clone()方法

解析：
构造函数的作用是完成对象的初始化。当程序执行到new操作符时，首先去看new操作符后面的类型，因为知道了类型，才能知道要分配多大的内存空间。分配完内存之后，再调用构造函数，填充对象的各个域，这一步叫做对象的初始化。而选项B、D中，对象的初始化并不是通过构造函数完成的，而是读取别的内存区域中的对象的各个域来完成。
readObject方法只是从文件中还原对象，clone只是一种复制拷贝对象。