Java专项练习（三）

关于打*的题目，要么是我不会，要么就是我没有认真听课，后期会努力学习补充每道题的解析的！
(╹▽╹)
Java专项练习（二）
Java专项练习（一）

401、下列类定义代码，当用来声明对象car，并用Car car=new Car();实例化后，可以通过car对象直接赋值的字段是（）

public class Car
{
	public String type;
	String NO;
	private int heavy;
	double speed;
	protected String owner;
	public String price;
	private String color;
}

A.type,No
B.type,price
C.heavy,owner
D.type,owner,price
解析：
public权限是在本类、子类和类外都可被对象访问： protect权限是在本类或子类中可被对象访问： private权限是只能在本类内被访问

402、以下哪个不是Collection的子接口？

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

解析：
Collection主要的子接口:
List:可以存放重复内容
Set:不能存放重复内容,所有重复的内容靠hashCode()和equals()两个方法区分
Queue:队列接口
SortedSet:可以对集合中的数据进行排序

Map是键值对类型容器的顶级接口

403、下列说法正确的是( )

A.volatile,synchronized
都可以修改变量，方法以及代码块
B.volatile，synchronized 在多线程中都会存在阻塞问题
C.volatile能保证数据的可见性，但不能完全保证数据的原子性，synchronized即保证了数据的可见性也保证了原子性
D.volatile解决的是变量在多个线程之间的可见性、原子性，而sychroized解决的是多个线程之间访问资源的同步性
解析：
多线程中volatile 和synchronized的特性考察。

404、下面的程序将来打印什么?（）

public class TestIncr {
    public static void main(String args[]) {
        int i = 0;
        i = i++ + i;
        System.out.println("I =" +i);
    }
}

A.I = 1
B.I = 2
C.I = 3
D.编译出错
解析：
i    i++
0    1(此时i未被调用，所以i的值依旧为0)
所以i = i++ + i = 1 + 0 = 1;

405、下面的方法，当输入为2的时候返回值是多少？

public static int getValue(int i) {
    int result = 0;
    switch (i) {
        case 1:
            result = result + i;
        case 2:
            result = result + i * 2;
        case 3:
            result = result + i * 3;
        }
    return result;
}

A.0
B.2
C.4
D.10
解析：
没有break，发生case穿透现象，程序会继续向下执行，直到遇到break或者结束switch语句的大括号为止。

406、给出以下代码

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

请给出结果：（）
A.运行时抛出异常
B.true
C.Fred
D.第三行编译错误
解析：

new Object(){
public boolean equals(Object obj){
return true;
}
};
就是那个匿名类，继承并重写了Object类的equals方法，o只是指向所创建匿名对象的一个引用
将Object换成String，就会提示Cannot inherit from final 'java.lang.String

代码重写了equals方法，所以不管比较的是什么内容，传进来之后都会返回true。

407、socket编程中，以下哪个socket的操作是不属于服务端操作的（）？

A.accept
B.listen
C.connect
D.close
解析：

