Java选择题（六）

1.以下关于Integer与int的区别错误的是

正确答案: D 你的答案: D (正确)
A.int是java提供的8种原始数据类型之一
B.Integer是java为int提供的封装类
C.int的默认值为0
D.Integer的默认值为1

解释：
int 是八大基本数据类型之一（byte,char,short,int,long,float,double,boolean）
Integer 是 int 包装类;
int是基本数据类型，默认值为0,
Integer 是类，默认值为null；
Integer 表示的是对象，用一个引用指向这个对象,
int是基本数据类型，直接存储数值。

2.在程序代码中写的注释太多，会使编译后的程序尺寸变大。

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

解释：
编译后的程序尺寸即class文件大小
过多注释影响编译效率，影响合作开发效率
注释不会影响class文件的执行效率

3.代码

System.out.println(10%3*2);

将打印？

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

解释：%和*是同一个优先级，从左到右运算

4.有以下程序片段，下列哪个选项不能插入到第一行 。（ ）。

1.

2.public  class  A{

3.//do sth

4. }

正确答案: A 你的答案: A (正确)
A.public class MainClass{ }
B.package mine;
C.class ANotherClass{ }
D.import java.util.*;

解释：
Java一个源程序只能有一个public类存在，且类名与文件名相同。Java程序是从main方法开始执行的，public为类加载器提供入口，然后找到public类中的main方法开始执行。如果存在多个public类，程序将不知道该从哪里执行。
注意，内部类可以是public的，因为内部类是作为外部类的成员存在的

5.在Web应用程序的文件与目录结构中，web.xml是放置在( )中。

正确答案: A 你的答案: D (错误)
A.WEB-INF目录
B.conf目录
C.0lib目录
D.classes目录

解释：web.xml文件是用来初始化配置信息，web.xml是放置在WEB-INF目录中

6.有关线程的叙述正确的是()

正确答案: C 你的答案: C (正确)
A.可以获得对任何对象的互斥锁定。
B.通过继承Thread类或实现Runnable接口，可以获得对类中方法的互斥锁定。
C.线程通过使用synchronized关键字可获得对象的互斥锁定。
D.线程的创建只能通过继承Thread类来实现。

解释：采用synchronized修饰符实现的同步机制叫做互斥锁机制，它所获得的锁叫做互斥锁。每个对象都有一个monitor(锁标记)，当线程拥有这个锁标记时才能访问这个资源，没有锁标记便进入锁池。任何一个对象系统都会为其创建一个互斥锁，这个锁是为了分配给线程的，防止打断原子操作。每个对象的锁只能分配给一个线程，因此叫做互斥锁。

7.类 ABC 定义如下：

1 ． public  class  ABC{

2 ． public  int  max( int  a, int  b) {   }

3 ．

4 ． }

将以下哪个方法插入行 3 是不合法的。（ ）。

正确答案: B 你的答案: A (错误)
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){ }

解释：
重写和重载：
这两个都是多态的一种表现形式。
重载：
1、 重载是在编译器通过方法中形参的静态类型确定调用方法版本的过程。
2、 重载是多态在编译期的表现形式
3、 重载的判定只有两个条件（其他的条件都不能作为判定）：
1、 方法名一致
2、形参列表不同
重写：
1、重写在方法运行时，通过调用者的实际类型来确定调用的方法版本。（具体细说，就是子父类中的重写方法在对应的class文件常量池的位置相同，一旦子类没有重写，那么子类的实例就会沿着这个位置往上找，直到找到父类的同名方法）
2、重写只发生在可见的实例方法中：
1、静态方法不存在重写，形式上的重写只能说是隐藏。
2、私有方法也不存在重写，父类中private的方法，子类中就算定义了，就是相当于一个新的方法。
3、静态方法和实例方法不存在相互重写。
3、重写满足一个规则：两同两小一大
1、两同：方法名和形参列表一致
2、两小：重写方法的返回值（引用类型）和抛出异常，要和被重写方法的返回值（引用类型）和抛出异常相同或者是其子类。注意，一旦返回值是基本数据类型，那么重写方法和被重写方法必须相同，且不存在自动拆装箱的问题。
3、一大：重写方法的访问修饰符大于等于被重写方法的访问修饰符。

8.以下代码的循环次数是

public class Test {
public static void main(String args[]) {
int i = 7;
do {
System.out.println(--i);
--i;
} while (i != 0);
System.out.println(i);
}
}

正确答案: D 你的答案: C (错误)
A.0
B.1
C.7
D.无限次

