Java选择题（三）

1.Java Application 源程序的主类是指包含有（ ）方法的类。
正确答案: A 你的答案: A (正确)
A.public static void main方法
B.toString方法
C.init方法
D.actionPerfromed方法

解释：
java程序种类：
1.内嵌于web文件中，有浏览器观看的applet
2.可独立运行的application
3.服务器端的servlets

2.如果类的方法没有返回值，该方法的返回值类型应当是abstract。（）
正确答案: B 你的答案: B (正确)
A.正确
B.错误

解释：如果类的方法没有返回值，该方法的返回值类型应当是void。
被abstract修饰的类是抽象类，抽象类不能被实例化，但是可以被继承，也可以继承。

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

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() ; //必须强制类型转化

4.定义：String s1 = “uml”; String s2 = “uml”; String s3= new String(“uml”); String s4= new String(“uml”);那么，s1==s2；s3 == s4；s1.equals(s3); 判断正确与否
正确答案: A 你的答案: A (正确)
A.T，F，T
B.F，T，F

解释：= =比较两个引用的地址和值 equals：比较两个引用的值 1、s1==s2 true s1和s2指向字符串常量池中同一个地址 2、s3 和 s4 都显示使用了new，是不同的对象， 当然不相等 3、s1 和 s3 的值都是 “uml”，当然相等

5.设有定义 int a=3 ，b=4，c=5； 则以下的表达式中 ， 值为 false 的是 （）

正确答案: D 你的答案: D (正确)
A.a < b && b < c
B.a <= b
C.a < ( b + c )
D.! ( a < b )

解释：
a < b && b < c true && true true
a <= b true
a < ( b + c ) true !
( a < b ) !true false

6.以下类定义中的错误是什么？（）

bstract class xy
{
    abstract sum (int x, int y) { }
}

正确答案: C 你的答案: B (错误)
A.没有错误
B.类标题未正确定义
C.方法没有正确定义
D.没有定义构造函数

解释：
1、抽象方法不能有方法体，这是规定
2、该方法缺少返回值，只有构造没有返回值

7.关于访问权限，说法正确的是？ ( )
正确答案: A 你的答案: B (错误)
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

解释： private 权限限于同一个类中； default 权限限于同一个包中，即包权限＝default权限；
protected权限限于同一个包中，以及不在同一个包中的子类 public 权限在不同包中都可以

8.计算机所能处理的最小的数据项称为（）
正确答案: A 你的答案: B (错误)
A.位
B.字节
C.字
D.双字

解释：位、字节、字是计算机数据存储的单位。位是最小的存储单位，每一个位存储一个1位的二进制码，一个字节由8位组成。而字通常为16、32或64个位组成。

9.运用下列哪个命令能够获取JVM的内存映像
正确答案: B 你的答案: B (正确)
A.jinfo
B.jmap
C.jhat
D.jstat

解释：
1、jps：查看本机java进程信息。

2、jstack：打印线程的栈信息，制作线程dump文件。

3、jmap：打印内存映射，制作堆dump文件

4、jstat：性能监控工具

5、jhat：内存分析工具

6、jconsole：简易的可视化控制台

7、jvisualvm：功能强大的控制台

10.给定代码：

public class SwitchTest{//1
    public static void main(String[] args) {//2
        System.out.println("value="+switchit(4));//3
    }//4
    public static int switchit(int x) {
        int j=1;
        switch (x) {
        case 1:j++;
        case 2:j++;
        case 3:j++;
        case 4:j++;
        case 5:j++;
        default:j++;
        }
        return j+x;
    }
}

第三行将输出什么？
正确答案: B 你的答案: A (错误)
A.value=6
B.value=8
C.value=3
D.value=5
E.value=4

解释： 没有break，从case 4开始一直执行到最后，j自加3次变成了4,结果返回8

11.以下程序的执行结果是：

