java测试复盘4（2019.8.28）

复盘4

1.问题：
下面的方法，当输入为2的时候返回值是多少？ D*

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

A.0
B.2
C.4
D.10
解析：switch结构中没有break;switch case 方法中若，没有break跳出执行则程序就会从第一个匹配上的case一直执行到整个结构结束。

2.问题：
下列不属于算法结构的是（）C*
A.输入数据
B.处理数据
C.存储数据
D.输出结果
解析：算法包括0个或多个输入，1个或多个输出，中间有穷个处理过程。
存储结构不属于算法结构

3.问题：
(多选)下面有关java的instanceof、?、&、&&说法正确的有？ ABCD*
A.instanceof 可用来判断某个实例变量是否属于某种类的类型。
B."?：" 三目运算符
C.&在逻辑运算中是非短路逻辑与，在位运算中是按位与
D.&& 逻辑运算：逻辑与
解析：值得一提的是：1、三目运算是右结合的。2、&不短路，&&短路。

4.问题：
(多选)如果Child extends Parent，那么正确的有（）？ BCD*
A.如果Child是class，且只有一个有参数的构造函数，那么必然会调用Parent中相同参数的构造函数
B.如果Child是interface，那么Parent必然是interface
C.如果Child是interface，那么Child可以同时extends Parent1，Parent2等多个interface
D.如果Child是class，并且没有显示声明任何构造函数，那么此时仍然会调用Parent的构造函数
解析：A 可以调用父类无参的构造函数，子类的有参构造函数和是否调用父类的有参数的构造函数无必然联系。 B 接口继承的时候只能继承接口不能继承类，因为如果类可以存在非抽象的成员，如果接口继承了该类，那么接口必定从类中也继承了这些非抽象成员，这就和接口的定义相互矛盾，所以接口继承时只能继承接口。 C 接口可以多继承可以被多实现，因为接口中的方法都是抽象的，这些方法都被实现的类所实现，即使多个父接口中有同名的方法，在调用这些方法时调用的时子类的中被实现的方法，不存在歧义；同时，接口的中只有静态的常量，但是由于静态变量是在编译期决定调用关系的，即使存在一定的冲突也会在编译时提示出错；而引用静态变量一般直接使用类名或接口名，从而避免产生歧义，因此也不存在多继承的第一个缺点。 对于一个接口继承多个父接口的情况也一样不存在这些缺点。所以接口可以多继承。 D 子类即使没有显示构造函数，也会有个无参数的默认构造函数，仍然会调用父类的构造函数

5.问题：
在java中，在同一包内，类Cat里面有个公有方法sleep()，该方法前有static修饰，则可以直接用Cat.sleep()。（ ） A*
A.正确
B.错误
解析：object中无sleep方法，只有wait，notify等方法

6.问题：
以下哪个不属于JVM堆内存中的区域（）？ B*
A.survivor区
B.常量池
C.eden区
D.old区
解析：jvm堆分为：新生代（一般是一个Eden区，两个Survivor区），老年代（old区）。
常量池属于 PermGen（方法区）

7.问题：
.以下哪项不属于java类加载过程？ B*
A.生成java.lang.Class对象
B.int类型对象成员变量赋予默认值
C.执行static块代码
D.类方法解析
解析：类的加载包括：加载，验证，准备，解析，初始化。 选项A：生成java.lang.Class对象是在加载时进行的。生成Class对象作为方法区这个类的各种数据的访问入口。 选项B：既然是对象成员，那么肯定在实例化对象后才有。在类加载的时候会赋予初值的是类变量，而非对象成员。 选项C：这个会调用。可以用反射试验。 选项D：类方法解析发生在解析过程

8.问题：
下列有关Servlet的生命周期，说法不正确的是？ A*
A.在创建自己的Servlet时候，应该在初始化方法init()方法中创建Servlet实例
B.在Servlet生命周期的服务阶段，执行service()方法，根据用户请求的方法，执行相应的doGet()或是doPost()方法
C.在销毁阶段，执行destroy()方法后会释放Servlet 占用的资源
d.destroy()方法仅执行一次，即在服务器停止且卸载Servlet时执行该方法
解析：创建Servlet的实例是由Servlet容器来完成的，且创建Servlet实例是在初始化方法init()之前