解释：
执行1次，输出是6，然后再减1为5进行while判定不为o再进入do
执行2次，输出是4，然后再减1为3进行while判定不为o再进入do
执行3次，输出是2，然后再减1为1进行while判定不为o再进入do
执行4次，输出是0，然后再减1为-1进行while判定不为o再进入do
永远执行不到0

9.基本的Java语言函数存储在以下哪个java包中？（）

正确答案: A 你的答案: A (正确)
A.java.lang
B.java.io
C.java.net
D.java.util

解释：
java.lang包包含
包装类
String 类
Math 类 —— 包含函数
Class 类
Object 类

10.建立Statement对象的作用是？

正确答案: C 你的答案: C (正确)
A.连接数据库
B.声明数据库
C.执行SQL语句
D.保存查询结果

解释：
1、Statement对象用于执行不带参数的简单SQL语句。
2、Prepared Statement 对象用于执行预编译SQL语句。
3、Callable Statement对象用于执行对存储过程的调用。

11.下面这三条语句

System.out.println(“is ”+ 100 + 5)；
System.out.println(100 + 5 +“ is”)；
System.out.println(“is ”+ (100 + 5))；
的输出结果分别是？ ( )

正确答案: D 你的答案: C (错误)
A.is 1005, 1005 is, is 1005
B.is 105, 105 is, is 105
C.is 1005, 1005 is, is 105
D.is 1005, 105 is, is 105

解释：
1."is"说明后面的内容都会被强制转换为string，所以是最后结果是拼接起来的
2.100+5先得到105，然后与is拼接
3.先算括号内的

12.在使用 interface 声明一个外部接口时，只可以使用（ ）修饰符修饰该接口。

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

解释： 接口的方法都是 public abstract 变量都是public static final的

13.关于Java语言的内存回收机制，下列选项中最正确的一项是

正确答案: C 你的答案: C (正确)
A.Java程序要求用户必须手工创建一个线程来释放内存
B.Java程序允许用户使用指针来释放内存
C.内存回收线程负责释放无用内存
D.内存回收线程不能释放内存对象

解释：
A，java的内存回收是自动的，Gc在后台运行，不需要用户手动操作
B，java中不允许使用指针
D，内存回收线程可以释放无用的对象内存

14.判断对错。List，Set，Map都继承自继承Collection接口。
正确答案: B 你的答案: A (错误)
A.对
B.错

解释：List，Set等集合对象都继承自Collection接口
Map是一个顶层结果，不继承自Collection接口

15.____技术是一种可以使音频，视频和其他多媒体信息在 Internet 及 Intranet 上以实时的，无需下载等待的方式进行播放的技术。

正确答案: A 你的答案: C (错误)
A.流媒体
B.多媒体
C.复合媒体
D.音视媒体

解释：
流媒体技术是一种可以使音频，视频和其他多媒体信息在 Internet 及 Intranet 上以实时的，无需下载等待的方式进行播放的技术。
流媒体又叫流式媒体，它是指商家用一个视频传送服务器把节目当成数据包发出，传送到网络上。

16.如果定义一种表达式结构：(+ 6 3)的值为9，(- 6 3)的值为3，(* 6 3)的值为18，(/ 6 3)的值为2；那么对于表达式(* (- 16 (* 3 2 2 )) (+ 5 (/ 6 (- 5 3))))输出的结果为____。

正确答案: D 你的答案: D (正确)
A.44
B.40
C.40
D.32
E.24
F.21

解释：
(* (- 16 (* 3 2 2 )) (+ 5 (/ 6 (- 5 3))))
(* (- 16 (* 3 2 2 )) (+ 5 (/ 6 2)))
(* (- 16 (* 3 2 2 )) (+ 5 3))
(* (- 16 (* 3 2 2 )) 8)
(* (- 16 12) 8)
(* 4 8)
32

17.在 JAVA 编程中， Java 编译器会将 Java 程序转换为（ ）

正确答案: A 你的答案: A (正确)
A.字节码
B.可执行代码
C.机器代码
D.以上都不对

解释：
编译器将Java源代码编译成字节码class文件
类加载到JVM里面后，执行引擎把字节码转为可执行代码
执行的过程，再把可执行代码转为机器码，由底层的操作系统完成执行

18.下列表述错误的是？（）

正确答案: D 你的答案: D (正确)
A.int是基本类型，直接存数值，Integer是对象，用一个引用指向这个对象。
B.在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过
C.封装的主要作用在于对外隐藏内部实现细节，可以增强程序的安全性
D.final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性。

解释：
抽象类：子类继承重写
final：不允许重写
所以此项矛盾

19.在基本JAVA类型中，如果不明确指定，整数型的默认是什么类型？带小数的默认是什么类型？