static boolean foo(char c)
 {
 System.out.print(c);
 return true;
 }
 public static void main(String[] args) {
 int i =0;
 for(foo('A');foo('B')&&(i<2);foo('C'))
 {
 i++;
 foo('D');
 }
 }

正确答案: A 你的答案: B (错误)
A.ABDCBDCB
B.ABCDABCD
C.编译时出错
D.运行时抛出异常

解释：

for(初始化语句; 布尔表达式; 更新语句) {

正文过程;
}

执行顺序: 
1.初始化语句, 仅在循环开始前执行一次;
2.布亇表达式, 用于决定是否继续执行正文过程, 表达式中异常则结束循环; 
3.正文过程, 如果过程中存在break, return或者异常, 循环结束(不会执行更新语句),        如果遇到continue, 则会执行更新语句后进入下一轮循环; 
4.更新语句, 注意更新语句不做逻辑真假判断, 到这里一轮循环结束;
5.布亇表达式, 进入新一轮循环;
6.......

12.下面有关jsp中静态include和动态include的区别，说法错误的是？
正确答案: D 你的答案: B (错误)
A.动态INCLUDE:用jsp:include动作实现
B.静态INCLUDE:用include伪码实现，定不会检查所含文件的变化，适用于包含静态页面<%@ include file=“included.htm” %>
C.静态include的结果是把其他jsp引入当前jsp，两者合为一体;动态include的结构是两者独立，直到输出时才合并
D.静态include和动态include都可以允许变量同名的冲突.页面设置也可以借用主文件的

解释：
**静态的include：是jsp的指令来实现的，<% @ include file=“xx.html”%> 特点是共享request请求域，先包含再编译，不检查包含页面的变化。
**动态的include：是jsp动作来实现的，<jsp:includepage=“xx.jsp” flush=“true”/> 这个是不共享request请求域，先编译在包含，是要检查包含页面的变化的。

13.以下代码将打印出

public static void main(String args[]) {
      List  Listlist1 = new ArrayList();
      Listlist1.add(0);
      List Listlist2 = Listlist1;
        System.out.println(Listlist1.get(0) instanceof Integer);
        System.out.println(Listlist2.get(0) instanceof Integer);
}

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

解释:
不指定ArrayList类型，存入数据，再次取出时，默认是Object类型；但这个题的关键是instanceof关键字，instanceof执行时类似利用java反射机制，识别对象信息。

14.运行代码，结果正确的是：

Boolean flag = false;
if(flag = true){
System.out.println("true");
}else{
System.out.println("false");
}

正确答案: B 你的答案: A (错误)
A.编译错误
B.TRUE
C.FALSE
D.什么也没有输出

解释：
if(flag = true)的时候flag已经是true了，所以输出true；
要是为if(flag == true)输出才为false；

15.关于java编译和运行命令叙述不正确的是？ ( )
正确答案: A 你的答案: A (正确)
A.运行“java Scut.class”
B.运行“java Scut”
C.运行“javac Scut.java”的输出文件是Scut.class
D.java这个命令的运行对象是Scut.class

解释：
A 错误 运行命令是 java + 你的 Java 程序的名字但是不加后缀 所以这道题错在多了 .class这个后缀
B 正确
C javac 是编译命令，后跟 你的 Java 程序名字加后缀，也就是 YourClassName.java 所以答案正确
D JVM（Java 虚拟机）运行的是编译后的字节码文件（以.class为后缀的文件），也就是 YourClassName.class 所以答案正确

16.对接口的描述正确的是()

正确答案: A 你的答案: D (错误)
A.一个类可以实现多个接口
B.接口可以有非静态的成员变量
C.在jdk8之前，接口可以实现方法
D.实现接口的任何类，都需要实现接口的方法