408、以下会产生精度丢失的类型转换是( ）

A.float a=10
B.int a=（int）8846.0
C.byte a=10； int b=-a
D.double d=100
解析：
精度丢失只会发生在从大范围到小范围的转换，
B选项为double到int转换，为大范围向小范围。

409、 如下代码的 结果是什么 ?

class Base {
    Base() {
    System.out.print("Base"); 
    }
}
public class Alpha extends Base {
    public static void main( String[] args ) {
        new Alpha();
        //调用父类无参的构造方法
        new Base();
    } 
}

A.Base
B.BaseBase
C.编译失败
D.代码运行但没有输出
E.运行时抛出异常
解析：
子类继承父类，在创建对象时，先调用父类的静态成员和静态方法，再是子类的静态成员和静态方法，再是父类的构造函数，再是子类的构造函数。

此处由于无静态函数和静态方法，所以先调用父类的构造函数然后是子类的构造函数。
先创建了子类对象，调用了父类中默认无参的构造函数打印出Base,子类默认无参的构造函数内部无内容；
接着创建了父类对象，调用了父类中默认无参的构造函数打印出Base。
所以结果是BaseBase.

410、Math.round(11.5) 等于多少 (). Math.round(-11.5) 等于多少 ( ).

A.11 ,-11
B.11 ,-12
C.12 ,-11
D.12 ,-12
解析：
round函数是取最接近整数，如果遇到一样近，则取最大值。

*411、下面哪个不对？

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
解析：

四个选项都来自于Java API原文.
A选项是RuntimeException的定义;
B选项是把Error的第二段定义拿来改掉换成RuntimeException,但这样说对于RuntimeException也没错;
C选项也是把Error的定义换成了RuntimeException,但这里的"indicates serious problems"不应该用在RuntimeException上,Error才表示严重的错误,RuntimeException并不是.

412、有以下一个对象：

public class DataObject implements Serializable{
    private static int i=0;
    private String word=" ";
    public void setWord(String word){
        this.word=word;
    }
    public void setI(int i){
        Data0bject.i=i;
     }
}

创建一个如下方式的DataObject:

DataObject object=new Data0bject ( );
object.setWord("123");
object.setI(2); 

将此对象序列化为文件，并在另外一个JVM中读取文件，进行反序列化，请问此时读出的Data0bject对象中的word和i的值分别为：

A.“”, 0
B.“”, 2
C.“123”, 2
D.“123”, 0

解析：
序列化保存的是对象的状态，静态变量属于类的状态，因此，序列化并不保存静态变量。所以i是没有改变的

413、在第16行插入哪段代码可以获得一个Point对象的坐标?( )

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

A.Point p = Line.getPoint();
B.Line.Point p = Line.getPoint();
C.Point p = (new Line()).getPoint();
D.Line.Point p = (new Line()).getPoint();

解析：

414、对下面Spring声明式事务的配置含义的说明错误的是（）

<bean id="txProxyTemplate" abstract="true"
class=
"org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    <property name="transactionManager" ref="myTransactionManager" />
<property name="transactionAttributes">      
 <props>
        <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
         <prop key="*">PROPAGATION_REQUIRED</prop>
     </props>
</property> 
</bean>

A.定义了声明式事务的配置模板
B.对get方法采用只读事务
C.缺少sessionFactory属性的注入
D.配置需要事务管理的bean的代理时，通过parent引用这个配置模板，代码如下：

<bean id="petBiz" parent="txProxyTemplate">
         <property name="target"ref="petTarget"/>
</bean>

解析：

https://www.nowcoder.com/questionTerminal/0ae7fe7ffb2345fba9c967eb18af0d5c

415、Java数据库连接库JDBC用到哪种设计模式?

A.生成器
B.桥接模式
C.抽象工厂
D.单例模式
解析：
https://www.nowcoder.com/questionTerminal/134a62da02d34bc6a7ff309af3fbb76f

416、以下哪项不属于java类加载过程？

A.生成java.lang.Class对象
B.int类型对象成员变量赋予默认值
C.执行static块代码
D.类方法解析
解析：
参考书籍
深入理解java虚拟机 周志明著
原文链接 http://www.importnew.com/18548.html

*417、关于HashMap和Hashtable正确的说法有（）

A.都实现了Map接口
B.Hashtable类不是同步的，而HashMap类是同步的
C.Hashtable不允许null键或值
D.HashMap不允许null键或值
解析：
后续学到了在整理哈

418、如果进栈序列为e1，e2，e3，e4，则可能的出栈序列是()注：一个元素进栈后可以马上出栈，不用等全部进栈

A.e3，e1，e4，e2
B.e2，e4，e3，e1
C.e2，e3，e4，e1
D.任意顺序都有可能

解析：
栈stack先进后出
1.进一个出一个e1,e2,e3,e4
2.进两个出一个e2,e4,e3,e1
3.先进两个出一个再进一个出一个e2,e3,e4,e1
4.先进一个出一个再进两个出一个e1,e3,e4,e2
5.进三个出一个e3,e4,e2,e1
6.进一个出一个在进三个e1,e4,e3,e2
7.全进再出e4,e3,e2,e1
…

*419、下面有关 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 ）、扩展加载器（ Extension ）、系统加载器（ System ）和用户自定义类加载器（ java.lang.ClassLoader 的子类）。
从 Java 2 （ JDK 1.2 ）开始，类加载过程采取了父亲委托机制（ PDM ）。 PDM 更好的保证了 Java 平台的安全性，在该机制中， JVM 自带的 Bootstrap 是根加载器，其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载，父类加载器无能为力时才由其子类加载器自行加载。 JVM 不会向 Java 程序提供对 Bootstrap 的引用。下面是关于几个类加载器的说明：

Bootstrap ：一般用本地代码实现，负责加载 JVM 基础核心类库（ rt.jar ）；
Extension ：从 java.ext.dirs 系统属性所指定的目录中加载类库，它的父加载器是 Bootstrap ；
system class loader ：又叫应用类加载器，其父类是 Extension 。它是应用最广泛的类加载器。它从环境变量 classpath 或者系统属性 java.class.path 所指定的目录中记载类，是用户自定义加载器的默认父加载器。
用户自定义类加载器： java.lang.ClassLoader 的子类

父类委托机制是可以修改的，有些服务器就是自定义类加载器优先的。

420、在Java线程状态转换时，下列转换不可能发生的有（）？

A.初始态->运行态
B.就绪态->运行态
C.阻塞态->运行态
D.运行态->就绪态
解析：

*421、以下关于对象序列化描述正确的是

A.使用FileOutputStream可以将对象进行传输
B.使用PrintWriter可以将对象进行传输
C.使用transient修饰的变量不会被序列化
D.对象序列化的所属类需要实现Serializable接口
解析：
学习中！
对应知识为Java输入输出流

422、在JDK1.7中，下述说法中抽象类与接口的区别与联系正确的有哪些？

A.抽象类中可以有普通成员变量，接口中没有普通成员变量。
B.抽象类和接口中都可以包含静态成员常量。
C.一个类可以实现多个接口，但只能继承一个抽象类
D.抽象类中可以包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法。
解析：

423、关于下面这段Java程序，哪些描述是正确的：（ ）

public class ThreadTest extends Thread {
    public void run() {
        System.out.println("In run");
        yield();
        System.out.println("Leaving run");
    }
    public static void main(String []argv) {
        (new ThreadTest()).start();
    }
}

A.程序运行输出只有In run
B.程序运行输出只有Leaving run
C.程序运行输出先有In run后有Leaving run
D.程序运行输出先有Leaving run后有In run
E.程序没有任何输出就退出了
F.程序将被挂起，只能强制退出
解析：
Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。

yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

结论：yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

424、Java7特性中,abstract class和interface有什么区别。

A.抽象类可以有构造方法，接口中不能有构造方法
B.抽象类中可以有普通成员变量，接口中没有普通成员变量
C.抽象类中不可以包含静态方法，接口中可以包含静态方法
D.一个类可以实现多个接口，但只能继承一个抽象类。
解析：
同422题

*425、以下说法中正确的有？

A.StringBuilder是 线程不安全的
B.Java类可以同时用 abstract和final声明
C.HashMap中，使用 get(key)==null可以 判断这个Hasmap是否包含这个key
D.volatile关键字不保证对变量操作的原子性
解析：
线程问题
A.StringBuilder线程不安全，StringBuffer线程安全。
B.同时用 abstract和final就会自相矛盾。
C.Hashmap中的value可以之null，get(key)==null有两种情况，一是key不存在，二是该key中存的是null，所以应该使用map.containskey(key)返回的true/false来判断是否存在这个key。
D.volatile关键字有两个作用：
1.并发环境可见性：volatile修饰后的变量能够保证该变量在线程间的可见性，线程进行数据的读写操作时将绕开工作内存（CPU缓存）而直接跟主内存进行数据交互，即线程进行读操作时直接从主内存中读取，写操作时直接将修改后端变量刷新到主内存中，这样就能保证其他线程访问到的数据是最新数据
2.并发环境有序性：通过对volatile变量采取内存屏障（Memory barrier）的方式来防止编译重排序和CPU指令重排序，具体方式是通过在操作volatile变量的指令前后加入内存屏障，来实现happens-before关系，保证在多线程环境下的数据交互不会出现紊乱。

426、以下说法错误的是（ ）

A.final修饰的方法不能被重载
B.final可以修饰类、接口、抽象类、方法和属性
C.final修饰的方法也不能被重写
D.final修饰的属性是常量，不可以修改
解析：
final修饰符
1.final修饰符可以修饰类、成员变量和成员方法。
2.final修饰类，意味着这个类不能再作为父类派生出其他子类，这样的类为最终类，如：String类。
3.final修饰一个变量，即定义一个常量，常量不占内存，因此其值也不会改变。
4.final定义最终方法，表示该方法不能被覆盖，即子类可以继承但不能重写该方法，称为最终方法。

427、下面关于面向对象的一些理解哪些是错误的( )

A.面向对象的最重要的特性是支持继承、封装和多态
B.系统设计应该遵循开闭原则，系统应该稳定不不可修改，但应支持通过继承、组合等方式进行扩展
C.函数式的语言必然是面向对象的语言
D.面向对象设计时，每个类的职责应该单一，不要再一个类中引入过多的接口
E.过程式语言和面向对象的语言各有其优势，过程式语言更加灵活，面向对象语言更加强调抽象和封装
F.Java和C++都是静态类型的面向对象编程语言
解析：

*428、下面HttpServletResponse方法调用，那些给客户端回应了一个定制的HTTP回应头：( )

A.response.setHeader(“X-MyHeader”, “34”);
B.response.addHeader(“X-MyHeader”, “34”);
C.response.setHeader(new HttpHeader(“X-MyHeader”, “34”));
D.response.addHeader(new HttpHeader(“X-MyHeader”, “34”));
E.response.addHeader(new ServletHeader(“X-MyHeader”, “34”));
F.response.setHeader(new ServletHeader(“X-MyHeader”, “34”));
解析：
网络编程内容 我还没认真学到那里o(╥﹏╥)o

429、在 main() 方法中给出数组buffer和下标i，如果将此下标中的元素显示到控制台上，需要使用（ ）。

A.System.out.print (buffer[i]);
B.FileOutputStream fout = new FileOutputStream(this.filename);
C.FileInputStream fin = new FileInputStream(this.filename);
D.System.in.read(buffer)。
解析：
题目已经给出了让表示数组中对应下标的值，所以当然会A啦。
BC都是文件输出输入流，D是标准输入流

430、 能使程序块显示字符串 “good” 的 x 值的范围 是 。

if (x>0)
    System.out.println("excellent");
else if (x>-3)
    System.out.println("good");
else
    System.out.println("normal");

A.x > 0
B.x > -3
C.x <= -3
D.-3 < x <= 0
解析：
兄弟们，就是分段函数，自己画个图，很好理解的

431、类Test1定义如下:     将以下哪种方法插入行3是不合法的。

public class Test1{//1
    public float aMethod(float a,float b){}//2 
    //3
}//4

A.public int aMethod(int a,int b){}
B.private float aMethod(int a,int b,int c){}
C.public float aMethod(float a,float b){}
D.public float aMethod(float a,float b,float c){}
解析：
对于方法重载的考察
重载要点：
首先重载的方法名必须相同
1.形参个数不同；如D与题目方法构成重载
2.形参类型不同；如A与题目方法构成重载
3.形参次序不同；如
public aMethod(float a,int b){}; public aMethod(int a,float b){};

public int aMethod(float a,float b){}
public float aMethod(float b,float a){}

注意：访问权限可以不一样，方法返回类型可以不同，但是这两种情况都不算重载

432、下面关于 new 关键字的表述错误的是（）

A.new关键字在生成一个对象时会为对象开辟内存空间
B.new关键字在生成一个对象时会调用类的构造方法
C.new关键字在生成一个对象时会将生成的对象的地址返回
D.Java中只能通过new关键字来生成一个对象
解析：

java中创建对象有以下几种方法：
1.用new语句创建对象，这是最常用的创建对象的方式。
2.运用反射手段，调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。
3.调用对象的clone()方法。
4.运用反序列化手段，调用java.io.ObjectInputStream对象的readObject()方法.

433、

public class Test1 {

    static int cnt = 6;

    static {
        cnt += 9;
    }

    public static void main(String[] args) {
        System.out.println("cnt =" + cnt);
    }

    static {
        cnt /= 3;
    }
}

A.cnt=5
B.cnt=2
C.cnt=3
D.cnt=6
解析：
在JVM调用mian方法之前先用进行静态内容的初始化。顺序为：父类的静态变量和方法，按顺序执行；子类的静态变量和方法，按顺序执行。

434、下列关于修饰符混用的说法，错误的是( )

A.abstract不能与final并列修饰同一个类
B.abstract 类中不建议有private的成员
C.abstract 方法必须在abstract类或接口中
D.static方法中能直接处理非static的属性
解析：
A.因为抽象类里只有变量和抽象方法的方法头，不能实例化，需要子类来对抽象方法进行具体化即被继承；而final类被称为最终类，不能派生子类，不能被继承，也不能被更改。二者概念相冲突，所以必定不能一起修饰同一个类。
B.可以有private成员，但是一般不建议，因为private成员只能被类本身的对象访问，所以在abstract类中定义private成员不会被他的子类访问到，因此也可以说是无意义。
C.抽象类中必定有抽象方法，有抽象方法的一定是抽象类；接口是一系列抽象方法的集合。
D.静态方法只能调用静态成员变量。但是实例方法可以调用实例变量、静态变量和静态方法。
类加载的时候，static属性比非static先初始化，那么一个存在的总不能访问一个没有存在的吧。

435、分析以下代码，说法正确的是（）

 public static void main(String[] args) {
     System.out.println(val());
 }
 
 public static int val() {
     int num = 5;
     try {
     num = num / 0;
 } catch (Exception e) {
     num = 10;
 } finally {
     num = 15;
 }
 return num;
 }

A.运行时报错
B.程序正常运行，输出值为5
C.程序正常运行，输出值为10
D.程序正常运行，输出值为15
解析：
有异常，try,catch,finally按顺序执行，最后返回num的值；
无异常，try,finally,最后返回num的值。
显然是第一种情况，有异常。

436、一个以". java"为后缀的源文件，哪些说法是正确的？

A.只能包含一个类，类名必须与文件名相同
B.只能包含与文件名相同的类，以及其中的内部类
C.只能有一个与文件名相同的类，可以包含其他类
D.可以包含任意类
解析：
当编写一个java源代码文件时，此文件通常被称为编译单元（有时也被称为转译单元）。每个编译单元都必须有一个后缀名.java，而在编译单元内则可以有一个public类，该类的名称必须与文件的名称相同（包括大小写，但不包括文件的后缀名.java）。每个编译单元只能有一个public类，否则编译器就不会接受。如果在该编译单元之中还有额外的类的话，那么在包之外的世界是无法看见这些类的，这是因为它们不是public类，而且它们主要用来为主public类提供支持。 -------《Java 编程思想》

437、关键字super的作用是？

A.用来访问父类被隐藏的非私有成员变量
B.用来调用父类中被重写的方法
C.用来调用父类的构造函数
D.以上都是
解析：
super代表父类对应的对象，所以用super访问在子类中无法直接使用的父类成员和方法

438、关于Java语言中的final关键字的使用，下列说法正确的是（）

A.在使用final关键字定义的方法里面必须使用final关键字定义变量。
B.使用final关键字定义变量，必须在变量定义的同时给定变量的具体数值，完成变量初始化。
C.final关键字可以用来修饰方法，表明此方法不可以被子类重写。
D.使用final关键字定义变量，必须同时使用static关键字。

解析：
同426
A 选项在 final 定义的方法里，不是必须要用 final 定义变量。
B final 定义的变量，可以在不是必须要在定义的同时完成初始化，也可以在构造方法中完成初始化。
C 正确，final修饰方法，称为最终方法，不可修改，不能被子类重写，但是可以被重载。
D final 定义变量，可以用 static 也可以不用。

439、Java 中，以下不是修饰符 final 作用的是( )。

A.修饰常量
B.修饰不可被继承的类
C.修饰不可变类
D.修饰不可覆盖的方法
解析：
同426解析
ABD是final的基本修饰类别C选项不理解什么是不可变类

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

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

A.2
B.10
C.11
D.不确定
解析：
第一次运行是给i赋初值为2，然后判断是否小于等于10，然后执行代码，再执行i++。第二次判断i++是否小于等于10，满足条件执行代码，再执行i++。如此反复，最后一次肯定是i=10,输出为10,然后执行i++,此时i=11,再判断11是否小于10，不满足，跳出循环。所以i的值为11.

441、检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。

public class HelloB extends HelloA 
{
 public HelloB()
 {
 }
 {
     System.out.println("I’m B class");
 }
 static
 {
     System.out.println("static B");
 }
 public static void main(String[] args)
 {
     new HelloB();
 }
}
class HelloA
{
 public HelloA()
 {
 }
 {
     System.out.println("I’m A class");
 }
 static
 {
     System.out.println("static A");
 }
}

A.
static A
I’m A class
static B
I’m B class
B.
I’m A class
I’m B class
static A
static B
C.
static A
static B
I’m A class
I’m B class
D.
I’m A class
static A
I’m B class
static B
解析：
代码块执行顺序：
父类的静态变量和父类的静态代码块（按在代码中的顺序执行）、子类的静态变量和子类的静态代码块（按在代码中的顺序执行）、
父类的构造函数、子类的构造函数。
父类的成员函数、子类的成员函数。
静态域正确的理解是这样的:
并不是静态块最先初始化,而是静态域.而静态域中包含静态变量、静态块和静态方法,其中需要初始化的是静态变量和静态块.而他们两个的初始化顺序是靠他们俩的位置决定的!

442、下列哪些语句关于内存回收的说明是正确的? ( )

A.程序员必须创建一个线程来释放内存
B.内存回收程序负责释放无用内存
C.内存回收程序允许程序员直接释放内存
D.内存回收程序可以在指定的时间释放内存对象
解析：

*443、通过HttpServletRequest. getParameter获取的参数.

A.总是采用UTF-8编码
B.总是采用lS08859-1编码
C.由客户端浏览器和Web容器配置共同决定编码
D.由服务器所在的操作系统决定编码
解析：
网络编程 还没学习

444、What is the result of compiling and executing the following fragment of code:

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

A.The code fails to compile at the “if” statement.
B.An exception is thrown at run-time at the “if” statement.
C.The text“true” is displayed.
D.The text“false”is displayed.
解析：

=是赋值，给flag赋值成true，所以输出为true.

*445、下面关于Spring的说法中错误的是（）

A.Spring是一个支持快速开发Java EE框架的框架
B.Spring中包含一个“依赖注入”模式的实现
C.使用Spring可以实现声明式事务
D.Spring提供了AOP方式的日志系统
解析：
Spring我还没有学啊

446、假定Base b = new Derived（）; 调用执行b.methodOne（）后，输出结果是什么？

public class Base
{
   public void methodOne()
   {
      System.out.print("A");
      methodTwo();
   }

   public void methodTwo()
   {
      System.out.print("B");
   }
}

public class Derived extends Base
{
   public void methodOne()
   {
      super.methodOne();
      System.out.print("C");
   }

   public void methodTwo()
   {
      super.methodTwo();
      System.out.print("D");
   }
}

A.ABDC
B.AB
C.ABCD
D.ABC
解析：
只要是被子类重写的方法，不被super调用都是调用子类方法

447、下面属于java引用类型的有？

A.String
B.byte
C.char
D.Array
解析：
引用类型包括类、接口和数组类型以及特殊的null类型

448、下面哪些标识符正确的是（）

A.MyWorld
B.parseXML
C.-value
D.&maybe
解析：
标识符的定义：
由数字、字母、下划线、$构成，不能以数字开头，不能用保留字和关键字。

449、下面的类哪些可以处理Unicode字符?

A.InputStreamReader
B.BufferedReader
C.Writer
D.PipedInputStream
解析：

简单地说，字符流是字节流根据字节流所要求的编码集解析获得的
可以理解为字符流=字节流+编码集
所以本题中和字符流有关的类都拥有操作编码集(unicode)的能力。

450、Consider the following code:

Integer s=new Integer(9);
Integer t=new Integer(9);
Long u=new Long(9);

Which test would return true?
A.(su)
B.(st)
C.(s.equals(t))
D.(s.equals(9))
E.(s.equals(new Integer(9))
解析：

==比较地址
equals比较内容
s和t都是分别创建的两个对象，地址不同，当然为false啦.

*451、关于抽象类与接口，下列说法正确的有？

A.优先选用接口，尽量少用抽象类
B.抽象类可以被声明使用，接口不可以被声明使用
C.抽象类和接口都不能被实例化。
D.以上说法都不对
解析：
A选项有待考察 虽然我选对了￣□￣｜｜

452、不能用来修饰interface的有（ ）（仅限外部接口）

A.private
B.public
C.protected
D.static
解析：

453、下面代码在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.t.a
B.this.c
C.Test.b
D.t.c

解析：
实例变量只能用对象来调用；类变量可以由类名和对象来调用。

454、下列说法正确的是（）？

A.对于局部内部类，只有在方法的局部变量被标记为final或局部变量是effctively final的，内部类才能使用它们
B.成员内部类位于外部类内部，可以直接调用外部类的所有方法（静态方法和非静态方法）
C.由于匿名内部类只能用在方法内部，所以匿名内部类的用法与局部内部类是一致的
D.静态内部类可以直接访问外部类的非静态成员
解析：

455、在使用super和this关键字时，以下描述错误的是（）

A.在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过
B.super()和this()不一定要放在构造方法内第一行
C.this()和super()可以同时出现在一个构造函数中
D.this()和super()可以在static环境中使用，包括static方法和static语句块
解析：
super和this都只能位于构造器的第一行，而且不能同时使用，这是因为会造成初始化两次，this用于调用重载的构造器，super用于调用父类被子类重写的方法

456、往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;}
}

