刷牛客之路-Java基础题(一)

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_33248299/article/details/88795695

1.应用程序的main方法中有以下语句，则输出的结果( )

String s1=new String（ ” xyz ” ）;
String s2=new String（ ” xyz ” ）;
Boolean b1=s1.equals(s2);
Boolean b2=(s1==s2);
System .out.print(b1+ ” ” +b2); 

结果:true false

• 这题考察的就是equals方法和==
• 首先对于equals方法，它是Object类的方法，如果没有重写的话参照源码可以看到它return的是this==obj也就是比较的对象的引用是否相等，但是String重写了Object类的equals方法，比较的事指向的引用里面的值
• 而对于==，对于基本类型，==是比较的是它们的值；对于引用类型，比较的是它们的地址

2.Which is not Java primitive types?

A.short
B.Boolean
C.byte
D.float

• 这题考察的是基本类型
• java规定类名首字母必须大写，这里可以直观的看出来Boolean是一个引用类型，不是基本数据类型
• java中的基本数据类型都对应一个引用类型，如Float是float的引用类型，Integer是int的引用类型
• 所以选B

3.Please write the output result

public class Test
{
     public static void changeStr(String str)
     {
         str = "welcome";
     }
     public static void main(String[] args)
     {
         String str = "1234";
         changeStr(str);
         System.out.println(str);
     }
}

A.1234
B.welcome
C.空
D.不确定

• 考察Java方法参数传递特性
• Java方法调用中，只存在值传递调用
• 此处，实参str是引用变量，由于java方法调用是值传递，所以形参str得到的是实参str的一个拷贝。此时形参str和实参str均指向字符串"1234"。
• 然后，在changeStr方法中，形参str指向了一个新的字符串"welcom"，而后方法结束，形参str被销毁。而实参str仍然指向字符串"1234"
• 所以选A

4.下面有关java final的基本规则，描述错误的是？

A.final修饰的类不能被继承
B.final修饰的成员变量只允许赋值一次，且只能在类方法赋值
C.final修饰的局部变量即为常量，只能赋值一次。
D.final修饰的方法不允许被子类覆盖

• 考察final的作用
• final修饰的成员变量为基本数据类型时，在赋值之后无法改变
• 当final修饰的成员变量为引用数据类型时，在赋值后其指向地址无法改变，但是对象内容还是可以改变的

public static void main(String[] args){
        final Student s1 = new Student("lisi",18);
        Student s2 = new Student("zhangsi",32);
        //s1=s2; 报错  想改变地址
        System.out.println("name:"+s1.getName()+" age:"+s1.getAge());
        s1.setName("zhangsi");//改变对象内容
        s1.setAge(32);//改变对象内容
        System.out.println("name:"+s1.getName()+" age:"+s1.getAge());
    }

name:lisi age:18
name:zhangsi age:32

• final修饰的成员变量在赋值时可以有三种方式。
  • 在声明时直接赋值
  • 在构造器中赋值
  • 在初始代码块(｛ ｝)中进行赋值
• 类方法就是静态代码块
• 所以选B

5.java 语言使用的字符码集是

A.ASCII
B,BCD
C.DCB
D.Unicode

• Java语言使用的是Unicode字符集。而ASCII是国际上使用最广泛的字符编码；BCD是一种数字压缩存储编码方法。
• 所以D

6.关于final说法正确的是

A.final类的方法肯定不能被同一个包的类访问
B.final类的方法能否被同一个包的类访问不是由final决定
C.final方法等同于private方法
D.final对象本身的引用和值都不能改变

• 能不能被一个包访问是和访问控制符有关系
• 所以选B

7.关于ASCII码和ANSI码，以下说法不正确的是

A.标准ASCII只使用7个bit
B.在简体中文的Windows系统中，ANSI就是GB2312
C.ASCII码是ANSI码的子集
D.ASCII码都是可打印字符

• 标准ASCII只使用7个bit，扩展的ASCII使用8个bit
• ANSI通常使用 0x00~0x7f 范围的1 个字节来表示 1 个英文字符，即ASCII码
• 简体中文的ANSI是gb2312
• ASCII码包含一些特殊空字符
• 所以D

8.下面哪种情况会导致持久区jvm堆内存溢出

A.循环上万次的字符串处理
B.在一段代码内申请上百M甚至上G的内存
C.使用CGLib技术直接操作字节码运行，生成大量的动态类
D.不断创建对象

堆内存设置原理
JVM堆内存分为2块：Permanent Space 和 Heap Space。
Permanent 即 持久代（Permanent Generation），主要存放的是Java类定义信息，与垃圾收集器要收集的Java对象关系不大。
Heap = { Old + NEW = {Eden, from, to} }，Old 即 年老代（Old Generation），New 即 年轻代（Young Generation）。年老代和年轻代的划分对垃圾收集影响比较大。
年轻代
所有新生成的对象首先都是放在年轻代。年轻代的目标就是尽可能快速的收集掉那些生命周期短的对象。年轻代一般分3个区，1个Eden区，2个Survivor区（from 和 to）。
大部分对象在Eden区中生成。当Eden区满时，还存活的对象将被复制到Survivor区（两个中的一个），当一个Survivor区满时，此区的存活对象将被复制到另外一个Survivor区，当另一个Survivor区也满了的时候，从前一个Survivor区复制过来的并且此时还存活的对象，将可能被复制到年老代。
2个Survivor区是对称的，没有先后关系，所以同一个Survivor区中可能同时存在从Eden区复制过来对象，和从另一个Survivor区复制过来的对象；而复制到年老区的只有从另一个Survivor区过来的对象。而且，因为需要交换的原因，Survivor区至少有一个是空的。特殊的情况下，根据程序需要，Survivor区是可以配置为多个的（多于2个），这样可以增加对象在年轻代中的存在时间，减少被放到年老代的可能。
针对年轻代的垃圾回收即 Young GC。
年老代
在年轻代中经历了N次（可配置）垃圾回收后仍然存活的对象，就会被复制到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象。
针对年老代的垃圾回收即 Full GC。
持久代
用于存放静态类型数据，如 Java Class, Method 等。持久代对垃圾回收没有显著影响。但是有些应用可能动态生成或调用一些Class，例如 Hibernate CGLib 等，在这种时候往往需要设置一个比较大的持久代空间来存放这些运行过程中动态增加的类型。

