java se 计算机专业技能-Java专项练习(选择题)（二）

1.以下代码执行后输出结果为（ ）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

public class ExceptionTest {     public void method()     {         try         {             System.out.println("进入到try块");         }         catch (Exception e)         {              System.out.println("异常发生了！");         }         finally         {             System.out.println("进入到finally块");         }             System.out.println("后续代码");  }      public static void main(String[] args)      {          ExceptionTest test = new ExceptionTest();          test.method();      }  }

• 进入到try块  异常发生了！  进入到finally块  后续代码
• 进入到try块  进入到finally块  后续代码
• 进入到try块  后续代码
• 异常发生了！  后续代码

解析：

try { //执行的代码，其中可能有异常。一旦发现异常，则立即跳到catch执行。否则不会执行catch里面的内容 }

catch { //除非try里面执行代码发生了异常，否则这里的代码不会执行 }

finally { //不管什么情况都会执行，包括try catch 里面用了return ,可以理解为只要执行了try或者catch，就一定会执行 finally }

注意分析catch和finally里边有return的情况，若同时存在return语句，则返回finally中的return

2.下列叙述错误的是（ ）

• java程序的输入输出功能是通过流来实现的
• java中的流按照处理单位可分成两种：字节流和字符流
• InputStream是一个基本的输出流类。
• 通过调用相应的close（）方法关闭输入输出流

解析：java的输入流主要是InputStream和Reader作为基类，而输出流则是主要由outputStream和Writer作为基类。它们都是一些抽象基类，无法直接创建实例。

3.下面不是类及类成员的访问控制符的是(      )。（不考虑内部类的情况）

• public
• private
• static
• protected

解析：类访问控制符只有三种：public ，private， protected；static和访问控制无关

4.关于AOP错误的是？

• AOP将散落在系统中的“方面”代码集中实现
• AOP有助于提高系统可维护性
• AOP已经表现出将要替代面向对象的趋势
• AOP是一种设计模式，Spring提供了一种实现

解析：AOP和OOP都是一套方法论，也可以说成设计模式、思维方式、理论规则等等。
AOP不能替代OOP，OOP是obejct abstraction，而AOP是concern abstraction，前者主要是对对象的抽象，诸如抽象出某类业务对象的公用接口、报表业务对象的逻辑封装，更注重于某些共同对象共有行为的抽象，如报表模块中专门需要报表业务逻辑的封装，其他模块中需要其他的逻辑抽象 ，而AOP则是对分散在各个模块中的共同行为的抽象，即关注点抽象。一些系统级的问题或者思考起来总与业务无关又多处存在的功能，可使用AOP，如异常信息处理机制统一将自定义的异常信息写入响应流进而到前台展示、行为日志记录用户操作过的方法等，这些东西用OOP来做，就是一个良好的接口、各处调用，但有时候会发现太多模块调用的逻辑大都一致、并且与核心业务无大关系，可以独立开来，让处理核心业务的人专注于核心业务的处理，关注分离了，自然代码更独立、更易调试分析、更具好维护。
核心业务还是要OOP来发挥作用，与AOP的侧重点不一样，前者有种纵向抽象的感觉，后者则是横向抽象的感觉， AOP只是OOP的补充，无替代关系。

5.在socket编程中，可以使用方法（      ）获取本机的ip地址

• getInetAddress()
• getLocalAddress()
• getReuseAddress()
• getLocalPort()

解析：

getInetAddress获取主机名和IP地址

getLocalAddress()顾名思义，获取本地IP地址

getReuseAddress()返回布尔类型，表示复用地址

getLocalPort() API 的说明：“Returns the Internet Protocol (IP) port number of the interface on which the request was received. ”

6.如何跳出Array的forEach循环？（ ）

• break
• return true
• return false
• 以上都不是

解析：

break：跳出当前循环

return：从当前方法直接退出

continue：结束本次循环，进行下次循环（不会跳出循环）

7.

1	public interface IService {String NAME="default";}

默认类型等价表示是哪一项:（）

• public String NAME="default";
• public static String NAME="default";
• public static final String NAME="default";
• private String NAME="default";

解析：在interface里面的变量都是public static final 的。所以你可以这样写：
public static final int i=10;
或则
int i=10；（可以省略掉一部分）

注意在声明的时候要给变量赋予初值

解释：

首先你要弄清接口的含义.接口就是提供一种统一的’协议’,而接口中的属性也属于’协议’中的成员.它们是公共的,静态的,最终的常量.相当于全局常量.
抽象类是不’完全’的类,相当于是接口和具体类的一个中间层.即满足接口的抽象,也满足具体的实现.
如果接口可以定义变量，但是接口中的方法又都是抽象的，在接口中无法通过行为来修改属性。有的人会说了，没有关系，可以通过实现接口的对象的行为来修改接口中的属性。这当然没有问题，但是考虑这样的情况。如果接口A中有一个public访问权限的静态变量a。按照Java的语义，我们可以不通过实现接口的对象来访问变量a，通过A.a = xxx;就可以改变接口中的变量a的值了。正如抽象类中是可以这样做的，那么实现接口A的所有对象也都会自动拥有这一改变后的a的值了，也就是说一个地方改变了a，所有这些对象中a的值也都跟着变了。这和抽象类有什么区别呢，怎么体现接口更高的抽象级别呢，怎么体现接口提供的统一的协议呢，那还要接口这种抽象来做什么呢？所以接口中不能出现变量，如果有变量，就和接口提供的统一的抽象这种思想是抵触的。所以接口中的属性必然是常量，只能读不能改，这样才能为实现接口的对象提供一个统一的属性。

通俗的讲，你认为是要变化的东西，就放在你自己的实现中，不能放在接口中去，接口只是对一类事物的属性和行为更高层次的抽象。对修改关闭，对扩展（不同的实现implements）开放，接口是对开闭原则的一种体现。

8.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?

• I only
• II only
• III only
• I and II only
• I， II， and III

解析：

&& 运算时出现false时运算结果就判断为false

a != 3 && a != 4 && a != 5 && a != 6

a = 4;

因为a != 4 false 所以 结果false；

a = 6;

因为a != 6 false 所以 结果false；

a = 8;

因为a != 3  a != 4  a != 5  a != 6都为 ture 所以 结果true

所以

答案D

9.在开发中使用泛型取代非泛型的数据类型（比如用ArrayList取代ArrayList），程序的运行时性能会变得更好。（） 

• 正确
• 错误

解析：

使用泛型的好处：

1，类型安全。 泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。没有泛型，这些假设就只存在于程序员的头脑中（或者如果幸运的话，还存在于代码注释中）。

2，消除强制类型转换。 泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。

3，潜在的性能收益。 泛型为较大的优化带来可能。在泛型的初始实现中，编译器将强制类型转换（没有泛型的话，程序员会指定这些强制类型转换）插入生成的字节码中。但是更多类型信息可用于编译器这一事实，为未来版本的 JVM 的优化带来可能。由于泛型的实现方式，支持泛型（几乎）不需要 JVM 或类文件更改。所有工作都在编译器中完成，编译器生成类似于没有泛型（和强制类型转换）时所写的代码，只是更能确保类型安全而已。

所以泛型只是提高了数据传输安全性，并没有改变程序运行的性能

10.有如下一段代码，请选择其运行结果（）

1 2 3 4 5 6 7 8 9 10

public class StringDemo{   private static final String MESSAGE="taobao";   public static void main(String [] args) {     String a ="tao"+"bao";     String b="tao";     String c="bao";     System.out.println(a==MESSAGE);     System.out.println((b+c)==MESSAGE);   } }

• true true
• false false
• true false
• false true

解析：答案：C
要注意两个问题：
1，字符串在java中存储在字符串常量区中
2，==判断的是对象引用是否是同一个引用，判断字符串相等要用equals方法
首先判断a==MESSAGE 同一份字符串常量在内存中只有一份，因此是同一地址，返回true

再次比较(b+c)==MESSAGE 这相当于 new String(b+c)==MESSAGE 这里new了一个String对象，所以返回false

这里有个详细的解释过程：

对于这道题，考察的是对String类型的认识以及编译器优化。Java中String不是基本类型，但是有些时候和基本类型差不多，如String b =  "tao" ; 可以对变量直接赋值，而不用 new 一个对象（当然也可以用 new）。所以String这个类型值得好好研究下。

Java中的变量和基本类型的值存放于栈内存，而new出来的对象本身存放于堆内存，指向对象的引用还是存放在栈内存。例如如下的代码：

int  i=1;

    String s =  new  String( "Hello World" );

变量i和s以及1存放在栈内存，而s指向的对象”Hello World”存放于堆内存。

栈内存的一个特点是数据共享，这样设计是为了减小内存消耗，前面定义了i=1，i和1都在栈内存内，如果再定义一个j=1，此时将j放入栈内存，然后查找栈内存中是否有1，如果有则j指向1。如果再给j赋值2，则在栈内存中查找是否有2，如果没有就在栈内存中放一个2，然后j指向2。也就是如果常量在栈内存中，就将变量指向该常量，如果没有就在该栈内存增加一个该常量，并将变量指向该常量。

如果j++，这时指向的变量并不会改变，而是在栈内寻找新的常量（比原来的常量大1），如果栈内存有则指向它，如果没有就在栈内存中加入此常量并将j指向它。这种基本类型之间比较大小和我们逻辑上判断大小是一致的。如定义i和j是都赋值1，则i==j结果为true。==用于判断两个变量指向的地址是否一样。i==j就是判断i指向的1和j指向的1是同一个吗？当然是了。对于直接赋值的字符串常量（如String s=“Hello World”；中的Hello World）也是存放在栈内存中，而new出来的字符串对象（即String对象）是存放在堆内存中。如果定义String s=“Hello World”和String w=“Hello World”，s==w吗？肯定是true，因为他们指向的是同一个Hello World。

堆内存没有数据共享的特点，前面定义的String s =  new  String( "Hello World" );后，变量s在栈内存内，Hello World 这个String对象在堆内存内。如果定义String w = new  String( "Hello World" );，则会在堆内存创建一个新的String对象，变量w存放在栈内存，w指向这个新的String对象。堆内存中不同对象（指同一类型的不同对象）的比较如果用==则结果肯定都是false，比如s==w？当然不等，s和w指向堆内存中不同的String对象。如果判断两个String对象相等呢？用equals方法。

说了这么多只是说了这道题的铺垫知识，还没进入主题，下面分析这道题。 MESSAGE 成员变量及其指向的字符串常量肯定都是在栈内存里的，变量 a 运算完也是指向一个字符串“ taobao ”啊？是不是同一个呢？这涉及到编译器优化问题。对于字符串常量的相加，在编译时直接将字符串合并，而不是等到运行时再合并。也就是说

String a =  "tao" + "bao" ;和String a =  "taobao" ;编译出的字节码是一样的。所以等到运行时，根据上面说的栈内存是数据共享原则，a和MESSAGE指向的是同一个字符串。而对于后面的(b+c)又是什么情况呢？b+c只能等到运行时才能判定是什么字符串，编译器不会优化，想想这也是有道理的，编译器怕你对b的值改变，所以编译器不会优化。运行时b+c计算出来的"taobao"和栈内存里已经有的"taobao"是一个吗？不是。b+c计算出来的"taobao"应该是放在堆内存中的String对象。这可以通过System. out .println( (b+c)== MESSAGE );的结果为false来证明这一点。如果计算出来的b+c也是在栈内存，那结果应该是true。Java对String的相加是通过StringBuffer实现的，先构造一个StringBuffer里面存放”tao”,然后调用append()方法追加”bao”，然后将值为”taobao”的StringBuffer转化成String对象。StringBuffer对象在堆内存中，那转换成的String对象理所应当的也是在堆内存中。下面改造一下这个语句System. out .println( (b+c).intern()== MESSAGE );结果是true， intern() 方***先检查 String 池 ( 或者说成栈内存 ) 中是否存在相同的字符串常量，如果有就返回。所以 intern()返回的就是MESSAGE指向的"taobao"。再把变量b和c的定义改一下，

final  String b =  "tao" ;

         final  String c =  "bao"     

       System. out .println( (b+c)== MESSAGE );

现在b和c不可能再次赋值了，所以编译器将b+c编译成了”taobao”。因此，这时的结果是true。

在字符串相加中，只要有一个是非final类型的变量，编译器就不会优化，因为这样的变量可能发生改变，所以编译器不可能将这样的变量替换成常量。例如将变量b的final去掉，结果又变成了false。这也就意味着会用到StringBuffer对象，计算的结果在堆内存中。

    如果对指向堆内存中的对象的String变量调用intern()会怎么样呢？实际上这个问题已经说过了，(b+c).intern()，b+c的结果就是在堆内存中。对于指向栈内存中字符串常量的变量调用intern()返回的还是它自己，没有多大意义。它会根据堆内存中对象的值，去查找String池中是否有相同的字符串，如果有就将变量指向这个string池中的变量。

String a = "tao"+"bao";

       String b = new String("taobao")；

      System.out.println(a==MESSAGE); //true

      System.out.println(b==MESSAGE);  //false

      b = b.intern();

      System.out.println(b==MESSAGE); //true

System. out .println(a==a.intern());  //true

 

11.list是一个ArrayList的对象，哪个选项的代码填到//todo delete处，可以在Iterator遍历的过程中正确并安全的删除一个list中保存的对象？（）

1 2 3 4 5 6 7 8 9 10 11

Iterator it = list.iterator(); int index = 0; while (it.hasNext()) {     Object obj = it.next();     if (needDelete(obj))  //needDelete返回boolean，决定是否要删除     {         //todo delete     }     index ++; }

• it.remove();

• list.remove(obj);

• list.remove(index);

• list.remove(obj,index);

解析：Iterator  支持从源集合中安全地删除对象，只需在 Iterator 上调用 remove() 即可。这样做的好处是可以避免 ConcurrentModifiedException ，当打开 Iterator 迭代集合时，同时又在对集合进行修改。有些集合不允许在迭代时删除或添加元素，但是调用 Iterator 的remove() 方法是个安全的做法。

12.关于访问权限说法正确 的是 ？ ( )

• 外部类前面可以修饰public,protected和private
• 成员内部类前面可以修饰public,protected和private
• 局部内部类前面可以修饰public,protected和private
• 以上说法都不正确

解析：

	private	default	protected	public
同一个类中	√	√	√	√
同一个包中		√	√	√
子类中			√	√
全局范围内				√

（ 1 ）对于外部类而言，它也可以使用访问控制符修饰，但外部类只能有两种访问控制级别： public 和默认。因为外部类没有处于任何类的内部，也就没有其所在类的内部、所在类的子类两个范围，因此 private 和 protected 访问控制符对外部类没有意义。

（ 2 ）内部类的上一级程序单元是外部类，它具有 4 个作用域：同一个类（ private ）、同一个包（ protected ）和任何位置（ public ）。

（ 3 ） 因为局部成员的作用域是所在方法，其他程序单元永远不可能访问另一个方法中的局部变量，所以所有的局部成员都不能使用访问控制修饰符修饰。

13.

下列代码执行结果为（） public static void main(String args[])throws InterruptedException{             Thread t=new Thread(new Runnable() {                 public void run() {                     try {                         Thread.sleep(2000);                     } catch (InterruptedException e) {                         throw new RuntimeException(e);                     }                     System.out.print("2");                 }             });             t.start();                           t.join();             System.out.print("1");         }

• 21
• 12
• 可能为12，也可能为21
• 以上答案都不对

解析：因为子线程的休眠时间太长，因此主线程很有可能在子线程之前结束也就是输出结果是12，但是子线程用了join函数，因此主线程必须等待子线程执行完毕才结束因此输出结果只能是21。

join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。

14.URL u =new URL("http://www.123.com");。如果www.123.com不存在，则返回______。

• http://www.123.com
• ””
• null
• 抛出异常

解析：我们在执行URL u =new URL("http://www.123.com");这句话的时候确实要抛出异常，但是这个异常属于IOException，不管网址是否存在，最后都会返回该网址的一个连接，打印出来就是该网址。

15.假设 a 是一个由线程 1 和线程 2 共享的初始值为 0 的全局变量，则线程 1 和线程 2 同时执行下面的代码，最终 a 的结果不可能是（）

boolean isOdd = false;

for(int i=1;i<=2;++i)

{

if（i%2==1）isOdd = true；

else isOdd = false；

a+=i*(isOdd?1:-1)；

}

• -1
• -2
• 0
• 1

解析：假设两线程为A、B，设有3种情况：

1.AB不并发：此时相当于两个方法顺序执行。A执行完后a=-1，B使用-1作为a的初值，B执行完后a=-2
2.AB完全并发：此时读写冲突，相当于只有一个线程对a的读写最终生效。相同于方法只执行了一次。此时a=-1
3.AB部分并发：假设A先进行第一次读写，得到a=1;之后A的读写被B覆盖了。B使用用1作为a的初值，B执行完后a=0

16.关于Java和C/C++的比较，下列哪个描述是错误的？

• Java不支持指针，C/C++支持
• Java程序不需要显式地关心内存释放，而C/C++需要
• Java和C++一样，是纯编译型语言，因此它们的class都是在编译时静态联编(static binding)的
• Java数组、字符串不可能溢出，C/C++数组、字符串则有可能溢出边界

解析：

C，java不完全算是编译型语言，他编译的字节码文件运行时是解释执行的，其次，java和C++的类也不都完全是静态绑定的，比如C+++的虚函数，java的父类引用子类对象等情况。
D，java也可以数组溢出，溢出是会抛出异常，也就是ArrayIndexOutOfBoundsException

Java和C++的区别：
1. Java是解释型语言，所谓的解释型语言，就是源码会先经过一次编译，成为中间码，中间码再被解释器解释成机器码。对于Java而言，中间码就是字节码(.class)，而解释器在JVM中内置了。
2. C++是编译型语言，所谓编译型语言，就是源码一次编译，直接在编译的过程中链接了，形成了机器码。
3. C++比Java执行速度快，但是Java可以利用JVM跨平台。
4. Java是纯面向对象的语言，所有代码（包括函数、变量）都必须在类中定义。而C++中还有面向过程的东西，比如是全局变量和全局函数。
5. C++中有指针，Java中没有，但是有引用。
6. C++支持多继承，Java中类都是单继承的。但是继承都有传递性，同时Java中的接口是多继承，类对接口的实现也是多实现。
7. C++中，开发需要自己去管理内存，但是Java中JVM有自己的GC机制，虽然有自己的GC机制，但是也会出现OOM和内存泄漏的问题。C++中有析构函数，Java中Object的finalize方法
8. C++运算符可以重载，但是Java中不可以。同时C++中支持强制自动转型，Java中不行，会出现ClassCastException（类型不匹配）。

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

• static
• package
• private
• public

解析：

• 普通类（外部类）：只能用public、default（不写）、abstract、final修饰。
• （成员）内部类：可理解为外部类的成员，所以修饰类成员的public、protected、default、private、static等关键字都能使用。
• 局部内部类：出现在方法里的类，不能用上述关键词来修饰。
• 匿名内部类：给的是直接实现，类名都没有，没有修饰符。

18.java中关于继承的描述正确的是（）

• 一个子类只能继承一个父类
• 子类可以继承父类的构造方法
• 继承具有传递性
• 父类一般具有通用性，子类更具体

解析： 

子类构造器会默认调用super()(无论构造器中是否写有super（）),用于初始化父类成员，同时当父类中存在有参构造器时，必须提供无参构造器，子类构造器中并不会自动继承有参构造器，仍然默认调用super()，使用无参构造器。当父类中只有有参构造器时，默认在子类中需要使用super(父类构造器参数)才能调用父类的有参构造器，可以实现继承。
package struct;

class parent{
public parent(int a) {
System.out.println("我是父类构造方法"+a);
// TODO Auto-generated constructor stub
}

public void read(){
System.out.println("我是父类的方法");
}
}

public class Test extends parent{
public Test() {
super(3);
System.out.println("我是子类的构造方法");
super.read();
}
public static void main(String[] args) {
Test t = new Test();
}
}
输出为：
我是父类构造方法3
我是子类的构造方法
我是父类的方法

19.下列不是 Java 关键字的是 （ ）

• abstract
• false
• native
• sizeof

解析：（1）48个关键字：abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。（2）5个保留字（现在没用以后可能用到作为关键字）：goto、const，true、false、null。

20.Given the following code:

       import EnclosingOne.InsideOne

1 2 3 4 5 6 7 8 9 10 11 12 13 14

1.class Enclosingone 2.{ 3.    public class InsideOne {} 4. 5.} 6.public class inertest 7.{ 8.    public static void main(string[]args) 9.    { 10.        EnclosingOne eo = new EnclosingOne(); 11.        //insert code here 12.    } 13. 14.}

Which statement at line 11 constructs an instance of the inner class?

• InsideOne ei=eo.new InsideOne();
• eo.InsideOne ei=eo.new InsideOne();
• InsideOne ei=EnclosingOne.new InsideOne();
• EnclosingOne.InsideOne ei=eo.new InsideOne();

解析：第11行中的哪个语句构造了内部类的实例？

对于A答案 主要在开头添加 import EnclosingOne.Insider这一句，不然的话A肯定是错误，其他类不能够直接引用内部类的

21.与InputStream流相对应的Java系统的“标准输入对象”是（）

• System.in
• System.out
• System.err
• System.exit()

解析：A.标准输入 B.标准输出 C.错误输出 D.结束程序

22.（C#、JAVA）扩展方法能访问被扩展对象的public成员

• 能
• 不能

解析：简单来说就是子类能够访问父类的public方法，这肯定可以，只不过父类的private方法不能直接调用，可以在子类的构造方法中通过super关键字进行访问；

扩展方法——子类，被扩展方法——父类

23.在Java中，关于HashMap类的描述，以下错误的是（）？

• HashMap能够保证其中元素的顺序
• HashMap允许将null用作值
• HashMap允许将null用作键
• HashMap使用键/值得形式保存数据

解析：HashMap的底层是由数组加链表实现的，对于每一个key值，都需要计算哈希值，然后通过哈希值来确定顺序，并不是按照加入顺序来存放的，因此可以认为是无序的，但不管是有序还是无序，它都一个自己的顺序。故A错。

最开始有Hashtable，Hashtable是不允许key和value的值为空的，但后来开发者认为有时候也会有key值为空的情况，因为可以允许null为空，通过查看HashMap的源代码就知道：if(key = null) {putForNullKey(value);};

Map底层都是用key/value键值对的形式存放的

24.下面有个hibernate延迟加载，说法错误的是？

• Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）
• Hibernate3 提供了属性的延迟加载功能
• get支持延迟加载，load不支持延迟加
• hibernate使用Java反射机制，而不是字节码增强程序来实现透明性

解析：Hibernate 中 get()和load() 的区别：

1.get()采用立即加载方式,而load()采用 延迟加载 ; get()方法执行的时候,会立即向数据库发出查询语句, 而load()方法返回的是一个***(此***中只有一个id属性),只有等真正使用该对象属性的时候,才会发出 sql语句 

2.如果数据库中没有对应的记录,get()方法返回的是null.而load()方法出现异常ObjectNotFoundException

25.以下代码段执行后的输出结果为

1 2 3 4 5 6 7

public class Test { public static void main(String args[]) { int x = -5; int y = -12; System.out.println(y % x); } }

• -1
• 2
• 1
• -2

解析：Y(除数) % X(被除数) 当除数与被除数的符号相同时，取余和取模的结果是完全相同的； 当除数与被除数的符号不相同时，结果不同。

具体说，取余结果的符号与除数相同；取模结果的符号与被除数相同。 通常取模运算也叫取余运算，他们都遵循除法法则，返回结果都是余数；

当x和y的正负相同时，取余和取模结果相同；

当x和y的正负不同时，取余结果的符号和x相同，取模结果的符号和y相同。（口诀：取余取头，取模取尾）

1.取余 　　 rem(3,2)=1 　　 rem(-3,-2)=-1 　　 rem(3,-2)=1 　　 rem(-3,2)=-1 　　

2.取模 　　 mod(3,2)=1 　　 mod(-3,-2)=-1 　　 mod(3,-2)=-1 　　 mod(-3,2)=1

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

• final i;
• static int i;
• static final int  i=234;
• final float i=3.14f;

解析： 整型：int，常量：final，

27.关于ASCII码和ANSI码，以下说法不正确的是（）？

• 标准ASCII只使用7个bit
• 在简体中文的Windows系统中，ANSI就是GB2312
• ASCII码是ANSI码的子集
• ASCII码都是可打印字符

解析：

A、标准ASCII只使用7个bit，扩展的ASCII使用8个bit。

B、ANSI通常使用 0x00~0x7f 范围的1 个字节来表示 1 个英文字符。超出此范围的使用0x80~0xFFFF来编码，即扩展的ASCII编码。不同 ANSI 编码之间互不兼容。

在简体中文Windows操作系统中，ANSI 编码代表 GBK 编码；在繁体中文Windows操作系统中，ANSI编码代表Big5；在日文Windows操作系统中，ANSI 编码代表 Shift_JIS 编码。

C、ANSI通常使用 0x00~0x7f 范围的1 个字节来表示 1 个英文字符，即ASCII码

D、ASCII码包含一些特殊空字符

28.java8中，下面哪个类用到了解决哈希冲突的开放定址法

• LinkedHashSet
• HashMap
• ThreadLocal
• TreeMap

解析：ThreadLocalMap中使用开放地址法来处理散列冲突，而HashMap中使用的是分离链表法。之所以采用不同的方式主要是因为：在ThreadLocalMap中的散列值分散得十分均匀，很少会出现冲突。并且ThreadLocalMap经常需要清除无用的对象，使用纯数组更加方便。

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

• 初始态->运行态
• 就绪态->运行态
• 阻塞态->运行态
• 运行态->就绪态

解析：选AC，只有就绪态和运行态可以直接相互转换，其他都是单向的。

简易版：

30.类之间存在以下几种常见的关系：

• “USES-A”关系
• “HAS-A”关系
• “IS-A”关系
• “INHERIT-A”关系

解析：

use-a 是依赖关系

has-a   一般是组合关系

is-a   一般是继承关系   

 

31.队列(Queue)是先进先出的。（  ）

• 正确
• 错误

解析：可以这样理解： 1.队列：先进先出。很好理解就是排队。 2.栈：后进先出。就像堆放在桌子上的一碟碟盘子，最后放的，肯定是最先拿的。

32.final方法等同于private方法。（  ）

• 正确
• 错误

解析：private方法只可以在类的内部使用，在类外根本访问不到， 而final方法可以在类外访问，但是不可以重写该方法，就是说可以使用该方法的功能但是不可以改变其功能，这就是private方法和final方法的最大区别

33.下面代码运行结果是（）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

public class Test{      public int add(int a,int b){             try {              return a+b;                }          catch (Exception e) {               System.out.println("catch语句块");          }          finally{               System.out.println("finally语句块");          }          return 0;     }       public static void main(String argv[]){           Test test =new Test();           System.out.println("和是："+test.add(9, 34));       } }

• catch语句块
  和是：43

• 编译异常

• finally语句块
  和是：43

• 和是：43
  finally语句块

解析：先来看一段代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

public abstract class Test {     public static void main(String[] args) {         System.out.println(beforeFinally());     }           public static int beforeFinally(){         int a = 0;         try{             a = 1;             return a;         }finally{             a = 2;         }     } } /**output: 1 */

从结果上看，貌似`finally` 里的语句是在`return` 之后执行的，其实不然，实际上`finally` 里的语句是在在`return` 之前执行的。那么问题来了，既然是在之前执行，那为什么`a` 的值没有被覆盖了？
实际过程是这样的：当程序执行到try{}语句中的return方法时，它会干这么一件事，将要返回的结果存储到一个临时栈中，然后程序不会立即返回，而是去执行finally{}中的程序， 在执行`a = 2`时，程序仅仅是覆盖了a的值，但不会去更新临时栈中的那个要返回的值 。执行完之后，就会通知主程序“finally的程序执行完毕，可以请求返回了”，这时，就会将临时栈中的值取出来返回。这下应该清楚了，要返回的值是保存至临时栈中的。
再来看一个例子,稍微改下上面的程序：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

public abstract class Test {     public static void main(String[] args) {         System.out.println(beforeFinally());     }           public static int beforeFinally(){         int a = 0;         try{             a = 1;             return a;         }finally{             a = 2;             return a;         }     } } /**output: 2 */

在这里，finally{}里也有一个return，那么在执行这个return时，就会更新临时栈中的值。同样，在执行完finally之后，就会通知主程序请求返回了，即将临时栈中的值取出来返回。故返回值是2.

34.下面哪个不对？

• RuntimeException is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.
• 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
• An RuntimeException is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch.
• NullPointerException is one kind of RuntimeException

解析：RuntimeException是Throwable的子类，它指示一个合理的应用程序不应该试图捕捉的严重问题。运行时异常： 都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。

35.下面有关maven和ant的描述，描述错误的是？

• Ant 没有正式的约定如一个一般项目的目录结构，你必须明确的告诉 Ant 哪里去找源代码
• Maven 拥有约定，因为你遵循了约定，它已经知道你的源代码在哪里
• maven和ant都有“生命周期”的概念，当你输入一个命令后，maven或者ant会执行一系列的有序的步骤，直到到达你指定的生命周期
• Ant构建文件默认命名为build.xml，Maven默认构建文件为pom.xml

解析：Ant和Maven都是基于Java的构建(build)工具。理论上来说，有些类似于（Unix）C中的make ，但没有make的缺陷。Ant是软件构建工具，Maven的定位是软件项目管理和理解工具。
Ant特点 ：
没有一个约定的目录结构 ，必须明确让ant做什么，什么时候做，然后编译，打包 ，没有生命周期，必须定义目标及其实现的任务序列 ，没有集成依赖管理。
Maven特点：
拥有约定，知道你的代码在哪里，放到哪里去 ，拥有一个生命周期，例如执行 mvn install 就可以自动执行编译，测试，打包等构建过程 ，只需要定义一个pom.xml,然后把源码放到默认的目录，Maven帮你处理其他事情 ，拥有依赖管理，仓库管理。

36.对于子类的构造函数说明，下列叙述中错误的是（    ）。

• 子类可以继承父类的构造函数。
• 子类中调用父类构造函数不可以直接书写父类构造函数，而应该用super();。
• 用new创建子类的对象时，若子类没有带参构造函数，将先执行父类的无参构造函数，然后再执行自己的构造函数。
• 子类的构造函数中可以调用其他函数。

解析：A.java继承中对构造函数是不继承的，只是显式或者隐式调用。

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

• 程序计算器
• 方法区
• java虚拟机栈
• java堆

解析：私有线程区域：程序计数器、虚拟机栈、本地方法栈

   线程共享区域：堆、方法区

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

• java.servlet
• javax.servlet
• servlet.http
• javax.servlet.http

解析：JavaSE API里没有关于Servlet的包，JavaEE API里关于Servlet的全部包如图所示：

39.下面有关Java的说法正确的是（    ）

• 一个类可以实现多个接口
• 抽象类必须有抽象方法
• protected成员在子类可见性可以修改
• 通过super可以调用父类构造函数
• final的成员方法实现中只能读取类的成员变量
• String是不可修改的，且java运行环境中对string对象有一个对象池保存

解析：

1 2 3 4 5 6 7 8 9 10 11 12 13

抽象类能继承一个普通类（或抽象类），实现多个接口。     抽象类和普通类相比只是不能被实例化，只能作为子类的超类。     抽象类是用来捕捉子类的通用特性的，被用来创建继承层级里子类的模板。     可以有默认的方法实现。     抽象类可以有构造方法。     可以有main方法。     不必须有抽象方法，但是包含抽象方法的类一定是抽象类。       ===接口===     接口能实现多个其他接口。     接口是抽象方法的集合，一个类实现了某个接口就必须实现抽象方法。     接口抽象方法默认修饰符是public（可以不写），不能使用其他修饰符。     java 8中接口可以包含具体的方法实现，方法实现必须default修饰。

40.Hashtable 和 HashMap 的区别是：

• Hashtable 是一个哈希表，该类继承了 AbstractMap，实现了 Map 接口
• HashMap 是内部基于哈希表实现，该类继承AbstractMap，实现Map接口
• Hashtable 线程安全的，而 HashMap 是线程不安全的
• Properties 类 继承了 Hashtable 类，而 Hashtable 类则继承Dictionary 类
• HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。

解析：Hashtable：

（1）Hashtable 是一个散列表，它存储的内容是键值对(key-value)映射。

（2）Hashtable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为null。

（3）HashTable直接使用对象的hashCode。

HashMap：

（1）由数组+链表组成的，基于哈希表的Map实现，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的。

（2）不是线程安全的，HashMap可以接受为null的键(key)和值(value)。

（3）HashMap重新计算hash值

41.下面是findSum（int m.int n）方法的定义，方法调用findSum（1，5）的返回结果是( )

int findSum（int m, int n）{

    int sum=0；

    for（int i=m；i<=n；i++）{

        sum+=i；

    }

    return sum；

}

• 1
• 5
• 10
• 15

解析：for(i=1;i<=5;i++) 这样理解就好了，sum是1+2+3+4+5；

42.多重继承的概念在Java中实现是通过如下哪些？（）

I. 扩展两个或多个类

II. 扩展一个类并实现一个或多个接口。

III. 实现两个或更多接口。

• 只有I &II
• 只有II & III
• 只有III
• 都是

解析：Java只支持单继承，实现多重继承三种方式：（1）直接实现多个接口 （2）扩展(extends)一个类然后实现一个或多个接口  （3）通过内部类去继承其他类

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

1 2 3 4 5 6 7 8 9 10 11

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

• false，false
• false，true
• true，false
• true，true

解析：==可用于基本类型和引用类型：当用于基本类型时候，是比较值是否相同；当用于引用类型的时候，是比较对象是否相同。"=="和"!="比较的是地址 指第一个new()c出来的地址，所以因为两次new() 分出的内存也不同，所以，System.out.print(n1 == n2);返回 false，!=就返回true。

44.下面哪个不是标准Statement类？

• Statement
• PreparedStatement
• CallableStatement
• BatchedStatement

解析：Statement在JDBC中相当于SQL语句的载体

A，Statement是最基本的用法，采用字符串拼接的方式，存在注入漏洞

B，PreparedStatement对Statement中的SQL语句进行预编译，同时检查合法性，效率高

C，CallableStatement接口扩展 PreparedStatement，用来调用存储过程,它提供了对输出和输入/输出参数的支持。CallableStatement 接口还具有对 PreparedStatement 接口提供的输入参数的支持。

D，不是标准的Statement类

45.下列哪个修饰符可以使在一个类中定义的成员变量只能被同一包中的类访问？

• private
• 无修饰符
• public
• protected

解析：

名称	说明	备注
public	可以被任何类访问
protected	可以被同一包中的所有类访问 可以被所有子类访问	子类没有在同一包中也可以访问
private	只能够被当前类的方法访问
缺省 无访问修饰符	可以被同一包中的所有类访问	如果子类没有在同一个包中，也不能访问

 

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

• class中的constructor不可省略
• constructor必须与class同名，但方法不能与class同名
• constructor在一个对象被new时执行
• 一个class只能定义一个constructor

解析：

A 省略构造函数,编译器会自动生成。

D 构造函数可以重载

B 方法是可以和类名同名的，和构造方法唯一的区别就是，构造方法没有返回值。

47.下面哪一项不属于优化Hibernate所鼓励的？

• 使用单向一对多关联，不使用双向一对多
• 不用一对一，用多对一取代
• 配置对象缓存，不使用集合缓存
• 继承类使用显式多态

解析：A.使用单向一对多关联，不使用双向一对多

Hibernate鼓励使用双向一对多关联，不使用单向一对多关联。单向一对多关联映射是在one端维护关系的，必须先保存many端后才可以保存one端，所以在保存many端时该端不知道one端是否存在相应的数据，所以只能将维护的关系字段设置为null，如果为非空则无法保存。因为是one端维护关系，所以在保存one端时，会发出多余的update语句维护many端的外键关系。

48.以下表达式中，正确的是（）

• byte i=128
• boolean i=null
• long i=0xfffL
• double i=0.9239d

解析：A、128会视为int型，赋值给byte时要强转 ，byte ，1字节，值域-128至127 ；

B、boolean为基本类型，null只能赋值给引用类型，null表示没有地址；null可以赋值给引用变量，不能将null赋给基本类型变量，例如int、double、float、boolean；

C、十六进制，l、L表示long类型 D、d、D表示double。

49.下列关于while循环、do-while循环和for循环说法错误的是

• while循环先执行条件判断，do-while循环执行循环体
• do-while循环结束的条件是关键字while后的条件表达式成立
• for循环结构中的3个表达式缺一不可
• while循环能够实现的操作，for循环也能实现

解析：B，正确答案是：do-while循环结束的条件是关键字while后的判断语句不成立

50.下述有关c++的虚类和java接口的描述，说法错误的是？

• c++虚类相当与java里面的抽象类
• c++中没有接口的概念，与之对应的是纯虚类，对应的是java的接口
• 纯虚函数和虚函数的区别在于前者只包含定义，而后者还可以包含函数体。
• 一个抽象类和接口中的方法必须是抽象方法

解析：C选项也是错的。纯虚函数也可以定义。

D：1、一个子类只能继承一个抽象类（虚类），但能实现多个接口；

2、一个抽象类可以有构造方法，接口没有构造方法；

3、一个抽象类中的方法不一定是抽象方法，即其中的方法可以有实现（有方法体），接口中的方法都是抽象方法，不能有方法体，只有声明；

4、一个抽象类可以是public、private、protected、default, 接口只有public;

5、一个抽象类中的方法可以是public、private、protected、default， 接口中的方法只能是public和default

51.如果希望某个变量只可以被类本身访问和调用，则应该使用下列哪一种访问控制修饰？

• public
• private
• private protected
• protected

解析：

52.已知int a[]=new int[10]，则下列对数组元素的访问不正确的是（）

• a[0]
• a[1]
• a[9]
• a[10]

解析：数组的角标是从0开始的。从arr[0]到arr[arr.length-1]。

53.以下代码在编译和运行过程中会出现什么情况

1 2 3 4 5 6 7 8 9 10

public class TestDemo{     private int count;     public static void main(String[] args) {         TestDemo test=new TestDemo(88);         System.out.println(test.count);     }      TestDemo(int a) {          count=a;     } }

• 编译运行通过，输出结果是88
• 编译时错误，count变量定义的是私有变量
• 编译时错误，System.out.println方法被调用时test没有被初始化
• 编译和执行时没有输出结果

解析：private是私有变量，只能用于当前类中，题目中的main方法也位于当前类，所以可以正确输出。

54.明朝时期张居正改革的一条鞭法的主要思想是()

• 面向过程
• 万物皆数
• 统一接口
• 泛型编程

解析：一条鞭法的主要思想是“税以银征收”，取消了原本的田赋、力役和其他杂税，促进自然经济的瓦解和商品经济的发展。面向过程是指以过程为中心的编程思想，形成模块化特点。万物皆数是毕达哥拉斯学派的数学哲学理念（特指有理数），属于世界观的一种。泛型编程是一种语言机制，能够帮助实现一个通用的标准容器库。所谓通用的标准容器库，就是要能够做到，比如用一个List类存放所有可能类型的对象这样的事；泛型编程让你编写完全一般化并可重复使用的算法，其效率与针对某特定数据类型而设计的算法相同。泛型即是指具有在多种数据类型上皆可操作的含意，与模板有些相似。一条鞭法的主要思想并不是以征税过程为中心的思想，同时也不是在多种类型上的操作。

55.Which of the following can be applied to constructors:

• final
• static
• synchronized
• native
• None of these.

解析：下列哪一项可以应用于构造函数？

识别合法的构造方法；

1.构造方法可以被重载，一个构造方法可以通过this关键字调用另一个构造方法，this语句必须位于构造方法的第一行；重载：方法的重载(overload)：重载构成的条件：方法的名称相同，但参数类型或参数个数不同，才能构成方法的重载。

2.当一个类中没有定义任何构造方法，Java将自动提供一个缺省构造方法；

3.子类通过super关键字调用父类的一个构造方法；

4.当子类的某个构造方法没有通过super关键字调用父类的构造方法，通过这个构造方法创建子类对象时，会自动先调用父类的缺省构造方法

5.构造方法不能被static、final、synchronized、abstract、native修饰，但可以被public、private、protected修饰；

6.构造方法不是类的成员方法；

7.构造方法不能被继承。

56.JSP分页代码中，哪个步骤次序是正确的？

• 先取总记录数，得到总页数，最后显示本页的数据。
• 先取所有的记录，得到总页数，再取总记录数，最后显示本页的数据。
• 先取总页数，得到总记录数，再取所有的记录，最后显示本页的数据。
• 先取本页的数据，得到总页数，再取总记录数，最后显示所有的记录。

解析：

1、count(*)得到总记录数

2、计算总页数

3、获取所有记录(这一步不需要，可以直接获取指定页数数据)

4、过滤显示本页数据

57.下列不属于Java语言性特点的是（）

• Java致力于检查程序在编译和运行时的错误
• Java能运行虚拟机实现跨平台
• Java自己操纵内存减少了内存出错的可能性
• Java还实现了真数组，避免了覆盖数据类型的可能

解析：Java致力于检查程序在编译和运行时的错误。
Java虚拟机实现了跨平台接口
类型检查帮助检查出许多开发早期出现的错误。
Java自己操纵内存减少了内存出错的可能性。
Java还实现了真数组，避免了覆盖数据的可能。
注意，是避免数据覆盖的可能，而不是数据覆盖类型

58.下面这段java代码，当 T 分别是引用类型和值类型的时候，分别产生了多少个T对象和T类型的值（）
T t = new T();(值类型时:T t;)
Func(t);
Func 定义如下：
public void Func(T t) {  }

• 1  1
• 2  1
• 2  2
• 1  2

解析：D。引用类型作为函数的参数时，复制的是引用的地址，不会产生一个新的T；而如果T是值类型，其作为函数实参时会复制其值，也就是产生了一个新的T。所以D选项正确。

59.面向对象程序设计方法的优点包含：（）

• 可重用性
• 可扩展性
• 易于管理和维护
• 简单易懂

60.下面哪项技术可以用在WEB开发中实现会话跟踪实现？（）

• session
• Cookie
• 地址重写
• 隐藏域

解析：会话跟踪是一种灵活、轻便的机制，它使Web上的状态编程变为可能。
HTTP是一种无状态协议，每当用户发出请求时，服务器就会做出响应，客户端与服务器之间的联系是离散的、非连续的。当用户在同一网站的多个页面之间转换时，根本无法确定是否是同一个客户，会话跟踪技术就可以解决这个问题。当一个客户在多个页面间切换时，服务器会保存该用户的信息。
有四种方法可以实现会话跟踪技术：URL重写、隐藏表单域、Cookie、Session。
1）隐藏表单域：，非常适合步需要大量数据存储的会话应用。
2）URL 重写:URL 可以在后面附加参数，和服务器的请求一起发送，这些参数为名字/值对。
3）Cookie:一个 Cookie 是一个小的，已命名数据元素。服务器使用 SET-Cookie 头标将它作为 HTTP响应的一部分传送到客户端，客户端被请求保存 Cookie 值，在对同一服务器的后续请求使用一个Cookie 头标将之返回到服务器。与其它技术比较，Cookie 的一个优点是在浏览器会话结束后，甚至在客户端计算机重启后它仍可以保留其值。
4）Session：使用 setAttribute(String str,Object obj)方法将对象捆绑到一个会话。

61. 设Tree为已定义的类名，下列语句能正确创建 Tree 对象的是 。（）

• Tree t=new Tree;
• Tree t=new Tree();
• Tree t=Tree();
• Tree t[ ]=new Tree[10];

解析：总结：

A: 少括号

B: 正确（但是要前提，Tree类中存在无参构造器，并且是public的。如果Tree中存在有参构造器且无参构造器不存在或者无参构造器为private的话，选B也是错误的）

C: 缺少new，没有创建新的对象

D:题中创建的是数组对象，而不是Tree对象。

62.通过HttpServletRequest. getParameter获取的参数.（）

• 总是采用UTF-8编码
• 总是采用lS08859-1编码
• 由客户端浏览器和Web容器配置共同决定编码
• 由服务器所在的操作系统决定编码

解析：

1、浏览器根据jsp页面开头声明的编码方式对request中参数编码；

2、tomcat默认解码是ISO-8859-1， 但是我们可以显示指定解码格式通过调用 request.setCharacterEncoding("UTF-8")，或者修改tomcat的配置文件server.xml中的编码，添加uriEncoding属性。

63.以下关于集合类ArrayList、LinkedList、HashMap描述错误的是（）

• HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值
• ArrayList和LinkedList均实现了List接口
• 添加和删除元素时，ArrayList的表现更佳
• ArrayList的访问速度比LinkedList快

解析： 

1. List 是一个有序集合，可以存放重复的数据 (有序：存进是什么顺序，取出时还是什么顺序)
                (1).ArrayList 底层是数组适合查询，不适合增删元素。
                (2).LinkedList 底层是双向链表适合增删元素，不适合查询操作。
                (3).Vector 底层和ArrayList相同，但是Vector是线程安全的，效率较低很少使用

2. Set 是一个无序集合，不允许放重复的数据 (无序不可重复，存进和取出的顺序不一样)
                (1).HashSet 底层是哈希表/散列表
                (2).TreeSet 继承sartedSet接口（无需不可重复，但存进去的元素可以按照元素的大小自动排序）

3. Map 是一个无序集合，以键值对的方式存放数据，键对象不允许重复，值对象可以重复。

                (1).HashMap实现不同步，线程不安全。  HashTable线程安全

                (2).HashMap中的key-value都是存储在Entry中的。

                (3).HashMap可以存null键和null值，不保证元素的顺序恒久不变，它的底层使用的是数组和链表，通过hashCode()方法和equals方法保证键的唯一性

64.当你编译和运行下面的代码时，会出现下面选项中的哪种情况？

1 2 3 4 5 6

public class Pvf{     static boolean Paddy;     public static void main(String args[]){         System.out.println(Paddy);     } }

• 编译时错误
• 编译通过并输出结果false
• 编译通过并输出结果true
• 编译通过并输出结果null

解析:类中声明的变量有默认初始值；方法中声明的变量没有默认初始值，必须在定义时初始化，否则在访问该变量时会出错。

boolean类型默认值是false

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

What is the result?

• ABDCBDCB
• ABCDABCD
• Compilation fails.
• An exception is thrown at runtime.

解析：for(条件1;条件2;条件3) {

    //语句

}

执行顺序是条件1->条件2->语句->条件3->条件2->语句->条件3->条件2........

如果条件2为true，则一直执行。如果条件2位false，则for循环结束

66.下面程序的运行结果：()

1 2 3 4 5 6 7 8 9 10 11 12 13

public static void main(String args[]) {         Thread t=new Thread(){         public void  run(){             dianping();                       }     };     t.run();     System.out.print("dazhong");     }     static void dianping(){         System.out.print("dianping"); }

• dazhongdianping
• dianpingdazhong
• a和b都有可能
• dianping循环输出，dazhong夹杂在中间

解析：在上面main()方法中，并没有创建一个新的线程，只是简单地方法调用而已，如果想要创建线程，需要t.start();创建线程，等待cpu时间片，而run()方法只是简单地方法调用，所以先执行run()，再输出dazhong

67.如下代码的 结果是什么 ?

1 2 3 4 5 6 7 8 9 10 11 12

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

• Base
• BaseBase
• 编译失败
• 代码运行但没有输出
• 运行时抛出异常

解析：在执行new Alpha()时，会先执行父类的构造方法，再执行相应的子类的构造方法，所以此处会打印Base，在执行new Base()时，会直接执行Base中无参构造器的代码，再输出Base，

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

• Servlet对象
• HTTP服务器
• Web容器
• JSP网页

解析：web容器是一种服务程序，在服务器一个端口就有一个提供相应服务的程序，而这个程序就是处理从客户端发出的请求，如JAVA中的Tomcat容器，ASP的IIS或PWS都是这样的容器。一个服务器可以多个容器。

69.Gadget has-a Sprocket and Gadget has-a Spring and Gadget is-a Widget and Widget has-a Sprocket 以下哪两段代码可以表示这个关系? (选择两项) (    )

• class Widget { Sprocket s; }
  class Gadget extends Widget { Spring s; }

• class Widget { }
  class Gadget extends Widget { Spring s1; Sprocket s2; }

• class Widget { Sprocket s1; Spring s2; }
  class Gadget extends Widget { }

• class Gadget { Spring s; }
  class Widget extends Gadget{ Sprocket s; }

解析：

is-a   表示继承：Gadget is-a Widget就表示Gadget 继承 Widget；

has-a表示从属：Gadget has-a Sprocket就表示Gadget中有Sprocket的引用，Sprocket是Gadget的组成部分；

like-a表示组合：如果A like-a B，那么B就是A的接口

由题意可知：

Gadget是子类，有Spring和Sprocket的引用

Widget是父类，有Sprocket的引用。

70.Java类Demo中存在方法func0、func1、func2、func3和func4，请问该方法中，哪些是不合法的定义？( )

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

public class Demo{ 　　float func0() 　　{ 　　　　byte i=1; 　　　　return i; 　　} 　　float func1() 　　{ 　　　　int i=1; 　　　　return; 　　} 　　float func2() 　　{ 　　　　short i=2; 　　　　return i; 　　} 　　float func3() 　　{ 　　　　long i=3; 　　　　return i; 　　} 　　float func4() 　　{ 　　　　double i=4; 　　　　return i; 　　} }

• func1
• func2
• func3
• func4

解析：这道题考的是数据类型转换问题。由大到小需要强制转换，由小到大不需要。

A：return;   没有返回值，错误

B：short → float 无须强制转换，正确

C：long → float  无须强制转换（这个最选项容易出错），正确。

float占4个字节为什么比long占8个字节大呢，因为底层的实现方式不同。

浮点数的32位并不是简单直接表示大小，而是按照一定标准分配的。

第1位，符号位，即S

接下来8位，指数域，即E。

剩下23位，小数域，即M，取值范围为[1 ,2 ) 或[0 , 1)

然后按照公式： V=(-1)^s * M * 2^E

也就是说浮点数在内存中的32位不是简单地转换为十进制，而是通过公式来计算而来，通过这个公式虽然，只有4个字节，但浮点数最大值要比长整型的范围要大。

D：double → float 没有强制转换，错误。

据类型的转换，分为自动转换和强制转换。自动转换是程序在执行过程中 “ 悄然 ” 进行的转换，不需要用户提前声明，一般是从位数低的类型向位数高的类型转换；强制类型转换则必须在代码中声明，转换顺序不受限制。

自动数据类型转换

自动转换按从低到高的顺序转换。不同类型数据间的优先关系如下：
低 ---------------------------------------------> 高
byte,short,char-> int -> long -> float -> double

运算中，不同类型的数据先转化为同一类型，然后进行运算，转换规则如下：

操作数 1 类型	操作数 2 类型	转换后的类型
byte 、 short 、 char	int	int
byte 、 short 、 char 、 int	long	long
byte 、 short 、 char 、 int 、 long	float	float
byte 、 short 、 char 、 int 、 long 、 float	double	double

强制数据类型转换

强制转换的格式是在需要转型的数据前加上 “( )” ，然后在括号内加入需要转化的数据类型。有的数据经过转型运算后，精度会丢失，而有的会更加精确

71.若有定义：byte[]x={11,22,33,﹣66}；其中0≤k≤3，则对x数组元素错误的引用是（）

• x[5-3]
• x[k]
• x[k+5]
• x[0]

解析：

A: x[5-3]，小标为2 √

B: x[k], k的范围0~3 √

C: x[k+5], 小标范围为5~8 越界×

D: x[0], 小标为0 √

72.java语言中的数组元素下标总是从0开始，下标可以是整数或整型表达式。（）

• 正确
• 错误

解析：例如平时有这样的用法

for(int i=0;i<10;i++){

    a[i+1]=a[i]

}

这个i+1就是整数型表达式  或者a[5+3]就是a[8]

73.关于抽象类和接口叙述正确的是？ ( )

• 抽象类和接口都能实例化的
• 抽象类不能实现接口
• 抽象类方法的访问权限默认都是public
• 接口方法的访问权限默认都是public

解析：抽象类特点:
1.抽象类中可以构造方法
2.抽象类中可以存在普通属性，方法，静态属性和方法。
3.抽象类中可以存在抽象方法。
4.如果一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法。
5.抽象类中的抽象方法，需要有子类实现，如果子类不实现，则子类也需要定义为抽象的。
6,抽象类不能被实例化，抽象类和抽象方法必须被abstract修饰

关键字使用注意：
抽象类中的抽象方法（其前有abstract修饰）不能用private、static、synchronized、native访问修饰符修饰。

接口特点：

1.在接口中只有方法的声明，没有方法体。
2.在接口中只有常量，因为定义的变量，在编译的时候都会默认加上public static final
3.在接口中的方法，永远都被public来修饰。
4.接口中没有构造方法，也不能实例化接口的对象。（所以接口不能继承类）
5.接口可以实现多继承
6.接口中定义的方法都需要有实现类来实现，如果实现类不能实现接口中的所有方法则实现类定义为抽象类。
7，接口可以继承接口，用extends

74.下列说法正确的有（）

• 数组是一种对象
• 数组属于一种原生类
• int number=[]={31,23,33,43,35,63}
• 数组的大小可以任意改变

75.下面关于垃圾收集的说法正确的是（）

• 一旦一个对象成为垃圾，就立刻被收集掉。
• 对象空间被收集掉之后，会执行该对象的finalize方法
• finalize方法和C++的析构函数是完全一回事情
• 一个对象成为垃圾是因为不再有引用指着它，但是线程并非如此

解析：B：对象空间被收集前执行finalize（）方法，而不是对象空间被收集之后再执行，如果这样的话执行finalize（）就没有意义了。

76.默认RMI采用的是什么通信协议？

• HTTP
• UDP/IP
• TCP/IP
• Multicast

解析：因为RMI，全称Remote Method Invocation，意思是远程方法调用，如果只知道Mac地址那就没法玩了，需要知道IP地址，所以采用的网际层以上的协议，而应用层的协议层次又太高了，的比如HTTP。剩下的也就只有TCP/IP协议了。RMI采用的是TCP/IP协议

77.下面有关webservice的描述，错误的是？

• Webservice是跨平台，跨语言的远程调用技术
• Webservice通信机制实质就是json数据交换
• Webservice采用了soap协议（简单对象协议）进行通信
• WSDL是用于描述 Web Services 以及如何对它们进行访问

解析：Webservice是跨平台，跨语言的远程调用技术;

它的通信机制实质就是xml数据交换;
它采用了soap协议（简单对象协议）进行通信

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

• equals(Object obj) 指示某个其他对象是否与此对象“相等”
• copy() 创建并返回此对象的一个副本
• wait() 导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法
• toString() 返回该对象的字符串表示

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

79.在java中，下列对继承的说法，正确的是（ ）

• 子类能继承父类的所有成员
• 子类继承父类的非私有方法和状态
• 子类只能继承父类的public方法和状态
• 子类只能继承父类的方法

解析：

1：如果父类中的成员使用public修饰，子类无条件继承。
2：如果父类中的成员使用protected修饰，子类也继承，即使父类和子类不在同一个包中。
3：如果父类和子类在同一个包中，此时子类可以继承父类中 缺省修饰符的成员。
4：如果父类中的成员使用private修饰，子类打死也都继承不到。private只能在本类中访问。
5：父类的构造器，子类也不能继承，因为构造器必须和当前的类名相同。

6：父类的方法使用final修饰，子类可以继承，但不可重写

7：如果一个类使用final修饰，则不可以继承

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

• 数组是一个对象，不同类型的数组具有不同的类
• 数组长度是可以动态调整的
• 数组是一个连续的存储结构
• 一个固定长度的数组可类似这样定义：int array[100]
• 两个数组用Object 里equals方法比较时，会逐个遍历其中的元素，对每个元素进行比较
• java中不存在 int *a这样的东西做数组的形参

解析：E：明显是错误的，数组用equals比较时，不是比较内容，而是比较的是值（地址，显然是两个对象，地址不同），默认采用的object中的equals来进行比较，看源码的都知道。

81.判断对错。List，Set，Map都继承自继承Collection接口。

• 对
• 错

解析：

82.在 Applet 中，方法执行的顺序是 ?（ ）

• init(), start(), paint(),stop(),destroy().
• init(),paint(),start(),stop(),destroy().
• paint(),start(),stop(),destroy().
• init(), start(),stop(),destroy(),paint().

解析：init 初始化，start启动运行，paint 窗口最小化等时候需要暂停，stop 停止，destory 销毁;

83.

1 2 3 4 5 6 7 8 9 10 11 12

public class Test{     static int cnt = 6;     static{         cnt += 9;     } public static void main(String[] args）{     System.out.println（“cnt =” + cnt); } static{     cnt /=3;     }; }

cnt的值是（）

• cnt=5
• cnt=2
• cnt=3
• cnt=6

解析：

（1）父类静态成员和静态初始化块，按在代码中出现的顺序依次执行。

（2）子类静态成员和静态初始化块，按在代码中出现的顺序依次执行。

（3）父类实例成员和实例初始化块，按在代码中出现的顺序依次执行。

（4）执行父类构造方法。

（5）子类实例成员和实例初始化块，按在代码中出现的顺序依次执行。

（6）执行子类构造方法。

 

初始化顺序：

1.先父类，后子类

2.先属性，后构造函数

3.先静态，后非静态

4.静态属性和静态代码块，谁在前面先执行谁

5.同一类型（非数据类型，指以上），按代码先后顺序

84.下列方法定义中 ， 正确 的是 （）

• int x( ){ char ch=’a’; return (int)ch; }
• void x( ){ ...return true; }
• int x( ){ ...return true; }
• int x( int a, b){ return a+b; }

解析：

A.Java中涉及到byte、short和char类型都可以强制转化为int，符合返回类型 A正确

B.方法中定义为void 应该没有返回值，但返回值为boolean类型 B错

C. 方法中类型为int，应该返回int类型值，但是 返回值为boolean类型 C错 

D.方法应该定义为int(int a,int b)，所以D错

85.看以下代码：
文件名称：forward.jsp

1 2 3 4 5 6

<html>        <head><title> 跳转  title> head>       <body>            <jsp:forward page="index.htm"/>           body>  html>

如果运行以上jsp文件，地址栏的内容为

• http://127.0.0.1:8080/myjsp/forward.jsp
• http://127.0.0.1:8080/myjsp/index.jsp
• http://127.0.0.1:8080/myjsp/index.htm
• http://127.0.0.1:8080/myjsp/forward.htm

解析：

forward和redirect是最常问的两个问题

forward，服务器获取跳转页面内容传给用户，用户地址栏不变，举例：你把钱包落在出租车上，你去警察局（forward.jsp）报案，警察局说钱包落在某某公司的出租车上（index.html)，这时你不用亲自去找某某公司的出租车,警察局让出租车自己给你送来，你只要在警察局等就行。所以地址栏不变，依然为forward.jsp

redirect，是服务器向用户发送转向的地址，redirect后地址栏变成新的地址

因此这个题是A

86.类Parent和Child定义如下：

1 ．class  Parent{ 2.         public  float  aFun(float a, float b) { } 3 ．} 4 ．class  Child  extends  Parent{ 5 ． 6 ．}

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

• float aFun(float  a,  float  b){ }
• public int aFun(int a, int b) { }
• public float aFun(float  p,  float q){ }
• private int aFun(int a,  int  b){ }

解析：

A.方法重写(覆盖)。子类方法不能缩小父类方法的访问权限，错误。

B.方法重载。参数列表不同，满足重载条件，正确。

C.方法重写(覆盖)。方法声明和父类相同，满足重写条件，正确。

D.方法重载。参数列表不同，满足重载条件，正确。

87.off-heap是指那种内存（）

• JVM GC能管理的内存

• JVM进程管理的内存

• 在JVM老年代内存区

• 在JVM新生代内存

解析：off-heap叫做堆外内存，将你的对象从堆中脱离出来序列化，然后存储在一大块内存中，这就像它存储到磁盘上一样，但它仍然在RAM中。对象在这种状态下不能直接使用，它们必须首先反序列化，也不受垃圾收集。序列化和反序列化将会影响部分性能（所以可以考虑使用FST-serialization）使用堆外内存能够降低GC导致的暂停。堆外内存不受垃圾收集器管理，也不属于老年代，新生代。

88.Java的体系结构包含（    ）。

• Java编程语言
• Java类文件格式
• Java API
• JVM

解析：Java体系结构包括四个独立但相关的技术：

• Java程序设计语言
• Java.class文件格式
• Java应用编程接口（API）
• Java虚拟机

我们再在看一下它们四者的关系：

    当我们编写并运行一个Java程序时，就同时运用了这四种技术，用Java程序设计语言编写源代码，把它编译成Java.class文件格式，然后再在Java虚拟机中运行class文件。当程序运行的时候，它通过调用class文件实现了Java API的方法来满足程序的Java API调用

89.程序中常采用变量表示数据，变量具有名、地址、值、作用域、生存期等属性。关于变量的叙述，（）是正确的。

• 根据作用域规则，在函数中定义的变量只能在函数中引用
• 在函数中定义的变量，其生存期为整个程序执行期间
• 在函数中定义的变量不能与其所在函数的形参同名
• 在函数中定义的变量，其存储单元在内存的栈区

解析：B：局部变量在函数内部或循环内部，随函数的退出或循环退出就不存在了

90.Consider the following code:

1 2 3

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

Which test would return true?

• (s==u)

• (s==t)

• (s.equals(t))

• (s.equals(9))

• (s.equals(new Integer(9))

解析：

• int和int之间，用==比较，肯定为true。基本数据类型没有equals方法
• int和Integer比较，Integer会自动拆箱，== 和 equals都肯定为true
• int和new Integer比较，Integer会自动拆箱，调用intValue方法, 所以 == 和 equals都肯定为true

• Integer和Integer比较的时候，由于直接赋值的话会进行自动的装箱。所以当值在[-128,127]中的时候，由于值缓存在IntegerCache中，那么当赋值在这个区间的时候，不会创建新的Integer对象，而是直接从缓存中获取已经创建好的Integer对象。而当大于这个区间的时候，会直接new Integer。
  当Integer和Integer进行==比较的时候，在[-128,127]区间的时候，为true。不在这个区间，则为false
  当Integer和Integer进行equals比较的时候，由于Integer的equals方法进行了重写，比较的是内容，所以为true

• Integer和new Integer ： new Integer会创建对象，存储在堆中。而Integer在[-128,127]中，从缓存中取，否则会new Integer.
  所以 Integer和new Integer 进行==比较的话，肯定为false ; Integer和new Integer 进行equals比较的话，肯定为true

• new Integer和new Integer进行==比较的时候，肯定为false ; 进行equals比较的时候，肯定为true
  原因是new的时候，会在堆中创建对象，分配的地址不同，==比较的是内存地址，所以肯定不同

• 装箱过程是通过调用包装器的valueOf方法实现的
  拆箱过程是通过调用包装器的xxxValue方法实现的（xxx表示对应的基本数据类型）

• 总结：Byte、Short、Integer、Long这几个类的valueOf方法实现类似的。所以在[-128,127]区间内，==比较的时候，值总是相等的（指向的是同一对象），在这个区间外是不等的。
  而Float和Double则不相等， Boolean的值总是相等的

 

在这里， s 和 t 都是 Integer 类型且值都为 9 ，因此结果为真。

(s.equals(9)) , 在进行 equals 比较之前，会对 9 调用 Integer.valueOf 方法，进行自动装箱 , 由于 IntegerCache 中已经存在 9 ，所以，直接返回其引用，引用相同， equals 就自然相同了。所以结果为真。

(s.equals( new Integer(9)) ，直接创建了一个新的 Integer 实例，但且值也为 9 ，所以，满足条件，返回真。

91.this代表了()的对象引用,super表示的是当前对象的()对象?

• 当前类 当前类
• 当前类的父类 当前类
• 当前类  当前类的父类
• 以上都不正确

解析：this代表当前对象，也就是当前类的对象的引用；super代表其父类对象

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

• 不同的形参名称
• 不同的返回值类型
• 不同的形参列表
• 不同的访问权限

解析：

重载：

1. 编译时的多态；

2. 重载发生在同一个类中；

3. 函数名相同，参数列表不同(参数的类型，顺序，个数 和参数名没有关系)  和方法的返回值类型无关   (因为编译器 并不知道 调用哪一个函数)；

4. 可以抛出不同的异常，可以有不同修饰符。

重写：

1. 运行时的多态；

2. 重载发生在子类与父类中；

3. 遵循两同两小一大： 

            两同：

                        函数名相同

                        参数列表相同

            两小：

                        子类被重写方法的返回值类型小于父类被重写方法的返回值

                        子类被重写方法抛出异常的类型小于父类被重写方法抛出异常的类型

            一大：

                        子类被重写方法的访问权限大于等于父类被重写方法的访问权限

     4.构造方法不能被重写，声明为 final 的方法不能被重写，声明为 static 的方法不能被重写（隐藏），但是能够被再次声明，父类的私有方法，子类可以继承 但是子类不能访问，子类不能重写父类的私有方法。

93.枚举（enum）属于原始数据类型（primitive type）。

• 正确

• 错误

解析：在Java中，变量有两种类型，一种是原始类型，一种是引用类型。

原始类型一共有8种，它们分别是char,boolean,byte,short,int,long,float,double。在Java API中，有它们对应的包装类，分别是(首字母大写)Character,Boolean,Byte,Short,Integer,Long,Float,Double(char,int的变化稍微大点)。

JAVA JVM对于不同的原始类型会分配不同的存储空间，具体分配如下：

byte  : 1个字节    8位                              最大值: 127   (有符号)

short : 2个字节    16位                            32767

int :     4个字节    32位                            2147483647

long:   8个字节    64位                            9223372036854775807

float:   4个字节    32位                            3.4028235E38

double:8个字节   64位                            1.7976931348623157E308

枚举（enum）类型是Java 5新增的特性，它是一种新的类型，允许用常量来表示特定的数据片断，而且全部都以类型安全的形式来表示，是特殊的类，可以拥有成员变量和方法。

94.在 main() 方法中给出的字节数组，如果将其显示到控制台上，需要（ ）。

• 标准输出流System.out.println()。
• 建立字节输出流。
• 建立字节输入流。
• 标准输入流System.in.read()。

解析：

• 标准输出流System.out.println()。out是java.io.PrintStream类的对象，而println()是java.io.PrintStream类里的一个方法，它的作用就是用来在控制台输出信息的。

• 标准输入流System.in.read()，一次只能读取一个字符，返回输入字符的ASCII码

95.关于下面程序，哪些描述是正确的: (  )

1 2 3 4 5 6 7 8 9

public class While { public void loop() { int x= 10; while ( x )  { System.out.print("x minus one is " + (x - 1)); x -= 1; } } }

• 行1有语法错误
• 行4有语法错误
• 行5有语法错误
• 行6有语法错误
• 行2有语法错误,loop是关键字
• 程序能够正常编译和运行

解析：java中while（）中参数必须是布尔类型，while()括号里参数必须是布尔类型，要么true要么false

96.哪个类可用于处理 Unicode?（）

• InputStreamReader
• BufferedReader
• Writer
• PipedInputStream

解析：Unicode是由两个字节组成的，而InputStreamReader是将字节流转换成字符流供我们使用。同时InputStreamReader也可以指定字符集的编码。

97.（）运算符把其操作数中所有值为0和所有值为1的位分别在结果的相应中设置1和0

• &
• |
• ！
• ~

解析：~是位运算符（取反操作），意义是按位非（NOT）
按位非也叫做补，一元运算符NOT“~”是对其运算数的每一位取反。

• 仅用于整数值
• 反转位，即0位变为1位，1变成0
• 在所有情况下〜x等于（-x）- 1

例如 ：~ 0111 (7) = 1000 (8)

98.下面是java语言的基本特性是？（）

• 封装
• 多态
• 继承
• 高效

99.通过JDBC访问数据库包含下面哪几步？

• 载入JDBC驱动程序
• 建立连接
• 执行查询或更新
• 关闭连接

解析：1、加载JDBC驱动程序； 2、提供JDBC连接的URL；3、创建数据库的连接；4、创建一个Statement；5、执行SQL语句 ；6、处理结果 ；7、关闭JDBC对象。

100.有以下程序段， 则下面正确的选项是（）

1 2 3 4 5 6 7 8 9 10 11 12 13

public class MyThead extends Thread{     public static void main(String[] args) {         MyThead t=new MyThead();         MyThead s=new MyThead();         t.start();         System.out.println("one.");         s.start();         System.out.println("two.");     }     public void run() {         System.out.println("Thread");     } }

• 编译失败

• 程序运行可能结果为：
  one.
  Thread
  two.
  Thread

• 程序运行可能结果是：
  one.
  two.
  Thread
  Thread

• 程序运行结果不稳定

解析：start()是开启线程，等待获得时间片，一到获得时间片就执行。所以可能一开启就获得了时间片执行，也有可能等到two输出后才获得了时间片。所以BC都可能，所以D也正确。

101.要在session对象中保存属性，可以使用以下哪个语句(      )

• session.getAttribute(“key”，”value”)
• session.setAttribute(“key”，”value”)
• session.setAttribute(“key”)
• session.getAttribute(“key”)

解析：session.setAttribute()和session.getAttribute()配对使用，作用域是整个会话期间，在所有的页面都使用这些数据的时候使用。request.getAttribute()表示从request范围取得设置的属性，必须要先setAttribute设置属性，才能通过getAttribute来取得，设置与取得的为Object对象类型。其实表单控件中的Object的 name与value是存放在一个哈希表中的，所以在这里给出Object的name会到哈希表中找出对应它的value。setAttribute()的参数是String和Object。

102.以下关于构造函数的描述错误的是 （ ）

• 每个类有且只能有一个构造函数。
• 构造函数是类的一种特殊函数，它的方法名必须与类名相同
• 构造函数的主要作用是完成对类的对象的初始化工作
• 一般在创建新对象时，系统会自动调用构造函数

解析：一个类可以自定义无穷多个构造函数

103.在异常处理中，如释放资源，关闭数据库、关闭文件应由（ ）语句来完成。

• try子句
• catch子句
• finally子句
• throw子句

解析：

• try:可能发生异常的语句
• catch:捕获，并处理异常（printStackTrace()用来跟踪异常事件发生时执行堆栈的内容）
• throw:方法内部抛异常
• throws:声明方法异常
• finaly：代码中无论是否有异常都会执行，清除资源

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

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

• private void fly(){}
• void fly(){}
• protected void fly(){}
• public void fly(){}

解析：接口方法默认是public abstract的，且实现该接口的类中对应的方法的可见性不能小于接口方法的可见性，因此也只能是public的。

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

1 2 3 4 5 6 7 8 9 10 11 12 13

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

• ABDCBDCB
• ABCDABCD
• 编译时出错
• 运行时抛出异常

解析：for的执行顺序：条件1->条件2->条件4->条件3->条件2->条件4->条件3->条件2

106.命令javac-d参数的用途是？（）

• 指定编译后类层次的根目录
• 指定编译时需要依赖类的路径
• 指定编译时的编码
• 没有这一个参数

解析：

-d destination 目的地

-s source 起源地

javac -d 指定放置生成的类文件的位置

javac -s 指定放置生成的源文件的位置

107.列表(List)和集合(Set)下面说法正确的是？  ( )

• Set中至多只能有一个空元素
• List中至多只能有一个空元素
• List和Set都可以包含重复元素的有序集合
• List和Set都是有序集合

解析：Set 不能有重复的元素，且是无序的，要有空值也就只能有一个。因为它不允许重复。 List 可以有重复元素，且是有序的，要有空值也可以有多个，因为它可重复

108.下列哪个说法是正确的（）

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

解析：A：ConcurrentHashMap 使用segment来分段和管理锁，segment继承自ReentrantLock，因此ConcurrentHashMap使用ReentrantLock来保证线程安全。

B：HashMap定义规则如下：

public class HashMap
    extends AbstractMap
    implements Map, Cloneable, Serializable

C：应该是Arrays.asList()，其将一个数组转化为一个List对象，这个方***返回一个ArrayList类型的对象， 这个ArrayList类并非java.util.ArrayList类，而是Arrays类的内部类： 

109.Java多线程有几种实现方法？

• 继承Thread类

• 实现Runnable接口

• 实现Thread接口

• 以上都不正确

 

解析：多线程一共有三种实现方式

方式1：继承Thread类，并重写run()方法

方式2：实现Runnable接口，实现run()方法

方式3：实现Callable接口，线程结束后可以有返回值，但是该方式是依赖于线程池的。

110.（）运算符和（）运算符分别把一个值的位向左和向右移动

• <<
• >>
• &&
• ||

111.Java Application 中的主类需包含main方法，以下哪项是main方法的正确形参？（    ）

• String  args
• String[] args
• Char  arg
• StringBuffer[] args

解析：String[] args /  String args[] / String... args都是正确的。

112.对于application，主线程main（）方法执行的线索，对于applet，主线程是浏览器加载并执行java小程序。

• 正确
• 错误

113.下面程序的输出是:()

1 2 3 4 5

String x="fmn"; x.toUpperCase(); String y=x.replace('f','F'); y=y+"wxy"; System.out.println(y);

• FmNwxy
• fmnwxy
• wxyfmn
• Fmnwxy

解析：

String x="fmn";  “fmn”是在常量池里的不可变对象。

x.toUpperCase();   在堆中new一个"FMN"对象，但无任何引用指向它。

String y=x.replace('f','F'); 在堆中 new一个"Fmn"对象，y指向它。

y=y+"wxy"; 在堆中 重新new一个"Fmnwxy"对象， 修改y指向，现在y指向它。

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

public class Test {     public static int aMethod(int i)throws Exception     {         try{             return i / 10;         }         catch (Exception ex)         {             throw new Exception("exception in a Method");         } 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");     } }

• exception in main finished
• finally finished
• exception in main finally
• finally exception in main finished

解析：i / 10;无论i是多少，永远不会抛出异常，所以catch语句不会执行。而finally语句是必定执行的语句。所以先指向aMathod()的finally代码块，输出finally。然后执行main()方法的最后一条输出语句，输出finished。

115.顺序执行下列程序语句后，则b的值是（）

String a="Hello";

String b=a.substring(0,2);

• Hello
• Hel
• He
• null

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

116.下列不属于算法结构的是（）

• 输入数据
• 处理数据
• 存储数据
• 输出结果

解析：算法包括0个或多个输入，1个或多个输出，中间有穷个处理过程。存储结构不属于算法结构

117.下面哪些具体实现类可以用于存储键，值对，并且方法调用提供了基本的多线程安全支持：()

• java.util.ConcurrentHashMap
• java.util.Map
• java.util.TreeMap
• java.util.SortMap
• java.util.Hashtable
• java.util.HashMap

解析：Hashtable的方法都是synchrnized修饰的线程安全，ConcurrentHashMap并发容器，JDK7采用分段锁，JDK8采用CAS算法，线程安全，建议使用，Connections工具类提供了一个方法synchrnizedMap可以把Map同步，本质就是给每一个方法加上synchrnized关键字进行同步。

118.以下 json 格式数据，错误的是（）

• {company：4399}
• {"company":{"name":[4399,4399,4399]}}
• {[4399,4399,4399]}
• {"company":[4399,4399,4399]}
• {"company":{"name":4399}}

解析：A:错误  {company：4399} 首先，其为json对象。但json对象要求属性必须加双引号。

C:错误  {[4399,4399,4399]} 。使用 {} 则为json对象。json对象必须由一组有序的键值对组成。

119.对于构造方法，下列叙述正确的是（ ）。

• 构造方法的优先级一般比代码块低。
• 构造方法的返回类型只能是void型。
• 构造方法的主要作用是完成对类的对象的初始化工作。
• 一般在创建新对象时，系统会自动调用构造方法。

解析：java程序初始化顺序：父类静态变量，父类静态代码块（只执行一次），子类静态变量，子类静态代码块（只执行一次），父类非静态变量，父类非静态代码块，父类构造函数，子类非静态变量，子类非静态代码块，子类构造函数

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

1 2 3 4 5 6 7 8 9 10

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

• 程序运行输出只有In run
• 程序运行输出只有Leaving run
• 程序运行输出先有In run后有Leaving run
• 程序运行输出先有Leaving run后有In run
• 程序没有任何输出就退出了
• 程序将被挂起，只能强制退出

解析Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。

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

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