Java选择题（九）

1.java7后关键字 switch 支不支持字符串作为条件：（）

正确答案: A 你的答案: A (正确)
A.支持
B.不支持

解释:
switch(exp)，在JDK7之前，只能是byte、short、char、int或者对应的包装类，或者枚举常量（内部也是由整型或字符类型实现）。
为什么必须是这些呢，因为其实exp只是对int型支持的，其他都是因为可以自动拆卸或者自动向上转型到int，所以才可以。
到了JDK7的时候，String被引入了，为什么String能被引入呢？
其实本质上还是对int类型值得匹配。
原理如下，通过对case后面得String对象调用hashCode方法，得到一个int类型得hash值，然后用这个hash值来唯一标识这个case。那么当匹配时，首先调用exp的hashCode，得到exp的hash值，用这个hash值来匹配所有case，如果没有匹配成功，就说明不存在；如果匹配成功了，接着会调用字符串的equals方法进行匹配。（hash值一致，equals可不一定返回的就是true）。
所以，exp不能为null，cas子句使用的字符串也不能为null，不然会出现空指针异常。

2.关于下面程序 ThisTest .java 运行结果 说法正确的是 ： ( )

public class ThisTest {
            public static void main(String args[]) {
                String x="7";       
        int y = 2;
                int z=2;              
        System.out.println(x+y+z);
            }  
}

正确答案: B 你的答案: B (正确)
A.11
B.722
C.22
D.程序有编译错误

解释：
+号两边如果有一边为字符类型 则为字符串连接
如果变为y+z+x 则等价于(y+z)+x 输出47

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

正确答案: A 你的答案: B (错误)
A.让该类不使用任何关键字
B.使用private关键字
C.使用protected关键字
D.使用void关键字

解释：
default和protected的区别是：
前者只要是外部包，就不允许访问。
后者只要是子类就允许访问，即使子类位于外部包。
总结：default拒绝一切包外访问；protected接受包外的子类访问

4.下面有关java object默认的基本方法，说法错误的是？

正确答案: B 你的答案: D (错误)
A.equals(Object obj) 指示某个其他对象是否与此对象“相等”
B.copy() 创建并返回此对象的一个副本
C.wait() 导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法
D.toString() 返回该对象的字符串表示

解释：
java object默认的基本方法中没有copy()，含有如下方法：
getClass(), hashCode(), equals(), clone(), toString(), notify(), notifyAll(), wait(), finalize()

5.下面赋值语句中正确的是（）

正确答案: A 你的答案: B (错误)
A.double d=5.3e12;
B.float f=11.1;
C.int i=0.0;
D.Double oD=3;

解释：
java中整型默认的是int,浮点默认的是double.
B: double类型的11.1 转成 float，是需要强制转换的
C: double类型的0.0 转成 int，也是需要强制转换的
D: int 转为 封装类型Double，是无法编译的
Double oD = 3.0， 会把double类型的3.0自动装箱为Double，没有问题

6.如下哪些是 java 中有效的关键字（）

正确答案: A D 你的答案: D (错误)
A.native
B.NULL
C.false
D.this

解释：
常考的、不是关键字的有：
true、false、null、sizeof、friendly

7.下列说法正确的是（）？

正确答案: B D 你的答案: B (错误)
A.我们直接调用Thread对象的run方法会报异常，所以我们应该使用start方法来开启一个线程
B.一个进程是一个独立的运行环境，可以被看做一个程序或者一个应用。而线程是在进程中执行的一个任务。Java运行环境是一个包含了不同的类和程序的单一进程。线程可以被称为轻量级进程。线程需要较少的资源来创建和驻留在进程中，并且可以共享进程中的资源
C.synchronized可以解决可见性问题，volatile可以解决原子性问题
D.ThreadLocal用于创建线程的本地变量，该变量是线程之间不共享的

解释：
volatile与synchronized的区别：
volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的,需要从主存中读取,synchronized则是锁定当前变量,只有当前线程可以访问该变量,其他线程被阻塞住.
volatile仅能使用在变量级别,synchronized则可以使用在变量,方法.
volatile仅能实现变量的修改可见性,但不具备原子特性,而synchronized则可以保证变量的修改可见性和原子性.
volatile不会造成线程的阻塞,而synchronized可能会造成线程的阻塞.
volatile标记的变量不会被编译器优化,而synchronized标记的变量可以被编译器优化.

8.下面代码在main()方法中第八行后可以正常使用的是（ ）

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 D 你的答案: A D (正确)
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: 合理

9.常用的servlet包的名称是？

正确答案: B D 你的答案: A D (错误)
A.java.servlet
B.javax.servlet
C.servlet.http
D.javax.servlet.http