所以，当一组对象生成时，内存申请过程如下：
JVM会试图为相关Java对象在年轻代的Eden区中初始化一块内存区域。
当Eden区空间足够时，内存申请结束。否则执行下一步。
JVM试图释放在Eden区中所有不活跃的对象（Young GC）。释放后若Eden空间仍然不足以放入新对象，JVM则试图将部分Eden区中活跃对象放入Survivor区。
Survivor区被用来作为Eden区及年老代的中间交换区域。当年老代空间足够时，Survivor区中存活了一定次数的对象会被移到年老代。
当年老代空间不够时，JVM会在年老代进行完全的垃圾回收（Full GC）。
Full GC后，若Survivor区及年老代仍然无法存放从Eden区复制过来的对象，则会导致JVM无法在Eden区为新生成的对象申请内存，即出现“Out of Memory”。
OOM（“Out of Memory”）异常一般主要有如下2种原因：

1. 年老代溢出，表现为：java.lang.OutOfMemoryError:Javaheapspace
   这是最常见的情况，产生的原因可能是：设置的内存参数Xmx过小或程序的内存泄露及使用不当问题。
   例如循环上万次的字符串处理、创建上千万个对象、在一段代码内申请上百M甚至上G的内存。还有的时候虽然不会报内存溢出，却会使系统不间断的垃圾回收，也无法处理其它请求。这种情况下除了检查程序、打印堆内存等方法排查，还可以借助一些内存分析工具，比如MAT就很不错。

2. 持久代溢出，表现为：java.lang.OutOfMemoryError:PermGenspace
   通常由于持久代设置过小，动态加载了大量Java类而导致溢出 ，解决办法唯有将参数 -XX:MaxPermSize 调大（一般256m能满足绝大多数应用程序需求）。将部分Java类放到容器共享区（例如Tomcat share lib）去加载的办法也是一个思路，但前提是容器里部署了多个应用，且这些应用有大量的共享类库

9.如何获取ServletContext设置的参数值

A.context.getParameter()
B.context.getInitParameter()
C.context.getAttribute()
D.context.getRequestDispatcher()

• getParameter()是获取POST/GET传递的参数值
• getInitParameter获取Tomcat的server.xml中设置Context的初始化参数
• getAttribute()是获取对象容器中的数据值
• getRequestDispatcher是请求转发
• 所以选B

10.下面哪些接口直接继承自Collection接口

A.List
B.Map
C.Set
D.Iterator

• 所以选AC

11.不考虑反射，关于私有访问控制符 private 修饰的成员变量，以下说法正确的是

A.可以三种类所引用：该类自身、与它在同一包中的其他类，在其他包中的该类的子类
B.可以被两种类访问和引用：该类本身、该类的所有子类
C.只能被该类自身所访问和修改
D.只能被同一个包中的类访问

• 考察权限符知识
• 果然选C

12.设Tree为已定义的类名，下列语句能正确创建 Tree 对象的是

A.Tree t=new Tree;
B.Tree t=new Tree();
C.Tree t=Tree();
D.Tree t[ ]=new Tree[10];

• 果然选B

13.关于抽象类和接口叙述正确的是

A.抽象类和接口都能实例化的
B.抽象类不能实现接口
C.抽象类方法的访问权限默认都是public
D.接口方法的访问权限默认都是public

• 考察接口和抽象类的特点

• 关于抽象类的特点

  • 抽象类中可以有构造方法
  • 抽象类中可以存在普通属性，方法，静态属性和方法
  • 抽象类中可以存在抽象方法
  • 如果一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法
  • 抽象类中的抽象方法，需要有子类实现，如果子类不实现，则子类也需要定义为抽象的。
  • 抽象类不能被实例化，抽象类和抽象方法必须被abstract修饰
  • 抽象类中的抽象方法（其前有abstract修饰）不能用private、static、synchronized、native访问修饰符修饰
  • 抽象类中得方法访问修饰符默认是default的

• 关于接口的特点

  • 在接口中只有方法的声明，没有方法体
  • 在接口中只有常量，因为定义的变量，在编译的时候都会默认加上public static final
  • 在接口中的方法，永远都被public来修饰。
  • 接口中没有构造方法，也不能实例化接口的对象
  • 接口可以实现多继承
  • 接口中定义的方法都需要有实现类来实现，如果实现类不能实现接口中的所有方法则实现类定义为抽象类。
  • 接口可以继承接口，用extends

• 所以这题选D

14.以下程序段的输出结果为

public class EqualsMethod
{
    public static void main(String[] args)
    {
        Integer n1 = new Integer(47);
        Integer n2 = new Integer(47);
        System.out.print(n1 == n2);
        System.out.print(",");
        System.out.println(n1 != n2);
    }
}

A.false，false
B.false，true
C.true，false
D.true，true

• == 对于基本类型比较的是值 但是对引用类型就是比较的地址
• 所以false true 选B

15.关于下列程序段的输出结果，说法正确的是

public class MyClass{
static int i;
public static void main(String argv[]){
System.out.println(i);
}
}

A.有错误，变量i没有初始化。
B.null
C.1
D.0

• 类(静态)变量在不设置初始值时，会进行默认值赋值
• 而局部方法中声明的变量则必须进行初始化，他不会进行默认值赋值
• 以下图是其他类型的类变量初始值默认值 char是\u0000
• 所以此题选C

16.在开发中使用泛型取代非泛型的数据类型（比如用ArrayList取代ArrayList），程序的运行时性能会变得更好

A.对
B.错

• 泛型仅仅是java的一颗语法，它不会影响java虚拟机生成的汇编代码，在编译阶段，虚拟机就会把泛型的类型擦除，还原成没有泛型的代码，顶多编译速度稍微慢一些，执行速度是完全没有什么区别的
• 所以选B

