Java选择题30道(八）

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java选择题30道(八），小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含18048字，纯文字阅读大概需要26分钟。

内容图文

1.若在某一个类定义中定义有如下的方法： abstract void performDial( ); 该方法属于（）

正确答案: D 你的答案: D (正确)
A.本地方法
B.最终方法
C.解态方法
D.抽象方法

解释：
本地方法：简单地讲，一个native Method就是一个java调用非java代码的接口；native方法表示该方法要用另外一种依赖平台的编程语言实现。
最终方法：final void B(){},这样定义的方法就是最终方法，最终方法在子类中不可以被重写，也就是说，如果有个子类继承了这个最终方法所在的类，那么这个子类中不能出现void B(){}这样的方法。
最终类：final class A {},这样定义的类就是最终类，最终类不能被继承。
abstract修饰抽象类

2.有程序片段如下，以下表达式结果为 true 的是（ ）

Float  s=new  Float(0.1f);

Float  t=new  Float(0.1f);

Double  u=new  Double(0.1);

正确答案: B 你的答案: B (正确)
A.s==t
B.s.equals(t)
C.u.equals(s)
D.t.equals(u)

解释：
loat的==比较的是地址，只有同一个类才会返回true，但是equals不是，Float的equals被重写了，只校验类型是不是Float以及值是否相同即可

3.类方法中可以直接调用对象变量。（ ）

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

解释：当试图在类方法（也就是静态方法）中调用类的非静态变量时，eclipse 给出了这么一句话 Cannot make a static reference to the non-static field xxx（xxx代表你所写的非静态域的名字）。这句话意思很简单，就是不能静态方法中引用非静态的域。
原因也很简单关于类初始化的过程中，静态域是随着类加载就完成了初始化，而非静态域此时都没有完成初始化，你引用它肯定就出错了。

4.下列循环语句序列执行完成后，i的值是（）

int i;
for(i=2;i<=10;i++){
System.out.println(i);
}

正确答案: C 你的答案: C (正确)
A.2
B.10
C.11
D.不确定

解释：
for循环的执行顺序：
for（表达式1;表达式2;表达式3）
{
//循环体
}

1. 表达式1执行一次，判断表达式2是否成立，如果成立执行循环体；
2. 循环体结束，表达式3执行一次，判断表达式2是否成立，如果成立执行循环体；
3. 依次进行2的操作。直到表达式2不成立，退出循环。
   所以，这个题最后依次执行体是i++；i这个时候已经是11了，判断11大于10，退出循环。

5.JAVA中，下列语句哪一个正确（）

正确答案: C 你的答案: C (正确)
A.class中的constructor不可省略
B.constructor必须与class同名，但方法不能与class同名
C.constructor在一个对象被new时执行
D.一个class只能定义一个constructor

解释：
类中有缺省构造器，不一定要定义构造器
方法可以和类同名，和构造器区别在于必须要有返回值类型
一个类可以定义多个参数列表不同的构造器，实现构造器重载

6.以下哪个不能用来处理线程安全

正确答案: D 你的答案: D (正确)
A.synchronized关键字
B.volatile关键字
C.Lock类
D.transient关键字

解释：synchrozied关键字称作同步，主要用来给方法、代码块加锁，被加锁的代码段，同一时间内多线程同时访问同一对象的加锁方法/代码块时，只能有一个线程执行能执行方法/代码块中的代码，其余线程必须等待当前线程执行完以后才执行该方法/代码块。
volatile关键字1.保证了不同线程对该变量操作的内存可见性.(当一个线程修改了变量,其他使用次变量的线程可以立即知道这一修改)。2.禁止了指令重排序.
Lock接口提供了与synchronized关键字类似的同步功能，但需要在使用时手动获取锁和释放锁。
transient关键字 简单地说，就是让某些被修饰的成员属性变量不被序列化。

7.DBMS 中实现事务持久性的子系统是()

正确答案: D 你的答案: D (正确)
A.安全性管理子系统
B.完整性管理子系统
C.并发控制子系统
D.恢复管理子系统

解释：
原子性：事务是一组不可分割的操作单元，这组单元要么同时成功要么同时失败（由DBMS的事务管理子系统来实现）；
一致性：事务前后的数据完整性要保持一致（由DBMS的完整性子系统执行测试任务）；
隔离性:多个用户的事务之间不要相互影响，要相互隔离（由DBMS的并发控制子系统实现）；
持久性:一个事务一旦提交，那么它对数据库产生的影响就是永久的不可逆的，如果后面再回滚或者出异常，都不会影响已提交的事务（由DBMS的恢复管理子系统实现的）

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

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

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

9.关于下列代码的执行顺序，下面描述正确的有哪些选项（）

public class HelloA {
    public HelloA() { 
        System.out.println("A的构造函数");
    }
{ 
    System.out.println("A的构造代码块");
}
static { 
    System.out.println("A的静态代码块");
}
public static void main(String[] args) {
    HelloA a = new HelloA();
}
}

正确答案: A B C 你的答案: A (错误)
A.打印顺序A的静态代码块> A的构造函数
B.打印顺序A的静态代码块> A的构造代码块
C.打印顺序A的构造代码块> A的构造函数
D.打印顺序A的构造函数> A的构造代码块

解释：
加载顺序：
1.父类静态代码块
2.子类静态代码块
3.父类构造代码块
4.父类构造函数
5.子类构造代码块
6.子类构造方法
总结：先静态后非静态，先父类后子类。

10.以下代码定义了一个变量，如何输出这个变量的值？

正确答案: A C D 你的答案: B (错误)
A.<% String myBean = (String)pageContext.getAttribute(“stringBean”,PageContext.PAGE_SCOPE);
%>
<%=myBean%>
B.<bean:write name=“helloworld”/>
C.<bean:write name=“stringBean”/>
D.<%=stringBean%>

解释：
A选项：
通过 pageContext（PageContext类的实例，提供对JSP页面所有对象以及命名空间的访问） 获取stringBean 的值，赋给 String 类型的变量 myBean，然后通过 Jsp 表达式 处理该值。
bean:define
题目中的 Struts 的bean:define 标签定义了一个字符串变量 stringBean ,它的值为 helloworld。
bean:write
bean:write相当于 <%=request.getAttribute(“something”)%> 其中 something 是属性的名字。所以 B 错，C对。
D选项：
通过Jsp 表达式 获取变量 stringBean 的值

11.区分类中重载方法的依据是( )。

正确答案: C 你的答案: C (正确)
A.不同的形参名称
B.不同的返回值类型
C.不同的形参列表
D.不同的访问权限

解释：
方法重写严格把握五点：
三同、一大、一小。具体内容以及与方法重载的区别见下：
方法重写
参数列表必须完全与被重写方法的相同；
返回类型必须完全与被重写方法的返回类型相同；
方法名相同；
以上为三同；
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
此为一大；
父类的成员方法只能被它的子类重写。
声明为final的方法不能被重写。
声明为static的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
此为一小；
构造方法不能被重写。
如果不能继承一个方法，则不能重写这个方法。
方法重载
被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。

12.以下多线程对int型变量x的操作，哪几个不需要进行同步（ ）

正确答案: D 你的答案: D (正确)
A.x=y;
B.x++;
C.++x;
D.x=1;

解释：
A.由于y的值不确定，所以要加锁；
B,C 两个在多线程情况下是必须要加锁的，因为他们是先被读入寄存器，然后再进行+1操作，如果没有加锁，那么可能会出现数据异常；
D 原子操作，所以不需要加锁
原子性：指该操作不能再继续划分为更小的操作。
Java中的原子操作包括：
1、除long和double之外的基本类型的赋值操作
2、所有引用reference的赋值操作
3、java.concurrent.Atomic.* 包中所有类的一切操作

13.执行下列代码的输出结果是( )

public class Demo{
　public static void main(String args[]){
　　　int num = 10;
　　　System.out.println(test(num));
}
public static int test(int b){
　　　try
　　　{
　　　　b += 10;
　　　　return b;
　　　}
　　　catch(RuntimeException e)
　　　{
　　　}
　　　catch(Exception e2)
　　　{
　　　}
　　　finally
　　　{
　　　　b += 10;
　　　　return b;
　　　}
　　}
}

正确答案: C 你的答案: C (正确)
A.10
B.20
C.30
D.40

解释：
关于try catch 知识：程序运行到 try块，b=20;并没有发生异常，不运行catch块，运行到return b;因为finally块无论如何都要运行，因此并不发生返回动作，进行运行finally块，b=30;
进行程序返回输出；

14.以下哪个不是Collection的子接口？

正确答案: D 你的答案: D (正确)
A.List
B.Set
C.SortedSet
D.Map

解释：
java的容器包括collection（存放对象的集合）和map（存放键值对的映射表，两个对象，key和value）
所以collection和map是平级的

15.哪个类可用于处理 Unicode?

正确答案: A 你的答案: A (正确)
A.InputStreamReader
B.BufferedReader
C.Writer
D.PipedInputStream

解释：
Unicode是由两个字节组成的，而InputStreamReader是将字节流转换成字符流供我们使用。同时InputStreamReader也可以指定字符集的编码。
发表于 2017-09-11 20:27:50

16.下列语句中，正确的是

正确答案: B 你的答案: D (错误)
A.float x=0.0
B.boolean b=3>5
C.、char c=“A”
D.double =3.14

解释：
在java里面 float类型数据类型初始化时必须使用后缀f 因为java默认浮点型是double 用后缀f表示为float类型；
A应为：float x = 0.0f;
布尔值可以是一个表达式的值，但必须是一个true或者false值
B正确
char只能是一个字符 而不是一个字符串
C应为：char c=‘A’;
D没变量名…没变量名…没变量名…重要的事情说三遍

17.关于HashMap和Hashtable正确的说法有（）

正确答案: A C 你的答案: A C (正确)
A.都实现了Map接口
B.Hashtable类不是同步的，而HashMap类是同步的
C.Hashtable不允许null键或值
D.HashMap不允许null或值

解释：
1、继承不同。public class Hashtable extends Dictionary implements Map
public class HashMap extends AbstractMap implements Map
2、Hashtable 中的方法是同步的，而HashMap中的方法在缺省情况下是非同步的。在多线程并发的环境下，可以直接使用Hashtable，但是要使用HashMap的话就要自己增加同步处理了。
3、Hashtable中，key和value都不允许出现null值。
在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。当get()方法返回null值时，即可以表示 HashMap中没有该键，也可以表示该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键， 而应该用containsKey()方法来判断。
4、两个遍历方式的内部实现上不同。
Hashtable、HashMap都使用了 Iterator。而由于历史原因，Hashtable还使用了Enumeration的方式 。
5、哈希值的使用不同，HashTable直接使用对象的hashCode。而HashMap重新计算hash值。
6、Hashtable和HashMap它们两个内部实现方式的数组的初始大小和扩容的方式。HashTable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数

18.关于OutOfMemoryError，下面说法正确的是（）？

正确答案: A B C 你的答案: B C (错误)
A.java.lang.OutOfMemoryError: PermGen space 增加-XX:MaxPermSize这个参数的值的话，这个问题通常会得到解决。
B.java.lang.OutOfMemoryError: Requested array size exceeds VM limit当你正准备创建一个超过虚拟机允许的大小的数组时，这条错误将会出现
C.java.lang.OutOfMemoryError: Java heap space 一般情况下解决这个问题最快的方法就是通过-Xmx参数来增加堆的大小
D.java.lang.OutOfMemoryError: nativeGetNewTLA这个异常只有在jRockit虚拟机时才会碰到

A：属于运行时常量池导致的溢出，设置-XX：MaxPermSize可以解决这个问题，
B：属于堆空间不足导致的错误，问题比较少见，解决方式和C相同，
C：属于java堆内存问题，一般的手段是通过内存映像分析工具，对Dump出来的堆转储存快照进行分析，重点是确认内存中的对象是否是有必要的，也就是要判断是出现了内存泄漏，还是出现了内存溢出，如果是内存列楼，通过工具检查泄露对象打GC Roots的引用链信息，可以准确的确定出泄露代码的位置，不存在泄露，就应该检查虚拟机的堆参数，如果可以继续调大，可以设置-Xmx解决问题
D：java.lang.OutOfMemoryError: nativeGetNewTLA指当虚拟机不能分配新的线程本地空间(Thread Local Area）的时候错误信息，此错误是线程申请一个新的TLA时产生的，这个异常一般只会发生在jRockit虚拟机，只有过于绝对。

19.对 Map 的用法，正确的有：

正确答案: C D 你的答案: B C (错误)
A.new java.util.Map().put(“key” , “value”) ;
B.new java.util.SortedMap().put(“key” , “value”) ;
C.new java.util.HashMap().put( null , null ) ;
D.new java.util.TreeMap().put( 0 , null ) ;

解释：
Map和SortedMap是接口，不能直接new对象，A,B错误
HashMap 允许null-null键值对 C正确
TreeMap 允许value值为null，不允许key值为null，D是value为null，key不为null，正确

20.下面几个关于Java里queue的说法哪些是正确的（）？

正确答案: A C 你的答案: C D (错误)
A.LinkedBlockingQueue是一个可选有界队列，不允许null值
B.PriorityQueue，LinkedBlockingQueue都是线程不安全的
C.PriorityQueue是一个无界队列，不允许null值，入队和出队的时间复杂度是O（log(n)）
D.PriorityQueue，ConcurrentLinkedQueue都遵循FIFO原则

解释：
A、LinkedBlockingQueue是一个基于节点链接的可选是否有界的阻塞队列，不允许null值。
B、LinkedBlockingQueue是一个线程安全的阻塞队列，实现了先进先出等特性。
C、PriorityQueue是一个队列，不允许null值，入队和出队的时间复杂度是O（log(n)）。
D、PriorityQueue是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。ConcurrentLinkedQueue是一个基于链接节点的线程安全队列，该队列的元素遵循FIFO原则。

21.类 ABC 定义如下：

public  class  ABC{

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

 }

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

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

22.关于protected 修饰的成员变量，以下说法正确的是

正确答案: A 你的答案: A (正确)
A.可以被该类自身、与它在同一个包中的其它类、在其它包中的该类的子类所访问
B.只能被该类本身和该类的所有的子类访问
C.只能被该类自身所访问
D.只能被同一个包中的类访问

解释:
java中有四大修饰符，分别为private,default,protected,public,下面主要是四者之间的区别

• private(私有的)
  private可以修饰成员变量，成员方法，构造方法，不能修饰类(此刻指的是外部类，内部类不加以考虑)。被private修饰的成员只能在其修饰的本类中访问，在其他类中不能调用，但是被private修饰的成员可以通过set和get方法向外界提供访问方式- default(默认的)
• defalut即不写任何关键字，它可以修饰类，成员变量，成员方法，构造方法。被默认权限修饰后，其只能被本类以及同包下的其他类访问。
• protected(受保护的)
  protected可以修饰成员变量，成员方法，构造方法，但不能修饰类(此处指的是外部类，内部类不加以考虑)。被protected修饰后，只能被同包下的其他类访问。如果不同包下的类要访问被protected修饰的成员，这个类必须是其子类。
• public(公共的)
  public是权限最大的修饰符，他可以修饰类，成员变量，成员方法，构造方法。被public修饰后，可以再任何一个类中，不管同不同包，任意使用。
  public protected default private
  同一个类 √ √ √ √
  同一个包 √ √ √
  子类 √ √
  不同包 √

23.以下程序会输出什么

        int a =100,b=50,c=a---b,d=a---b;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);

正确答案: C 你的答案: B (错误)
A.100 48 48 49
B.100 49 48 52
C.98 50 50 49
D.98 50 50 48

解释：
先考虑a–，a执行后自减操作，即先用a后再自减1，与–a先反
（1）c=a—b，先执行a-b操作，得到c=50，再执行a减1操作，得到a=99
（2）d=a—b，先执行a-b操作，得到d=49，再执行a减1操作，得到a=98

24.如果int x=20, y=5，则语句System.out.println(x+y +""+(x+y)+y); 的输出结果是（）

正确答案: D 你的答案: C (错误)
A.2530
B.55
C.2052055
D.25255

解释：
1）不论有什么运算，小括号的优先级都是最高的，先计算小括号中的运算，得到x+y +""+25+y
2）任何字符与字符串相加都是字符串，但是是有顺序的，字符串前面的按原来的格式相加，字符串后面的都按字符串相加，得到25+“”+25+5
3）上面的结果按字符串相加得到25255

25.下列关于JavaBean的说法正确的是：

正确答案: A 你的答案: A (正确)
A.Java文件与Bean所定义的类名可以不同，但一定要注意区分字母的大小写
B.在JSP文件中引用Bean，其实就是用语句
C.被引用的Bean文件的文件名后缀为.java
D.Bean文件放在任何目录下都可以被引用

解释：
A: Bean定义的类名的含义应该是实例化的一个类，在JSP中相当于id，class属性对应的是需要编译的类，在后面用到id的实例化类名 需要区分大小写
B: 是声明了一个Bean 不是引用
C: 引用的文件是web-Inf\class\下的class文件
D: 需要放在web-Inf\class\

26.关于匿名内部类叙述正确的是？ ( )

正确答案: B 你的答案: D (错误)
A.匿名内部类可以继承一个基类，不可以实现一个接口
B.匿名内部类不可以定义构造器
C.匿名内部类不能用于形参
D.以上说法都不正确

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

27.以下代码执行的结果显示是多少（）？

正确答案: B 你的答案: B (正确)
A.num * count = 505000
B.num * count = 0
C.运行时错误
D.num * count = 5050

解释：
1.for循环外面count=0,循环里面的count=count++;(count的值都等于count值，而后面count自加不影响count结果，因此这个式子无意义);循环count都为0（因count++是先返回count的本身值再自加1的）！
2.若是改为count=++count;（先自加，再返回自加后的值），结果就是5050101=510050了！
3.改为count++;结果就是5050101=510050了！

28.关于 java 的异常处理机制的叙述哪些正确？

正确答案: A B 你的答案: AB (正确)
A.不论程序是否发生错误及捕捉到异常情况，都会执行finally部分
B.当try区段的程序发生异常时，才会执行catch区段的程序
C.catch部分捕捉到异常情况时，才会执行finally部分
D.其它选项都不正确

解释：
A、不论程序是否发生错误及捕捉到异常情况，都会执行finally部分。（正确）
B、 当try区段的程序发生异常时，才会执行catch区段的程序。（正确）
C、 catch部分捕捉到异常情况时，才会执行finally部分（错误，不管有没有捕捉到异常，都会执行finally）

29.以下代码的运行结果是什么( )

class Supper{     
 public int get()    
  {          
System.out.println("Supper");         
 return 5;     
 }    
 }     
public class Sub{     
 public int get()    
 {         
 System.out.println("Sub");        
 return new Integer("5");          }      
 public static void main(String args[]) {          
 new Supper().get();        
   new Sub().get();          }   
  }

正确答案: A 你的答案: A (正确)
A.Supper Sub
B.Supper 5 Sub
C.Supper 5 5 Sub
D.Supper Sub 5 5

30.下面哪几个语句正确的声明一个整型的二维数组（）

正确答案: C D 你的答案: C (错误)
A.int a[][]=new int[][]
B.int b[10][10]=new int[][]
C.int c[][]=new int[10][10]
D.int []d[]=new int[10][10]

解释：

1. 定义一维数组时，必须显式指明数组的长度；
2. 定义***数组时，其一维数组的长度必须首先指明，其他维数组长度可以稍后指定；
3. 采用给定值初始化数组时，不必指明长度；
4. “[]” 是数组运算符的意思，在声明一个数组时，数组运算符可以放在数据类型与变量之间，也可以放在变量之后。

内容总结

以上是互联网集市为您收集整理的Java选择题30道(八）全部内容，希望文章能够帮你解决Java选择题30道(八）所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端