解释：
JEE5.0中的Servlet相关的就下面这几个包:
javax.servlet
javax.servlet.jsp
java.servlet.jsp.el
java.servlet.jsp.tagext
而最用得多的就是
javax.servlet
javax.servlet.http
这两个包了.

10.关于Java中的数组，下面的一些描述，哪些描述是准确的：（ ）

正确答案: A C F 你的答案: A E F (错误)
A.数组是一个对象，不同类型的数组具有不同的类
B.数组长度是可以动态调整的
C.数组是一个连续的存储结构
D.一个固定长度的数组可类似这样定义: int array[100]
E.两个数组用equals方法比较时，会逐个便利其中的元素，对每个元素进行比较
F.可以二维数组，且可以有多维数组，都是在Java中合法的

解释：
数组是一种引用数据类型 那么他肯定是继承Object类的 所以里面有equals() 方法 但是肯定没有重写过 因为他并不是比较数组内的内容
使用Arrays.equals() 是比较两个数组中的内容。

11.下列Java常见事件类中哪个是鼠标事件类？（）

正确答案: C 你的答案: C (正确)
A.InputEvent
B.KeyEvent
C.MouseEvent
D.WindowEvent

解释：
InputEvent输入事件，KeyEvent按键事件，MouseEvent鼠标事件，WindowEvent窗体事件

12.下列语句序列执行后，输出结果是（）

public class ex{
public static void main(String[]args){
int a=13;
a=a/5；
System.out.println(a);
}
}

正确答案: B 你的答案: B (正确)
A.1
B.2
C.3
D.4

解释：
a是int类型,13/5得到一个浮点类型,浮点类型转成整数类型的原则是,不四舍五入,直接截断小数点后的部分.

13.已知如下类说明：

public class Test{
    private float f=1.0f;
    int m=12;
    static int n=1;
    public static void main(String args[]){
        Test t=new Test();
    }
}

如下哪些使用是正确的（）
正确答案: D 你的答案: B (错误)
A.t.f = 1.0
B.this.n
C.Test.m
D.Test.n

解释：
A：编译不成功，因为float浮点类型默认是double类型 所以float f=1.0f;（必须加上f 强调定义的是float）此处是精度由高(double)向低(float)转型所以会报错 但是若是float f=1;这里是默认类型是Int 类型 精度由低(int)向高转型(float)不丢失精度不会报错。
B：this的使用时针对在方法内部使局部变量等值于实例变量而使用的一个关键字，此处的n是静态变量而非实例变量 所以this的调用会出错（试想一下，static本来是全类中可以使用的，是全局的，你非得this去调用，这不是区分局部变量和实例变量的分水线吗？但是此处是全局的，不需要区分）
C：m是实例变量，什么是实例变量：就是需要new 一个对象出来才能使用的，这里直接用类名就调用了，jvm怎么知道m是谁？
D：类变量可以通过类直接调用

14.Java 的屏幕坐标是以像素为单位，容器的左下角被确定为坐标的起点。

正确答案: B 你的答案: B (正确)
A.正确
B.错误

解释：容器的左上角被确定为坐标的起点。

15.选项中哪一行代码可以替换 //add code here 而不产生编译错误

public abstract class MyClass {
     public int constInt = 5;
     //add code here
     public void method() {
     } 
}

正确答案: A 你的答案: A (正确)
A.public abstract void method(int a);
B.consInt=constInt+5;
C.public int method();
D.public abstract void anotherMethod(){}

解释：
A：抽象类可以包含抽象方法
B：类中定义成员和方法，不能直接进行运算，可以写在代码块{}或者静态代码块中static{}中
C: 与第四行想要构成重载，二者区别是返回类型，但是返回类型不能作为重载的依据
D: 该方法使用abstract修饰，是抽象方法，但是他有方法体(带有{}的就是方法体，即使里面是空的)，就不能作为抽象方法

10. class Line {
11. public class Point { public int x,y;}
12. public Point getPoint() { return new Point(); }
13. }
14. class Triangle {
15. public Triangle() {
16. // insert code here
17. }
18. }
19. 

在第16行插入哪段代码可以获得一个Point对象的坐标?( )
正确答案: D 你的答案: C (错误)
A。Point p = Line.getPoint();
B.Line.Point p = Line.getPoint();
C.Point p = (new Line()).getPoint();
D.Line.Point p = (new Line()).getPoint();

17.What will happen when you attempt to compile and run the following code?

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

正确答案: D 你的答案: D (正确)
A.compiletime error
B.prints:1
C.prints:2
D.prints:3
E.prints:7
F.prints:8