17.下面哪个方法与Applet的显示无关

A.draw
B.paint
C.repaint
D.update

• Applet显示相关的方法主要有3个
  • paint(Graphicsg)方法，具体执行Applet的绘制
  • update(Graphicsg)()方法，主要用于更新Applet的显示
  • repaint()方法，主要用于Applet的重新显示，它调用update()方法实现对Applet的更新
• 所以此题选A

18.JMX是在哪一个JDK版本开始支持？

A.1.3
B.1.5
C.1.6
D.1.7

• JMX(Java Management Extensions，即Java管理扩展)是一个为应用程序、设备、系统等植入管理功能的框架。JMX可以跨越一系列异构操作系统平台、系统体系结构和网络传输协议，灵活的开发无缝集成的系统、网络和服务管理应用

• 顶多考1.8和1.9的新特性。。。。所以选A。。。。。。。

19.下面有关 java 类加载器,说法正确的是?

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中jre/lib/rt.jar里所有的class，由C++实现，不是ClassLoader子类
• Extension ClassLoader:负责加载java平台中扩展功能的一些jar包，包括$JAVA_HOME中jre/lib/*.jar或-Djava.ext.dirs指定目录下的jar包
• App ClassLoader:负责记载classpath中指定的jar包及目录中class
• Custom ClassLoader:属于应用程序根据自身需要自定义的ClassLoader，如tomcat、jboss都会根据j2ee规范自行实现ClassLoader
• 加载过程中会先检查类是否被已加载，检查顺序是自底向上，从Custom ClassLoader到BootStrap ClassLoader逐层检查，只要某个classloader已加载就视为已加载此类，保证此类只所有ClassLoader加载一次。而加载的顺序是自顶向下，也就是由上层来逐层尝试加载此类
• 所以ABCD都是对的

20.jvm中垃圾回收分为scanvenge gc和full GC，其中full GC触发的条件可能有哪些

A.栈空间满
B.年轻代空间满
C.老年代满
D.持久代满
E.System.gc()

• full GC触发的条件，除直接调用System.gc外，触发Full GC执行的情况有如下四种

  • 旧生代空间不足:旧生代空间只有在新生代对象转入及创建为大对象、大数组时才会出现不足的现象，当执行Full GC后空间仍然不足，则抛出如下错误：java.lang.OutOfMemoryError: Java heap space 为避免以上两种状况引起的FullGC，调优时应尽量做到让对象在Minor GC阶段被回收、让对象在新生代多存活一段时间及不要创建过大的对象及数组

  • Permanet Generation空间满:PermanetGeneration中存放的为一些class的信息等，当系统中要加载的类、反射的类和调用的方法较多时，Permanet Generation可能会被占满，在未配置为采用CMS GC的情况下会执行Full GC。如果经过Full GC仍然回收不了，那么JVM会抛出如下错误信息：java.lang.OutOfMemoryError: PermGen space 为避免Perm Gen占满造成Full GC现象，可采用的方法为增大Perm Gen空间或转为使用CMS GC

  • CMS GC时出现promotion failed和concurrent mode failure:对于采用CMS进行旧生代GC的程序而言，尤其要注意GC日志中是否有promotion failed和concurrent mode failure两种状况，当这两种状况出现时可能会触发Full GC。
    promotionfailed是在进行Minor GC时，survivor space放不下、对象只能放入旧生代，而此时旧生代也放不下造成的；concurrent mode failure是在执行CMS GC的过程中同时有对象要放入旧生代，而此时旧生代空间不足造成的。
    应对措施为：增大survivorspace、旧生代空间或调低触发并发GC的比率，但在JDK 5.0+、6.0+的版本中有可能会由于JDK的bug29导致CMS在remark完毕后很久才触发sweeping动作。对于这种状况，可通过设置-XX:CMSMaxAbortablePrecleanTime=5（单位为ms）来避免

  • 统计得到的Minor GC晋升到旧生代的平均大小大于旧生代的剩余空间:这是一个较为复杂的触发情况，Hotspot为了避免由于新生代对象晋升到旧生代导致旧生代空间不足的现象，在进行Minor GC时，做了一个判断，如果之前统计所得到的Minor GC晋升到旧生代的平均大小大于旧生代的剩余空间，那么就直接触发Full GC。例如程序第一次触发MinorGC后，有6MB的对象晋升到旧生代，那么当下一次Minor GC发生时，首先检查旧生代的剩余空间是否大于6MB，如果小于6MB，则执行Full GC。当新生代采用PSGC时，方式稍有不同，PS GC是在Minor GC后也会检查，例如上面的例子中第一次Minor GC后，PS GC会检查此时旧生代的剩余空间是否大于6MB，如小于，则触发对旧生代的回收

• 除了以上4种状况外，对于使用RMI来进行RPC或管理的Sun JDK应用而言，默认情况下会一小时执行一次Full GC。可通过在启动时通过- java-Dsun.rmi.dgc.client.gcInterval=3600000来设置Full GC执行的间隔时间或通过-XX:+ DisableExplicitGC来禁止RMI调用System.gc

• 所以CDE

21.创建一个标识有“开始”按钮的语句是

A.JTextField b = new JTextField(“开始”);
B.JLabel b = new JLabel(“开始”);
C.JCheckbox b = new JCheckbox(“开始”);
D.JButton b = new JButton(“开始”);

• 从上到下分别是文本 标签 复选框 按钮
• 所以选D

22.对于一个类的构造函数，其函数名与类名

A.完全相同
B.基本相同
C.不相同
D.无关系

• 类的构造函数，必须完全相同
• 所以选A

23.接口不能扩展（继承）多个接口

A.对
B.错

• Java中类是单继承，但接口可以多继承，Interfere1 extends Interface2,Interface3
• 所以错误

24.根据以下代码段,执行new Child(“John”, 10); 要使数据域data得到10，则子类空白处应该填写

class Parent {
    private int data;
    public Parent(int d){ data = d; }
}
class Child extends Parent{
    String name;
    public Child(String s, int d){
        ___________________
        name = s;
    }
}

A.data = d;
B.super.data = d;
C.Parent(d);
D.super(d);

• 考察super的作用
• 子父类存在同名成员时，子类中默认访问子类的成员，可通过super指定访问父类的成员，格式：super.xx (注：xx是成员名)
• 创建子类对象时，默认会调用父类的无参构造方法，可通过super指定调用父类其他构造方法，格式：s uper(yy) (注：yy是父类构造方法需要传递的参数)

25.设int x=1,float y=2,则表达式x/y的值是

A.0
B.1
C.2
D.以上都不是

• 自动向上转型（低到高）
• byte-short-int-long-float-double（最高）
• 所以是0.5 D

26.经过强制类型转换以后，变量a，b的值分别为多少

short a =128；
byte b =(byte) a；

A.128 127
B.128 - 128
C.128 128
D.编译错误

• 这题先放一边吧…选B

27.下面哪个不属于HttpServletResponse接口完成的功能

A.设置HTTP头标
B.设置cookie
C.读取路径信息
D.输出返回数据

• 设置HTTP头标

response.setHeader(“Refresh”,“3”); //三秒刷新页面一次

• 设置cookie

  Cookie c1 = new Cookie(“username”,“only”);
  response.addCookie(c1);

• 输出返回数据
  HttpServleteResponse.getOutputStream().write();

• 读取路径信息,request读取路径信息

从request获取各种路径总结
request.getRealPath("url"); // 虚拟目录映射为实际目录
request.getRealPath("./");    // 网页所在的目录
request.getRealPath("../"); // 网页所在目录的上一层目录
request.getContextPath();    // 应用的web目录的名称

• 所以选C

28.关于sleep()和wait()，以下描述错误的一项是

A.sleep是线程类（Thread）的方法，wait是Object类的方法；
B.sleep不释放对象锁，wait放弃对象锁
C.sleep暂停线程、但监控状态仍然保持，结束后会自动恢复
D.wait后进入等待锁定池，只有针对此对象发出notify方法后获得对象锁进入运行状态

• D

29.ResultSet中记录行的第一列索引为

A.-1
B.0
C.1
D.以上都不是

• ResultSet跟普通的数组不同，索引从1开始而不是从0开始

30.以下 json 格式数据，错误的是

A.{company：4399}
B.{“company”:{“name”:[4399,4399,4399]}}
C.{[4399,4399,4399]}
D.{“company”:[4399,4399,4399]}
E.{“company”:{“name”:4399}}

• AC

31.类声明中，声明一个类不能再被继承的关键字是

A.public
B.abstract
C.final
D.static

• public：访问控制修饰符，用于修饰类、类的方法、属性或者构造器。
• abstract：用于修饰抽象类或者抽象方法
• static：用于修饰类、方法或者成员变量，表明该类是静态类或者方法、成员变量属于当前类
• final关键字可用于修饰类、变量和方法。final修饰的类不能被继承，final修饰的方法不能被重写，final修饰的基本类型变量不能改变，修饰的引用类型变量值可以变，但是地址不能变
• 所以C

32.java7后关键字 switch 支不支持字符串作为条件

A.支持
B.不支持

• 在Java7之前，switch只能支持 byte、short、char、int或者其对应的封装类以及Enum类型。在Java7中，呼吁很久的String支持也终于被加上了
• 在switch语句中，表达式的值不能是null，否则会在运行时抛出NullPointerException。在case子句中也不能使用null，否则会出现编译错误
• 所以A

33.以下java程序代码，执行后的结果是

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

A.Fred
B.true
C.编译错误
D.运行时抛出异常

• 重写了object 的equals 的方法，使他怎么输出都是true

34.下面代码的输出结果是什么

public class ZeroTest {
    public static void main(String[] args) {
     try{
       int i = 100 / 0;
       System.out.print(i);
  }catch(Exception e){
       System.out.print(1);
       throw new RuntimeException();
  }finally{
       System.out.print(2);
  }
      System.out.print(3);
 }
 }

A.3
B.123
C.1
D.12

• 此题考察finally的用途
• 只需要记住finally拥有决定执行权 不论抛不抛异常
• 此题抛了异常 会打印出1和2 本来会打印出3的 但是catch里面又throw了一个异常 所以打印3的语句并不会执行
• 所以D

35.BufferedReader的父类是以下哪个

A.FilterReader
B.InputStreamReader
C.PipedReader
D.Reader

• 所以选D

36.要导入java/awt/event下面的所有类，叙述正确的是

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.*这种只会导当前层的
• 所以必须得import java.awt.event.*
• 选C

37.对于子类的构造函数说明，下列叙述中错误的是

A.子类可以继承父类的构造函数
B.子类中调用父类构造函数不可以直接书写父类构造函数，而应该用super();
C.用new创建子类的对象时，若子类没有带参构造函数，将先执行父类的无参构造函数，然后再执行自己的构造函数
D.子类的构造函数中可以调用其他函数

• java继承中对构造函数是不继承的，只是显式或者隐式调用
• 所以A

38.java中关于继承的描述正确的是

A.一个子类只能继承一个父类
B.子类可以继承父类的构造方法
C.继承具有传递性
D.父类一般具有通用性，子类更具体

• 和上面那题一样，继承中对构造函数是不继承的，只是显式或者隐式调用
• ACD都对的

39.往OuterClass类的代码段中插入内部类声明, 哪一个是错误的

public class OuterClass{
    private float f=1.0f;
    //插入代码到这里
}

A.class InnerClass{
public static float func(){return f;}
}
B.abstract class InnerClass{
public abstract float func(){}
}
C.static class InnerClass{
protected static float func(){return f;}
}
D.public class InnerClass{
static float func(){return f;}
}

• 这题主要考察以后几个知识点

  • 静态内部类才可以声明静态方法
  • 静态方法不可以使用非静态变量
  • 抽象方法不可以有函数体

• 所以选ABCD

40.mysql数据库，game_order表表结构如下，下面哪些sql能使用到索引

A.select * from game_order where plat_game_id=5 and plat_id=134

B.select * from game_order where plat_id=134 and
plat_game_id=5 and plat_order_id=’100’

C.select * from game_order where plat_order_id=’100’

D.select * from game_order where plat_game_id=5 and
plat_order_id=’100’ and plat_id=134

E.select * from game_order where plat_game_id=5 and plat_order_id=’100’

• BCDE

41.下面是findSum（int m.int n）方法的定义，方法调用findSum（1，5）的返回结果是

int findSum（int m, int n）{
    int sum=0；
    for（int i=m；i<=n；i++）{
        sum+=i；
    }
    return sum；
}

A.1
B.5
C.10
D.15

• 1+2+3+4+5=15 选D

42.下列选项中符合Java命名规则的标识符是

A.2japro
B.&Class
C.const
D._123

• 由26个英文字母大小写，数字：0-9 符号：_ $ 组成
• 标识符应以字母、_ 、$开头，不能以数字开头
• 标识符不能是关键字
• Java中严格区分大小写
• 所以D const是保留字

43.下列方法定义中 ， 正确 的是

A.int x( ){ char ch=’a’; return (int)ch; }
B.void x( ){ ...return true; }
C.int x( ){ ...return true; }
D.int x( int a, b){ return a+b; }

• B没有返回值
• C返回值是int
• D应该是b没申明类型
• 所以A byte、short和char类型都可以强制转化为int

44.下面哪个修饰符修饰的变量是所有同一个类生成的对象共享的

A.public
B.private
C.static
D.final

• 此题考察static的作用
• static表示静态变量，归类所有，该类的所有对象公用

45.下列哪个修饰符可以使在一个类中定义的成员变量只能被同一包中的类访问

A.private
B.无修饰符
C.public
D.protected

• 选B

46.关于 Socket 通信编程，以下描述正确的是

A.客户端通过new ServerSocket()创建TCP连接对象
B.客户端通过TCP连接对象调用accept()方法创建通信的Socket对象
C.客户端通过new Socket()方法创建通信的Socket对象
D.服务器端通过new ServerSocket()创建通信的Socket对象

• 客户端通过new Socket()方法创建通信的Socket对象
• 服务器端通过new ServerSocket()创建TCP连接对象 accept接纳客户端请求
• 所以选C

47.变量a是一个64位有符号的整数，初始值用16进制表示为：0x7FFFFFFFFFFFFFFF;变量b是一个64位有符号的整数，初始值用16进制表示为：0x8000000000000000。则a+b的结果用10进制表示为多少

A.1
B.-1
C.2⁶³⁺²62+…+2²⁺²1+2^0
D.–(2⁶³⁺²62+…+2²⁺²1+2^0)

• B

48.非抽象类实现接口后，必须实现接口中的所有抽象方法，除了abstract外，方法头必须完全一致

A.正确
B.错误

• 实际上这道题考查的是两同两小一大原则

  • 方法名相同，参数类型相同
  • 子类返回类型小于等于父类方法返回类型
  • 子类抛出异常小于等于父类方法抛出异常
  • 子类访问权限大于等于父类方法访问权限

• 在实现接口方法的时候，也必须使用public(接口默认方法权限也是public)

49.根据下面的代码，

String s = null;

会抛出NullPointerException异常的有（）

A.if( (s!=null) & (s.length()>0) )
B.if( (s!=null) && (s.length()>0) )
C.if( (s==null) | (s.length()==0) )
D.if( (s==null) || (s.length()==0) )

• | &和&& ||不同的是，前者判断条件都会执行
• 比如A s!=null返回false 还会执行s.length()>0 而B s!=null返回false 就不会执行s.length()>0
• |也是如此
• 所以AC

50.下面的类哪些可以处理Unicode字符

A.InputStreamReader
B.BufferedReader
C.Writer
D.PipedInputStream

• 能处理Unicode字符 那么就一定必须是字符流
• 后缀是Stream的都是字节流，其他的都是字符流
• 所以ABC

51.若 a 的值为 3 时，下列程序段被执行后， c 的值是多少

int c = 1;
if ( a>0 ){
    if ( a>3){
        c = 2;
    }
    else{
        c = 3;
    }
}
else{
    c = 4;
}

A.1
B.2
C.3
D.4

• 判断执行应该没什么好说的
• 选C

52.编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为(

A.java
B.class
C.html
D.exe

• 从第一天学习Java起就知道了选B

53.下列说法哪个正确( )

A.不需要定义类，就能创建对象
B.对象中必须有数据域和方法
C.数据域可以是基本类型变量，也可以是一个对象
D.数据域必须是基本类型变量

• 没有模板，怎么可能创建对象，创建对象必须先要定义类，常识
• 对象中的数据域和方法取决于该对象的类，类里面有就有，没有就没有
• 数据域不一定是基本类型，也可以是引用类型
• 所以选C

54. i 的最终结果是？

int  i, sum=0;
for(i=0;i<10;++i,sum+=i);

A.10
B.9
C.11
D.以上答案都不正确

• 循环没什么好说的 选A

55.关于访问权限，说法正确的是

A.类A和类B在同一包中，类B有个protected的方法testB，类A不是类B的子类（或子类的子类），类A可以访问类B的方法testB
B.类A和类B在同一包中，类B有个protected的方法testB，类A不是类B的子类（或子类的子类），类A不可以访问类B的方法testB
C.访问权限大小范围：public > 包权限 > protected > private
D.访问权限大小范围：public > 包权限 > private > protected

• 权限大小public>protected>包权限>private
• protected比包权限大一点 子类能够访问
• 所以选A

56.关于JAVA的垃圾回收机制，下面哪些结论是正确

A.程序可以任意指定释放内存的时间
B.JAVA程序不能依赖于垃圾回收的时间或者顺序
C.程序可明确地标识某个局部变量的引用不再被使用
D.程序可以显式地立即释放对象占有的内存

• java提供了一个系统级的线程，即垃圾回收器线程。用来对每一个分配出去的内存空间进行跟踪。当JVM空闲时，自动回收每块可能被回收的内存，GC是完全自动的，不能被强制执行。程序员最多只能用System.gc()来建议执行垃圾回收器回收内存，但是具体的回收时间，是不可知的
• 当对象的引用变量被赋值为null，可能被当成垃圾
• 所以选B

57.下面有关JAVA swing的描述，说法错误的是？

A.Swing是一个基于Java的跨平台MVC框架。使用单线程模式。
B.Swing 是为了解决 AWT 存在的问题而新开发的包，它以 AWT 为基础的
C.Swing优化了AWT，运行速度比AWT快
D.Swing是一个基于组件的框架，所有的组件都是从javax.swing.JComponent类继承来的

• Swing 是在AWT的基础上构建的一套新的图形界面系统，它提供了AWT 所能够提供的所有功能，并且用纯粹的Java代码对AWT 的功能进行了大幅度的扩充。AWT 是基于本地方法的C/C++程序，其运行速度比较快；Swing是基于AWT 的Java程序，其运行速度比较慢
• 所以选C

58.关于AWT和Swing说法正确的是？

A.Swing是AWT的子类
B.AWT在不同操作系统中显示相同的风格
C.AWT不支持事件类型，Swing支持事件模型
D.Swing在不同的操作系统中显示相同的风格

• Swing是轻量级组件，AWT是重量级组件，不存在 继承关系
• AWT由于不完善，是用本地化方法实现窗体创建，所以显示风格跟平台相关
• Swing是弥补这一缺点，窗体的创建与平台无关
• awt与swing都支持事件模型
• 所以选D

59.关于ThreadLocal类 以下说法正确的是

A.ThreadLocal继承自Thread
B.ThreadLocal实现了Runnable接口
C.ThreadLocal重要作用在于多线程间的数据共享
D.ThreadLocal是采用哈希表的方式来为每个线程都提供一个变量的副本
E.ThreadLocal保证各个线程间数据安全，每个线程的数据不会被另外线程访问和破坏

ThreadLocal的类声明：
public class ThreadLocal<T>

• 所以AB都错了
• ThreadLocal类为每一个线程都维护了自己独有的变量拷贝。每个线程都拥有了自己独立的一个变量。
  所以ThreadLocal重要作用并不在于多线程间的数据共享，而是数据的独立
• 由于每个线程在访问该变量时，读取和修改的，都是自己独有的那一份变量拷贝，不会被其他线程访问，
  变量被彻底封闭在每个访问的线程中。所以E对。
• ThreadLocal中定义了一个哈希表用于为每个线程都提供一个变量的副本

static class ThreadLocalMap {

        static class Entry extends WeakReference<ThreadLocal> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }

        /**
         * The table, resized as necessary.
         * table.length MUST always be a power of two.
         */
        private Entry[] table;
}