解析:
1.静态内部类才可以声明静态方法
2.静态方法不可以使用非静态变量
3.抽象方法不可以有函数体

457、一个抽象类并不需要其中所有的方法都是抽象的。（ 对 ）

解析：
抽象类中不一定包括抽象方法，可以有非抽象方法即成员方法。
但是包含抽象方法的类一定是抽象类。

458、如果类的方法的返回值为空，该方法的返回类型应是：( )

A.void
B.null
C.abstract
D.default
解析：
看了下这题下面的讨论。没有返回值一般说的是构造函数，而返回值为空用的是void。

*459、 Java 语言中，负责并发管理的机制是（ ）

A.垃圾回收
B.虚拟机
C.代码安全
D.多线程
解析：
线程学习ing

选项A，Java语言中，垃圾回收机制对系统中不使用的内存进行回收，从而使程序员从繁忙的内存管理中解放出来。
选项B，Java编写好的程序首先由编译器转换为标准字节代码，然后由虚拟机执行。虚拟机把字节代码程序与各操作系统和硬件分开，使Java程序独立于平台。
选项C，Java的代码安全检测体现在多个层次上，在编译层、解释层、平台层分别作不同的安全检查。
选项D，多线程是Java程序的并发机制，它能同步共享数、处理不同的事件。