解释：
D.1.JVM加载class文件时，就会执行静态代码块，静态代码块中初始化了一个变量x并初始化为5，由于该变量是个局部变量，静态代码快执行完后变被释放。
2.申明了两个静态成员变量x，y，并没有赋初值，会有默认出值，int类型为0，
3.执行x–操作，变量单独进行自增或自减操作x–和--x的效果一样，此时x变为了-1
4.调用MyMethod()方法，在该方法中对x和y进行计算，由于x和y都是静态成员变量，所以在整个类的生命周期内的x和y都是同一个
5.y=x++ + ++x可以看成是y=(x++)+(++x)，当++或者–和其它变量进行运算时，x++表示先运算，再自增，++x表示先自增再参与运算
所以就时x为-1参与运算，然后自增，x此时为0，++x后x为1，然后参与运算，那么y=-1+1就为0，此时x为1
6.执行并打印x+y + ++x运算方式和第5步相同，最后计算结果就为3.

18.下列描述错误的是?

正确答案: B D 你的答案: A (错误)
A.类只能继承一个父类，但是可以实现多个接口
B.抽象类自身可以定义成员而接口不可以
C.抽象类和接口都不能被实例化(忽略匿名内部类)
D.一个类可以有多个父类和多个基接口

解释：
A、java为单继承，多实现。可以实现多个接口。
B、接口允许定义成员，但必须是常量。
C、抽象类和接口类的无法实例化，任何编译器中直接使用new会报错。
D、同A，单继承，多实现。

19.下面哪些赋值语句是正确的（）

正确答案: A B D 你的答案: B D (错误)
A.long test=012
B.float f=-412
C.int other =(int)true
D.double d=0x12345678
E.byte b=128

解释：
基本类型与基本封装类型
A和B选项如果为 Long Float，则是需要在数值后面加L和F，但是他们是基本类型，会进行转化，所以不需要带，

20.CMS垃圾回收器在那些阶段是没用用户线程参与的

正确答案: A C 你的答案: C (错误)
A.初始标记
B.并发标记
C.重新标记
D.并发清理

解释：
用户线程（user-level threads）指不需要内核支持而在用户程序中实现的线程，其不依赖于操作系统核心，应用进程利用线程库提供创建、同步、调度和管理线程的函数来控制用户线程。
CMS的GC过程有6个阶段（4个并发，2个暂停其它应用程序）

1. 初次标记(STW initial mark)
2. 并发标记(Concurrent marking)
3. 并发可中断预清理(Concurrent precleaning)
4. 最终重新标记(STW remark)
5. 并发清理(Concurrent sweeping)
6. 并发重置(Concurrent reset)
   在初次标记，重新标志的时候，要求我们暂停其它应用程序，那么这两个阶段用户线程是不会参与的

21.下列程序执行后结果为( )

class A {
    public int func1(int a, int b) {
        return a - b;
    }
}
class B extends A {
    public int func1(int a, int b) {
        return a + b;
    }
}
public class ChildClass {
    public static void main(String[] args) {
    A a = new B();
    B b = new B();
    System.out.println("Result=" + a.func1(100, 50));
    System.out.println("Result=" + b.func1(100, 50));
    }
}

正确答案: A 你的答案: A (正确)
A.Result=150Result=150
B.Result=100Result=100
C.Result=100Result=150
D.Result=150Result=100

解释：
此题考查的是多态。
对于多态，可以总结它为：
一、使用父类类型的引用指向子类的对象；
二、该引用只能调用父类中定义的方法和变量；
三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）
四、变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。
多态的3个必要条件：
1.继承 2.重写 3.父类引用指向子类对象。
向上转型： Person p = new Man() ; //向上转型不需要强制类型转化
向下转型： Man man = (Man)new Person() ; //必须强制类型转化

22.在异常处理中，若try中的代码可能产生多种异常则可以对应多个catch语句，若catch中的参数类型有父类子类关系，此时应该将父类放在后面，子类放在前面。
正确答案: A 你的答案: A (正确)
A.正确
B.错误

解释：
首先所有异常都是Exception的子类。
比如用Exception
因为所有异常都是Exception的子类,如果你把Exception放在前边捕获,后边的catch将永远不会执行

For which of these values of a
I. 4
II.6
III. 8
is the expression
(a != 3 && a != 4 && a != 5 && a != 6)
false?

正确答案: D 你的答案: D (正确)
A.I only
B.II only
C.III only
D.I and II only
E.I， II， and III

解释：
a != 3 && a != 4 && a != 5 && a != 6
四个条件逻辑与操作，任意一个为false都会导致与操作结果为false
a=4导致第二个条件为false
a=6导致第四个条件为false
a=8则所以都为true
所以选D

24.根据以下接口和类的定义，要使代码没有语法错误，则类Hero中应该定义方法( )。