• 所以D对
• 所以DE

60.JDK提供的用于并发编程的同步器有哪些
A.Semaphore
B.CyclicBarrier
C.CountDownLatch
D.Counter

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

61.进行Java基本的GUI设计需要用到的包是（）

A.java.io
B.java.sql
C.java.awt
D.java.rmi

• java.awt javax.swing

• C

62.关于构造方法的说法哪个正确（）？

A.一个类只能有一个构造方法
B.一个类可以有多个不同名的构造方法
C.构造方法与类同名
D.构造方法必须自己定义，不能使用父类的构造方法

• C

63.在Java Applet程序用户自定义的Applet子类中，一般需要重载父类的( )方法来完成一些画图操作

A.start( )
B.stop( )
C.init( )
D.paint( )

• 画图操作，很明显是paint（）方法

64.下面有关servlet中init,service,destroy方法描述错误的是？

A.init()方法是servlet生命的起点。一旦加载了某个servlet，服务器将立即调用它的init()方法
B.service()方法处理客户机发出的所有请求
C.destroy()方法标志servlet生命周期的结束
D.servlet在多线程下使用了同步机制，因此，在并发编程下servlet是线程安全的

• ABC是正确的 所以D错
• servlet在多线程下其本身并不是线程安全的

65.关于抽象类的叙述正确的是？( )