多线程应该是一种实现方式，而不是管理机制的，管理机制作用应该还是落在jvm上面了吧

460、下列关于Java类中方法的定义，正确的是（）

A.若代码执行到return语句，则将当前值返回，而且继续执行return语句后面的语句。
B.只需要对使用基本数据类型定义的属性使用getter和setter，体现类的封装性。
C.方法的返回值只能是基本数据类型。
D.在同一个类中定义的方法，允许方法名称相同而形参列表不同。
解析：
A.return即结束程序，遇到return就不会执行后面的代码了，但是要考虑特殊的try,catch,finally语句中return。
B.数据域和方法都可以被封装。数据域可以是基本数据类型也可以是引用类型。但不是这么体现的。
C.方法的返回值也可以是引用数据类型
D.这句话说的是方法重载。

461、以下说法错误的是（）

A.数组是一个对象
B.数组不是一种原生类
C.数组的大小可以任意改变
D.在Java中，数组存储在堆中连续内存空间里
解析：
选C
A、数组就是一个对象，在堆上分类内存。
B、数组不是原生类，原生类就是基本数据类型
C、数组是定长的
D、数组就是连续内存。

*462、 在 applet 的方法中 , 可关闭小应用程序并释放其占用资源的是（ ）

A.stop()
B.paint()
C.init()
D.destroy()
解析：

