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

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

• Java程序要求用户必须手工创建一个线程来释放内存
• Java程序允许用户使用指针来释放内存
• 内存回收线程负责释放无用内存
• 内存回收线程不能释放内存对象

解析：选C

A，java的内存回收是自动的，Gc在后台运行，不需要用户手动操作

B，java中不允许使用指针

D，内存回收线程可以释放无用的对象内存

2.下面有关JDK中的包和他们的基本功能，描述错误的是？

• java.awt： 包含构成抽象窗口工具集的多个类，用来构建和管理应用程序的图形用户界面
• java.io：　 包含提供多种输出输入功能的类
• java.lang： 包含执行与网络有关的类，如URL，SCOKET，SEVERSOCKET
• java.util：　 包含一些实用性的类

解析：

java.awt： 包含构成抽象窗口工具集的多个类，用来构建和管理应用程序的图形用户界面

java.lang： 提供java编成语言的程序设计的基础类

java.io：　 包含提供多种输出输入功能的类，

java.net：　 包含执行与网络有关的类，如URL，SCOKET，SEVERSOCKET，

java.applet： 包含java小应用程序的类

java.util：　 包含一些实用性的类

3.关于下面程序 ThisTest .java 运行结果 说法正确的是 ： ( )

1 2 3 4 5 6 7 8

public class ThisTest {             public static void main(String args[]) {                 String x="7";                int y = 2;                 int z=2;                       System.out.println(x+y+z);             }   }

• 11
• 722
• 22
• 程序有编译错误

解析：+号两边如果有一边为字符类型  则为字符串连接

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

• stop()
• paint()
• init()
• destroy()

解析：Applet 类是浏览器类库中最为重要的类，同时也是所有 JAVA 小应用程序的基本类。 一个 Applet 应用程序从开始运行到结束时所经历的过程被称为 Applet 的生命周期。 Applet 的生命周期涉及 init() 、 start() 、 stop() 和 destroy() 四种方法，这 4 种方法都是 Applet 类的成员，可以继承这些方法，也可以重写这些方法，覆盖原来定义的这些方法。除此之外，为了在 Applet 程序中实现输出功能，每个 Applet 程序中还需要重载 paint() 方法：

1、  public void init()

init()方法是 Applet 运行的起点。当启动 Applet 程序时，系统首先调用此方法，以执行初始化任务。

2、  public void start()

start()方法是表明 Applet 程序开始执行的方法。当含有此 Applet 程序的 Web 页被再次访问时调用此方法。因此，如果每次访问 Web 页都需要执行一些操作的话，就需要在 Applet 程序中重载该方法。在 Applet 程序中，系统总是先调用 init() 方法，后调用 start() 方法。

3、  public void stop()

stop()方法使 Applet 停止执行，当含有该 Applet 的 Web 页被其他页代替时也要调用该方法。

4、  public void destroy()

destroy()方法收回 Applet 程序的所有资源，即释放已分配给它的所有资源。在 Applet 程序中，系统总是先调用 stop() 方法，后调用 destroy() 方法。

5、  paint(Graphics g)

paint(Graphics g)方法可以使 Applet 程序在屏幕上显示某些信息，如文字、色彩、背景或图像等。参数 g 是 Graphics 类的一个对象实例，实际上可以把 g 理解为一个画笔。对象 g 中包含了许多绘制方法，如 drawstring() 方法就是输出字符串。

5.如果一个接口Cup有个方法use()，有个类SmallCup实现接口Cup，则在类SmallCup中正确的是？  ( )

• void use() { …}
• protected void use() { …}
• public void use() { …}
• 以上语句都可以用在类SmallCup中

解析：既然是实现接口，就要实现接口的所以方法，相当于重写方法，方法的重写需要满足：三同一大一小（方法名、返回值类型、形参相同；访问权限>=重写前；抛出异常<=重写前）

6.Test.main()函数执行后的输出是（ ）

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 31 32

class Test {     public static void main(String[] args) {         System.out.println(new B().getValue());     }     static class A {         protected int value;         public A (int v) {             setValue(v);         }         public void setValue(int value) {             this.value= value;         }         public int getValue() {             try {                 value ++;                 return value;             } finally {                 this.setValue(value);                 System.out.println(value);             }         }     }     static class B extends A {         public B () {             super(5);             setValue(getValue()- 3);         }         public void setValue(int value) {             super.setValue(2 * value);         }     } }

• 6 7 7
• 22 34 17
• 22 74 74
• 11 17 34

解析：

思考和解决这个题的主要核心在于对java多态的理解。个人理解时，执行对象实例化过程中遵循多态特性 ==> 调用的方法都是将要实例化的子类中的重写方法，只有明确调用了super.xxx关键词或者是子类中没有该方法时，才会去调用父类相同的同名方法。

Step 1:  new B()构造一个B类的实例

此时super(5)语句调用显示调用父类A带参的构造函数，该构造函数调用setValue(v)，这里有两个注意点一是虽然构造函数是A类的构造函数，但此刻正在初始化的对象是B的一个实例，因此这里调用的实际是B类的setValue方法，于是调用B类中的setValue方法 ==> 而B类中setValue方法显示调用父类的setValue方法，将B实例的value值设置为2 x 5 = 10。
紧接着，B类的构造函数还没执行完成，继续执行setValue(getValue()- 3) // 备注1语句。

先执行getValue方法，B类中没有重写getValue方法，因此调用父类A的getValue方法。这个方法比较复杂，需要分步说清楚：

1. 调用getValue方法之前，B的成员变量value值为10。
2. value++ 执行后， B的成员变量value值为11，此时开始执行到return语句，将11这个值作为getValue方法的返回值返回出去
3. 但是由于getValue块被try finally块包围，因此finally中的语句无论如何都将被执行，所以步骤2中11这个返回值会先暂存起来，到finally语句块执行完毕后再真正返回出去。
4. 这里有很重要的一点：finally语句块中 this.setValue(value)方法调用的是B类的setValue方法。为什么？因为此刻正在初始化的是B类的一个对象（运行时多态），就像最开始第一步提到的一样(而且这里用了使用了this关键词显式指明了调用当前对象的方法)。因此，此处会再次调用B类的setValue方法，同上，super.关键词显式调用A的setValue方法，将B的value值设置成为了2 * 11 = 22。
5. 因此第一个打印项为22。  
6. finally语句执行完毕 会把刚刚暂存起来的11 返回出去，也就是说这么经历了这么一长串的处理，getValue方法最终的返回值是11。

回到前面标注了 //备注1 的代码语句，其最终结果为setValue(11-3)=>setValue(8)
而大家肯定也知道，这里执行的setValue方法，将会是B的setValue方法。 之后B的value值再次变成了2*8 = 16;