A.抽象类不可以实例化
B.抽象类就是一种特殊的接口
C.抽象类的方法都是抽象方法
D.抽象类的导出类一定不是抽象类

• A

66.Java语言中，如果"xyz"没有被创建过，String s =new String(“xyz”);创建了几个string object？

A.1
B.2
C.3
D.4

http://blog.sina.com.cn/s/blog_6a6b14100100zn6r.html

67.对于以下代码段，4个输出语句中输出true的个数是( )

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

  A
|     |
B     C
|
D

• D属于B,D属于A,D属于D,D不属于C
• 所以选C

68.下列程序的运行结果

public void getCustomerInfo() {
        try {
            // do something that may cause an Exception
        } catch (java.io.FileNotFoundException ex) {
            System.out.print("FileNotFoundException!");
        } catch (java.io.IOException ex) {
            System.out.print("IOException!");
        } catch (java.lang.Exception ex) {
            System.out.print("Exception!");
        }
    }

A.IOException!
B.IOException!Exception!
C.FileNotFoundException!IOException!
D.FileNotFoundException!IOException!Exception!

• 题目说抛出一个异常，但是没说具体是什么异常，那么就要分情况了：
• 如果抛出一个FileNotFoundException(或其子类)，那么最终结果就打印FileNotFoundException
• 如果抛出一个IOException,或者IOException的子类(不包含FileNotFoundException及其子类)，那么最终结果就打印IOException
• 如果抛出一个Exception(不包含IOException及其子类),那么最终结果就打印Exception.
• 以上，所以3个皆有可能.但是，不管是哪一种情况，只会输出其中之一。
• 从答案上来看，B,C，D的输出情况是不存在的。因此选A