463、下列表述错误的是？（）

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

464、 关于下面代码 int[] x=new int[25]; 描述正确的是（）

A.x[25]存放了数据“\0”。
B.x[24] 存放了数据“\0”。
C.若访问x[25]，程序将抛出异常。
D.x[1]访问此数组的第一个元素。
解析：
java数组没有/0，判断结尾时直接以数组长度判断

465、执行下列代码的输出结果是( )

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

解析：
如果finally块中有return语句的话，它将覆盖掉函数中其他return语句。

*466、一个文件中的字符要写到另一个文件中，首先需要（ ）。

A.System.out.print (buffer[i]);
B.FileOutputStream fout = new FileOutputStream(this.filename);
C.FileInputStream fin = new FileInputStream(this.filename);。
D.System.in.read(buffer)。
解析：
程序的逻辑很简单。程序必须打开两个文件，以可读的方式打开一个已有文件和以可写的方式打开一个新文件，后将已有文件中的内容，暂时存放在内存中，再写入新的文件，后关闭所有文件，程序结束。
根据题意，首先需要读入一个文件中的字符，需要FileInputStream fin = new FileInputStream(this.filename);

*467、 列表(List)和集合(Set)下面说法正确的是？ ( )

A.Set中至多只能有一个空元素
B.List中至多只能有一个空元素
C.List和Set都可以包含重复元素的有序集合
D.List和Set都是有序集合
解析：

java里面讲的有序无序，指的是你按照顺序存进去数据，然后再按照顺序取出来，两者是一样的。比如List(0)我放的是“a”，那么我list.get(0)取出来也是“a”。并不代表我存了打乱顺序存1到10十个数，它会自己给按照升序或者降序给你排好序。

*468、下面有关JSP内置对象的描述，说法错误的是？

A.session对象：session对象指的是客户端与服务器的一次会话，从客户连到服务器的一个WebApplication开始，直到客户端与服务器断开连接为止
B.request对象：客户端的请求信息被封装在request对象中，通过它才能了解到客户的需求，然后做出响应
C.application对象：多个application对象实现了用户间数据的共享，可存放全局变量
D.response对象：response对象包含了响应客户请求的有关信息
解析：

*469、指出下列程序运行的结果：

public class Example{
    String str=new String("tarena");
    char[]ch={'a','b','c'};
    public static void main(String args[]){
        Example ex=new Example();
        ex.change(ex.str,ex.ch);
        System.out.print(ex.str+" and ");
        System.out.print(ex.ch);
    }
    public void change(String str,char ch[]){
   //引用类型变量，传递的是地址，属于引用传递。
        str="test ok";
        ch[0]='g';
    }
}

A.tarena and abc
B.tarena and gbc
C.test ok and abc
D.test ok and gbc
解析：
引用自该题目下的讨论。
String str=new String(“tarena”);
语句执行的时候，首先会检查字符串常量池有没有“tarena”，如果没有，就在字符串常量池创建一个“tarena”，然后根据字符串常量池的“tarena”，在堆中创建一个“tarena”对象，这个str指向堆中的“tarena”对象；如果字符串常量池有“tarena”，就直接在堆中创建一个“tarena”对象。
总的来说，就是在堆中有一个str成员变量，指向堆中的一个地址A，地址A中的值是“tarena”。且由于字符串底层是final类型的数组实现，那么这个地址A的值“tarena”是不变的。str的值始终是“tarena”，除非将str指向其他地址。

char[]ch={“a”’,“b”,“c”};
同样，上面语句在堆中创建一个成员变量ch，并创建一个地址B，B中的值是数组的元素：“a”、“b”、“c”，该成员变量ch指向地址B

public void change(String str,char ch[]){
//引用类型变量，传递的是地址，属于引用传递。
str=“test ok”;
ch[0]=“g”;
}
上面语句执行的时候，在栈中创建2个局部变量str、ch，局部变量str被赋予A地址的副本，指向A地址。而局部变量ch被赋予地址B的副本，指向地址B。