Step2:  new B().getValue()

B类中没有独有的getValue方法，此处调用A的getValue方法。同Step 1，

1. 调用getValue方法之前，B的成员变量value值为16。
2. value++ 执行后， B的成员变量value值为17，此时执行到return语句，会将17这个值作为getValue方法的返回值返回出去
3. 但是由于getValue块被try finally块包围而finally中的语句无论如何都一定会被执行，所以步骤2中17这个返回值会先暂存起来，到finally语句块执行完毕后再真正返回出去。
4. finally语句块中继续和上面说的一样: this.setValue(value)方法调用的是B类的setValue()方法将B的value值设置成为了2 * 17 = 34。
5. 因此第二个打印项为34。
6. finally语句执行完毕 会把刚刚暂存起来的17返回出去。
7. 因此new B().getValue()最终的返回值是17.

Step3:  main函数中的System.out.println

将刚刚返回的值打印出来，也就是第三个打印项：17

最终结果为 22 34 17。 如果朋友们在看的过程中仍然有疑问，可以亲自把代码复制进去ide，在关键语句打下断点，查看调用方法的对象以及运行时的对象值，可以有更深刻的理解。

本地运行结果如下：

7.String与StringBuffer的区别。

• String是不可变的对象，StringBuffer是可以再编辑的
• 字符串是常量，StringBuffer是变量
• String是可变的对象，StringBuffer是不可以再编辑的
• 以上说法都不正确

解析：String, StringBuffer,StringBuilder的区别

1.可变与不可变

String类中使用字符数组保存字符串，如下就是，因为有“final”修饰符，所以可以知道string对象是不可变的。

private final char value[];

      String：为不可变对象,一旦被创建,就不能修改它的值，对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.

StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，如下就是，可知这两种对象都是可变的。

char[] value;

     StringBuffer：是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象 , 它只能通过构造函数来建立,  如： StringBuffer sb = new StringBuffer();

不能通过赋值符号对他进行付值. ， 如 sb = "welcome to here!";//error
对象被建立以后,在内存中就会分配内存空间,并初始保存一个null.向StringBuffer中赋值的时候可以通过它的append方法.      sb.append("hello");

2.是否多线程安全

String中的对象是不可变的，也就可以理解为常量， 显然线程安全 。

AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。

StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的 。看如下源码：

1   public   synchronized  StringBuffer reverse() {

2       super .reverse();

3       return   this ;

4  }

5  

6   public   int  indexOf(String str) {

7       return  indexOf(str, 0);         //存在 public synchronized int indexOf(String str, int fromIndex) 方法

8  }

StringBuilder并没有对方法进行加同步锁，所以是非线程安全的 。

 3.StringBuilder与StringBuffer共同点

StringBuilder与StringBuffer有公共父类AbstractStringBuilder( 抽象类 )。

抽象类与接口的其中一个区别是：抽象类中可以定义一些子类的公共方法，子类只需要增加新的功能，不需要重复写已经存在的方法；而接口中只是对方法的申明和常量的定义。

StringBuilder、StringBuffer的方法都会调用AbstractStringBuilder中的公共方法，如super.append(...)。只是StringBuffer会在方法上加synchronized关键字，进行同步。

最后，如果程序不是多线程的，那么使用StringBuilder效率高于StringBuffer。

效率比较String < StringBuffer < StringBuilder，但是在String S1 =“This is only a”+“simple”+“test”时，String效率最高。

 

8.以下哪些继承自 Collection 接口（）

• List

• Set

• Map

• Array

解析：

9.下面哪些写法能在 java8 中编译执行（）

• dir.listFiles((File f)->f.getName().endsWith(“.Java”));
• dir.listFiles((File f)=>f.getName().endsWith(“.Java”));
• dir.listFiles((_.getName().endsWith(“.Java”)));
• dir.listFiles( f->f.getName().endsWith(“.Java”));

解析：Lanbda表达式的主要作用就是代替匿名内部类的繁琐语法， 它由三部分组成：

（1） 形参列表。形参列表允许省略形参类型。如果形参列表中只有一个参数，甚至连形参列表的圆括号也可以省略。

（2） 箭头（→）。必须通过英文中画线和大于符号组成。

（3）代码块。如果代码块只包含一条语句，Lambda表达式允许省略代码块的花括号，那么那条语句就不要用花括号表示语句结束。Lambda代码块只有一条return语句，甚至可以省略return关键字。Lambda表达式需要返回值，而它的代码块中仅有一套省略了return的语句。Lambda表达式会自动返回这条语句的值。

由此可见，应该是A和D正确。

10.下面哪些描述是正确的：（  ）

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