正确答案: B 你的答案: D (错误)
A.int float
B.int double
C.long float
D.long double

解释：
比如表达式
byte a=2;
a=a-10；
由于10是整型int，因此表达式a-10；将自动转换成int类型，int类型在赋值给byte，会编译错误
byte a=2;
a-=10;
不会发生编译错误，因为复合运算符是一个带有隐式转换的运算符，将右侧表达式类型自动转换成左侧表达式类型

20.在 Java 中，属于整数类型变量的是（）

正确答案: C 你的答案: C (正确)
A.single
B.double
C.byte
D.char

解释：
Java中的四类八种基本数据类型
第一类：整数类型 byte short int long
第二类：浮点型 float double
第三类：逻辑型 boolean(它只有两个值可取true false)
第四类：字符型 char

21.关于以下application,说法正确是什么？

public class Test {
    static int x=10;
    static {x+=5;}
    public static void main(String[] args) //4
        {
        System.out.println("x="+x);
    }
    static{x/=3;};
}//9

正确答案: B 你的答案: D (错误)
A.4行与9行不能通过编译，因为缺少方法名和返回类型
B.编译通过，执行结果是：x=5
C.编译通过，执行结果是：x=3
D.9行不能通过编译，因为只能有一个静态初始化器

解释：
首先明确一下执行顺序，静态代码块先于主方法执行，静态代码块之间遵从代码顺序执行。
所以：先初始化静态变量x=10；//x=10
执行第一个静态代码块，x=x+5; //x=15
执行第二静态代码块 x=x/3; //x=5
执行主方法： 输出x=5

22.下列整型常量 i 的定义中，正确的是( )

正确答案: C 你的答案: B (错误)
A.final i;
B.static int i;
C.static final int i=234;
D.final float i=3.14f;

解释：
java中final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。int关键字修饰整型类型。static修饰静态变量，即当利用这个关键字来修饰一个变量的时候，在创建对象之前就会为这个变量在内存中创建一个存储空间。以后创建对对象如果需要用到这个静态变量，那么就会共享这一个变量的存储空间。
A：缺少必要的整型类型声明
B：缺少常量关键字final
D：定义一个浮点常量

23.下列整型常量 i 的定义中，正确的是( )

正确答案: C 你的答案: B (错误)
A.final i;
B.static int i;
C.static final int i=234;
D.final float i=3.14f;

解释：
因为是整型
所以要申明 int
所以A D不对
又因为是常量
所以 要用final限制
所以
答案 C

24.下列代码编译和运行的结果是：（）

public class Threads4{
 public static void main(String[] args){
 new Threads4().go();
 }
 public void go(){
 Runnable r=new Runnable(){
 public void run(){
 System.out.print("foo");
 }
 };
 Thread t=new Thread(r);
 t.start();
 }
 }

正确答案: C 你的答案: A (错误)
A.编译错误
B.抛出运行时异常
C.输出：foo
D.代码正常运行，但是无输出

解释：
在java多线程中实现多线程的方式有两种①extends Thread ②implements Runnable。这两种情况是我们最常见的，还有一种是由第二种变形而来的直接new Runnable(){}，我们都知道java的接口是不可以实例化的，但代码中的new Runnable(){xxx}确是实例化了，为什么？ 接口和抽象类不可以实例化是对的，这个是java语法规范来的，而new Runnable(){}其实不是实例化Runnable接口来的，实际上一种内部类的一种简写 在这里：
①首先构造了一个”implements Runnable “的无名local内部类(方法内的内部类)
②然后构造了这个无名local内部类的一个实例
③然后用Runnable来表示这个无名local内部类的type(OO多态)。 例如上面这段代码编译后你会看到其实是编译了两个类来的，如下：
其中Text2$1就是无名local内部内类，这个也就很好地解释了为什么在main（）方法中new Runnable(){xxx}里面的调用main()方法中的变量的时候要用final关键字来修饰

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

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

正确答案: B 你的答案: C (错误)
A.false，false
B.false，true
C.true，false
D.true，true

解释：
首先 我们要知道 == 这个比较符号
== 可用于基本类型和引用类型：当用于基本类型时候，是比较值是否相同；当用于引用类型的时候，是比较对象是否相同。
“== " 和”!="比较的是地址 指第一个n ew()c出来的地址
所以因为两次new() 分出的内存也不同
所以
System.out.print(n1 == n2);返回 false
！=就返回true

26.Java用（）机制实现了线程之间的同步执行

正确答案: A 你的答案: A (正确)
A.监视器
B.虚拟机
C.多个CPU
D.异步调用