当 str=“test ok”; 执行的时候，我们知道地址A的内容是不会变的，那么即使局部变量str指向地址A，它的值变化也不会引起地址A的值变化，而是在栈中开辟一个地址C，地址C的值是“test ok”，局部变量str指向地址C，而成员变量str仍然指向地址A，且值是“tarena”。

当 ch[0]=“g”; 执行的时候，由于地址B的值可变，那么局部变量ch的值的变化，会导致地址B的值的变化，地址B第一个值就从"a"变为"g"，因此成员变量ch指向地址B，它的值也变化，为 [“g”,“b”,“c”]

470、 下面哪个方法是 public void example(){…} 的重载方法？ ( )

A.public void Example( int m){…}
B.public int example(){…}
C.public void example2(){…}
D.public int example ( int m, float f){…}
解析：
同431
方法重载的考察

方法名相同------------------排除AC选项。
方法的参数类型，参数个不一样。-----------------B选项和题目中的都没有参数，所以排除B选项。
方法的返回类型可以不相同
方法的修饰符可以不相同 

471、一个容器类数据结构，读写平均，使用锁机制保证线程安全。如果要综合提高该数据结构的访问性能，最好的办法是______。

A.只对写操作加锁，不对读操作加锁
B.读操作不加锁，采用copyOnWrite的方式实现写操作
C.分区段加锁
D.无法做到
解析：
A，只对写操作加锁，不对读操作加锁，会造成读到脏数据
B，CopyOnWrite的核心思想是利用高并发往往是读多写少的特性，对读操作不加锁，对写操作，先复制一份新的集合，在新的集合上面修改，然后将新集合赋值给旧的引用。这里读写平均，不适用
C，分段加锁，只在影响读写的地方加锁，锁可以用读写锁，可以提高效率

*472、以下代码执行的结果显示是多少（ ）？

A.true,false,true
B.false,true,false
C.true,true,false
D.false,false,true
解析：

473、要导入java/awt/event下面的所有类，叙述正确的是？()

解析：导包只可以导到当前层，不可以再导入包里面的包中的类 。

474、在Web应用程序中，( )负责将HTTP请求转换为HttpServletRequest对象

A.Servlet对象
B.HTTP服务器
C.Web容器
D.JSP网页
解析：
web容器是一种服务程序，在服务器一个端口就有一个提供相应服务的程序，而这个程序就是处理从客户端发出的请求，如JAVA中的Tomcat容器，ASP的IIS或PWS都是这样的容器。一个服务器可以多个容器。

*475、在各自最优条件下,对N个数进行排序,哪个算法复杂度最低的是? （）

A.插入排序
B.快速排序
C.堆排序
D.归并排序
解析：

*476、Java多线程有几种实现方法？

A.继承Thread类
B.实现Runnable接口
C.实现Thread接口
D.以上都不正确
解析：
1、继承Thread类，Override它的run方法；
2、实现Runnable接口，实现run方法；

由于Java只有单继承，所以，第一种方法只能继承一个Thread；第二种则可以实现多继承。

477、java中提供了哪两种用于多态的机制

A.通过子类对父类方法的覆盖实现多态
B.利用重载来实现多态.即在同一个类中定义多个同名的不同方法来实现多态。
C.利用覆盖来实现多态.即在同一个类中定义多个同名的不同方法来实现多态。
D.通过子类对父类方法的重载实现多态
解析：
Java通过方法重写和方法重载实现多态
方法重写是指子类重写了父类的同名方法
方法重载是指在同一个类中，方法的名字相同，但是参数列表不同

478、若需要定义一个类，下列哪些修饰符是允许被使用的？（ ）

A.static
B.package
=C.private
D.public==
解析：
这题只说定义一个类，但是没有说这个类是普通外部类或者内部类。
因为普通类也就是外部类，通过 eclipse 的警告“Illegal modifier for the class Test; only public, abstract & final are permitted” 可知只能用 public, abstract 和 final 修饰。
内部类则可以用 修饰成员变量的修饰符修饰内部类，比如 private, static, protected 修饰。

479、以下关于JAVA语言异常处理描述正确的有？

A.throw关键字可以在方法上声明该方法要抛出的异常。
B.throws用于抛出异常对象。
C.try是用于检测被包住的语句块是否出现异常，如果有异常，则捕获异常，并执行catch语句。
D.finally语句块是不管有没有出现异常都要执行的内容。
E.在try块中不可以抛出异常
解析：
thhrow 是抛出对象例如：throw new RuntimeException() , 而throws是在方法后面抛出异常

480、下面关于volatile的功能说法正确的是哪个

A.原子性
B.有序性
C.可见性
D.持久性
解析：
synchronized保证三大性，原子性，有序性，可见性，volatile保证有序性，可见性，不能保证原子性

481、多态的作用（）

A.隐藏细节
B.提高可重用性
C.扩展代码模块
D.提高编译可靠性

482、java运行时内存分为“线程共享”和“线程私有”两部分，以下哪些属于“线程共享”部分

A.程序计算器
B.方法区
C.java虚拟机栈
D.java堆
解析：
私有:java虚拟机栈，程序计数器，本地方法栈 共享:java堆，方法区

*483、下面正确的2项是？

public class NameList
{
    private List names = new ArrayList();
    public synchronized void add(String name)
    {
        names.add(name);
    }
    public synchronized void printAll() {
        for (int i = 0; i < names.size(); i++)
        {
            System.out.print(names.get(i) + "");
        }
    }

    public static void main(String[]args)
    {
        final NameList sl = new NameList();
        for (int i = 0; i < 2; i++)
        {
            new Thread()
            {
                public void run()
                {
                    sl.add("A");
                    sl.add("B");
                    sl.add("C");
                    sl.printAll();
                }
            } .start();
        }
    }
}

A.运行的时候可能抛异常
B.运行的时候可能没有输出，也没有正常退出
C.代码运行的时候可能没有输出，但是正常退出
D.代码输出"A B A B C C "
E.代码输出"A B C A B C A B C "
F.代码输出"A A A B C A B C C "
G.代码输出"A B C A A B C A B C "
解析：
线程问题

484、以下类型为Final类型的为（）

A.HashMap
B.StringBuffer
C.String
D.Hashtable
解析：
通过阅读源码可以知道，string与stringbuffer都是通过字符数组实现的。
其中string的字符数组是final修饰的，所以字符数组不可以修改。
stringbuffer的字符数组没有final修饰，所以字符数组可以修改。
string与stringbuffer都是final修饰，只是限制他们所存储的引用地址不可修改。
至于地址所指内容能不能修改，则需要看字符数组可不可以修改。

485、Java Applet在被浏览器加载的时候首先被执行且在applet整个生命周期中被运行一次的方法是（）