public class Test { public static class A { private B ref; public void setB(B b) { ref = b; } } public static Class B { private A ref; public void setA(A a) { ref = a; } } public static void main(String args[]) { … start(); …. } public static void start() { A a = new A(); B b = new B(); a.setB(b); b = null; // a = null; … } }

• b = null执行后b可以被垃圾回收
• a = null执行后b可以被垃圾回收
• a = null执行后a可以被垃圾回收
• a,b必须在整个程序结束后才能被垃圾回收
• 类A和类B在设计上有循环引用，会导致内存泄露
• a, b 必须在start方法执行完毕才能被垃圾回收

解析：

11.java 中哪个关键字可以对对象加互斥锁？

• transient
• synchronized
• serialize
• static

解析：synchronized  关键字  : 用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这个段代码。

volatile：用来确保将变量的跟新操作通知到其他线程，当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。然而，在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比 synchronized关键字更轻量级的同步机制。

serialize：Java 对象序列化为二进制文件。

12.假定AB为一个类，则执行 “AB ab = new AB(a,5);”语句时将自动调用该类的(    )。

• 带参构造函数
• 无参构造函数
• 拷贝构造函数
• 重载赋值运算

解析：这个是实例化对象 

new AB();表示使用无参构造函数实例化对象调用的无参构造函数 

new AB(a,5); 表示调用的是有参构造函数 new AB (char i , int j ); 

13.为初始化其成员变量，每个类都定义的方法是（）

• 方法
• main
• 构造方法
• 对象

解析：构造方法的作用是对象初始化（属性初始化）。

14.关于抽象类叙述正确的是？ ( )

• 抽象类不能实现接口
• 抽象类必须有“abstract class”修饰
• 抽象类必须包含抽象方法
• 抽象类也有类的特性，可以被实例化

解析：

A.抽象类是可以实现接口的，而且抽象类也可以继承自抽象类

C.抽象类指有abstract修饰的class，其可以包含抽象方法，也可以不包含

D.抽象类和接口都是不能被实例化的，只有具体的类才可以被实例化

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

1.

2.public  class  A{

3.//do sth

4. }

• public class  MainClass{ }
• package  mine;
• class ANotherClass{   }
• import  java.util.*;

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

16.

1 2 3 4 5 6 7

class Foo {     final int i;     int j;     public void doSomething() {         System.out.println(++j + i);     } }

的输出是？

• 0
• 1
• 2
• 不能执行，因为编译有错

解析：final类型的变量一定要初始化，因为final的变量不可更改。可以在定义的时候初始化，也可以在构造器中初始化。

17.关键字super的作用是？

• 用来访问父类被隐藏的非私有成员变量
• 用来调用父类中被重写的方法
• 用来调用父类的构造函数
• 以上都是

解析：super代表父类对应的对象，所以用super访问在子类中无法直接使用的父类成员和方法。

18.下面程序的运行结果（）

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

Object obj=new Object();         List aList=new ArrayList();         List bList=new LinkedList();                   long t1=System.currentTimeMillis();         for(int i=0;i<50000;i++){             aList.add(0,obj);         }         long t2=System.currentTimeMillis()-t1;                   t1=System.currentTimeMillis();         for(int i=0;i<50000;i++){             bList.add(0,obj);         }         long t3=System.currentTimeMillis()-t1;

• t2
• t2=t3
• 不确定
• t2>t3

解析：ArrayList内部是动态数组实现，在增加空间时会复制全部数据到新的容量大一些的数组中。而LinkedList内部为双向链表，可以按需分配空间，扩展容量简单，因此LinkedList用时少。

19.java程序内存泄露的最直接表现是（ ）

• 频繁FullGc
• jvm崩溃
• 程序抛内存控制的Exception
• java进程异常消失

解析：java是自动管理内存的，通常情况下程序运行到稳定状态，内存大小也达到一个基本稳定的值，但是内存泄露导致Gc不能回收泄露的垃圾，内存不断变大；最终超出内存界限，抛出OutOfMemoryExpection。

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

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

解析：接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。另外，接口和抽象类在方法上有区别：    

1.抽象类可以有构造方法，接口中不能有构造方法。  

2.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

3.抽象类中可以有普通成员变量，接口中没有普通成员变量 

4. 抽象类中的抽象方法的访问类型可以是public，protected和默认类型

5. 抽象类中可以包含静态方法，接口中不能包含静态方法

6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型

7. 一个类可以实现多个接口，但只能继承一个抽象类。二者在应用方面也有一定的区别：接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用，例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的Servlet都继承这个抽象基类，在抽象基类的service方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码。

21.类Car里面有个方法run()，如果直接用Car.run()，则方法run前面必须用的关键词是？  ( )

• class
• final
• public
• static

解析：被sataic声明的为静态方法，可以直接通过类名调用而不需要通过对象调用。

22.关于对象成员占用内存的说法哪个正确？（ ）

• 同一个类的对象共用同一段内存
• 同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间
• 对象的方法不占用内存
• 以上都不对

解析：当创建一个新的实例对象时，它会得到一块新的内存空间。但是类中的静态成员变量是所有对象共有的，也就是在一片属于类的存储空间中，被所有对象共有。

23.在java中，无论在何处调用，使用静态属性必须以类名做前缀。

• 正确
• 错误

解析：

1.如果是本类使用，可以直接就用静态变量名。

2.如果是其他类使用，可以使用类名来调用，也可以创建一个实例对象来调用。

3.如果静态变量所在的类是静态类，那么不管在本类里或者在其他外部类，都可以直接使用静态变量名。

24.在java中，已定义两个接口B和C，要定义一个实现这两个接口的类，以下语句正确的是（）

• interface  A extends B，C
• interface  A eimplements  B，C
• class  A implements  B，C
• class  A implements  B，implements C

解析：类实现多个接口的时候，只需要一个implements，多个接口通过逗号进行隔开，先继承类再实现接口。

25.给定代码：

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

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

第三行将输出什么？

• value=6
• value=8
• value=3
• value=5
• value=4

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

26.以下哪个不能用来处理线程安全（）

• synchronized关键字
• volatile关键字
• Lock类
• transient关键字

解析：

synchrozied关键字称作同步，主要用来给方法、代码块加锁，被加锁的代码段，同一时间内多线程同时访问同一对象的加锁方法/代码块时，只能有一个线程执行能执行方法/代码块中的代码，其余线程必须等待当前线程执行完以后才执行该方法/代码块。

volatile关键字1.保证了不同线程对该变量操作的内存可见性.(当一个线程修改了变量,其他使用次变量的线程可以立即知道这一修改)。2.禁止了指令重排序.

Lock接口提供了与synchronized关键字类似的同步功能，但需要在使用时手动获取锁和释放锁。

transient关键字  简单地说，就是让某些被修饰的成员属性变量不被序列化。

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

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

public class ClassTest{      String str = new String("hello");      char[] ch = {'a','b','c'};      public void fun(String str, char ch[]){      str="world";      ch[0]='d';  }  public static void main(String[] args) {      ClassTest test1 = new ClassTest();      test1.fun(test1.str,test1.ch);      System.out.print(test1.str + " and ");      System.out.print(test1.ch);      }  }

• hello and dbc
• world and abc
• hello and abc
• world and dbc

解析：

new出来的对象都放在堆中，而没有new的都放在栈中。

  str="world";

     ch[0]='d';

这两个都不是new出来的所以放在栈中。