69.关于数据库连接的程序，以下哪个语句的注释是错误的（ ）

A.Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”); //指定MySQL JDBC驱动程序
B.String url=”jdbc:odbc:student_access”; //指定数据源为student_access
C.Connection con=DriverManager.getConnection(url); //创建连接指定数据库的对象
D.Statement stmt=con.creatStatement();//创建执行SQL语句的Statement对象

• mysql驱动不是这个
• 所以选A

70.在Struts框架中如果要使用Validation作验证的话，需要使用以下哪个Form？

A.ActionForm
B.ValidatorActionForm
C.ValidatorForm
D.DynaValidatorActionForm

• DynaValidatorActionForm 动态验证表单

• Validation 确认的意思

• 这个好像是struts 1 的知识…

71.可以把任何一种数据类型的变量赋给Object类型的变量

A.正确
B.错误

• java所有类默认继承Object类(包括自定义类)
• 所以选A

72.ArrayList和LinkList的描述，下面说法错误的是

A.LinkedeList和ArrayList都实现了List接口
B.ArrayList是可改变大小的数组，而LinkedList是双向链接串列
C.LinkedList不支持高效的随机元素访问
D.在LinkedList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在ArrayList的中间插入或删除一个元素的开销是固定的

• ABC都对的
• D中 linkedList底层是双向链表 而ArrayList底层是数组,顺序存储的线性表 所以说反了