解释:
A，一个类只能有一个直接父类，但是继承是有传递性的。一个类可以实现多的接口。一个接口可以继承多个类。
B，接口中没有普通变量（普通成员变量），接口中都是常量，默认修饰符：public static final
C，JDK8之前，接口中的方法都是默认public
abstract的，JDK8之后，接口中可以有static、default的修饰的方法，一旦被修饰，方法必须有方法体（抽象方法可是没有方法体的），接口中的方法都不能被private和protected修饰，同时外部接口、类只能被public修饰或者不写，但是内部接口、类可以被四个访问修饰符修饰。
D，
实现接口，其实就是需要重写接口中的abstract方法，一旦实现的类没有重写完，那么这个类必须是个抽象类（抽象类中可以没有抽象方法，但是有抽象方法的类必须是抽象类）。

17.有以下程序片段且Interesting不是内部类，下列哪个选项不能插入到行1。（ ）

1.
2.public class Interesting{
3. // 省略代码
4.}

正确答案: D 你的答案: B (错误)
A.import java.awt.*;
B.package mypackage;
C.class OtherClass{ }
D.public class MyClass{ }

解释：一个.java文件中，可以有多个类，包括内部类和外部类。考虑到内部类的原因，一个.java文件可以中可以有多个public类。
但是对于外部类而言，一个.java文件必须只能有一个public类，同时这个类的类名必须和.java的文件名一致（包括大小写）。

18.下JAVA程序的输出是什么（）

public class HelloSogou{
     public static synchronized void main(String[] a){
         Thread t=new Thread(){
             public void run(){Sogou();}
     };
     t.run();
     System.out.print("Hello");
     }
     static synchronized void Sogou(){
     System.out.print("Sogou");
    }
}

正确答案: B 你的答案: A (错误)
A.HelloSogou
B.SogouHello
C.Hello
D.结果不确定

19若有下列定义，下列哪个表达式返回false？

String s = "hello";
String t = "hello";
char c[] = {'h','e','l','l','o'} ;

正确答案: B 你的答案: D (错误)
A.s.equals(t);
B.t.equals©;
C.s==t;
D.t.equals(new String(“hello”));

解释：A、D选项是对字符串内容的比较。JVM为了减少字符串对象的重复创建，其维护了一个特殊的内存，这段内存被成为字符串常量池。代码中出现字面量形式创建字符串对象时，JVM首先会对这个字面量进行检查，如果字符串常量池中存在相同内容的字符串对象的引用，则将这个引用返回，否则新的字符串对象被创建，然后将这个引用放入字符串常量池，并返回该引用。所以返回true。
C选项是引用地址的比较，同上也属于常量池的同一个字符串地址，所以相等返回true。

20.请问所有的异常类皆直接继承于哪一个类？（）
正确答案: C 你的答案: D (错误)
A.java.applet.Applet
B.java.lang.Throwable
C.java.lang.Exception
D.java.lang.Error

21.顺序执行下列程序语句后，则b的值是（）
String a=“Hello”;
String b=a.substring(0,2);

正确答案: C 你的答案: B (错误)
A.Hello
B.Hel
C.He
D.null

解释：substring 方法将返回一个包含从 start 到最后（不包含 end ）的子字符串的字符串。

22.如下的Java程序

public class Test { 
     public static void main(String[] args) { 
     System.out.println(args[0]); 
     } 
} 

若采用命令行“java Test one two three”调用，则程序输出的结果为：
正确答案: B 你的答案: D (错误)
A.Test
B.one
C.two
D.java

解释：采用命令行“ java Test one two three ”调用 其中Test为调用的方法，而one two
three则为Test方法里面main函数的参数；
System.out.println(args[0]);表示输出第一个元素，故为one；

23.用命令方式运行以下代码的运行结果是（）
public class f{

    public static void main(String[] args){
        String foo1 = args[1];
        String foo2 = args[2];
        String foo3 = args[3];
    }
}

命令: java f a b c
正确答案: C 你的答案: C (正确)
A.程序编译错误
B.a b c
C.程序运行错误
D.f

24…Java1.8之后，Java接口的修饰符可以为（）
正确答案: D 你的答案: D (正确)
A.private
B.protected
C.final
D.abstract

25.（）运算符把其操作数中所有值为0和所有值为1的位分别在结果的相应中设置1和0
正确答案: D 你的答案: D (正确)
A.&
B.|
C.！
D.~