interface Action{  
    void fly();  
}
class Hero implements Action{  //……  }

正确答案: D 你的答案: D (正确)
A.private void fly(){}
B.void fly(){}
C.protected void fly(){}
D.public void fly(){}

解释：
在继承中，重写要求子类不能有比父类更加严格的访问修饰符。这一点和接口相似。
接口默认方法是public abstract。属性默认public static final。
而抽象类中的抽象方法修饰符可以是public或者protected。

25.假设如下代码中，若t1线程在t2线程启动之前已经完成启动。代码的输出是（）

public static void main(String[]args)throws Exception {
    final Object obj = new Object();
    Thread t1 = new Thread() {
        public void run() {
            synchronized (obj) {
                try {
                    obj.wait();
                    System.out.println("Thread 1 wake up.");
                } catch (InterruptedException e) {
                }
            }
        }
    };
    t1.start();
    Thread.sleep(1000);//We assume thread 1 must start up within 1 sec.
    Thread t2 = new Thread() {
        public void run() {
            synchronized (obj) {
                obj.notifyAll();
                System.out.println("Thread 2 sent notify.");
            }
        }
    };
    t2.start();
}

正确答案: B 你的答案: B (正确)
A.Thread 1 wake up
B.Thread 2 sent notify.
C.Thread 2 sent notify.
D.Thread 1 wake up
E.A、B皆有可能
F.程序无输出卡死

解释：
notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作

26.如果希望监听TCP端口9000，服务器端应该怎样创建socket?

正确答案: B 你的答案: B (正确)
A.new Socket(“localhost”,9000);
B.new ServerSocket(9000);
C.new Socket(9000);
D.new ServerSocket(“localhost”,9000);

解释:
ServerSocket (int port)
创建一个serversocket 绑定在特定的端口
Socket(InetAddress address, int port)
创建一个socket流，连接到特定的端口和ip地址

27.下列关于系列化和反序列化描述正确的是：

正确答案: A B 你的答案: B (错误)
A.序列化是将数据转为n个 byte序列的过程
B.反序列化是将n个 byte转换为数据的过程
C.将类型int转换为4 byte是反序列化过程
D.将8个字节转换为long类型的数据为序列化过程

解释：
序列化：将数据结构转换称为二进制数据流或者文本流的过程。序列化后的数据方便在网络上传输和在硬盘上存储。
反序列化：与序列化相反，是将二进制数据流或者文本流转换称为易于处理和阅读的数据结构的过程。
本质其实还是一种协议，一种数据格式，方便数据的存储和传输。

28.jdk1.8版本之前的前提下，接口和抽象类描述正确的有（ ）

正确答案: B C 你的答案: B (错误)
A.抽象类没有构造函数
B.接口没有构造函数
C.抽象类不允许多继承
D.接口中的方法可以有方法体

解释：
jdk1.8后接口中用static或default修饰的方法可以有方法体

29.下面有关servlet的层级结构和常用的类，说法正确的有?

正确答案: A B C D 你的答案: B D (错误)
A.GenericServlet类：抽象类，定义一个通用的、独立于底层协议的Servlet。
B.大多数Servlet通过从GenericServlet或HttpServlet类进行扩展来实现。
C.ServletConfig接口定义了在Servlet初始化的过程中由Servlet容器传递给Servlet得配置信息对象。
D.HttpServletRequest接口扩展ServletRequest接口，为HTTP Servlet提供HTTP请求信息。

解释：
HttpServlet是GenericServlet的子类。
GenericServlet是个抽象类，必须给出子类才能实例化。它给 出了设计servlet的一些骨架，定义了servlet生命周期，还有一些得到名字、配置、初始化参数的方法，其设计的是和应用层协议无关的，也就是说 你有可能用非http协议实现它。
HttpServlet是子类，当然就具有GenericServlet的一切特性，还添加了doGet, doPost, doDelete, doPut, doTrace等方法对应处理http协议里的命令的请求响应过程。
一般没有特殊需要，自己写的Servlet都扩展HttpServlet 。

30.CMS垃圾回收器在那些阶段是没用用户线程参与的

正确答案: A C 你的答案: A C (正确)
A.初始标记
B.并发标记
C.重新标记
D.并发清理

解释：
用户线程（user-level threads）指不需要内核支持而在用户程序中实现的线程，其不依赖于操作系统核心，应用进程利用线程库提供创建、同步、调度和管理线程的函数来控制用户线程。
CMS的GC过程有6个阶段（4个并发，2个暂停其它应用程序）

1. 初次标记(STW initial mark)
2. 并发标记(Concurrent marking)
3. 并发可中断预清理(Concurrent precleaning)
4. 最终重新标记(STW remark)
5. 并发清理(Concurrent sweeping)
6. 并发重置(Concurrent reset)
   在初次标记，重新标志的时候，要求我们暂停其它应用程序，那么这两个阶段用户线程是不会参与的