解释：
The code segments within a program that access the same object from separate, concurrent threads are called “critical sections”。
翻译：在一个程序当中代码段访问了同一个对象从单独的并发的线程当中，那么这个代码段叫”临界区”
怎么解决呢？使用同步的机制对临界区进行保护
同步的两种方式：同步块和同步方法
对于同步来说都是使用synchronized方法
每一个对象都有一个监视器，或者叫做锁。
同步块实例

package ticket; class Tickets { public static void main(String[] args)
    {
        sellTickets st = new sellTickets(); //四个线程同时卖这100张票，注意是同一个对象创建四个线程，他们共享同一个变量ticket new Thread(st).start(); new Thread(st).start(); new Thread(st).start(); new Thread(st).start();
    }
} class sellTickets implements Runnable { int ticket = 100;
    Object o = new Object();
    @Override public void run() { while(true)
        { //每一个对象都有一个监视器，或者叫做锁。同步块示例 synchronized (o) { if(ticket > 0)
                { //存在的隐藏的问题当ticket=1，它的时间片到期了进入到if语句中，第二个线程进入到if语句然后时间片到期 try { //线程睡眠,该方法需要写异常 Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();                   
                    } //第几个线程卖出了第多少张票 System.out.println(Thread.currentThread().getName() + "sell tickets" + ticket);
                    ticket--;
                }
            }
        }
    }
}

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

正确答案: B 你的答案: B (正确)
A.this.A(x)
B.this(x)
C.super(x)
D.A(x)

解释：
B。
this的作用其中一个就是在一个构造方法中调用另一个构造方法，格式为this(参数)；
super是调用父类的方法；
A(a)这种形式是在new一个类时使用。

28.下面关于Spring的说法中错误的是（）

正确答案: D 你的答案: D (正确)
A.Spring是一系列轻量级Java EE框架的集合
B.Spring中包含一个“依赖注入”模式的实现
C.使用Spring可以实现声明式事务
D.Spring提供了AOP方式的日志系统

解释：
答案：D
spring没有提供AOP方式的日志系统
AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态***实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。
Spring通过对AOP的支持，借助log4j等Apache开源组件实现了日志系统。

29.下面程序的输出结果是什么。

public class A2{ 
public static void main(String[] args){
    int[] a={2,4,6,8,3,6,9,12};
    doSomething(a,0,a.length-1);
    for(int i=0;i<=a.length-1;i++)
    System.out.print(a[i]+" ");
} 
private static void doSomething(int[] a,int start,int end){
    if(start<end){
        int p=core(a,start,end);
        doSomething(a,start,p-1);
        doSomething(a,p+1,end);
    }
}
private static int core(int[] a,int start,int end)
{
    int x=a[end];
    int i=start;
    for(int j=start;j<=end-1;j++){
        if(a[j]>=x){
            swap(a,i,j);
            i++;//交换了几次 
        }
    }//把最大的放到最后
    swap(a,i,end);//把最大的放到i的位置 
    return i;
} 
  
private static void swap(int[] a,int i,int j) 
{
    int tmp=a[i];
    a[i]=a[j];
    a[j]=tmp;
}
} 

正确答案: C 你的答案: D (错误)
A.找到最大值
B.找到最小值
C.从大到小的排序
D.从小到大的排序

30.String s = new String(“xyz”);创建了几个StringObject？

正确答案: A 你的答案: B (错误)
A.两个或一个都有可能
B.两个
C.一个
D.三个

解释：
1.String对象的两种创建方式:
第一种方式: String str1 = “aaa”; 是在常量池中获取对象(“aaa” 属于字符串字面量，因此编译时期会在常量池中创建一个字符串对象)，
第二种方式: String str2 = new String(“aaa”) ; 一共会创建两个字符串对象一个在堆中，一个在常量池中（前提是常量池中还没有 “aaa” 字符串对象）。
System.out.println(str1==str2);//false
2.String类型的常量池比较特殊。它的主要使用方法有两种：
直接使用双引号声明出来的String对象会直接存储在常量池中。
如果不是用双引号声明的String对象,可以使用 String 提供的 intern 方法。 String.intern() 是一个 Native 方法，它的作用是： 如果运行时常量池中已经包含一个等于此 String 对象内容的字符串，则返回常量池中该字符串的引用； 如果没有，则在常量池中创建与此 String 内容相同的字符串，并返回常量池中创建的字符串的引用。
String s1 = new String(“AAA”);
String s2 = s1.intern();
String s3 = “AAA”;
System.out.println(s2);//AAA
System.out.println(s1 == s2);//false，因为一个是堆内存中的String对象一个是常量池中的String对象，
System.out.println(s2 == s3);//true， s2,s3指向常量池中的”AAA“