 char[] ch = {'a','b','c'};

ch数组也不是new的所以放在栈中

而 test1.fun(test1.str,test1.ch);改的是栈中的数据   但是 System.out.print(test1.str + " and ");调用的是堆中的数据。所以数组改变了。字符没改变。

28.一个Java源程序文件中定义几个类和接口，则编译该文件后生成几个以.class为后缀的字节码文件。

• 正确
• 错误

解析：

一个.java文件中定义多个类：

注意一下几点：

(1) public权限类只能有一个（也可以一个都没有，但最多只有一个）；

(2)这个.java文件名只能是public 权限的类的类名；

(3)倘若这个文件中没有public 类，则它的.java文件的名字是随便的一个类名；

(4)当用javac命令生成编译这个.java 文件的时候，则会针对每一个类生成一个.class文件；

29.以下java程序代码，执行后的结果是（）

1 2 3 4 5 6 7 8 9 10

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

• Fred
• true
• 编译错误
• 运行时抛出异常

解析：

1、使用了匿名内部类，并重写了Object中的重写了equals()方法

2、o对象调用了equals方法

30.以下哪几种是java的基本数据类型。

• String
• int
• boolean
• Double

解析：java 8中基本数据类型：byte，short，int，long，double，float，boolean，char

Double在java.lang包，是double的一个包装类，不是基本数据类型（注意大小写）

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

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

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

• Result=150Result=150
• Result=100Result=100
• Result=100Result=150
• Result=150Result=100

解析：其实很简单，涉及转型的题目，分为向上或者向下转型。

关键的来了，不论向上或者向下转型，都是一句话，“编译看左边，运行看右边”。也就是编译时候，会看左边引用类型是否能正确编译通过，运行的时候是调用右边的对象的方法。

就本题来说，编译时候会发现左边满足条件所以编译通过，运行时候又会调用右边也就是 class B 的方法，所以答案都是150。

32.如果类的方法没有返回值，该方法的返回值类型应当是abstract。（）

• 正确
• 错误

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

33.HashMap的数据结构是怎样的？

• 数组
• 链表
• 数组+链表
• 二叉树

解析：HashMap 由数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的

34.java语言中，按照一定格式生成程序的文档的工具是？

• javac
• javah
• javadoc
• jar

解析：

jar         将许多文件组合成一个jar文件

javac    编译

javadoc 它从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档。

javah 把java代码声明的JNI方法转化成C\C++头文件。 JNI可参考java核心技术卷二第12章

35.This调用语句必须是构造函数中的第一个可执行语句。

• 正确
• 错误

解析：this()才必须是构造函数中的第一个可执行语句，用this调用语句并不需要。

36.Which statement is true for the class java.util.ArrayList?

• The elements in the collection are ordered.
• The collection is guaranteed to be immutable.
• The elements in the collection are guaranteed to be unique.
• The elements in the collection are accessed using a unique key.
• The elements in the collections are guaranteed to be synchronized.

解析：

Which statement is true for the class java.util.ArrayList?

下面那个选项有关java.util.ArrayList是正确的

A.The elements in the collection are ordered.

集合中的元素是排序的

B.The collection is guaranteed to be immutable.

集合不可改变

C.The elements in the collection are guaranteed to be unique.

集合中的元素必须唯一

D.The elements in the collection are accessed using a unique key.

集合中元素的键是唯一的

E.The elements in the collections are guaranteed to be synchronized.

集合中的元素是线程同步的

 

选A，元素在集合中有序，指的是元素插入过程中记录了元素的插入顺序。

37.结构型模式中最体现扩展性的模式是（）

• 装饰模式
• 合成模式
• 桥接模式
• 适配器

解析：

结构型模式是描述如何将类对象结合在一起，形成一个更大的结构，结构模式描述两种不同的东西：类与类的实例。故可以分为类结构模式和对象结构模式。

在GoF设计模式中，结构型模式有：

1.适配器模式 Adapter

  适配器模式是将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

  两个成熟的类需要通信，但是接口不同，由于开闭原则，我们不能去修改这两个类的接口，所以就需要一个适配器来完成衔接过程。

2.桥接模式 Bridge

  桥接模式将抽象部分与它的实现部分分离，是它们都可以独立地变化。它很好的支持了开闭原则和组合锯和复用原则。实现系统可能有多角度分类，每一种分类都有可能变化，那么就把这些多角度分离出来让他们独立变化，减少他们之间的耦合。

3.组合模式 Composite

  组合模式将对象组合成树形结构以表示部分-整体的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。

4.装饰模式 Decorator

装饰模式动态地给一个对象添加一些额外的职责，就增加功能来说，它比生成子类更灵活。也可以这样说，装饰模式把复杂类中的核心职责和装饰功能区分开了，这样既简化了复杂类，有去除了相关类中重复的装饰逻辑。 装饰模式没有通过继承原有类来扩展功能，但却达到了一样的目的，而且比继承更加灵活，所以可以说装饰模式是继承关系的一种替代方案。

5.外观模式 Facade

外观模式为子系统中的一组接口提供了同意的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

外观模式中，客户对各个具体的子系统是不了解的，所以对这些子系统进行了封装，对外只提供了用户所明白的单一而简单的接口，用户直接使用这个接口就可以完成操作，而不用去理睬具体的过程，而且子系统的变化不会影响到用户，这样就做到了信息隐蔽。

6.享元模式 Flyweight

 享元模式为运用共享技术有效的支持大量细粒度的对象。因为它可以通过共享大幅度地减少单个实例的数目，避免了大量非常相似类的开销。.