73.枚举（enum）属于原始数据类型（primitive type）

A.正确
B.错误

• java只有8种基本类型:byte,short,int,long,float,double,boolean,char
• enum是一种特殊的类 不是原始数据类型

74.要使某个类能被同一个包中的其他类访问，但不能被这个包以外的类访问，可以

A.让该类不使用任何关键字
B.使用private关键字
C.使用protected关键字
D.使用void关键字

• 默认关键字能够解决 所以选A

75.protected访问权限要小于包访问权限

A.正确
B.错误

• protected不仅具有包访问权限 而是不同包的子类也能访问

76.下面有关List接口、Set接口和Map接口的描述，错误的是

A.他们都继承自Collection接口
B.List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置
C.Set是一种不包含重复的元素的Collection
D.Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value

• 可以把Map接口和Collection接口是同一等级的 所以A错

77.在 main() 方法中给出的整型数组，如果将其写到一个文件中，需要

A.标准输出流System.out.println()。
B.建立数据字节输出流。
C.建立数据字节输入流。
D.标准输入流System.in.read()

• 读进去 写出来
• 读用输入流 写用输出流
• 所以B

78.类的析构函数是一个对象被( )时自动调用的

A.建立
B.撤消
C.赋值
D/引用

• 析构函数(destructor) 与 构造函数 相反，当对象结束其 生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做“清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）
• 所以选B

79.下面哪个不对？

A.RuntimeException is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.
B.A method is not required to declare in its throws clause any subclasses of RuntimeExeption that might be thrown during the execution of the method but not caught
C.An RuntimeException is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch.
D.NullPointerException is one kind of RuntimeException

• C

80.在Java中，对于不再使用的内存资源，如调用完成的方法，“垃圾回收器”会自动将其释放

A.正确
B.错误

• JVM 内存可简单分为三个区：

  • 堆区（heap）：用于存放所有对象，是线程共享的（注：数组也属于对象）

  • 栈区（stack）：用于存放基本数据类型的数据和对象的引用，是线程私有的（分为：虚拟机栈和本地方法栈）

  • 方法区（method）：用于存放类信息、常量、静态变量、编译后的字节码等，是线程共享的（也被称为非堆，即 None-Heap）

• Java 的垃圾回收器（GC）主要针对堆区

• 所以B

81.关于 Java 线程，下面说法错误的是

A.创建线程可以通过实现Runnable接口和继承Thread类
B.java利用线程使整个系统成为异步
C.新线程一旦被创建，它将自动开始运行

• 新线程创建完成之后，需要调用start()方法线程才会进入就绪状态，也不是一调用start()方法就立即运行，当CPU分配时间给它时，它才会运行
• 所以C

82.下列不属于访问控制符的是

A.public
B.private
C.protected
D.static

• D

83.以下关于Object类的说法正确的是

A.Java中所有的类都直接或间接继承自Object，无论是否明确的指明，无论其是否是抽象类。
B.Java中的接口(interface)也继承了Object类
C.利用“==”比较两个对象时，Java调用继承自Object的equals方法，判断是否相等。
D.如果类的定义中没有重新定义toString()方法，则该类创建的对象无法使用toStrig()方法。

• 如果一个接口也继承了Object 类，那么接口会继承Object类中的很多方法，显然会错
• == 请看第一道题
• 没重写toString会打印地址

84.关于JAVA堆，下面说法错误的是

A.所有类的实例和数组都是在堆上分配内存的
B.堆内存由存活和死亡的对象，空闲碎片区组成
C.数组是分配在栈中的
D.对象所占的堆内存是由自动内存管理系统回收

• 对象都是在堆里面的 数组也是对象 所以C错
• 数组的引用是在栈里面的

85.关于依赖注入，下列选项中说法错误的是

A.依赖注入能够独立开发各组件，然后根据组件间关系进行组装
B.依赖注入提供使用接口编程
C.依赖注入使组件之间相互依赖，相互制约
D.依赖注入指对象在使用时动态注入

• 依赖注入目的是减少组件之间的耦合度，使开发变得简单
• 所以C

86.能单独和finally语句一起使用的块是

A.try
B.catch
C.throw
D.throws

• 处理异常常用的两种方式：

  • try…catch(捕获处理机制)；
  • throws(冒泡处理机制).

• 注意细节：使用try…catch块捕获时可以没有catch块,但当没用catch块的时候必须得有finally块

• 所以选A

87.在JAVA中，假设A有构造方法A(int a)，则在类A的其他构造方法中调用该构造方法和语句格式应该为

A.this.A(x)
B.this(x)
C.super(x)
D.A(x)

• A.这是调用普通方法的写法
• C.这时显示调用父类构造方法
• D.调用静态方法
• 所以选B

88.下列关于容器集合类的说法正确的是

A.LinkedList继承自List
B.AbstractSet继承自Set
C.HashSet继承自AbstractSet
D.WeakMap继承自HashMap