解释：~是位运算符，意义是 按位非（NOT） 按位非也叫做补
，一元运算符NOT“~”是对其运算数的每一位取反。
仅用于整数值反转位，即0位变为1位，1变成0
在所有情况下〜x等于（-x）- 1

26.下面有关JAVA异常类的描述，说法错误的是？
正确答案: D 你的答案: A (错误)
A.异常的继承结构：基类为Throwable，Error和Exception继承Throwable，RuntimeException和IOException等继承Exception
B.非RuntimeException一般是外部错误(非Error)，其必须被 try{}catch语句块所捕获
C.Error类体系描述了Java运行系统中的内部错误以及资源耗尽的情形，Error不需要捕捉
D.RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等，必须被 try{}catch语句块所捕获

解释：运行时异常故名思议就是程序在运行的时候出现异常，隐含的一个前提就是程序在编译时是检测不到异常的存在，作者本人也并不知道是否自己的代码中含有运行时异常，所以根本也不可能提前使用try{}catch{}捕获．

27.结构型模式中最体现扩展性的模式是（）
正确答案: A 你的答案: B (错误)
A.装饰模式
B.合成模式
C.桥接模式
D.适配器

解释：装饰模式
定义：动态给一个对象添加一些额外的职责,就象在墙上刷油漆.使用Decorator模式相比用生成子类方式达到功能的扩充显得更为灵活。
设计初衷：通常可以使用继承来实现功能的拓展,如果这些需要拓展的功能的种类很繁多,那么势必生成很多子类,增加系统的复杂性,同时,使用继承实现功能拓展,我们必须可预见这些拓展功能,这些功能是编译时就确定了,是静态的。

28.定以下JAVA代码，这段代码运行后输出的结果是（）

public class Test
{  
    public static int aMethod(int i)throws Exception
    {
        try{
            return i/10;
        }
        catch (Exception ex)
        {
            throw new Exception("exception in a aMethod");
        }finally{
      System.out.printf("finally");
        }
} 
    public static void main(String[] args){
        try
        {
            aMethod(0);
        }
        catch (Exception ex)
        {
            System.out.printf("exception in main");
        }
        System.out.printf("finished");
    }
}

正确答案: B 你的答案: A B (错误)
A.exception in main finished
B.finally finished
C.exception in main finally
D.finally exception in main finally

29.下面哪些是重载的基本条件（）
正确答案: A B D 你的答案: C D (错误)
A.参数的类型不同
B.参数类型的顺序不同(比如 int a , float b 与 float b , int a)
C.函数的返回值类型不同
D.参数的个数不同

30.下面有关 java 类加载器,说法正确的是?()
正确答案: A B C D 你的答案: D (错误)
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 ）、扩展加载器（ Extension ）、系统加载器（System ）和用户自定义类加载器（ java.lang.ClassLoader 的子类）。从 Java 2 （ JDK 1.2）开始，类加载过程采取了父亲委托机制（ PDM ）。 PDM 更好的保证了 Java 平台的安全性，在该机制中， JVM 自带的Bootstrap是根加载器，其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载，父类加载器无能为力时才由其子类加载器自行加载。 JVM不会向 Java 程序提供对 Bootstrap 的引用。下面是关于几个类加载器的说明：
（1）Bootstrap ：一般用本地代码实现，负责加载 JVM 基础核心类库（ rt.jar ）；
（2）Extension ：从java.ext.dirs 系统属性所指定的目录中加载类库，它的父加载器是 Bootstrap ；
（3）system class loader：又叫应用类加载器，其父类是 Extension 。它是应用最广泛的类加载器。它从环境变量 classpath 或者系统属性java.class.path 所指定的目录中记载类，是用户自定义加载器的默认父加载器。
（4）用户自定义类加载器：java.lang.ClassLoader 的子类
父类委托机制是可以修改的，有些服务器就是自定义类加载器优先的。