A.init()
B.stop()
C.opreationcrawl()
D.reader()
解析：
Applet 是一种在 Web 环境下，运行于客户端的Java程序组件。Applet 必须运行于某个特定的“容器”，这个容器可以是浏览器本身，也可以是通过各种插件，或者包括支持 Applet 的移动设备在内的其他各种程序来运行。与一般的Java应用程序不同，Applet 不是通过 main 方法来运行的。Applet运行之前，先调用 Init() 方法，然后调用 start() 方法，最后调用 paint() 方法。

486、创建一个标识有“开始”按钮的语句是( )。

A.JTextField b = new JTextField(“开始”);
B.JLabel b = new JLabel(“开始”);
C.JCheckbox b = new JCheckbox(“开始”);
D.JButton b = new JButton(“开始”);
解析：
英语题

487、正则表达式语法中 \d 匹配的是？（）

A.数字
B.非数字
C.字母
D.空白字符
解析：

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

1.

2.public  class  A{

3.//do sth

4. } 

A.public class MainClass{ }
B.package mine;
C.class ANotherClass{ }
D.import java.util.*;
解析：
一个程序里只能有一个public类。

489、有这样一段程序：

public class Test{ 
    public static void main(String [] args){ 
        List list=new ArrayList(); 
        list.add("a");
        list.add("b");
        list.add("a");
        Set set=new HashSet(); 
        set.add("a"); 
        set.add("b"); 
        set.add("a"); 
        System.out.println(list.size()+","+set.size()); 
    } 
}

请问运行主要的程序会打印出的是什么（）
A.2,2
B.2,3
C.3,2
D.3,3
解析：
1、List和Set的区别，set中不能放重复的
2、Set中重复的定义，未定义自己的equels方法的话，调用默认的，也就是直接==

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

A.java.io
B.java.sql
C.java.awt
D.java.rmi
解析：

图形用户界面（Graphical User Interface，简称 GUI）是指采用图形方式显示的计算机操作用户界面。

java.io提供了全面的IO接口。包括：文件读写、标准设备输出等。
java.sql 提供使用 Java 编程语言访问并处理存储在数据源中的数据的 API。此 API 包括一个框架，凭借此框架可以动态地安装不同驱动程序来访问不同数据源。
java.awt是一个软件包，包含用于创建用户界面和绘制图形图像的所有分类。功能：包含用于创建用户界面和绘制图形图像的所有类。
java.rmi 提供 RMI 包。RMI 指的是远程方法调用 (Remote Method Invocation)。它是一种机制，能够让在某个 Java虚拟机上的对象调用另一个 Java 虚拟机中的对象上的方法。

491、 下列叙述错误的是（ ）

A.在接口中定义的方法除了default和static关键字修饰的方法拥有方法体，其他方法都应是没有方法体的抽象方法（JDK1.8以后）
B.一个java类只能有一个父类,但可以实现多个接口
C.在类声明中,用implements关键字声明该类实现的接口
D.定义接口时使用implements关键字。
解析：
定义接口用关键字interface;实现接口用关键字implements

492、定义接口时使用implements关键字。

A.233
B.223
C.221
D.222
解析：
i++是先输出i再++

493、能单独和finally语句一起使用的块是( )

A.try
B.catch
C.throw
D.throws
解析：

try{
}catch(){
}finally{
}
finally不管是否有异常都会执行，而且，try可以和catch和finally中的一个搭配使用，但是catch和finally不能单独使用

494、下面代码的输出结果是什么？

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
解析：
1、inti = 100/ 0; 会出现异常，会抛出异常，System.out.print(i)不会执行，
2、catch捕捉异常，继续执行System.out.print(1);
3、throw则是将异常抛给它的上一级处理，程序便不往下执行了。
4.无论如何finnaly一定会执行。

495、类方法中可以直接调用对象变量？ 错

解析：静态方法中不能调用对象的变量，因为静态方法在类加载时就初始化，对象变量需要在新建对象后才能使用

496、java Thread中，run方法和start方法的区别，下面说法错误的是？

A.通过调用Thread类的start()方法来启动一个线程，这时此线程是处于就绪状态，并没有运行。
B.他们都可以实现了多线程运行。
C.run方法是thread的一个普通方法调用。
D.调用start方法后，一旦得到cpu时间片，就开始执行run()方法。
解析：
1.start方法
用 start方法来启动线程，是真正实现了多线程， 通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法。但要注意的是，此时无需等待run()方法执行完毕，即可继续执行下面的代码。所以run()方法并没有实现多线程。
2.run方法
run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码。

497、Thread. sleep()是否会抛出checked exception?会

解析：Thread.sleep() 和 Object.wait(),都可以抛出 InterruptedException。这个异常是不能忽略的,因为它是一个检查异常(checked exception)

498、下面关于静态方法说明正确的是

A.在静态方法中可用this来调用本类的类方法
B.在静态方法中调用本类的静态方法时可直接调用
C.在静态方法中只能调用本类中的静态方法
D.在静态方法中绝对不能调用实例方法
解析：
A.静态成员随类的加载而加载，这个时候对象都还没有，this代表当前对象，所以this不能用于static方法中.C还可以调用静态变量D.可以通过对象.进行调用

499、关于以下程序代码的说明正确的

class HasStatic{
    private static int x = 100;
    public static void main(String args[ ]){
        HasStatic hs1 = new HasStatic();
        hs1.x++;
        HasStatic hs2 = new HasStatic();
        hs2.x++;
        hs1=new HasStatic();
        hs1.x++;
        HasStatic.x--;
        System.out.println( "x=" +x);
    }
}

A.5行不能通过编译，因为引用了私有静态变量
B.10行不能通过编译，因为x是私有静态变量
C.程序通过编译，输出结果为：x=103
D.程序通过编译，输出结果为：x=102
解析：
答案选D
因为x的 修饰符为 static 所以x为类变量，即对于所有的实例来说，他们访问的x为同一个x，类变量存储在方法区，不属于每个实例的私有，
刚开始x=100
调用hs1.x++ x为101;
调用hs2.x++ x为102;
调用hs1.x++ x为103 (此时hs1指向了一个新的HasStatic实例，但是依然访问的是同一个X)
调用HasStatic.x-- x为102
所以结果为D

500、 A 是抽象父类或接口， B ， C 派生自 A ，或实现 A ，现在 Java 源代码中有如下声明：问以下哪个说法是正确的？（ ）

1. A a0=new A();

2. A a1 =new B();

3. A a2=new C();