• linkedlist类是实现了List接口，而不是继承
• AbstractSet类实现Set接口
• HashSet继承 AbstractSet类，同时也实现set
• WeakMap是js里面的玩意儿
• 所以选C

89.java8中，忽略内部接口的情况，不能用来修饰interface里的方法的有

A.private
B.public
C.protected
D.static

• only public, abstract, default, static and strictfp are permitted
• 8之前是不能static的
• 所以AC

90.下面哪项技术可以用在WEB开发中实现会话跟踪实现

A.session
B.Cookie
C.地址重写
D.隐藏域

• ABCD都可以
• 隐藏表单域：<input type="hidden">，非常适合步需要大量数据存储的会话应用
• URL 重写:URL 可以在后面附加参数，和服务器的请求一起发送，这些参数为名字/值对
• Cookie:一个 Cookie 是一个小的，已命名数据元素。服务器使用 SET-Cookie 头标将它作为 HTTP
  响应的一部分传送到客户端，客户端被请求保存 Cookie 值，在对同一服务器的后续请求使用一个
  Cookie 头标将之返回到服务器。与其它技术比较，Cookie 的一个优点是在浏览器会话结束后，甚至
  在客户端计算机重启后它仍可以保留其值
• Session：使用 setAttribute(String str,Object obj)方法将对象捆绑到一个会话

91.类 ABC 定义如下

1 ． public  class  ABC{
2 ． public  int  max( int  a, int  b) {   }
3 ．
4 ． }

将以下哪个方法插入行 3 是不合法的
A.public float max(float a, float b, float c){ }
B.public int max (int c, int d){ }
C.public float max(float a, float b){ }
D.private int max(int a, int b, int c){ }

• B
• 重载是在编译器通过方法中形参的静态类型确定调用方法版本的过程
• 重载是多态在编译期的表现形式
• 重载的判定只有两个条件（其他的条件都不能作为判定）
• 方法名一致
• 形参列表不同

92.下面关于依赖注入(DI)的说法不正确的是

A.只有通过Spring才能实现依赖注入(DI)
B.依赖注入的主要目的是解耦合
C.常见的依赖注入方式有Setter和构造方法

• 依赖注入是一种思想，或者说是一种设计模式，在java中是通过反射机制实现，与具体框架无关
• 所以A

93.类A1和类A2在同一包中，类A2有个protected的方法testA2，类A1不是类A2的子类（或子类的子类），类A1可以访问类A2的方法testA2。（ ）

A.正确
B.错误

• protected子类能访问父类 所以A

94.java如何接受request域中的参数？

A.request.getRequestURL()
B.request. getAttribute()
C.request.getParameter()
D.request.getWriter()

• C
• request.getAttribute()方法返回request范围内存在的对象
• request.getParameter()方法是获取http提交过来的数据

95.对于abstract声明的类，下面说法正确的是

A.可以实例化
B.不可以被继承
C.子类为abstract
D.只能被继承
E.可以被抽象类继承

• 不能被实例化
• 可以被继承。派生类可以实现抽象方法
• 子类可以是抽象的，也可以非抽象的
• 可以被抽象类继承，也可以被非抽象类继承
• 抽象类也可以调用静态方法直接使用 所以D错 E对

96.静态变量static在不同的实例中地址是否一样？他们储存在什么区域？

A.地址一样，在堆栈区。
B.地址不一样，在堆栈区。
C.地址一样，在全局区。
D.地址不一样，在全局区。

• static变量也称作静态变量，静态变量和非静态变量的区别是：
  • 静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。所以在全局区
  • 而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响
• C

97.

int i=5;
int s=(i++)+(++i)+(i--)+(--i);
s=( )//s 的值是什么？

A.28
B.25
C.21
D.26
E.24
F.23

int s = (5)+(++6)+(7–)+(–6)
=5+7+7+5
=24;

• 所以E

98.下列哪个说法是正确的（）

A.ConcurrentHashMap使用synchronized关键字保证线程安全
B.HashMap实现了Collction接口
C.Array.asList方法返回java.util.ArrayList对象
D.SimpleDateFormat是线程不安全的

• ConcurrentHashMap 使用segment来分段和管理锁，segment继承自ReentrantLock，因此ConcurrentHashMap使用ReentrantLock来保证线程安全
• B错
• C中，应该是Arrays.asList()，其将一个数组转化为一个List对象，这个方法会返回一个ArrayList类型的对象， 这个ArrayList类并非java.util.ArrayList类，而是Arrays类的内部类：
• D对

99.下列正确的有

A.call by value不会改变实际参数的数值
B.call by reference能改变实际参数的参考地址
C.call by reference不能改变实际参数的参考地址
D.call by reference能改变实际参数的内容

• 基本类型和基本类型变量被当作参数传递给方法时，是值传递。
• 在方法实体中，无法给原变量重新赋值，也无法改变它的值
• 对象和引用型变量被当作参数传递给方法时，是引用传递
• 在方法实体中，无法给原变量重新赋值，但是可以改变它所指向对象的属性。
• 所以ACD

100.在Java语言中，下列关于字符集编码（Character set encoding）和国际化（i18n）的问题，哪些是正确的？

A.每个中文字符占用2个字节，每个英文字符占用1个字节
B.假设数据库中的字符是以GBK编码的，那么显示数据库数据的网页也必须是GBK编码的。
C.Java的char类型，通常以UTF-16 Big Endian的方式保存一个字符。
D.实现国际化应用常用的手段是利用ResourceBundle类

• 显然是错误的，Java一律采用Unicode编码方式，每个字符无论中文还是英文字符都占用2个字节

• 也是不正确的，不同的编码之间是可以转换的，通常流程如下：
  将字符串S以其自身编码方式分解为字节数组，再将字节数组以你想要输出的编码方式重新编码为字符串。
  例：String newUTF8Str = new String(oldGBKStr.getBytes(“GBK”), “UTF8”);

• 是正确的。Java虚拟机中通常使用UTF-16的方式保存一个字符

• 也是正确的。ResourceBundle能够依据Local的不同，选择性的读取与Local对应后缀的properties文件，以达到国际化的目的

• 所以CD