 享元模式是一个类别的多个对象共享这个类别的一个对象，而不是各自再实例化各自的对象。这样就达到了节省内存的目的。

7.***模式 Proxy   

为其他对象提供一种***，并由***对象控制对原对象的引用，以间接控制对原对象的访问。

38.下面有关JAVA swing的描述，说法错误的是？

• Swing是一个基于Java的跨平台MVC框架。使用单线程模式。
• Swing 是为了解决 AWT 存在的问题而新开发的包，它以 AWT 为基础的
• Swing优化了AWT，运行速度比AWT快
• Swing是一个基于组件的框架，所有的组件都是从javax.swing.JComponent类继承来的

解析：Swing 是在AWT的基础上构建的一套新的图形界面系统，它提供了AWT 所能够提供的所有功能，并且用纯粹的Java代码对AWT 的功能进行了大幅度的扩充。

AWT 是基于本地方法的C/C++程序，其运行速度比较快；Swing是基于AWT 的Java程序，其运行速度比较慢。

39.一般有两种用于创建线程的方法,一是(),二是()。

• 从Java.lang.Thread类派生一个新的线程类，重写它的runnable()方法
• 从Java.lang.Thread类派生一个新的线程类，重写它的run()方法
• 实现Thread接口，重写Thread接口中的run()方法
• 实现Runnable接口，重写Runnable接口中的run()方法

解析：

创建线程对象两种方式：

1.继承Thread类，重载run方法；

2.实现Runnable接口，实现run方法 。

40.下面哪几个函数 public void example(){....} 的重载函数？（）

• public void example(int m){...}
• public int example(){..}
• public void example2(){..}
• public int example(int m,float f){...}

解析：java重载的时候以参数个数和类型作为区分，方法名相同，返回类型可以相同也可以不同，但不以返回类型作为区分，所以b也是错的，因为b的参数列表和原来的一样。

41.关于容器下面说法正确的是？ ( )

• 列表(List)和集合(Set)存放的元素都是可重复的。
• 列表(List)和集合(Set)存放的元素都是不可重复的。
• 映射(Map)<key,value>中key是可以重复的。
• 映射(Map)<key,value>中value是可以重复的。

解析：

列表（List）的元素是有序、可重复的；

集合（Set）的元素是无序、不可重复的；

Map的key不能重复，value可以重复

42.关键字()表明一个对象或变量的引用在初始化后不能被修改。

• private
• final
• static
• 没有这种关键字

解析：final修饰的变量内容是不能修改的，如果final修饰一个对象的引用，那么指的是这个对象的地址值是无法改变的，对象的内容还是可以修改的。如果final修饰一个普通变量的话，就是变量的值无法修改。综上，final修饰变量的本质就是：修饰的变量值(地址或内容)无法改变。

43.Java Application(Java 应用程序)源程序文件编译后的字节码文件的扩展名是(    )。

• java
• class
• exe
• jar

解析：A: .java是java程序的源代码文件 B： .class不是类的扩展名，JVM并不能直接运行java源文件，需要通过javac将java源文件编译成字节码文件，也就是.class文件，JVM在运行某个类的时候，通过加载指定该.class文件就可以，因为class文件名与类名相同，但是他俩并不是一回事，运行的是类，不是文件。 C： java可以编写成.exe,虽然是exe文件，但是不代表是windows可执行文件，尽管扩展名一样； D： 可以打包成jar，需要有jdk支持，通过JVM运行，这个才是java真正的运行包。

44.下面关于垃圾收集的描述哪个是错误的？

• 使用垃圾收集的程序不需要明确释放对象
• 现代垃圾收集能够处理循环引用问题
• 垃圾收集能提高程序员效率
• 使用垃圾收集的语言没有内在泄漏问题

解析：也会有内存泄露问题，例如访问资源文件，流不关闭，访问数据库等连接不关闭。

45.请问以下代码运行结果是：

• try catch
• try finally  catch
• try finally
• try catch finally

解析：选 D

throws：写在方法声明之后，表示方法可能抛出异常，调用者需要处理这个异常。

throw：写在方法体中，表示方法一定会抛出一个异常，要么try...catch处理，要么throws抛出。

本题正是有了throw，所以才会顺序执行，否则不执行catch块中的语句。运行过程如下： 在执行到try代码块中，首先输出try，然后抛出异常，直接跳转到catch中，输出catch，然后跳转到finally块中，输出finally。

46.下列不正确的 Java 语言标识符是（ ）

• Sky
• $Computer
• for
• NULL

解析：for是关键字。  java关键字都是小写。

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

• 插入排序
• 快速排序
• 堆排序
• 归并排序

解析：

48.下面哪些标识符是正确的？

• MyWorld
• parseXML
• –value
• &amp;maybe

解析：Java中标识符有字母、数字、美元符号$、下划线4种，不能以数字开头，不能用保留字和关键字。

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

• 序列化是将数据转为n个 byte序列的过程
• 反序列化是将n个 byte转换为数据的过程
• 将类型int转换为4  byte是反序列化过程
• 将8个字节转换为long类型的数据为序列化过程

解析：

把你看得懂的转换为看不懂的，就是序列化。

把你看不懂的转换为看得懂的，就是反序列化。

序列化：将数据结构转换称为二进制数据流或者文本流的过程。序列化后的数据方便在网络上传输和在硬盘上存储。

反序列化：与序列化相反，是将二进制数据流或者文本流转换称为易于处理和阅读的数据结构的过程。

50.下面哪些情况下需要使用抽象类？

• 当一个类的一个或多个方法是抽象方法时
• 当类是一个抽象类的子类，并且不能为任何抽象方法提供任何实现细节或方法体时
• 当一个类实现多个接口时
• 当一个类实现一个接口，并且不能为任何抽象方法提供实现细节或方法体时

解析：抽象类：用abstract修饰，抽象类中可以没有抽象方法，但抽象方法肯定在抽象类中，且抽象方法定义时不能有方法体；抽象类不可以实例化，只能通过继承在子类中实现其所有的抽象方法；抽象类如果不被继承就没有任何意义；抽象类为子类定义了一个公共类型，封装了子类中的重复内容。

51.下面关于继承的描述正确的是

• 在Java中类只允许单一继承
• 在Java中一个类只能实现一个接口
• 在Java中一个类不能同时继承一个类和实现一个接口
• Java的单一继承使代码不可靠

解析：

A.类支持单根继承，接口支持多继承

B.类可以实现多接口

C.一个类能同时继承一个类和实现一个接口

D.单一继承使得代码更可靠

52.下列不属于类及类成员的访问控制符是：（ ）

• public
• private
• static
• protected

解析：3个访问控制符：private public protected 4个访问控制级别：private<default<protected<public

53.下面哪个描述正确? （）

• 程序中的注释越多，程序运行得越快。
• int是java.lang包中可用的类的名称
• 类总是有一个构造函数（可能由java编译器自动提供）
• 实例变量名称只能包含字母和数字

解析：

A.肯定错

B.int是java的基础类型，并不是类

C.正确

D.还可能有一些符号如：_   &

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

• 字节码
• 可执行代码
• 机器代码
• 以上都不对

解析：

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

55.Java的Daemon线程，setDaemon( )设置必须要？

• 在start之前
• 在start之后
• 前后都可以

解析：setDaemon()方法必须在线程启动之前调用，当线程正在运行时调用会产生异常。

java线程是一个运用很广泛的重点知识,我们很有必要了解java的daemon线程.

1.首先我们必须清楚的认识到java的线程分为两类: 用户线程和daemon线程

A.　　用户线程: 用户线程可以简单的理解为用户定义的线程,当然包括main线程(以前我错误的认为main线程也是一个daemon线程,但是慢慢的发现原来main线程不是,因为如果我再main线程中创建一个用户线程,并且打出日志,我们会发现这样一个问题,main线程运行结束了,但是我们的线程任然在运行).

B.　　daemon线程: daemon线程是为我们创建的用户线程提供服务的线程,比如说jvm的GC等等,这样的线程有一个非常明显的特征: 当用户线程运行结束的时候,daemon线程将会自动退出.(由此我们可以推出下面关于daemon线程的几条基本特点)

2.　daemon 线程的特点: 

A.　　守护线程创建的过程中需要先调用setDaemon方法进行设置,然后再启动线程.否则会报出IllegalThreadStateException异常.(个人在想一个问题,为什么不能动态更改线程为daemon线程?有时间一个补上这个内容,现在给出一个猜测: 是因为jvm判断线程状态的时候,如果当前只存在一个线程Thread1,如果我们把这个线程动态更改为daemon线程,jvm会认为当前已经不存在用户线程而退出,稍后将会给出正确结论,抱歉!如果有哪位大牛看到,希望给出指点,谢谢!)

B.　　由于daemon线程的终止条件是当前是否存在用户线程,所以我们不能指派daemon线程来进行一些业务操作,而只能服务用户线程.

C.　　daemon线程创建的子线程任然是daemon线程.

56.有以下代码片段：

String str1="hello";

String str2="he"+ new String("llo");

System.out.println(str1==str2);

请问输出的结果是：

• true
• 都不对
• null
• false

解析：

String str1="hello";    这样创建字符串是存在于常量池中

String str2=new String("hello");    str2存在于堆中，

==是验证两个对象是否是一个（内存地址是否相同），两者地址不同

用+拼接字符串时会创建一个新对象再返回。

57.对于以下代码段，4个输出语句中输出true的个数是(    )。

class A{} class B extends A{} class C extends A{} class D extends B{} A obj = new D(); System.out.println(obj instanceof B); System.out.println(obj instanceof C); System.out.println(obj instanceof D); System.out.println(obj instanceof A);

• 1
• 2
• 3
• 4

解析：