9.问题：
(多选) 有关finally语句块说法正确的是（ ） ABC*
A.不管catch是否捕获异常，finally语句块都是要被执行的
B.在try语句块或catch语句块中执行到System.exit(0)直接退出程序
C.finally块中的return语句会覆盖try块中的return返回
D.finally 语句块在 catch语句块中的return语句之前执行
解析：1、不管有木有出现异常，finally块中代码都会执行；
2、当try和catch中有return时，finally仍然会执行；
3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；
4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

10.问题：
在（ ）情况下适宜采用内联函数。 A*
A.函数代码小，频繁调用
B.函数代码多，频繁调用
C.函数体含有递归语句
D.函数体含有循环语句
解析：java中用final指明内联函数,编译器最终怎么处理有自己的优化方法,内联函数用增加存储空间换取调用函数的效率 ,适合代码少频繁调用的函数

11.问题：
关于依赖注入，下列选项中说法错误的是（）？ C*
A.依赖注入能够独立开发各组件，然后根据组件间关系进行组装
B.依赖注入提供使用接口编程
C.依赖注入使组件之间相互依赖，相互制约
D.依赖注入指对象在使用时动态注入
解析：依赖注入的动机就是减少组件之间的耦合度，使开发更为简洁

12.问题：
下面有关java内存模型的描述，说法错误的是？ D*
A.JMM通过控制主内存与每个线程的本地内存之间的交互，来为java程序员提供内存可见性保证
B.“synchronized” — 保证在块开始时都同步主内存的值到工作内存，而块结束时将变量同步回主内存
C.“volatile” — 保证修饰后在对变量读写前都会与主内存更新。
D.如果在一个线程构造了一个不可变对象之后（对象仅包含final字段），就可以保证了这个对象被其他线程正确的查看
解析：D.final只是指向不变，但是指向的值有可能变，所以依然不是线程安全

13.问题：

void main(void) {
    char *s = "1314520";
    int v1 = 0, v2 = 0, v3 = 0, v4 =0;
    for (int i = 0; s[i]; i++) {
        switch(s[i]) {
            default: v4++;
            case '1': v1++;
            case '2': v2++;
            cas3 '3': v3++;
        }
    }
    printf("%d, %d, %d, %d", v4,v1,v2,v3)
}  

A*
A.3,5,6,7
B.7,7,7,7
C.7,2,1,1
D.0,2,1,1
解析：default顾名思义是缺省情况，只有任何条件都不匹配的情况下才会执行，故会匹配到s[i]为‘4’，‘5’，‘0’ 的情况。于是v4++三次，v4=3.并且这个default后没有使用break语句，于是case‘1’、‘2’、‘3’都会执行三次。注意到所以语句都没有加break，则语句执行过之后会继续下面的case语句，另外由于s[i]中有两个1，故v1,v2,v3此时为5.另外有一个2，v2,v3++后为6，还有一个case3 于是v3++.最终v3为7.

14.问题：
下列不正确的 Java 语言标识符是（ ） C*
A.Sky
B.$ComputerC.forD.NULL解析：1）只能包含字母a-zA-Z，数字0-9，下划{线}_{和}美元符号$；
2）首字母不能为数字；
3）关键字和保留字不能作为标识符

15.问题：
下列有关Thread的描述，哪个是正确的？ C*
A.启动一个线程的方法是：thread. run()
B.结束一个线程的通常做法是：thread. stop()
C.将一个线程标记成daemon线程，意味着当主线程结束，并且没有其它正在运行的非daemon线程时，该daemon线程也会自动结束。
D.让一个线程等待另一个线程的通知的方法是：thread. sleep()
解析：启动线程方法start();线程stop方法已经被弃用；守护线程在非守护线程结束后，会自动结束；等待其他线程通知方法是wait()

16.问题：
静态内部类不可以直接访问外围类的非静态数据，而非静态内部类可以直接访问外围类的数据，包括私有数据。（ ） A*
A.正确
B.错误
解析：1.静态内部类可以访问外围类的静态数据，不能访问外围静态类的非静态数据；
2.非静态内部类可以访问外围类的所有数据，因为非静态内部类依赖于实例，但是自身不能定义静态数据

17.问题：
如果一个list初始化为{5，3，1}，执行以下代码后，其结果为（）？ B*

nums.add(6);
nums.add(0,4);
nums.remove(1);

A. [5, 3, 1, 6]
B．[4, 3, 1, 6]
C. [4, 3, 6]
D. [5, 3, 6]
解析：初始化为{5,3,1} nums.add(6)后list为{5,3,1,6} nums.add(0,4)是在0号索引上添加数字4得到list为{4,5,3,1,6} nums.remove(1)是将1号索引上的5进行remove得到list为{4,3,1,6}