A.第1行不能通过编译
B.第1、2行能通过编译，但第3行编译出错
C.第1、2、3行能通过编译，但第2、3行运行时出错
D.第1行、第2行和第3行的声明都是正确的
解析：
抽象类和接口都不能被实例化。但抽象类有构造方法，而接口没有。

501、以下选项中循环结构合法的是:

A.while(int i<7){i++;System.out.println("i is "+i);}
B.int j=3;while(j){ System.out.println("j is "+j);}
C.int j=0;for(int k=0;j+k!=10;j++,k++){System.out.println("j is "+j+“k is” +k);}
D.int j=0; do{System.out.println("j is "+j++);if(j==3){continue loop;}}while(j<10);

502、以下哪个不能用来处理线程安全

A.synchronized关键字
B.volatile关键字
C.Lock类
D.transient关键字

503、下面哪个Set类是按元素排好序的？

A.LinkedHashSet
B.TreeSet
C.HashSet
D.AbstractSet
解析：

504、如下代码的输出是

package Test;
public class Test {
    private static void test(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            try {
                if (arr[i] % 2 == 0) {
                    throw new NullPointerException();
                } else {
                    System.out.print(i);
                }
            } finally {
                System.out.print("e");
            }
        }
    }

    public static void main(String[]args) {
        try {
            test(new int[] {0, 1, 2, 3, 4, 5});
        } catch (Exception e) {
            System.out.print("E");
        }
    }

}

A.编译出错
B.eE
C.Ee
D.eE1eE3eE5
E.Ee1Ee3Ee5
解析：
由于arr[0] =0,所以在进入 test()方法里面会在第一个if 上抛出一个 NullPointerException,接着会执行 finally 的语句, (finally语句先于 return 和 throw语句执行)，输出一个’e，然后回到 main方法中，由于捕捉到异常，所以进入到catch语句中，然后打印一个’E’,所以最终结果为"eE"

*505、String s = new String(“xyz”);创建了几个StringObject？

A.两个或一个都有可能
B.两个
C.一个
D.三个
解析：
如果常量池没有，就会在常量池创建一个xyz字符串，然后执行new，在堆中再创建一个字符串；
如果常量池有，就会根据常量池中的xyz字符串，在堆中new一个新的字符串。
另外，字符串常量池在jdk1.7之后，也是存在于堆区。且常量池中保存的只是字符串的引用，实际上我们所说的常量池中的字符串，也是在堆中创建，但是他的引用在常量池中。

*506、下列哪个说法是正确的（）

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

*507、当我们需要所有线程都执行到某一处，才进行后面的的代码执行我们可以使用？

A.CountDownLatch
B.CyclicBarrier
C.Semaphore
D.Future

508、 已知 boolean result = false，则下面哪个选项是合法的：

A.result=1
B.result=true;
C.if(result!=0) {//so something…}
D.if(result) {//do something…}
解析：
1、boolean类型只有两个直接量值:true和false.
2、除成员变量会有默认初始值外，其他变量必须在第一次使用之前初始化

509、关于java集合下列说法不正确的有哪些（）

A.HashSet 它是线程安全的，不允许存储相同的对象
B.ConcurrentHashMap 它是线程安全的，其中存储的键对象可以重复，值对象不能重复
C.Collection接口是List接口和Set接口的父接口，通常情况下不被直接使用
D.ArrayList线程安全的，允许存放重复对象
解析：
HashSet和ArrayList一样线程不安全，ConcurrentHashMap键不能重复，值可以重复

*510、 对 Map 的用法，正确的有：

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 ) ;
解析：

*511、关于ThreadLocal类 以下说法正确的是

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

512、判断对错。在java的多态调用中，new的是哪一个类就是调用的哪个类的方法。（）

错
解析：

public class Father {
    public void say(){
        System.out.println("father");
    }
    public static void action(){
        System.out.println("爸爸打儿子！");
    }
}
public class Son extends Father{
    public void say() {
        System.out.println("son");
    }
   public static void action(){
        System.out.println("打打！");
    }
    public static void main(String[] args) {
        Father f=new Son();
        f.say();
        f.action();
    }
} 
/*
 输出：son
      爸爸打儿子！ 
*/

  当调用say方法执行的是Son的方法，也就是重写的say方法。
而当调用action方法时，执行的是father的方法。
  普通方法，运用的是动态单分配，是根据new的类型确定对象，从而确定调用的方法；
  静态方法，运用的是静态多分派，即根据静态类型确定对象，因此不是根据new的类型确定调用的方法

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

A、匿名内部类可以继承一个基类，不可以实现一个接口
B、匿名内部类不可以定义构造器
C、匿名内部类不能用于实参
D、以上说法都不正确

解析：

匿名内部类的创建格式为：
    new 父类构造器（参数列表）|实现接口（）{
         //匿名内部类的类体实现
    }

1.使用匿名内部类时，必须继承一个类或实现一个接口
2.匿名内部类由于没有名字，因此不能定义构造函数
3.匿名内部类中不能含有静态成员变量和静态方法 
4.匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。
5.匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

514、下面代码输出是？

enum AccountType
{
    SAVING, FIXED, CURRENT;
    private AccountType()
    {
        System.out.println("It is a account type");
    }
}
class EnumOne
{
    public static void main(String[]args)
    {
        System.out.println(AccountType.FIXED);
    }
}

A、编译正确，输出”It is a account type”once followed by”FIXED”
B、编译正确，输出”It is a account type”twice followed by”FIXED”
C、编译正确，输出”It is a account type”thrice followed by”FIXED”
D、编译正确，输出”It is a account type”four times followed by”FIXED”
解析：

515、假定Base b = new Derived（）; 调用执行b.methodOne（）后，输出结果是什么？

public class Base
{
   public void methodOne()
   {
      System.out.print("A");
      methodTwo();
   }

   public void methodTwo()
   {
      System.out.print("B");
   }
}

public class Derived extends Base
{
   public void methodOne()
   {
      super.methodOne();
      System.out.print("C");
   }

   public void methodTwo()
   {
      super.methodTwo();
      System.out.print("D");
   }
}

ABDC
解析：
  Java的多态调用，父类继承子类，本题中子类重写了父类的所有方法。所以在b.methodOne（）调用的是子类Derived的methodOne（）方法，它里面调用了父类的methodOne（），而父类的methodOne（）方法中

 public void methodOne()
   {
      System.out.print("A");
      methodTwo();
   }

methodTwo();此时调用的就是子类的方法；子类的方法因而再调用父类methodTwo();所以最后的输出是ADBC。

516、下面哪个流类不属于面向字符的流（）

A、BufferedWriter
B、FileInputStream
C、ObjectInputStream
D、InputStreamReader