    A

|        |

B     C

|

D

D属于B,D属于A,D属于D,D不属于C

所以选C

58.以下哪个区域不属于新生代？

• eden区
• from区
• 元数据区
• to区

解析：

Java 中的堆是 JVM 所管理的最大的一块内存空间，主要用于存放各种类的实例对象。

在 Java 中，堆被划分成两个不同的区域：新生代 ( Young )、老年代 ( Old )。新生代 ( Young ) 又被划分为三个区域：Eden、From Survivor、To Survivor。
这样划分的目的是为了使 JVM 能够更好的管理堆内存中的对象，包括内存的分配以及回收。
堆的内存模型大致为：

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

1 2 3 4 5 6 7

public class Test { public static void main(String args[]) { int i = -5; i =  ++(i++); System.out.println(i); } }

• -7
• -3
• 编译错误
• -5

解析：

1.先执行括号中的i++  在执行i++的时候  Java会将i先存放到一个临时变量中去  并返回该临时变量的值（假设为temp）

2.所以 这句可以拆成  temp = i （值为-5） 并返回temp的值  然后 i自加1 此时 i 的值为-4  但是之后 执行就会出现问题 由于返回了temp的值 继续执行的表达式为  i =  ++(-5);  单目运算符无法后跟一个字面量  所以在IDEA编辑器中提示Variable expected（此处应为变量） 故选择C选项  

60.给出下面的代码段:

public class Base{
int w, x, y ,z;
public Base(int a,int b)
{
x=a; y=b;
}
public Base(int a, int b, int c, int d)
{
// assignment x=a, y=b
w=d;z=c;
}}
在代码说明// assignment x=a, y=b处写入如下哪几个代码是正确的？（）

• Base(a,b);
• x=a, y=b;
• x=a; y=b;
• this(a,b);

解析：

A错，调用Base这个构造方法应该这样  new Base(a,b)
B错，和C相比应该是分号不是逗号，帅的一塌糊涂
C正常赋值操作
D调用本类的构造方法

61.下列说法哪个正确(    )

• 不需要定义类，就能创建对象
• 对象中必须有数据域和方法
• 数据域可以是基本类型变量，也可以是一个对象
• 数据域必须是基本类型变量

解析：

A.没有模板，怎么可能创建对象，创建对象必须先要定义类，常识

B.对象中的数据域和方法取决于该对象的类，类里面有就有，没有就没有

D.数据域不一定是基本类型，也可以是引用类型

62.下列语句序列执行后，输出结果是（）

public class ex{

public static void main(String[]args){

int a=13;

a=a/5；

System.out.println(a);

}

}

• 1
• 2
• 3
• 4

解析：a是int类型,13/5得到一个浮点类型,浮点类型转成整数类型的原则是,不四舍五入,直接截断小数点后的部分。

63.Java中所有类的父类是（ ）。

• Father
• Dang
• Exception

• Object

解析：java中Object是所有类的父亲,所有类的对象都是Class的实例。

64.下面程序的运行结果是

String str1 = "hello";
String str2 = "he" + new String("llo");
System.err.println(str1 == str2);

• true
• false
• exception
• 无输出

解析：String str1 = "hello";这里的str1指的是方法区的字符串常量池中的“hello”，编译时期就知道的； String str2 = "he" + new String("llo");这里的str2必须在运行时才知道str2是什么，所以它是指向的是堆里定义的字符串“hello”，所以这两个引用是不一样的。 如果用str1.equal(str2)，那么返回的是True；因为两个字符串的内容一样。

65.导出类调用基类的构造器必须用到的关键字： ( )

• this
• final
• super
• static

解析：基类就是父类，也叫超类。导出类就是子类，也叫派生类。

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

• x[25]存放了数据“\0”。
• x[24] 存放了数据“\0”。
• 若访问x[25]，程序将抛出异常。
• x[1]访问此数组的第一个元素。

解析：

A:不存在x[25] 索引从0开始到length-1
B:x[24] 存的是默认值0(java中没有'\0'这一说)
C:超出内存 正确
D:第二元素

67.如下语句通过算术运算和逻辑运算之后i和 j的结果是（ ）

1 2 3 4 5 6

int i=0; int j=0; if((++i>0)||(++j>0)) { //打印出i和j的值。 }

• i=0;j=0
• i=1;j=1
• i=0;j=1
• i=1;j=0

解析：&& 和 || 为短路与 短路或

&&若前面的表达式为false,整个逻辑表达式为false,所以后面的表达式无论true和false都无法影响整个表达式的逻辑结果，所以为了提高代码执行速率，这里后面的表达式就不会执行。

||若前面表达式为true,整个逻辑表达式为true,则后面的表达式无需计算。

& 和 | 为不短路与 不短路或
无论什么情况，前面的和后面的都要执行。

68.以下代码运行输出的是

1 2 3 4 5 6 7 8 9 10 11

public class Person{     private String name = "Person";     int age=0; } public class Child extends Person{     public String grade;     public static void main(String[] args){         Person p = new Child();         System.out.println(p.name);     } }

• 输出：Person
• 没有输出
• 编译出错
• 运行出错

解析：Java中对字段属性是静态绑定，方法成员是动态绑定，这里错在：在子类中试图访问父类的private字段，所以编译不通过，将private去掉就可访问，不是动态绑定的问题，它本来就属于静态绑定。

69.下面代码的运行结果为：（）

1 2 3 4 5 6 7 8

import java.io.*; import java.util.*; public class foo{ public static void main (String[] args){ String s; System.out.println("s=" + s); } }

• 代码得到编译，并输出“s=”
• 代码得到编译，并输出“s=null”
• 由于String s没有初始化，代码不能编译通过
• 代码得到编译，但捕获到 NullPointException异常

解析：局部变量可以先申明不用必须初始化，但使用到了一定要先初始化

70.jvm中垃圾回收分为scanvenge gc和full GC，其中full GC触发的条件可能有哪些

• 栈空间满
• 年轻代空间满
• 老年代满
• 持久代满
• System.gc()

解析：垃圾收集机制：新生代、老年代、持久代

1，新生代：（1）所有对象创建在新生代的Eden区，当Eden区满后触发新生代的Minor GC，将Eden区和非空闲Survivor区存活的对象复制到另外一个空闲的Survivor区中。（2）保证一个Survivor区是空的，新生代Minor GC就是在两个Survivor区之间相互复制存活对象，直到Survivor区满为止。

2，老年代：当Survivor区也满了之后就通过Minor GC将对象复制到老年代。老年代也满了的话，就将触发Full GC，针对整个堆（包括新生代、老年代、持久代）进行垃圾回收。

3，持久代：持久代如果满了，将触发Full GC。

发表于 2018-04-11 17:54:45

 

System.gc是有可能触发full gc的。这个方法的调用是建议jvm进行full gc，虽然只是建议而非一定，但很多情况下会触发full gc，从而增加了full gc的频率，但弊端是增加了间歇性停顿的次数，不建议使用。

71.只有实现了()接口的类，其对象才能序列化。

• Serializable
• Cloneable
• Comparable
• Writeable

解析：

A、Serializable接口是专门提供给类实现序列化用的。要实现序列化对象必须要实现 Serializable 接口；

B、可进行复制；

C、比较器；

D、hadoop中的接口；

72.下列修饰符中与访问控制权限无关的是？（ ）

• private
• public
• protected
• final

解析：java常见修饰符

权限修饰符：

private :        修饰私有变量

默认修饰符default（不用把default写出来）： 比private限制更少，但比protected限制更多

protected:    修饰受保护变量

public :         修饰公有变量

状态修饰符：

final 最终变量（final修饰类，该类不能被继承，final修饰方法，该方法不能被重写，final修饰变量，该变量不能被重新赋值（相当于常量））

static 静态变量（随着类的加载而加载，优先于对象存在，被所有对象所共享，可以通过类名调用）

抽象修饰符：

abstract 抽象类&抽象方法（抽象类不能被实例化，抽象类中不一定有抽象方法，但有抽象方法的类必须定义为抽象类）

73.Which of the following statements are valid array declaration?
(A) int number();
(B) float average[];
(C) double[] marks;
(D) counter int[];

• (B) & (C)
• (A)
• (A) & (C)
• (D)

解析：数据的两种定义方式。 int[] nums; int nums[];

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

• WEB-INF目录
• conf目录
• lib目录
• classes目录

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

75.java中将ISO8859-1字符串转成GB2312编码，语句为 ？  

• new String("ISO8859-1".getBytes("ISO8859-1"),"GB2312")
• new String(String.getBytes("GB2312"）, ISO8859-1)
• new String(String.getBytes("ISO8859-1"))
• new String(String.getBytes("GB2312"))

解析：byte [  ]  String.getBytes(String charsetName);  得到的是以charsetName编码得到的byte数组；

String的构造函数有： String (byte[] bytes, String  charsetName);

getBytes(String charsetName)

使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。

 

String.getBytes("ISO8859-1"）表示获取这个字符串的byte数组，

然后new String(String.getBytes("ISO8859-1"），GB2312)是上面的字符数组按照GB2312编码成新的字符串

76.设int x=1,float y=2,则表达式x/y的值是：（）

• 0
• 1
• 2
• 以上都不是

解析：本题的意义在于两点，明白这两点之后题会不会本身就不重要了：

①float x = 1；与float x = 1.0f，这两种对于float类型的变量来说定义的方式都是正确的，也是比较常见的笔试题里面考察类型转换的例子，当第一种情况时，是将低精度int向上转型到float，是由于java的特性导致而不需要进行强制转换，而第二种情况则是比较正式的对于float变量的定义，由于这种类型本身在工作项目中并不常见，常用的带小数的数字我们一般都直接使用double类型，而double类型直接定义是没有问题的：double x = 1.0。而由于float的精度没有double类型高，因此必须对其进行显示的格式书写，如果没有这个f，就默认是double类型了。当然double x = 1.0d也是正确的命名，不信你可以尝试，虽然这是一个令人窒息的操作。

②当多个精度的数字同时进行运算时，最终结果以最高精度为准。在多数情况下，整数和小数的各级混合运算中，一般结果都是double类型的。但就本题而言，结果是float类型的，因为x，y两个数字精度最高的就是float，所以最终结果是0.5，并且这个0.5是float类型的。为什么说不是double类型呢，当然如果你这样处理：double m = x/y，当然m是double类型的，也不会报错，而如果你写成int m = x/y，编译器报错提示的时候就会让你转换成float或者进行强制转换成int，他是不会提示你转换成double的，尽管这么写并没有报错，原因就是①中所说的向上强转。float转换成double不需要任何提示。

77.可以将布尔值与整数进行比较吗 ？

• 可以
• 不可以

78.使用mvc模式设计的web应用程序具有以下优点,除了？

 

• 可维护行强
• 可扩展性强
• 代码重复少
• 大大减少代码量

解析：MVC全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。MVC被独特的发展起来用于映射传统的输入、处理和输出功能在一个逻辑的图形化用户界面的结构中。
MVC只是将分管不同功能的逻辑代码进行了隔离，增强了可维护和可扩展性，增强代码复用性，因此可以减少代码重复。但是不保证减少代码量，多层次的调用模式还有可能增加代码量。

79.Java 中的集合类包括 ArrayList 、 LinkedList 、 HashMap 等，下列关于集合类描述正确的是？（）

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

解析：

A、HashMap实现了Map接口的，它的Key和Value都可以是null，但是Hashtable种，Key和Value都不能是null。

B、ArrayList与LinkedList都实现了List接口，继承了AbstractList类。

C、ArrayList底层是动态数组是实现，随机位置添加和删除，都需要移动数组的数据，而LinkedList底层是双向链表，只需要修改Node节点的引用。

D、随机访问数组要比链表块。

下面放一张ArrayList和LinkedList的区别表：

80.下面代码在main()方法中第八行后可以正常使用的是（ ）

1 2 3 4 5 6 7 8 9 10

public class Test {     private int a=10;     int b=20;     static int c=1;     public static void main(String arg[])     {         Test t = new Test();     }  }

• t.a
• this.c
• Test.b
• Test.c

解析：

A :  在private  修饰不能在外部类中调用，main 方法属于Test类的方法， 所以 对象 t 可以在他自己的类方法中调用它的private

B ：static 方法中没有this 这么一说

C: b不是static变量

D: 合理    当通过对象去调用一个属性时，先找成员，再找静态，最后找父类。

81.（）仅包含方法定义和常量值。

• 接口
• 变量
• 单元
• 成员

解析：

接口中的所以方法都是抽象的-方法定义

接口中的值都是public static final的-常量值

82.代码String str=”123456a”；int i=Integer.parseInt(str);会报异常的是（）

• java.lang.NullPoninterException
• java.lang.NumberFormatException
• java.lang.RuntimeException
• java.lang.ArrayindexOutOfBoundsException

解析：

java.lang.NullPoninterException：变量未被初始化、对象未赋值、对象为空（俗称的空指针异常）
java.lang.NumberFormatException：数据格式转换失败（integer的取值范围为：-128~127，超过范围都会访问false）
java.lang.RuntimeException：运行时异常
java.lang.ArrayindexOutOfBoundsException：数组下标越界

83.如下的Java程序 

public class Test { 

     public static void main(String[] args) { 

     System.out.println(args[0]); 

     } 

} 

 若采用命令行“java Test one two three”调用，则程序输出的结果为：

• Test
• one
• two
• java

解析：

采用命令行“ java Test one two three ”调用

其中Test为调用的方法，而one two three则为Test方法里面main函数的参数；

  System.out.println(args[0]);表示输出第一个元素，故为one；

84.下面有关jdbc statement的说法错误的是？

• JDBC提供了Statement、PreparedStatement 和 CallableStatement三种方式来执行查询语句，其中 Statement 用于通用查询， PreparedStatement 用于执行参数化查询，而 CallableStatement则是用于存储过程
• 对于PreparedStatement来说，数据库可以使用已经编译过及定义好的执行计划，由于 PreparedStatement 对象已预编译过，所以其执行速度要快于 Statement 对象”
• PreparedStatement中，“?” 叫做占位符，一个占位符可以有一个或者多个值
• PreparedStatement可以阻止常见的SQL注入式攻击

解析：JDBC statement中的PReparedStatement的占位符对应着即将与之对应当值，并且一个占位符只能对应一个值，如果能对应多个就会引起混淆。sql语句是确定的，那么一个占位符必定只能对应一个值

85.下面有关jsp中静态include和动态include的区别，说法错误的是？  

• 动态INCLUDE:用jsp:include动作实现 
• 静态INCLUDE:用include伪码实现，定不会检查所含文件的变化，适用于包含静态页面<%@ include file="included.htm" %>
• 静态include的结果是把其他jsp引入当前jsp，两者合为一体;动态include的结构是两者独立，直到输出时才合并
• 静态include和动态include都可以允许变量同名的冲突.页面设置也可以借用主文件的

解析：

动态 INCLUDE 用 jsp:include 动作实现 <jsp:include page="included.jsp" flush="true" /> 它总是会检查所含文件中的变化 , 适合用于包含动态页面 , 并且可以带参数。各个文件分别先编译，然后组合成一个文件。

静态 INCLUDE 用 include 伪码实现 , 定不会检查所含文件的变化 , 适用于包含静态页面 <%@ include file="included.htm" %> 。先将文件的代码被原封不动地加入到了主页面从而合成一个文件，然后再进行翻译，此时不允许有相同的变量。

86.非抽象类实现接口后，必须实现接口中的所有抽象方法，除了abstract外，方法头必须完全一致.

• 正确
• 错误

解析：实际上这道题考查的是两同两小一大原则：方法名相同，参数类型相同

子类返回类型小于等于父类方法返回类型，
子类抛出异常小于等于父类方法抛出异常，
子类访问权限大于等于父类方法访问权限。

87.有关线程的哪些叙述是对的（）

• 一旦一个线程被创建，它就立即开始运行。
• 使用start()方法可以使一个线程成为可运行的，但是它不一定立即开始运行。
• 当一个线程因为抢先机制而停止运行，它可能被放在可运行队列的前面。
• 一个线程可能因为不同的原因停止并进入就绪状态。

解析：

在抢先式系统下，由高优先级的线程参与调度。分为2种情况：

1.若多个线程都处于就绪状态，则具有高优先级的线程会在低优先级之前得到执行；

2.在当前线程的运行过程中，如果有较高级别的线程准备就绪，则正在运行的较低级别的线程将被挂起，转到较高级别的线程运行，直到结束后又会转到原来被挂起的线程。

第二种情况就描述了C所代表的情况，可以看到当较高级别的线程抢去运行权并运行完成之后，是先将权利转给原来的线程的，所以C是正确的。

88.线程安全的map在JDK 1.5及其更高版本环境 有哪几种方法可以实现?

• Map map = new HashMap()
• Map map = new TreeMap()
• Map map = new ConcurrentHashMap();
• Map map = Collections.synchronizedMap(new HashMap());

解析：

1. HashMap,TreeMap 未进行同步考虑，是线程不安全的。

2. HashTable 和 ConcurrentHashMap 都是线程安全的。区别在于他们对加锁的范围不同，HashTable 对整张Hash表进行加锁，而ConcurrentHashMap将Hash表分为16桶(segment)，每次只对需要的桶进行加锁。

3. Collections 类提供了synchronizedXxx()方法，可以将指定的集合包装成线程同步的集合。比如，

List  list = Collections.synchronizedList(new ArrayList());

Set  set = Collections.synchronizedSet(new HashSet());

89.ervlet的生命周期可以分为初始化阶段，运行阶段和销毁阶段三个阶段，以下过程属于初始化阶段是（）。

• 加载Servlet类及.class对应的数据
• 创建servletRequest和servletResponse对象
• 创建ServletConfig对象
• 创建Servlet对象

解析：

初始化阶段：Servlet启动，会读取配置文件中的信息，构造指定的Servlet对象，创建ServletConfig对象，将ServletConfig作为参数来调用init()方法。

90.判断一块内存空间是否符合垃圾收集器收集的标准有哪些？

• 给对象赋予了空值null,以下再没有调用过
• 对象重新分配了内存空间
• 给对象赋予了空值null
• 给对象赋予了新值

解析：

在java语言中，判断一块内存空间是否符合垃圾收集器收集标准的标准只有两个：

1.给对象赋值为null，以下没有调用过。

2.给对象赋了新的值，重新分配了内存空间。

Cat obj=new Cat();

obj=null;//这个应该叫对象的引用置为了null，回收的是之前new Cat()时申请到的内存

obj=new Cat();//这个叫对象引用重新指向了另外一个对象，赋予了新值，回收的是上次new Cat()的内存