18.问题：
对于文件的描述正确的是（ ） D*
A.文本文件是以“.txt”为后缀名的文件，其他后缀名的文件是二进制文件。
B.File类是Java中对文件进行读写操作的基本类。
C.无论文本文件还是二进制文件，读到文件末尾都会抛出EOFException异常。
D.Java中对于文本文件和二进制文件，都可以当作二进制文件进行操作
解析：A.文件分为文本文件和二进制文件，计算机只认识二进制，所以实际上都是二进制的不同解释方式。文本文件是以不同编码格式显示的字符，例如Ascii、Unicode等，window中文本文件的后缀名有".txt",".log",各种编程语言的源码文件等；二进制文件就是用文本文档打开是看不懂乱码，只要能用文本打开的文件都可以算是文本文件，只是显示的结果不是你想要的，二进制文件只有用特殊的应用才能读懂的文件，例如".png",".bmp"等，计算机中大部分的文件还是二进制文件。 B.File类是对文件整体或者文件属性操作的类，例如创建文件、删除文件、查看文件是否存在等功能，不能操作文件内容；文件内容是用IO流操作的。 C.当输入过程中意外到达文件或流的末尾时，抛出EOFException异常,正常情况下读取到文件末尾时，返回一个特殊值表示文件读取完成，例如read()返回-1表示文件读取完成。 D.上面A选项已经说了，不论是文本文件还是二进制文件，在计算机中都是以二进制形式存储的，所以都当做二进制文件读取

19.问题：
下面哪一项不是加载驱动程序的方法？ A*
A.通过DriverManager.getConnection方法加载
B.调用方法 Class.forName
C.通过添加系统的jdbc.drivers属性
D.通过registerDriver方法注册
解析：DriverManager.getConnection方法返回一个Connection对象，这是加载驱动之后才能进行的

20.问题：
下列哪些操作会使线程释放锁资源？ BC*
A.sleep()
B.wait()
C.join()
D.yield()
解析：所谓的释放锁资源实际是通知对象内置的monitor对象进行释放，而只有所有对象都有内置的monitor对象才能实现任何对象的锁资源都可以释放。又因为所有类都继承自Object，所以wait(）就成了Object方法，也就是通过wait()来通知对象内置的monitor对象释放，而且事实上因为这涉及对硬件底层的操作，所以wait()方法是native方法，底层是用C写的。 其他都是Thread所有，所以其他3个是没有资格释放资源的 而join()有资格释放资源其实是通过调用wait()来实现的

21.问题：
下列说法正确的是( ) C*
A.volatile,synchronized 都可以修改变量，方法以及代码块
B.volatile，synchronized 在多线程中都会存在阻塞问题
C.volatile能保证数据的可见性，但不能完全保证数据的原子性，synchronized即保证了数据的可见性也保证了原子性
D.volatile解决的是变量在多个线程之间的可见性、原子性，而sychroized解决的是多个线程之间访问资源的同步性
解析：A.volatile只能修饰变量，synchrnized可以修饰代码块和方法 B.volatile不会造成线程阻塞 C.正确 D.volatile不能保证原子性

22.问题：
执行以下程序后的输出结果是（） D*

	public class Test {
    public static void main(String[] args) {
        StringBuffer a = new StringBuffer("A"); 
        StringBuffer b = new StringBuffer("B"); 
        operator(a, b); 
        System.out.println(a + "," + b); 
    } 
    public static void operator(StringBuffer x, StringBuffer y) { 
        x.append(y); y = x; 
    }
}

A.A,A
B.A,B
C.B,B
D.AB,B
解析：x,y是a,b的副本，x.append(y)使得AB在一起，而y=x后，y指向AB，方法结束后x,y消亡，故a-AB,b-B;

23.问题：
下面程序的运行结果（） A*

List<String> aa = new ArrayList<String>();
aa.add("F1");
aa.add("F2");
aa.add("F3");
for (String temp : aa) {
if ("F3".equals(temp)) {
aa.remove(temp);
 }
 }
 for (String temp : aa){
 System.out.println(temp);
 }

A.抛异常
B.F1F2
C.F1F2F3
D.F1
解析：1.普通for循环：可以删除 注意每次删除之后索引要–2.Iterator遍历：可以删除 不过要使用Iterator类中的remove方法，如果用List中的remove方法会报错3.增强for循环foreach：不能删除 强制用List中的remove方法会报错

24.问题：
URL u =new URL(“http://www.123.com”);。如果www.123.com不存在，则返回______。A*
A.http://www.123.com
B.””
C.null
D.抛出异常
解析：这个异常属于IOException，不管网址是否存在，最后都会返回该网址的一个连接，打印出来就是该网址。

25.问题：
(多选) 一般有两种用于创建线程的方法,一是(),二是()。 BD*
A.从Java.lang.Thread类派生一个新的线程类，重写它的runnable()方法
B.从Java.lang.Thread类派生一个新的线程类，重写它的run()方法
C.实现Thread接口，重写Thread接口中的run()方法
D.实现Runnable接口，重写Runnable接口中的run()方法
解析：创建线程对象两种方式：
1.继承Thread类，重载run方法；
2.实现Runnable接口，实现run方法

26.问题：
对于以下代码段，4个输出语句中输出true的个数是( )。 C*

class A{}
class B extends A{}
class C extends A{}
class D extends B{}
A obj = new D();
System.out.println(obj instanceof B);
System.out.println(obj instanceof C);
System.out.println(obj instanceof D);
System.out.println(obj instanceof A);

A.1
B.2
C.3
D.4
解析：C直接继承自A，obj的实际类型为D，和C没有关系。所以obj
instanceof C 输出false

27.问题：
一个文件中的数据要在控制台上显示，首先需要（ ）。 C*
A.使用标准输出流System.out.println()。
B.建立文件输出流。
C.建立文件输入流。
D.标准输入流System.in.read()
解析：1:创建File对象 File file = new File("URL)2:创建FileInputStrream对象 FileInputStrream in = new FileInputStrream(file); 读取文件的数据到控制台

28.问题：
在创建派生类对象，构造函数的执行顺序（） A*
A.基类构造函数，派生类对象成员构造函数，派生类本身的构造函数
B.派生类本身的构造函数，基类构造函数，对象成员构造函数
C.基类构造函数，派生类本身的构造函数，派生类对象成员构造函数
D.对象成员构造函数，基类构造函数，派生类本身的构造函数
解析：当派生类中不含对象成员时：在创建派生类对象时,构造函数的执行顺序是：基类的构造函数 → 派生类的构造函数； 在撤消派生类对象时,析构函数的执行顺序是：派生类的析构函数 → 基类的析构函数。
当派生类中含有对象成员时：在定义派生类对象时，构造函数的执行顺序：基类的构造函数 → 对象成员的构造函数 → 派生类的构造函数； 在撤消派生类对象时，析构函数的执行顺序：派生类的析构函数 → 对象成员的析构函数 → 基类的析构函数。

29.问题：
72. 有关下述Java代码描述正确的选项是____。 F*

	public class TestClass {
   private static void testMethod(){
        System.out.println("testMethod");
   }
   public static void main(String[] args) {
        ((TestClass)null).testMethod();
   }
}

A.编译不通过
B.编译通过，运行异常，报NullPointerException
C.编译通过，运行异常，报IllegalArgumentException
D.编译通过，运行异常，报NoSuchMethodException
E.编译通过，运行异常，报Exception
F.运行正常，输出testMethod
解析：1）此处是类对方法的调用，不是对象对方法的调用。 2）方法是static静态方法，直接使用"类.方法"即可，因为静态方法使用不依赖对象是否被创建。 null可以被强制类型转换成任意类型（不是任意类型对象），于是可以通过它来执行静态方法。 3）非静态的方法用"对象.方法"的方式，必须依赖对象被创建后才能使用，若将testMethod()方法前的static去掉，则会报 空指针异常 。此处也验证了2）的观点 当然，不管是否静态方法，都是已经存在的，只是访问方式不同。

30.问题：

class A{
    public A foo(){return this;}
}
class B extends A{
    public A foo(){
        return this;
    }
}
class C extends B
{
    _______
}

可以放入到横线位置，使程序正确编译运行，而且不产生错误的选项是（ ） C*
A.public void foo(){}
B.public int foo(){return 1;}
C.public A foo(B b){return b;}
D.public A foo(){return A;}
解析：重写 要求两同两小一大原则， 方法名相同，参数类型相同，子类返回类型小于等于父类方法返回类型， 子类抛出异常小于等于父类方法抛出异常， 子类访问权限大于等于父类方法访问权限。［注意：这里的返回类型必须要在有继承关系的前提下比较］ 重载 方法名必须相同，参数类型必须不同，包括但不限于一项，参数数目，参数类型，参数顺序
再来说说这道题 A B 都是方法名和参数相同，是重写，但是返回类型没与父类返回类型有继承关系，错误 D 返回一个类错误 c的参数类型与父类不同，所以不是重写，可以理解为广义上的重载访问权限小于父类，都会显示错误
虽然题目没点明一定要重载或者重写，但是当你的方法名与参数类型与父类相同时，已经是重写了，这时候如果返回类型或者异常类型比父类大，或者访问权限比父类小都会编译错误

31.问题：
下列类定义中哪些是合法的抽象类的定义？（） C*
A. abstract Animal{abstract void growl();}
B. class abstract Animal{abstract void growl();}
C. abstract class Animal{abstract void growl();}
D.
abstract class Animal{abstract void growl(){System.out.println( “growl”);};}
解析：1. 首先，类的修饰符，都应该在class关键字之前，AB错；
2. 抽象方法不能有方法体，D错

32.问题：
.给出以下代码 B*

public class TestObj{
    public static void main(String[] args){
        Object o=new Object(){
            public boolean equals(Object obj){
                return true;
            }
        };
        System.out.println(o.equals(“Fred”));
    }
}

请给出结果：（）
A. 运行时抛出异常
B. true
C. Fred
D. 第三行编译错误
解析：匿名内部类重写了equals方法 不管参数是什么 都会返回true

33.问题：
18.B*

Integer a = 1;
Integer b = 1;
Integer c = 500;
Integer d = 500;
System.out.print(a == b);
System.out.print(c == d);

上述代码返回结果为：
A. true、true
B. true、false
C. false、true
D. false、false
解析：Integer类似于String，当Integer的值在范围[-128,127]时，Integer不会生成新的对象，会直接从缓存中获取对象的引用。当超出这个范围后，会生成新的Integer对象。

34.问题：
有以下类定义： 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修饰子类，不实现抽象方法，方法的实现交由别的类实现。

35.问题：
要导入java/awt/event下面的所有类，叙述正确的是？() C*
A. import java.awt.和import java.awt.event.都可以
B. 只能是import java.awt.
C. 只能是import java.awt.event.
D. import java.awt.和import java.awt.event.都不可以
解析：import java.awt.;导入的是awt下的包，awt下的包中的不会被导入 import java.awt.event.; 导入的是event下面的类，java.awt中的其他包不会被导入

36.问题：
(多选)java中提供了哪两种用于多态的机制 AB*
A. 通过子类对父类方法的覆盖实现多态
B. 利用重载来实现多态.即在同一个类中定义多个同名的不同方法来实现多态。
C. 利用覆盖来实现多态.即在同一个类中定义多个同名的不同方法来实现多态。
D. 通过子类对父类方法的重载实现多态
解析：Java通过方法重写和方法重载实现多态
方法重写是指子类重写了父类的同名方法
方法重载是指在同一个类中，方法的名字相同，但是参数列表不同

37.问题：
(多选)有关会话跟踪技术描述正确的是（） ABC*
A. Cookie是Web服务器发送给客户端的一小段信息，客户端请求时，可以读取该信息发送到服务器端
B. 关闭浏览器意味着临时会话ID丢失，但所有与原会话关联的会话数据仍保留在服务器上，直至会话过期
C. 在禁用Cookie时可以使用URL重写技术跟踪会话
D. 隐藏表单域将字段添加到HTML表单并在客户端浏览器中显示
解析：B，会话ID存在于Session中，关闭浏览器，Session仍然保持，直至会话过期。但是关闭浏览器并不意味着会话ID丢失，因为与Session建立联系的是cookie，默认的cookie是在浏览器关闭时删除的，但是可以设置expire属性让cookie在浏览器关闭时不删除
D，隐藏表单如这种表单是隐藏的，用户在浏览器页面卡不到，只能在源码中看到，作用是传输数据

38.问题：
(多选)下列说法错误的有（ ） BCD*
A. 能被java.exe成功运行的java class文件必须有main()方法
B. J2SDK就是Java API
C. Appletviewer.exe可利用jar选项运行.jar文件
D. 能被Appletviewer成功运行的java class文件必须有main()方法
解析：B选项中J2SDK是编程工具，不是API. C选项中 Appletviewer.exe 就是用来解释执行java applet应用程序的,简单理解就是没有main函数的继承applet类的java类。 D选项中 能被Appletviewer成功运行的java class文件没有main()方法

39.问题：
类Car里面有个方法run()，如果直接用Car.run()，则方法run前面必须用的关键词是？ ( ) D*
A. class
B. final
C. public
D. static
解析：被sataic声明的为静态方法，可以直接通过类名调用而不需要通过对象调用

40.问题：
java中，静态变量static在不同线程的不同实例中地址是否一样？他们储存在什么区域？（） C*
A. 地址一样，在堆栈区。
B. 地址不一样，在堆栈区。
C. 地址一样，在全局区。
D. 地址不一样，在全局区。
解析：被static修饰的变量叫静态变量 被其他成员所共享！ 修饰的方法叫静态方法， 当类加载的时候被加载出来，优先于对象先加载！并且只加载一次 当被其他对象调用时 可以直接类名. 的方式所调用 加载后，存放在方法区中的静态常量，对应的方法存在静态方法区区，所以没错地址不变！

41.问题：
若有定义语句： int a=10 ; double b=3.14 ; 则表达式 ‘A’+a+b 值的类型是（） C*
A. char
B. int
C. double
D. float
解析：当类型不匹配时，需要进行类型转换，int转换为double丢失的信息最少，所以为double

42.问题：
下列哪一种叙述是正确的（） D*
A. abstract修饰符可修饰字段、方法和类
B. 抽象方法的body部分必须用一对大括号{ }包住
C. 声明抽象方法，大括号可有可无
D. 声明抽象方法不可写出大括号
解析：abstract可以修饰方法和类，不能修饰属性。抽象方法没有方法体，即没有大括号{}

43.问题：
有如下一段程序： B*

public class Test{
    private static int i=1;
    public int getNext(){
         return i++;
    }
    public static void main(String [] args){
        Test test=new Test();
        Test testObject=new Test();
        test.getNext();
        testObject.getNext();
        System.out.println(testObject.getNext());
    }
}

请问最后打印出来的是什么？（）
A.2
B.3
C.4
D.5
解析：return i++, 先返回i，然后i+1； 第一次调用getNext()方法时，返回的是1，但此时i=2； 第二次调用 getNext()方法时，返回的是2，但此时i=3； 第三次调用 getNext()方法时，返回的是3，但此时i=4；

44.问题：
下面哪段程序能够正确的实现了GBK编码字节流到UTF-8编码字节流的转换： B*
1 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”)
解析：先通过GBK编码还原字符串，在该字符串正确的基础上得到“UTF-8”所对应的字节串

45.问题：
Panel 和 Applet 的默认布局管理器是（ ）B*
A. CardLayout
B. FlowLayout
C. BorderLayout
D. GridLayout
解析：BorderLayout布局管理器，是Frame默认布局管理器，它是一个布置容器的边框布局，它可以对容器 组件 进行安排，并调整其大小，使其符合下列五个区域：北、南、东、西、中。每个区域最多只能包含一个组件，并通过相应的常量进行标识：NORTH、SOUTH、EAST、WEST、CENTER。 FlowLayout流式布局管理器,是Panel和Applet默认布局管理器，它具有指定的对齐方式以及指定的水平和垂直间隙。 GridLayout布局管理器,GridLayout(int rows,int cols,int hgap,int vgap);建立一个表格的版面对象。rows代表有几行，cols代表有几列；hgap是组件之间的水平距离，vgap是组件之间的竖直距离。

46.问题：
(多选)下面有关java类加载器，说法正确的是？ ABCD*
A. 引导类加载器（bootstrap class loader）：它用来加载 Java 的核心库，是用原生代码来实现的
B. 扩展类加载器（extensions class loader）：它用来加载 Java 的扩展库。
C. 系统类加载器（system class loader）：它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类
D. tomcat为每个App创建一个Loader，里面保存着此WebApp的ClassLoader。需要加载WebApp下的类时，就取出ClassLoader来使用
解析：· 启动类加载器（Bootstrap ClassLoader）：这个类加载器负责将存放在<JAVA_HOME>\lib目录中的。
· 扩展类加载器（Extension ClassLoader）： 它负责加载<JAVA_HOME>\lib\ext目录中的，或者被java.ext.dirs系统变量所指定的路径中的所有类库，开发者可以直接使用扩展类加载器。
· 应用程序类加载器（Application ClassLoader）： 它负责加载用户类路径（ClassPath）上所指定的类库，开发者可以直接使用这个类加载器，如果应用程序中没有自定义自己的类加载器，一般情况下这个就是程序中默认的类加载器

47.问题：
(多选) JAVA反射机制主要提供了以下哪些功能？ABCD*
A. 在运行时判断一个对象所属的类
B. 在运行时构造一个类的对象
C. 在运行时判断一个类所具有的成员变量和方法
D. 在运行时调用一个对象的方法
解析：Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

48.问题：
在Java中，( )类提供定位本地文件系统，对文件或目录及其属性进行基本操作 D*
A. FileInputStream
B. FileReader
C. FileWriter
D. File
解析：FileInputStream提供了对文件的字节读取；FileReader提供了对文件的字符读取；FileWriter提供了对文件的字符写入；File提供了对文件的基本操作，包括对删除，文件路径等操作

49.问题：
下列叙述错误的是（ ） D*
A. 在接口中定义的方法除了default和static关键字修饰的方法拥有方法体，其他方法都应是没有方法体的抽象方法（JDK1.8以后）
B. 一个java类只能有一个父类,但可以实现多个接口
C. 在类声明中,用implements关键字声明该类实现的接口
D. 定义接口时使用implements关键字
解析：A、JDK8开始，接口中可以定义有方法体的方法，方法必须被default和static修饰。除此之外，其他方法都是抽象方法。B、Java的语法是单继承，但是继承可以传递。其实B更准确一点是只能有一个直接父类。 C、继承用extends，实现用implements。先继承后实现。 D、类是class，接口是interface。

50.问题：
以下说法中正确的有？ A*
A. StringBuilder是 线程不安全的
B. Java类可以同时用 abstract和final声明
C. HashMap中，使用 get(key)==null可以 判断这个Hasmap是否包含这个key
D. volatile关键字不保证对变量操作的原子性
解析：StringBuffer是线程安全的，StringBuilder是线程不安全的，final修饰的类不能被重写

51.问题：
下面哪个标识符是合法的？ D*
A. “9HelloWorld”
B. “_Hello World”
C. "HelloWorld"
D. “Hello￥World”
解析：java的变量名有三种元素构成：数字+字符+$+下划线。java对这三种元素的顺序也是有要求的：不能以数字开头+不能是关键字.A中错在以数字开头、B中错在有空格、C中错在有.

52.问题：
当我们需要所有线程都执行到某一处，才进行后面的的代码执行我们可以使用？ A*
A. CountDownLatch
B. CyclicBarrier
C. Semaphore
D. Future
解析：这里应该是区分职责：countDownLatch是区分职责的，而CycilicBarrier线程所有的职责都是一样的。题目中没有说是同一种职责，应该选A，两种本来就很相似。

53.问题：
有一个源代码，只包含import java.util.* ; 这一个import语句，下面叙述正确的是？ ( ) C*
A. 只能写在源代码的第一句
B. 可以访问java/util目录下及其子目录下的所有类
C. 能访问java/util目录下的所有类，不能访问java/util子目录下的所有类
D. 编译错误
解析：导入java.util.*不能读取其子目录的类，因为如果java.util里面有个a类，java.util.regex里面也有个a类，我们若是要调用a类的方法或属性时，应该使用哪个a类呢。所以也应该选C

54.问题：
关于ASCII码和ANSI码，以下说法不正确的是（）？ D*
A. 标准ASCII只使用7个bit
B. 在简体中文的Windows系统中，ANSI就是GB2312
C. ASCII码是ANSI码的子集
D. ASCII码都是可打印字符
解析：A、标准ASCII只使用7个bit，扩展的ASCII使用8个bit。
B、ANSI通常使用 0x00~0x7f 范围的1 个字节来表示 1 个英文字符。超出此范围的使用0x80~0xFFFF来编码，即扩展的ASCII编码。不同 ANSI 编码之间互不兼容。在简体中文Windows操作系统中，ANSI 编码代表 GBK 编码；在繁体中文Windows操作系统中，ANSI编码代表Big5；在日文Windows操作系统中，ANSI 编码代表 Shift_JIS 编码。
C、ANSI通常使用 0x00~0x7f 范围的1 个字节来表示 1 个英文字符，即ASCII码
D、ASCII码包含一些特殊空字符