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

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

1.类 ABC 定义如下：

1 ． public  class  ABC{

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

3 ．

4 ． }

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

• public  float  max(float  a, float  b, float  c){  }
• public  int  max (int  c,  int  d){  }
• public  float  max(float  a,  float  b){  }
• private  int  max(int a, int b, int c){  }

解析：首先，了解重载的定义，Java的方法重载，就是在同一个类中可以创建多个方法，它们具有相同的名字，但具有不同的参数个数哥不同定义，调用方法时通过传递给它们的不同参数个数和类型来决定具体使用哪个方法。当方法同名时，至少需要下面之一不同: 1.参数个数不同 2.对应位置上的参数类型不同 看看B选项，方法同名不管，参数个数相同(都是2个)，对应位置上的参数类型都相同(都是int类型)，所以判断该方法不能插入。

2.以下关于 abstract 关键字的说法，正确的是（）

• abstract 可以与final 并列修饰同一个类。
• abstract 类中不可以有private的成员。
• abstract 类中必须全部是abstract方法。
• abstract 方法必须在abstract类或接口中。

解析：1.abstract类不能与final,static使用。final修饰方法，子类可以调用，但不能覆盖；2.最好不要有private因为私有和抽象放在一起，子类如果想重写父类的私有方法根本继承不过来，也就无法重写；3.抽象类中可以有非抽象方法；4.抽象类中可以都是非抽象的，但是抽象方法一定要在类和接口中。

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

Float  s=new  Float(0.1f);

Float  t=new  Float(0.1f);

Double  u=new  Double(0.1);

• s==t
• s.equals(t)
• u.equals(s)
• t.equals(u)

解析：题目A比较的是两个对象的地址，显然不同的对象地址不同，A是false。B同属于Float对象且值相等，true。C和D比较的对象不同，false。

4.下列代码中的错误是（）

(1)   public class Test

(2)   {

(3)       public static void main(String [] args)

(4)       {

(5)           int i;

(6)           i+=1;

(7)       }

(8)     }

• 非法的表达式 i+=1
• 找不到符号i
• 类不应为public
• 尚未初始化变量i

5.try块后必须有catch块。（）

• 正确
• 错误

解析：

catch可以省略，try的形式有三种：

try-catch

try-finally

try-catch-finally

但catch和finally语句不能同时省略！

6.执行如下程序，输出结果是（ ）

class Test
{
     private int data;
     int result = 0;
     public void m()
     {
         result += 2;
         data += 2;
         System.out.print(result + "  " + data);
     }
 }
 class ThreadExample extends Thread
 {
     private Test mv;
     public ThreadExample(Test mv)
     {
         this.mv = mv;
     }
     public void run()
     {
         synchronized(mv)
         {
             mv.m();
         }
     }
 }
 class ThreadTest
 {
     public static void main(String args[])
     {
         Test mv = new Test();
         Thread t1 = new ThreadExample(mv);
         Thread t2 = new ThreadExample(mv);
         Thread t3 = new ThreadExample(mv);
         t1.start();
         t2.start();
         t3.start();
     }
 }

• 0 22 44 6
• 2 42 42 4
• 2 24 46 6
• 4 44 46 6

解析：

Test mv =newTest()声明并初始化对data赋默认值 

使用synchronized关键字加同步锁线程依次操作m() 

t1.start();使得result=2,data=2,输出即为2 2 

t2.start();使得result=4,data=4,输出即为4 4 

t3.start();使得result=6,data=6,输出即为6 6 

System.out.print(result +" "+ data);是print()方法不会换行,输出结果为2 24 46 6

7.下面有关JSP内置对象的描述，说法错误的是？

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

解析：application对象是共享的，多个用户共享一个，以此实现数据共享和通信。

8.选项中哪一行代码可以替换 //add code here 而不产生编译错误

1 2 3 4 5

public abstract class MyClass {      public int constInt = 5;      //add code here      public void method() {      }

• public abstract void method(int a);
• consInt=constInt+5;
• public int method();
• public abstract void anotherMethod(){}

解析：

A是抽象方法，抽象类可以包含抽象方法，也可以不包含，实现重载。（√）

B 在类中不能constInt = constInt + 5（×）

C 返回值不能作为重载的依据（×）

D 有方法体的不能作为抽象函数（×）

9.String str1 = “abc”，“abc”分配在内存哪个区域？

• 堆
• 栈
• 字符串常量区
• 寄存器

解析：用new创建的对象在堆区；函数中的临时变量在栈去；java中的字符串在字符串常量区。

10.java如何返回request范围内存在的对象？

• request.getRequestURL()
• request.getAttribute()
• request.getParameter()
• request.getWriter()

解析：request.getAttribute()方法返回request范围内存在的对象，而request.getParameter()方法是获取http提交过来的数据。getAttribute是返回对象,getParameter返回字符串。

11.下列程序的运行结果

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

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

• pingpong
• pongping
• pingpong和pongping都有可能
• 都不输出

12.下列语句哪一个是不正确的（）

• Log4j支持按分钟为间隔生成新的日志文件
• Log4j是一个打印日志用的组件
• Log4j支持按年为间隔生成新的日志文件
• Log4j的日志打印级别可以在运行时重新设置

解析：日志的级别之间的大小关系如右所示：ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < OFF Log4j建议只使用四个级别，优先级从高到低分别是 ERROR > WARN > INFO > DEBUG。 log4j在运行期间是不可以重新设置的。

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

• 能被java.exe成功运行的java class文件必须有main()方法
• J2SDK就是Java API
• Appletviewer.exe可利用jar选项运行.jar文件
• 能被Appletviewer成功运行的java class文件必须有main()方法

14.下列关于一个类的静态成员的描述中，不正确的是（）

• 该类的对象共享其静态成员变量的值
• 静态成员变量可被该类的所有方法访问
• 该类的静态方法能访问该类的静态成员变量
• 该类的静态数据成员变量的值不可修改

解析： 静态数据成员变量的值可以修改。

15.下列描述中，错误的是（）

• SQL语言又称为结构化查询语言

• java中”static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问

• 面向对象开发中，引用传递意味着传递的并不是实际的对象，而是对象的引用，因此，外部对引用对象所做的改变不会反映到所引用的对象上

• java是强类型语言，javascript是弱类型语言

• 面向对象的三大特性包括：封装，继承，多态

解析：这道题选C，因为引用代表引用的是实际的对象，对引用的修改就是对对象的修改，可以理解为两把钥匙可以打开同一扇门，所以C错；其他几个选项都是对的。

16.下面代码的执行结果是 :

class Chinese{

    private static Chinese objref =new Chinese();

    private Chinese(){}

    public static Chinese getInstance() { return objref; }

}

 

public class TestChinese {

    public static void main(String [] args) {

    Chinese obj1 = Chinese.getInstance();

    Chinese obj2 = Chinese.getInstance();

    System.out.println(obj1 == obj2);

}

}

• true
• false
• TRUE
• FALSE

解析：单例模式，obj1和obj2其实是一个对象,应该返回true。

17.请问所有的异常类皆直接继承于哪一个类？（）

• java.applet.Applet
• java.lang.Throwable
• java.lang.Exception
• java.lang.Error

解析：

18.Given:

1 2 3 4 5 6 7 8 9 10

public class IfTest{     public static void main(string[]args){         int x=3;         int y=1;         if(x=y)             System.out.println(“Not equal”);         else             System.out.println(“Equal”);      } }

What is the result?

• The output is “Equal”
• The output in “Not Equal”
• An error at line 5 causes compilation to fall.
• The program executes but does not print a message.

解析：

这个题考查两个知识点：

1.Java中，赋值是有返回值的 ，赋什么值，就返回什么值。比如这题，x=y，返回y的值，所以括号里的值是1；

2.Java跟C的区别，C中赋值后会与0进行比较，如果大于0，就认为是true；而Java不会与0比较，而是直接把赋值后的结果放入括号。

19.关于java编译和运行命令叙述不正确的是？  ( )

• 运行“java Scut.class”
• 运行“java Scut”
• 运行“javac Scut.java”的输出文件是Scut.class
• java这个命令的运行对象是Scut.class

解析：

A  错误 运行命令是 java + 你的 Java 程序的名字但是不加后缀 所以这道题错在多了 .class这个后缀

B  正确

C  javac 是编译命令，后跟 你的 Java 程序名字加后缀，也就是 YourClassName.java 所以答案正确

D JVM （Java 虚拟机）运行的是编译后的字节码文件（以.class为后缀的文件），也就是 YourClassName.class 所以答案正确

20.关于异常的编程，以下描述错误的是：（ ）

• 在有除法存在的代码处，为了防止分母为零，必须抛出并捕获异常
• int i=Integer.parseInt(”123a”);将产生NumberFormatException
• int a[]=null; a[0]=1; 将产生NullPointerException
• 输入输出流编程中，读和写时都要抛出IOException

解析：Java的异常分为两种，一种是运行时异常（RuntimeException），一种是非运行异常也叫检查式异常（CheckedException）。

1.运行时异常不需要程序员去处理，当异常出现时，JVM会帮助处理。常见的运行时异常有：

ClassCastException(类转换异常)

ClassNotFoundException

IndexOutOfBoundsException(数组越界异常)

NullPointerException(空指针异常)

ArrayStoreException(数组存储异常，即数组存储类型不一致)

还有IO操作的BufferOverflowException异常

2.非运行异常需要程序员手动去捕获或者抛出异常进行显示的处理，因为Java认为Checked异常都是可以被修复的异常。常见的异常有：

IOException

SqlException

21.关于 Socket 通信编程，以下描述正确的是：（ ）

• 客户端通过new ServerSocket()创建TCP连接对象
• 客户端通过TCP连接对象调用accept()方法创建通信的Socket对象
• 客户端通过new Socket()方法创建通信的Socket对象
• 服务器端通过new ServerSocket()创建通信的Socket对象

解析：客户端通过new Socket()方法创建通信的Socket对象；服务器端通过new ServerSocket()创建TCP连接对象 accept接纳客户端请求。

22.由3 个“1”和 5 个“0”组成的 8 位二进制补码，能表示的最小整数（）

• -126
• -125
• -32
• -3

解析：既然求最小整数，那肯定先想到负数，则最高位（符号位）一定为1，原码中肯定是1所在的位数越高，值越小，而补码是由原码取反加1得到的，则在补码中1所在的位数一定要越低，即补码为1000 0011；由补码求得原码：1111 1101=-(64+32+16+8+4+1)=-125。

23.以下代码将打印出（）

1 2 3 4

public static void main (String[] args) {      String classFile = "com.jd.". replaceAll(".", "/") + "MyClass.class";     System.out.println(classFile); }

• com. jd
• com/jd/MyClass.class
• ///MyClass.class
• com.jd.MyClass

解析：C.由于replaceAll方法的第一个参数是一个正则表达式，而"."在正则表达式中表示任何字符，所以会把前面字符串的所有字符都替换成"/"。如果想替换的只是"."，那么就要写成"\\."。

24.下面哪些语法结构是正确的？

• public class A extends B implements C

• public class A implements A B

• public class A implements B,C,D

• public implements B

解析：

A选项- 标准写法，正确

1	public class A extends B implements C

B选项- implements接的是接口类 而A此处的定义又是class
循环矛盾，必然错误

1	public class A implements A B

C选项- 正确，一个类可以实现多个接口（但是题目拼写有误- -）

1	public class A implements B,C,D

D选项- 错误。

1	public implements B

另外补充一点，如果一个类既继承了某个基类，又实现了接口。那么extends关键字必须在implements之前。

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

• java.util.ConcurrentHashMap

• java.util.Map

• java.util.TreeMap

• java.util.SortMap

• java.util.Hashtable

• java.util.HashMap

解析：

java.util.concurrent.ConcurrentHashMap 线程安全

java.util.Map 接口

java.util.TreeMap

java.util.SortedMap 接口

java.util.Hashtable 线程安全

java.util.HashMap

26.下面有关servlet的层级结构和常用的类，说法正确的有?

• GenericServlet类：抽象类，定义一个通用的、独立于底层协议的Servlet。
• 大多数Servlet通过从GenericServlet或HttpServlet类进行扩展来实现
• ServletConfig接口定义了在Servlet初始化的过程中由Servlet容器传递给Servlet得配置信息对象
• HttpServletRequest接口扩展ServletRequest接口，为HTTP Servlet提供HTTP请求信息

解析：

27.下面程序输出结果为（）：
public class Demo{
public static void main (String [] args) {
String lx = “LeXin”;
String nb = lx;
lx = “Fenqile”;
System.out.println(nb);
}
}

• 程序异常，编译不通过
• 程序编写正常，可正常运行
• 程序输出值为“LeXin”
• 程序输出值为“Fenqile”

28.java8中，忽略内部接口的情况，不能用来修饰interface里的方法的有（ ）

• private
• public
• protected
• static

解析：Java8的接口方法可以有如下定义：only public, abstract, default, static and strictfp are permitted。

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

• private
• public
• protected
• static

解析：

类、方法、成员变量和局部变量的可用修饰符

修饰符	类		成员访求	构造方法	成员变量	局部变量
abstract（抽象的）		√	√	－	－	－
static （静态的）		－	√	－	√	－
public（公共的）		√	√	√	√	－
protected（受保护的）			√	√	√	－
private（私有的）		－	√	√	√	－
synchronized（同步的）		－	√	－	－	－
native（本地的）		－	√	－	－	－
transient（暂时的）		－	－	－	√	－
volatie（易失的）		－	－	－	√	－
final（不要改变的）		√	√	－	√	√

类 修饰符
Public	可以从其他类中访问
Abstract	本类不能被实例化
Final	不能再声明子类
构造函数修饰符
Public	可以从所有的类中访问
Protected	只能从自己的类和它的子类中访问
Private	只能在本类中访问
域/成员变量修饰符
Public	可以从所有的类中访问
Protected	只能从本类和它的子类中访问
Private	只能从本类中访问它
Static	对该类的所有实例只能有一个域值存在
transient	不是一个对象持久状态的一部份
Volatile	可以被异步的线程所修改
final	必须对它赋予初值并且不能修改它
局部变量 修饰符
final	必须对它赋予初值并且不能修改它
方法修饰符
Public	可以从所有的类中访问它
Protected	只能从本类及其子类中访问它
Private	只能从本类中访问它
abstract	没有方法体，属于一个抽象类
final	子类不能覆盖它
static	被绑定于类本身而不是类的实例
native	该方法由其他编程语言实现
asnchronized	在一个线程调用它之前必须先给它加

30.

1 2 3 4 5 6 7

byte b1=1,b2=2,b3,b6,b8; final byte b4=4,b5=6,b7; b3=(b1+b2);  /*语句1*/ b6=b4+b5;    /*语句2*/ b8=(b1+b4);  /*语句3*/ b7=(b2+b5);  /*语句4*/ System.out.println(b3+b6);

下列代码片段中，存在编译错误的语句是()

• 语句2
• 语句1
• 语句3
• 语句4

知识点：Java表达式转型规则由低到高转换：

1.所有的byte,short,char型的值将被提升为int型；

2.如果有一个操作数是long型，计算结果是long型；

3.如果有一个操作数是float型，计算结果是float型；

4.如果有一个操作数是double型，计算结果是double型；

5.被fianl修饰的变量不会自动改变类型，当2个final修饰相操作时，结果会根据左边变量的类型而转化。

解析：

语句1错误：b3=(b1+b2);自动转为int，所以正确写法为b3=(byte)(b1+b2);或者将b3定义为int；

语句2正确：b6=b4+b5;b4、b5为final类型，不会自动提升，所以和的类型视左边变量类型而定，即b6可以是任意数值类型；

语句3错误：b8=(b1+b4);虽然b4不会自动提升，但b1仍会自动提升，所以结果需要强转，b8=(byte)(b1+b4);

语句4错误：b7=(b2+b5); 同上。同时注意b7是final修饰，即只可赋值一次，便不可再改变。

31.main 方法是 Java Application 程序执行的入口点，以下描述哪项是合法的（）。

• public  static  void  main（ ）
• public  static  void   main（ String  args[] ）
• public static int  main（String  [] arg ）
• public  void  main（String  arg[] ）

解析：方法的名字必须是main，方法必须是public static void 类型的，方法必须接收一个字符串数组的参数  string[] args 和string args[]相同。

32.在 Java 中，存放字符串常量的对象属于（ ）类对象。

• Character

• String

• StringBuffer

• Vector

解析：生成字符串的两个类String和StringBuffer中，前者生成的字符串是不变字符串，不能直接对它的内容进行修改，而后者生成的字符串是可变的，可以对其内容进行修改。而Character类是对字符类型的类封装。Vector类是Java语言提供给用户的一种通用类，是一种链表结构的类型。

33.

1 2	以下语句的执行结果是什么？ 1+”10”+3+”2”

• ”11032”
• “16”
• 16
• “32101”

解析：

1 2 3 4 5

System.out.println(1+"10"+3+"2");//11032 System.out.println(1+2+"10"+3+"2");//31032 System.out.println(1+"10"+3+1+"2");//110312   注意“+”的两边的类型

在遇到string类型之前，int间使用“+”还是表示数值的相加，但是遇到第一个string后，后面就都是按string类型来了，变成字符串的拼接。

34.

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

class B extends Object {     static     {         System.out.println("Load B");     }     public B()     {         System.out.println("Create B");     } } class A extends B {     static     {         System.out.println("Load A");     }     public A()     {         System.out.println("Create A");     } }   public class Testclass {     public static void main(String[] args)     {         new A();     } }

• Load B ->Create B->Load A -> Create A
• Load B -> Load A  ->Create B  ->Create A
• Load B -> Create B-> Create A -> Load A
• Create B ->Create A ->Load B ->Load A

解析：初始化块在构造器执行之前执行，类初始化阶段先执行最顶层父类的静态初始化块，依次向下执行，最后执行当前类的静态初始化块；创建对象时，先调用顶层父类的构造方法，依次向下执行，最后调用本类的构造方法。

执行顺序：

父类静态代码块-》子类静态代码块-》父类构造代码块-》父类构造函数-》子类构造代码块-》子类构造函数

35.下列选项中属于面向对象设计方法主要特征的是（ ）。

• 继承
• 自顶向下
• 模块化
• 逐步求精

解析：面向对象如果有三大特征，那就是：封装、继承、多态；面向对象如果有四大特征，那就是：抽象、封装、继承、多态

36.执行下列程序的输出结果为（      ）

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

public class Test {  public static void main(String[] args) {  String s1 = "HelloWorld";  String s2 = new String("HelloWorld");  if (s1 == s2) {  System.out.println("s1 == s2");  } else {  System.out.println("s1 != s2");  }  if (s1.equals(s2)) {  System.out.println("s1 equals s2");  } else {  System.out.println("s1 not equals s2");  }  }  }

• s1 == s2
  s1 not equals s2

• s1 == s2
  s1 equals s2

• s1 != s2
  s1 not equals s2

• s1 != s2
  s1 equals s2

解析：== 和 equals():

(1)“==” 用于比较基本数据类型时比较的是值，用于比较引用类型时比较的是引用指向的地址。

(2)Object 中的equals() 与 “==” 的作用相同，但String类重写了equals()方法，比较的是对象中的内容。

37.JSP 表达式的写法：（）

• <% expression %>
• <=% expression %>
• <%= expression %>
• <expression/>

解析：正确答案应该是C。 A,C 都是正确的JSP语法。但是功能是不一样的。 

A JSP脚本(Scriptlet)，是Java代码块。

C JSP表达式(expression)，表达式是一个有返回值的式子，它返回的结果将由out.print()进行输出。

38.

1 2 3 4 5 6

Integer a = 1; Integer b = 1; Integer c = 500; Integer d = 500; System.out.print(a == b); System.out.print(c == d);

上述代码返回结果为：（）

• true、true
• true、false
• false、true
• false、false

解析：Interger的范围时[-128,127]，在这个范围内比较大小，相等为true，超过范围为false。

39.关于C++/JAVA类中static 成员和对象成员的说法正确的是？（）

• static 成员变量在对象构造时生成
• static 成员函数在对象成员函数中无法调用
• 虚成员函数不可能是static 成员函数
• static 成员函数不能访问static 成员变量

解析：

A、static成员变量是在类加载的时候生成的

B、static成员函数既可以通过类名直接调用，也可以通过对象名进行调用

C、虚函数是C++中的，虚函数不可能是static的，static为成员变量或函数，在类初始化是加载完成，可以被成员函数调用或访问

D、static成员函数可以访问static成员变量

40.下面属于java合法变量定义的是？（）

• final
• 1var1
• _var2
• var3&

解析：

A.final 是关键字

B.不能以数字做首写

C.首写字母可以为下划线

D.不能与&相组合来命名

41.设三个整型变量 x = 1 , y = 2 , z = 3，则表达式 y＋＝z－－/＋＋x 的值是(      )。

• 3
• 3.5
• 4
• 5

解析：y是2，返回的结果是2+（z--/++x），再来看z--/++x，结果应该是3/2，但是因为x,y,z都是int型的，所以最后的返回值只能是int，这时候z--/++x的值就是1，那么最终的结果就是2+1=3

z--是后减，先输出后减一

42.一般情况下，以下哪个选项不是关系数据模型与对象模型之间匹配关系？

• 表对应类
• 记录对应对象
• 表的字段对应类的属性
• 表之间的参考关系对应类之间的依赖关系

解析：一般关系数据模型和对象数据模型之间有以下对应关系：表对应类，记录对应对象，表的字段对应类的属性。

43.执行下面的程序段，语句3的执行次数为（）
for   （i=0; i<=n-1; i++)   (1)
for  (j=n; j>i; j--）           (2)
state;                      (3)

• n(n+2)/2
• (n-1)(n+2)/2
• n(n+1)/2
• (n-1)(n+2)

解析：选c，外循环有n次，当i=0,内循环为n次,当i=1,内循环为n-1次,当i=2时，内循环为n-2次，以此类推，总次数为n+(n-1)+(n-2)+......+2+1,就是个等差数列，等于n(n+1)/2。

44.有以下一个对象：

1 2 3 4 5 6 7 8 9 10

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:

1 2 3

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

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

• "", 0
• "", 2
• "123", 2
• "123", 0

解析：这道题的答案应该是: D,序列化保存的是对象的状态，静态变量属于类的状态，因此，序列化并不保存静态变量。所以i是没有改变的，string是数据类型，static表示的才是静态变量，string只是final类，并且实现了Serializable接口，所以能被序列化和反序列化。 另外外部类不能被static修饰。

45.关于Java语言描述正确的是？  ( )

• java和C++都保留了指针
• java和C++都有三个特征：封装、继承和多态
• java的垃圾回收机制是指程序结束时系统自动回收内存
• 以上说法都不正确

解析：A，Java没有指针，只有引用。

C，并不是程序结束的时候进行GC，GC的时间是不确定的，且GC的过程需要经过可达性分析，一个对象只有被标记两次才会被GC。

下图是一个对象被GC的全过程。

46.下面这条语句一共创建了多少个对象：String s="welcome"+"to"+360;

• 1
• 2
• 3
• 4

解析：

1 2 3 4 5 6

String test="javaandpython";  String str1="java";  String str2="and";  String str3="python";  System. out. println(test=="java"+"and"+"python"):  System. out. println(test ==str1 + str2 + str3);

对于上面这段代码，结果是true false

这是因为字符串字面量拼接操作是在Java编译器编译期间就执行了，也就是说编译器编译时，直接把"java"、"and"和"python"这三个字面量进行"+"操作得到一个"javaandpython" 常量，并且直接将这个常量放入字符串池中，这样做实际上是一种优化，将3个字面量合成一个，避免了创建多余的字符串对象（只有一个对象"javaandpython"，在字符串常量池中）。而字符串引用的"+"运算是在Java运行期间执行的，即str1 + str2 + str3在程序执行期间才会进行计算，它会在堆内存中重新创建一个拼接后的字符串对象。且在字符串常量池中也会有str1,str2与str3，这里创建多少个新的对象与原来字符串常量池中有没有str1\str2\str3有关，如果之前存在就不会创建新的对象。

总结来说就是：字面量"+"拼接是在编译期间进行的，拼接后的字符串存放在字符串池中；而字符串引用的"+"拼接运算实在运行时进行的，新创建的字符串存放在堆中。

那么再来看这题，很明显只在编译期间在字符串常量池中创建了"welcometo360"一个字符串

47.假如某个JAVA进程的JVM参数配置如下：
-Xms1G -Xmx2G -Xmn500M -XX:MaxPermSize=64M -XX:+UseConcMarkSweepGC -XX:SurvivorRatio=3,
请问eden区最终分配的大小是多少？

• 64M
• 500M
• 300M
• 100M

解析：

• Xms 起始内存
• Xmx 最大内存
• Xmn 新生代内存
• Xss 栈大小。 就是创建线程后，分配给每一个线程的内存大小
• -XX:NewRatio=n:设置年轻代和年老代的比值。如:为3，表示年轻代与年老代比值为1：3，年轻代占整个年轻代年老代和的1/4
• -XX:SurvivorRatio=n:年轻代中Eden区与两个Survivor区的比值。注意Survivor区有两个。如：3，表示Eden：Survivor=3：2，一个Survivor区占整个年轻代的1/5
• -XX:MaxPermSize=n:设置持久代大小

收集器设置

• -XX:+UseSerialGC:设置串行收集器
• -XX:+UseParallelGC:设置并行收集器
• -XX:+UseParalledlOldGC:设置并行年老代收集器
• -XX:+UseConcMarkSweepGC:设置并发收集器

垃圾回收统计信息

• -XX:+PrintGC
• -XX:+PrintGCDetails
• -XX:+PrintGCTimeStamps
• -Xloggc:filename

并行收集器设置

• -XX:ParallelGCThreads=n:设置并行收集器收集时使用的CPU数。并行收集线程数。
• -XX:MaxGCPauseMillis=n:设置并行收集最大暂停时间
• -XX:GCTimeRatio=n:设置垃圾回收时间占程序运行时间的百分比。公式为1/(1+n)

并发收集器设置

• -XX:+CMSIncrementalMode:设置为增量模式。适用于单CPU情况。
• -XX:ParallelGCThreads=n:设置并发收集器年轻代收集方式为并行收集时，使用的CPU数。并行收集线程数。

解：-Xms1G -Xmx2G -Xmn500M -XX:MaxPermSize=64M -XX:+UseConcMarkSweepGC -XX:SurvivorRatio=3,

-Xms1G    设置Java堆最小值为1G    

-Xmx2G    设置Java堆最大值为2G

-Xmn500M    设置新生代大小为500M（一个Eden区，两个Survivor区）

-XX:MaxPermSize=64M    设置永久代大小为64M

-XX:+UseConcMarkSweepGC     设置使用CMS收集器

-XX:SurvivorRatio=3    设置Eden区与Survivor区大小的比例

本题看新生代大小，新生代为500M，三个区比例为3：1：1，很容易计算出Eden大小为300M。

48.关于AWT和Swing说法正确的是？

• Swing是AWT的子类
• AWT在不同操作系统中显示相同的风格
• AWT不支持事件类型，Swing支持事件模型
• Swing在不同的操作系统中显示相同的风格

解析：AWT和Swing都是java中的包。

AWT(Abstract Window Toolkit)：抽象窗口工具包，早期编写图形界面应用程序的包。

Swing ：为解决 AWT 存在的问题而新开发的图形界面包。Swing是对AWT的改良和扩展。    

AWT和Swing的实现原理不同：
       AWT的图形函数与操作系统提供的图形函数有着一一对应的关系。也就是说，当我们利用 AWT构件图形用户界面的时候，实际上是在利用操作系统的图形库。
       不同的操作系统其图形库的功能可能不一样，在一个平台上存在的功能在另外一个平台上则可能不存在。为了实现Java语言所宣称的"一次编译，到处运行"的概念，AWT不得不通过牺牲功能来实现平台无关性。因此，AWT 的图形功能是各操作系统图形功能的“交集”。
        因为AWT是依靠本地方法来实现功能的，所以AWT控件称为“重量级控件”。 

       而Swing ，不仅提供了AWT 的所有功能，还用纯粹的Java代码对AWT的功能进行了大幅度的扩充。
       例如：并不是所有的操作系统都提供了对树形控件的支持， Swing则利用了AWT中所提供的基本作图方法模拟了一个树形控件。
       由于 Swing是用纯粹的Java代码来实现的，因此Swing控件在各平台通用。
       因为Swing不使用本地方法，故Swing控件称为“轻量级控件”。 

       AWT和Swing之间的区别：
       1)AWT 是基于本地方法的C/C++程序，其运行速度比较快；Swing是基于AWT的Java程序，其运行速度比较慢。
       2)AWT的控件在不同的平台可能表现不同，而Swing在所有平台表现一致。

       在实际应用中，应该使用AWT还是Swing取决于应用程序所部署的平台类型。例如：
       1)对于一个嵌入式应用，目标平台的硬件资源往往非常有限，而应用程序的运行速度又是项目中至关重要的因素。在这种矛盾的情况下，简单而高效的AWT当然成了嵌入式Java的第一选择。
       2)在普通的基于PC或者是工作站的标准Java应用中，硬件资源对应用程序所造成的限制往往不是项目中的关键因素。所以在标准版的Java中则提倡使用Swing， 也就是通过牺牲速度来实现应用程序的功能。

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

• num * count = 505000
• num * count = 0
• 运行时错误
• num * count = 5050

解析：count = count++ 原理是

temp = count；

count = count+1 ；

count = temp；   因此count始终是0 ，count = count++；中count++是先赋值，后++赋的值为0，所以count为0

50.What is displayed when the following is executed;

1 2 3

double d1=-0.5; System.out.println("Ceil d1="+Math.ceil(d1)); System.out.println("floor d1="+Math.floor(d1));

• Ceil d1=-0.0
  floor d1=-1.0

• Ceil d1=0.0
  floor d1=-1.0

• Ceil d1=-0.0
  floor d1=-0.0

• Ceil d1=0.0
  floor d1=0.0

• Ceil d1=0
  floor d1=-1

解析：ceil：大于等于 x，并且与它最接近的整；floor：小于等于 x，且与 x 最接近的整数。

51.下面哪些类实现或继承了 Collection 接口？

• HashMap
• ArrayList
• Vector
• Iterator

解析：

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

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

解析：ArrayList插入和现有项的删除开销很大,除非在末端，LinkedList插入和删除开销很小，ArrayList和LinkedList都是实现了List接口，HashMap可以用null值和空字符串作为K,不过只能有一个

53.下列关于if-else if选择结构的说法正确的是（）

• 多个else if块之间的顺序可以改变，改变之后对程序的执行结果没有影响
• 多个else if块之间的顺序可以改变，改变之后可能对程序的执行结果有影响
• 多个else if块之间的顺序不可以改变，改变后程序编译不通过
• 多个else if块之间的顺序可以改变，改变后程序编译可以通过

54.已知String a="a",String b="b",String c=a+b,String d=new String("ab") 以下操作结果为true的是

• (a+b).equals(c)
• a+b==c
• c==d
• c.equals(d)

解析：== 和 equals():

(1)“==” 用于比较基本数据类型时比较的是值，用于比较引用类型时比较的是引用指向的地址。

(2)Object 中的equals() 与 “==” 的作用相同，但String类重写了equals()方法，比较的是对象中的内容。

55.以下代码可以使用的修饰符是：（）

1 2 3

public interface Status {  /*INSERT CODE HERE*/  int MY_VALUE=10;  }

• final

• static

• abstract

• public

解析：abstract只能修饰类和方法 不能修饰字段

56.实现或继承了Collection接口的是（）

• Map
• List
• Vector
• Iterator
• Set

解析：

A，Map接口未实现Collection接口

B，List接口的定义为public interface List&lt;E&gt;extends Collection&lt;E&gt;C，Vector定义为

public class&nbsp;Vector&lt;E&gt;extends&nbsp;AbstractList&lt;E&gt;implements&nbsp;List&lt;E&gt;,&nbsp;RandomAccess,&nbsp;Cloneable,&nbsp;Serializable

Vector实现了List接口自然实现了Collection接口

D，Iterator接口未实现Collection接口

E，public interface Set&lt;E&gt;extends Collection&lt;E&gt; Set接口继承自Collection接口

57.以下哪些方法是Object类中的方法

• clone()
• toString()
• wait()
• finalize()

58.下列哪些操作会使线程释放锁资源？

• sleep()
• wait()
• join()
• yield()

解析：

1.sleep()方法

在指定时间内让当前正在执行的线程暂停执行，但不会释放“锁标志”。不推荐使用。

sleep()使当前线程进入阻塞状态，在指定时间内不会执行。

2.wait()方法

在其他线程调用对象的notify或notifyAll方法前，导致当前线程等待。线程会释放掉它所占有的“锁标志”，从而使别的线程有机会抢占该锁。

当前线程必须拥有当前对象锁。如果当前线程不是此锁的拥有者，会抛出IllegalMonitorStateException异常。

唤醒当前对象锁的等待线程使用notify或notifyAll方法，也必须拥有相同的对象锁，否则也会抛出IllegalMonitorStateException异常。

waite()和notify()必须在synchronized函数或synchronized　block中进行调用。如果在non-synchronized函数或non-synchronized　block中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。

3.yield方法 

暂停当前正在执行的线程对象。

yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。

yield()只能使同优先级或更高优先级的线程有执行的机会。 

4.join方法

等待该线程终止。

等待调用join方法的线程结束，再继续执行。如：t.join();//主要用于等待t线程运行结束，若无此句，main则会执行完毕，导致结果不可预测。

59.关于Java的一些概念，下面哪些描述是正确的：(        )

• 所有的Java异常和错误的基类都是java.lang.Exception, 包括java.lang.RuntimeException
• 通过try … catch … finally语句，finally中的语句部分无论发生什么异常都会得到执行
• java中所有的数据都是对象
• Java通过垃圾回收回收不再引用的变量，垃圾回收时对象的finallize方法一定会得到执行
• Java是跨平台的语言，无论通过哪个版本的Java编写的程序都能在所有的Java运行平台中运行
• Java通过synchronized进行访问的同步，synchronized作用非静态成员方法和静态成员方法上同步的目标是不同的

解析：

A:Java中所有错误和异常的父类是java.lang.Throwable

B：基本数据类型不是对象，不能用new的方法获取，但是每个基本数据类型都对应着封装类型，这些封装类型为了解决基本数据类型面向对象用的。

C:Java垃圾回收器负责回收无用对象占据的内存资源,但对象没有使用new获取了一块特殊区域，这块特殊区域的回收使用finallize（）

D：Java跨平台是因为有JVM的存在，Java的三个版本的运行需要各自不同的环境。

60.下列容器中，哪些容器按 key 查找的复杂度为 O(log(n)) （）

• std::unordered_set
• std::multimap
• std::map
• std::deque

61.AWT 中用来表示文本框的类是 ( )

• TextField
• Menu
• Label
• List

解析：

AWT(Abstract Window Toolkit)，中文译为抽象窗口工具包，该包提供了一套与本地图形界面进行交互的接口，是Java提供的用来建立和设置Java的图形用户界面的基本工具。

本题主要考查对AWT基本组件的了解。

B、Menu表示下拉菜单

C、Label表示标签

D、List表示列表框

62.下面关于依赖注入(DI)的说法不正确的是()

• 只有通过Spring才能实现依赖注入(DI)
• 依赖注入的主要目的是解耦合
• 常见的依赖注入方式有Setter和构造方法

解释：A,依赖注入是一种思想，或者说是一种设计模式，在java中是通过反射机制实现，与具体框架无关。

63.下列关于计算机系统和Java编程语言的说法，正确的是（）

• 计算机是由硬件、操作系统和软件组成，操作系统是缺一不可的组成部分。
• Java语言编写的程序源代码可以不需要编译直接在硬件上运行。
• 在程序中书写注释不会影响程序的执行，可以在必要的地方多写一些注释。
• Java的集成开发环境（IDE），如Eclipse，是开发Java语言必需的软件工具

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

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

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

• HelloSogou
• SogouHello
• Hello
• 结果不确定

解释：我觉得误区有两个：一个是run和start区别，Thread.run()是调用方法，Thread. start()是启动线程；另一个是锁持有问题。这个题是调用方法，和多线程就无关。链接：
代码执行过程如下：

首先执行main()方法，main方法获得锁---》t.run()不会创建线程，只是当作普通方法执行，因此Sougou()是在主线程里执行，输出Sogou ---》System.out.println("Hello") --》结束。其实自始至终都只有主线程的存在，所以没有存在过锁竞争，代码按照顺序执行。这里调用t.run();并没有启动一个新的线程，启动一个新线程要用t.start();所以执行顺序是先执行run（），再执行 System.out.print("HELLO");

但是如果这里是t.start()，执行过程如下：

执行main方法，main方法获得锁--》t.start()创建线程(thread1)--》t.start自动执行run方法，锁此时在主线程，线程阻塞--》主线程执行System.out.println("Hello"),执行完毕，释放锁---->thread1获取锁，执行Sougou方法，输出Sougou--》结束  此时输出为HelloSougou

 

 

65.若有定义语句： int a=10 ; double b=3.14 ; 则表达式 'A'+a+b 值的类型是（）

• char
• int
• double
• float

解析：char < short < int < float < double  不同类型运算结果类型向右边靠齐。

66.以下JAVA程序代码的输出是

1 2 3

public static void main(String args[]) { System.out.println(14^3); }

• 2744
• 13
• 17
• 11

解析：^表示异或 就是相同是0 不同是1

   14是1110

   3是0011

   所以14^3=1101，即13

67.以下哪项可能包含菜单条（ ）

• Panel
• Frame
• Applet
• Dialog

解析：Frame是Window的直接子类，一个Frame对象就是一个有标题有边界的顶层窗口；Panel是Container的直接子类，一个Panel对象用来添加组件和其他Panel对象的容器。

68.下列代码输出结果为（      ）

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

class Animal{     public void move(){         System.out.println("动物可以移动");     } } class Dog extends Animal{     public void move(){         System.out.println("狗可以跑和走");     }     public void bark(){         System.out.println("狗可以吠叫");     } } public class TestDog{     public static void main(String args[]){         Animal a = new Animal();         Animal b = new Dog();          a.move();         b.move();         b.bark();     } }

• 动物可以移动
  狗可以跑和走
  狗可以吠叫

• 动物可以移动
  动物可以移动
  狗可以吠叫

• 运行错误

• 编译错误

解析：编译看左边，运行看右边。 父类型引用指向子类型对象，无法调用只在子类型里定义的方法：Animal b = new Dog(); 编译器会把当前类型当做父类类型，但是运行时是右边子类类型，所以在用父类调用bark方法时，是不存在的，会编译报错

69.下面哪些是重载的基本条件（）

• 参数的类型不同
• 参数类型的顺序不同(比如 int a , float b 与 float b , int a)
• 函数的返回值类型不同
• 参数的个数不同

解析：重载的概念是：

          方法名称相同，参数个数、次序、类型不同

         因此重载对返回值没有要求，可以相同，也可以不同

         但是如果参数的个数、类型、次序都相同，方法名也相同，仅返回值不同，则无法构成重载

70.对于线程局部存储TLS(thread local storage)，以下表述正确的是（）

• 解决多线程中的对同一变量的访问冲突的一种技术
• TLS会为每一个线程维护一个和该线程绑定的变量的副本
• 每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了
• Java平台的java.lang.ThreadLocal是TLS技术的一种实现

解析：ThreadLocal可以给一个初始值，而每个线程都会获得这个初始化值的一个副本，这样才能保证不同的线程都有一份拷贝。ThreadLocal 不是用于解决共享变量的问题的，不是为了协调线程同步而存在，而是为了方便每个线程处理自己的状态而引入的一个机制。

71.有这样一段程序：

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

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

请问运行主要的程序会打印出的是什么（）

• 2,2
• 2,3
• 3,2
• 3,3

解析：list有序可重复，set无序不可重复

72.下列程序执行后输出结果为（      ）

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

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

• static BaseClass
  I’m BaseClass class
  static Base
  I’m Base class

• I’m BaseClass class
  I’m Base class
  static BaseClass
  static Base

• I’m BaseClass class
  static BaseClass
  I’m Base class
  static Base

• static BaseClass
  static Base
  I’m BaseClass class
  I’m Base class

解析：执行顺序从左到右： 父类静态代码块 ->子类静态代码块 ->父类非静态代码块 -> 父类构造函数 -> 子类非静态代码块 -> 子类构造函数。

结果为：父类静态代码块
              子类静态代码块
              父类非静态代码块
              父类构造函数
              子类非静态代码块
              子类构造函数 

73.计算机所能处理的最小的数据项称为（）

• 位
• 字节
• 字
• 双字

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

74.下列哪个选项是正确计算42度（角度）的余弦值？

• double d=Math.cos（42）
• double d=Math.cosine（42）
• double d=Math.cos（Math.toRadians（42））
• double d=Math.cos（Math.toDegrees（42））

解析：Math.cos为计算弧度的余弦值，Math.toRadians函数讲角度转换为弧度。

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

1 2 3 4 5 6 7 8 9 10 11

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

• 定义了声明式事务的配置模板

• 对get方法采用只读事务

• 缺少sessionFactory属性的注入

• 配置需要事务管理的bean的代理时，通过parent引用这个配置模板，代码如下：
  <bean id="petBiz" parent="txProxyTemplate"> <property name="target" ref="petTarget"/> </bean> 

解析：

1.Spring本身并不直接管理事务，而是提供了事务管理器接口，对于不同的框架或者数据源则用不同的事务管理器；而对于事务，它把相关的属性都封装到一个实体里边去，有以下的属性:

1 2 3 4

int propagationBehavior;    /*事务的传播行为*/     int isolationLevel;                /*事务隔离级别*/     int timeout;                            /*事务完成的最短时间*/     boolean readOnly;                /*是否只读*/

Spring提供了对编程式事务和声明式事务的支持，编程式事务是嵌在业务代码中的，而声明式事务是基于xml文件配置。

2. readOnly -- 事务隔离级别，表示只读数据，不更新数据

1	3.PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

1 2 3 4 5

PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。  PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。  PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。  PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。  PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。

76.下面哪个不属于HttpServletResponse接口完成的功能？

• 设置HTTP头标
• 设置cookie
• 读取路径信息
• 输出返回数据

解析：

答案：C

A：设置HTTP头标  

1	response.setHeader("Refresh","3"); //三秒刷新页面一次

B：设置cookie

1 2	Cookie c1 = new Cookie("username","only"); response.addCookie(c1);

C（错误）：读取路径信息,request读取路径信息

1 2 3 4 5

从request获取各种路径总结 request.getRealPath("url"); // 虚拟目录映射为实际目录 request.getRealPath("./");    // 网页所在的目录 request.getRealPath("../"); // 网页所在目录的上一层目录 request.getContextPath();    // 应用的web目录的名称

D：输出返回数据

1	HttpServleteResponse.getOutputStream().write();

77.下列哪个选项是合法的标识符？（）

• 123
• _name
• class
• first

解释：Java标识符由 数字、字母、下划线(_)、美元符号($) 组成， 首位不能是数字 。并且 Java关键字不能作为标识符 。

java的关键字不能作为标识符，java中的关键字如下：
访问控制：private    protected    public

类,方法和变量修饰符：abstract    class    extends    final    implements    interface    native    new   static    strictfp    synchronized    transient    volatile
    
程序控制：break    continue    return    do    while    if    else    for    instanceof    switch   case    default
    
异常处理：try    cathc    throw    throws

包相关：import    package
    
基本类型：boolean    byte    char    double    float    int    long    short    null    true    false

变量引用：super    this    void
    
保留字：goto    const

78.servlet周期包含哪些：（）

• 初始化
• 销毁
• 请求处理
• 开始

解析： Servlet 生命周期可被定义为从创建直到毁灭的整个过程。以下是 Servlet 遵循的过程：
            Servlet 通过调用 init () 方法进行初始化。
            Servlet 调用 service() 方法来处理客户端的请求。
            Servlet 通过调用 destroy() 方法终止（结束）。
            最后，Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。

79.关于下面的一段代码，以下哪些说法是正确的：

1 2 3 4 5 6 7 8 9 10

public static void main(String[] args) {     String a = new String("myString");     String b = "myString";     String c = "my" + "String";     String d = c;     System.out.print(a == b);     System.out.print(a == c);     System.out.print(b == c);     System.out.print(b == d); }

• System.out.print(a == b)打印出来的是false

• System.out.print(a == c)打印出来的是true

• System.out.print(b == c)打印出来的是false

• System.out.print(b == d)打印出来的是true

解析：

A：a指向堆内存，b指向常量池，因此地址不相等，false

B：java有常量优化机制，c也指向常量池，且与b指向同一个，则a与c地址不相等,false；

C：b与c地址相等，true

D：d是c的副本，地址相同，所以b与d地址相等，true

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

• 数组是一个对象，不同类型的数组具有不同的类
• 数组长度是可以动态调整的
• 数组是一个连续的存储结构
• 一个固定长度的数组可类似这样定义: int array[100]
• 两个数组用equals方法比较时，会逐个便利其中的元素，对每个元素进行比较
• 可以二维数组，且可以有多维数组，都是在Java中合法的

解析：D、数组的长度是固定的，int[] array =new int[100]就对了

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

• JTextField  b = new  JTextField(“开始”);
• JLabel  b = new  JLabel(“开始”);
• JCheckbox  b = new  JCheckbox(“开始”);
• JButton   b = new  JButton(“开始”);

解释：TextField  文本区域     Label   标签    Checkbox  勾选框    Button  按钮

82.欲定义类字段或类方法（静态方法），应该使用下列哪一个修饰符修饰（）

• public
• static
• protected
• synchronized

解释：修饰符，不存在先后顺序，除了基本类型，前面的都是修饰符， final static 都是修饰符 final static double PI =3.14;

A、 public可以修饰类，数据成员，构造方法，方法成员。被public修饰的成员 ，可以在任何一个类中被调用，不管同包或不同包，是权限最大的一个修饰符。
B、 static用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。
C、 private可以修饰数据成员，构造方法，方法成员，不能修饰类（此处指外部 类，不考虑内部类）。被private修饰的成员，只能在定义它们的类中使用，在 其他类中不能调用。
D、 synchronized可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。

83.StringBuffer类对象创建之后可以再修改和变动（）

• 正确
• 错误

解释：String对象不可变、StringBuffer对象可变的含义：

举个例子：

String str = "aa";

str = "aa"+"bb";

此时str的值为"aabb"，但是"aabb"不是在开始的字符串"aa"后面直接连接的"bb"，而是又新生成了字符串"aabb"，字符串"aa"一旦被初始化，那么它的值不可能再改变了；

StringBuffer strb = StringBuffer("aa");

strb.append("bb");

此时的strb的值也为"aabb"，但是"aabb"是直接在开始的字符串"aa"后面连接的“bb”，并没有生成新的字符串。

84.已知表达式int m[]={0，1，2，3，4，5，6}；下面哪个表达式的值与数组下标量最大值相等？

• m. length()
• m. length-1
• m. length()+1
• m. length+1

解释：数组的下标是从0开始的。

85.下列关于功能性注释不正确的说法是()

• 功能性注释嵌在源程序中，用于说明程序段或语句的功能以及数据的状态
• 注释用来说明程序段，需要在每一行都要加注释
• 可使用空行或缩进，以便很容易区分注释和程序
• 修改程序也应修改注释

86.以下程序

1 2 3 4 5 6

main() {  int m=12,n=34; printf("%d%d",m++,++n); printf("%d%d\n",n++,++m); }

程序运行后的输出结果是（）

• 12353514
• 12353513
• 12343514
• 12343513

解释：m++ = 12+1=13   但是先调用本身再加，++n = 34 +1 =35   先加再调用，n++ = 35 + 1 =36  但是先调用本身再加，++m = 13 + 1 =14   先加再调用。   

printf("%d%d",m++,++n); 12 35

printf("%d%d\n",n++,++m);35 14

87.JVM内存不包含如下哪个部分( )

• Stacks
• PC寄存器
• Heap
• Heap Frame

解释：

88.java中下面哪个能创建并启动线程（）

1 2 3 4 5

public class MyRunnable implements Runnable          {       public void run()             {           //some code here       }    }

• new Runnable(MyRunnable).start()
• new Thread(MyRunnable).run()
• new Thread(new MyRunnable()).start()
• new MyRunnable().start()

解释：首先：创建并启动线程的过程为：定义线程—》实例化线程—》启动线程。

一 、定义线程： 1、扩展java.lang.Thread类。 2、实现java.lang.Runnable接口。

二、实例化线程： 1、如果是扩展java.lang.Thread类的线程，则直接new即可。

        2、如果是实现了java.lang.Runnable接口的类，则用Thread的构造方法：

        Thread(Runnable target) 
        Thread(Runnable target, String name) 
        Thread(ThreadGroup group, Runnable target) 
        Thread(ThreadGroup group, Runnable target, String name) 
        Thread(ThreadGroup group, Runnable target, String name, long stackSize)

所以A、D的实例化线程错误。

三、启动线程： 在线程的Thread对象上调用start()方法，而不是run()或者别的方法。

所以B的启动线程方法错误。

 

 

89.以下程序输出（）

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

public static void main(String[] args) {    int num = 2;    switch (num) {    case 1:         ++num;    case 2:         ++num;    case 3:         ++num;    default:         ++num;    break;    }    System.out.println(num);  } }

• 2
• 3
• 4
• 5

解释：匹配到case 2 num->3 但是其后没有break,所以继续执行case 3 num->4、default  num->5而后结束，遇到break才跳出，所以答案为 5

90.定义有StringBuffer s1=new StringBuffer(10);s1.append(“1234”)则s1.length()和s1.capacity()分别是多少?

• 4   10
• 4   4
• 10  10
• 10  4

解释：

StringBuffer s = new StringBuffer(x);  x为初始化容量长度

s.append("Y"); "Y"表示长度为y的字符串

length始终返回当前长度即y；

对于s.capacity()：

1.当y<x时，值为x

以下情况，容器容量需要扩展

2.当x<y<2*x+2时，值为 2*x+2

3.当y>2*x+2时，值为y

91.下面叙述那个是正确的？（）

• java中的集合类（如Vector）可以用来存储任何类型的对象，且大小可以自动调整。但需要事先知道所存储对象的类型，才能正常使用。
• 在java中，我们可以用违例（Exception）来抛出一些并非错误的消息，但这样比直接从函数返回一个结果要更大的系统开销。
• java接口包含函数声明和变量声明。
• java中，子类不可以访问父类的私有成员和受保护的成员。

解释：B选项说的情况就是我们自定义异常的情况，请仔细读：我们可以用违例（Exception）来抛出一些并非错误的消息，可以，并非错误的消息。比如我自定义一个异常，若一个变量大于10就抛出一个异常，这样就对应了B选项说的情况，我用抛出异常说明这个变量大于10，而不是用一个函数体（函数体内判断是否大于10，然后返回true或false）判断，因为函数调用是入栈出栈，栈是在寄存器之下的速度最快，且占的空间少，而自定义异常是存在堆中，肯定异常的内存开销大！所以B对。
C选项说的是接口包含方法声明和变量声明。因为接口中方法默认是 abstract public,所以在接口只写函数声明是符合语法规则。但是变量默认是用public final static 修饰的，意思它是静态常量，常量不管在接口中还是类中必须在声明时初始化！所以C的后半句是错的，必须在声明时并给出初始化！

92.下面这段程序的输出结果是（）

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

public class Main {     public static void main(String[] args) {         split(12);     }     public static int split(int number) {         if (number > 1) {             if (number % 2 != 0) System.out.print(split((number + 1) / 2));                 System.out.print(split(number / 2));             }         return number;        } }

• 12136
• 63121
• 61213
• 11236

解释：考察方法进栈与出栈的顺序。先进后出

有个知识点，方法在出栈的时候，执行的是return语句。因为出栈就意味着方法结束并消费，如果没有return语句，那么方法出栈的时候什么都不执行，就直接销毁。

1.执行split（12）时，执行代码System.out.print(split(number / 2))

    split（12/2）进栈，此时number=6；

2.执行split（6）时，执行代码System.out.print(split(number / 2))

    split（6/2）进栈，此时number=3；

3.执行split（3）时，

1 2 3

第1行 if (number % 2 != 0) 第2行          System.out.print(split((number + 1) / 2)); 第3行    System.out.print(split(number / 2));

 按照顺序执行   

 先执行第2行

            首先split（(3+1)/2）进栈，此时number=2，

            再执行split（2），那么split（2/2）进栈，此时number=1， 最后return 1，

            注意此时第2行代码还没有结束

            此时

            split（2/2）出栈，输出1；

            split（(3+1)/2）出栈，输出2；

   第二行代码结束，再执行第三行，此时number=3，执行System.out.print(split(number / 2))

           split（3/2）进栈，number=1，return，那么就需要出栈了

split（3/2）出栈，输出1

split（6/2）出栈，输出3

split（12/2）出栈，输出6；

最终结果12136；

 

split（number）方法，最终返回的是number这个值，所以split（n）出栈的输出结果就是n

整理：

split（12/2）进栈

split（6/2）进栈

 

split（(3+1)/2）进栈

split（2/2）进栈

       split（2/2）出栈，输出1

        split（(3+1)/2）出栈，输出2

 

split（2/2）进栈

        split（2/2）出栈，输出1

 

split（6/2）出栈，输出3

split（12/2）出栈，输出6

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

• echo $$返回登录shell的PID和echo $？ 返回上一个命令的状态
• echo $$返回上一个命令和echo $的状态？ 返回登录shell的PID
• echo $$和echo $？ 返回一些无意义的整数值
• 所有陈述都是错误的

解释：

shell中的特殊变量：
变量名
含义
$0
shell或shell脚本的名字
$*
以一对双引号给出参数列表
$@
将各个参数分别加双引号返回
$#
参数的个数
$_
代表上一个命令的最后一个参数
$$
代表所在命令的PID
$!
代表最后执行的后台命令的PID
$?
代表上一个命令执行后的退出状态  echo $? 如果返回值是0，就是执行成功；如果是返回值是0以外的值，就是失败。

 

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

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

public class Test { public static void main(String[] args) { System.out.println(test());   } private static int test() { int temp = 1; try { System.out.println(temp); return ++temp; } catch (Exception e) { System.out.println(temp); return ++temp; } finally { ++temp; System.out.println(temp); } } }

• 1,2,2
• 1,2,3
• 1,3,3
• 1,3,2

解释：

执行顺序为：

输出try里面的初始temp：1；

temp=2；

保存return里面temp的值：2；

执行finally的语句temp：3，输出temp：3；

返回try中的return语句，返回存在里面的temp的值：2；

输出temp：2。

95.以下集合对象中哪几个是线程安全的（）

• LinkedList
• ArrayList
• Vector
• Hashtable

解释：

Collection 是对象集合， Collection 有两个子接口 List 和 Set,

---

List 可以通过下标 (1,2..) 来取得值，值可以重复,而 Set 只能通过游标来取值，并且值是不能重复的

ArrayList ， Vector ， LinkedList 是 List 的实现类

ArrayList 是线程不安全的， Vector 是线程安全的，这两个类底层都是由数组实现的

LinkedList 是线程不安全的，底层是由链表实现的

---

Map 是键值对集合

HashTable 和 HashMap 是 Map 的实现类

HashTable 是线程安全的，不能存储 null 值

HashMap 不是线程安全的，可以存储 null 值

简单记忆线程安全的集合类： 喂！SHE！  喂是指  vector，S是指 stack， H是指    hashtable，E是指：Eenumeration

96.以下哪些方法是Object类中的方法（）

• clone()
• toString()
• wait()
• finalize()

解释：全选，Object 类中方法及说明如下：

registerNatives()   //私有方法

getClass()    //返回此 Object 的运行类。
hashCode()    //用于获取对象的哈希值。
equals(Object obj)     //用于确认两个对象是否“相同”。
clone()    //创建并返回此对象的一个副本。
toString()   //返回该对象的字符串表示。   
notify()    //唤醒在此对象监视器上等待的单个线程。   
notifyAll()     //唤醒在此对象监视器上等待的所有线程。   
wait(long timeout)    //在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或        者超过指定的时间量前，导致当前线程等待。   
wait(long timeout, int nanos)    //在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量前，导致当前线程等待。
wait()    //用于让当前线程失去操作权限，当前线程进入等待序列
finalize()    //当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

97.有关会话跟踪技术描述正确的是（）

• Cookie是Web服务器发送给客户端的一小段信息，客户端请求时，可以读取该信息发送到服务器端
• 关闭浏览器意味着临时会话ID丢失，但所有与原会话关联的会话数据仍保留在服务器上，直至会话过期
• 在禁用Cookie时可以使用URL重写技术跟踪会话
• 隐藏表单域将字段添加到HTML表单并在客户端浏览器中显示

解释：

1.session用来表示用户会话，session对象在服务端维护，一般tomcat设定session生命周期为30分钟，超时将失效，也可以主动设置无效；

2.cookie存放在客户端，可以分为内存cookie和磁盘cookie。内存cookie在浏览器关闭后消失，磁盘cookie超时后消失。当浏览器发送请求时，将自动发送对应cookie信息，前提是请求url满足cookie路径；

3.可以将sessionId存放在cookie中，也可以通过重写url将sessionId拼接在url。因此可以查看浏览器cookie或地址栏url看到sessionId；

4.请求到服务端时，将根据请求中的sessionId查找session，如果可以获取到则返回，否则返回null或者返回新构建的session，老的session依旧存在，请参考API。

98.What is Static Method in Java（）

• It is a method which belongs to the class and not to the object(instance)
• A static method can access only static data. It can not access non-static data (instance variables)
• A static method can call only other static methods and can not call a non-static method from it.
• A static method can not be accessed directly by the class name and doesn’t need any object

解释：

A：静态方法是一个属于类而不属于对象(实例)的方法。（√）

B：静态方法只能访问静态数据。无法访问非静态数据(实例变量)。（√）

C：静态方法只能调用其他静态方法，不能从中调用非静态方法。（√）

D：静态方法不能通过类名直接访问，也不需要任何对象。（×） 静态方法可以直接用类名访问。

99.有关finally语句块说法正确的是（ ）

• 不管catch是否捕获异常，finally语句块都是要被执行的
• 在try语句块或catch语句块中执行到System.exit(0)直接退出程序
• finally块中的return语句会覆盖try块中的return返回
• finally 语句块在 catch语句块中的return语句之前执行

解释：D.不是return之前，是return执行完成之前，return表达式的结果会暂时保存起来，不会被改变。

100.关于volatile关键字，下列描述不正确的是？（）

• 用volatile修饰的变量，每次更新对其他线程都是立即可见的。
• 对volatile变量的操作是原子性的。
• 对volatile变量的操作不会造成阻塞。
• 不依赖其他锁机制，多线程环境下的计数器可用volatile实现。

解释：一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。

2）禁止进行指令重排序。

volatile只提供了保证访问该变量时，每次都是从内存中读取最新值，并不会使用寄存器缓存该值——每次都会从内存中读取。

而对该变量的修改，volatile并不提供原子性的保证。

由于及时更新，很可能导致另一线程访问最新变量值，无法跳出循环的情况

多线程下计数器必须使用锁保护。

 

101.下列程序段执行后t3的结果是（）。

int t1=2, t2=3, t3;

t3=t1<t2?t1:(t2+t1);

• 2
• 4
• 5
• 6

解释：if(t1<t2)
             t3=t1;
         else
             t3=t2+t1；

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

• a < b && b < c
• a <= b
• a < ( b + c )
• ! ( a < b )

解释：

a<b      true

!取反 false 所以选D

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

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

解释：选D

A、JDK8开始，接口中可以定义有方法体的方法，方法必须被default和static修饰。除此之外，其他方法都是抽象方法。

B、Java的语法是单继承，但是继承可以传递。其实B更准确一点是只能有一个直接父类。

C、继承用extends，实现用implements。先继承后实现。

D、类是class，接口是interface。

104.ArrayList和LinkList的描述，下面说法错误的是？

• LinkedeList和ArrayList都实现了List接口
• ArrayList是可改变大小的数组，而LinkedList是双向链接串列
• LinkedList不支持高效的随机元素访问
• 在LinkedList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在ArrayList的中间插入或删除一个元素的开销是固定的

解释：Arraylist的内存结构是数组，当超出数组大小时创建一个新的数组，把原数组中元素拷贝过去。其本质是顺序存储的线性表，插入和删除操作会引发后续元素移动，效率低，但是随机访问效率高

LinkedList的内存结构是用双向链表存储的，链式存储结构插入和删除效率高，不需要移动。但是随机访问效率低，需要从头开始向后依次访问

105.静态内部类不可以直接访问外围类的非静态数据，而非静态内部类可以直接访问外围类的数据，包括私有数据。（ ）

• 正确
• 错误

106.ResultSet中记录行的第一列索引为？

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

解释：ResultSet结果集读取数据的方法主要是getXXX() ，他的参数可以使整型表示第几列（是从1开始的），还可以是列名。

107.下面的switch语句中，x可以是哪些类型的数据：()

1 2 3 4 5

switch(x) { default: System.out.println("Hello"); }

• long
• char
• float
• byte
• double
• Object

解释：以java8为准，switch支持10种类型 基本类型：byte char short int

108.下列方法中哪个是线程执行的方法？ （）

• run（）
• start（）
• sleep（）
• suspend（）

解释：

run()方法用来执行线程体中具体的内容

start()方法用来启动线程对象，使其进入就绪状态

sleep()方法用来使线程进入睡眠状态

suspend()方法用来使线程挂起，要通过resume()方法使其重新启动

109.Which statement declares a variable a which is suitable for referring to an array of 50 string objects?（Java）

• char a[][];
• String a[];
• String[] a;
• Object a[50];
• String a[50];
• Object a[];

解释：哪个语句声明了一个变量a，它适合引用一个包含50个字符串对象的数组?

A：char[][] 定义了二位字符数组。在Java中，使用字符串对char数组赋值，必须使用toCharArray()方法进行转换。所以A错误。

B、C：在Java中定义String数组，有两种定义方式：String a[]和String[] a。所以B、C正确。

D、E：数组是一个引用类型变量 ，因此使用它定义一个变量时，仅仅定义了一个变量 ，这个引用变量还未指向任何有效的内存 ，因此定义数组不能指定数组的长度。所以D、E错误。

F：Object类是所有类的父类。子类其实是一种特殊的父类，因此子类对象可以直接赋值给父类引用变量，无须强制转换，这也被称为向上转型。这体现了多态的思想。所以F正确。

110.以下哪些方法可以取到http请求中的cookie值（）?

• request.getAttribute

• request.getHeader

• request.getParameter

• request.getCookies

解释：下面的方法可用在 Servlet 程序中读取 HTTP 头。这些方法通过 HttpServletRequest 对象可用：

1）Cookie[] getCookies()
返回一个数组，包含客户端发送该请求的所有的 Cookie 对象。

2）Object getAttribute(String name)
以对象形式返回已命名属性的值，如果没有给定名称的属性存在，则返回 null。

3）String getHeader(String name)
以字符串形式返回指定的请求头的值。Cookie也是头的一种；

4）String getParameter(String name)
以字符串形式返回请求参数的值，或者如果参数不存在则返回 null。

111.以下关于Integer与int的区别错误的是()

• int是java提供的8种原始数据类型之一
• Integer是java为int提供的封装类
• int的默认值为0
• Integer的默认值为1

解释：int 是八大基本数据类型之一（byte,char,short,int,long,float,double,boolean）
Integer 是 int 包装类;
int是基本数据类型，默认值为0,
Integer 是类，默认值为null；
Integer 表示的是对象，用一个引用指向这个对象,
int是基本数据类型，直接存储数值。

112.以下（）不是合法的标识符？

• STRING
• x3x
• void
• deSf

解释：void属于java中的关键字

[1]Java标识符只能由数字、字母、下划线“_”或“$”符号以及Unicode字符集组成

[2]Java标识符必须以字母、下划线“_”或“$”符号以及Unicode字符集开头

[3]Java标识符不可以是Java关键字、保留字（const、goto）和字面量（true、false、null）

[4]Java标识符区分大小写，是大小写敏感的

113.以下叙述正确的是

• 实例方法可直接调用超类的实例方法
• 实例方法可直接调用超类的类方法、
• 实例方法可直接调用子类的实例方法
• 实例方法可直接调用本类的实例方法

解释：无论是子类还是父类，在调用方法的时候考虑类的private 权限的方法，当父类中的方法（无论是实例方法还是静态方法），只要使用了private关键字，无论如何，在子类中都无法访问点用这个方法。 但是当方法的权限为private之外是，在子类中可以通过super关键字实现直接对父类的实例方法的调用，也可以通过创建父类实例对象实现对实例方法的调用，类方法可直接用父类名加类方法名的方式进行直接点用。 父类中的实例方法如果想调用子类中的方法，需要通过子类的实例对象的方式，调用其实例方法。

114.

1 2 3

String str = ""; System.out.print(str.split(",").length);

输出结果为：

• 0
• 1
• 出现异常

解释：

1 2 3 4 5 6 7 8

/**  * String split 这个方法默认返回一个数组，  * 如果没有找到分隔符，  * 会把整个字符串当成一个长度为1的字符串数组  * 返回到结果， 所以此处结果就是1  */  private static void testSpringSpilte(){         String str = "12,3";         String str2 = "123";         System.out.print(str.split(",").length);         System.out.print(str2.split(",").length);     } } 结果  2  1

115.关于Java中参数传递的说法，哪个是错误的？

• 在方法中，修改一个基础类型的参数不会影响原始参数值
• 在方法中，改变一个对象参数的引用不会影响到原始引用
• 在方法中，修改一个对象的属性会影响原始对象参数
• 在方法中，修改集合和Maps的元素不会影响原始集合参数

116.如何获取ServletContext设置的参数值？

• context.getParameter()
• context.getInitParameter()
• context.getAttribute()
• context.getRequestDispatcher()

解释：getParameter()是获取POST/GET传递的参数值；

getInitParameter获取Tomcat的server.xml中设置Context的初始化参数

getAttribute()是获取对象容器中的数据值；

getRequestDispatcher是请求转发。

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

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

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

• 打印顺序A的静态代码块> A的构造函数
• 打印顺序A的静态代码块> A的构造代码块
• 打印顺序A的构造代码块> A的构造函数
• 打印顺序A的构造函数> A的构造代码块

解释：就本题而言，首先搞清楚一个Java类的初始化顺序：1. 静态代码块；2. 普通代码块；3. 构造函数。

其次，静态代码块只加载一次；普通代码块创建几个对象就加载几次。

所以，我觉得本题的答案应该：

A的静态代码块

A的构造代码块

A的构造函数

118.ArrayLists和LinkedList的区别，下述说法正确的有？

• ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
• 对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
• 对于新增和删除操作add和remove，LinkedList比较占优势，因为ArrayList要移动数据。
• ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间。

解释：A. ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。  //正确，这里的所谓动态数组并不是那个“ 有多少元素就申请多少空间 ”的意思，通过查看源码，可以发现，这个动态数组是这样实现的，如果没指定数组大小，则申请默认大小为10的数组，当元素个数增加，数组无法存储时，系统会另个申请一个长度为当前长度1.5倍的数组，然后，把之前的数据拷贝到新建的数组。

B. 对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。//正确，ArrayList是数组，所以，直接定位到相应位置取元素，LinkedLIst是链表，所以需要从前往后遍历。

C. 对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。//正确，ArrayList的新增和删除就是数组的新增和删除，LinkedList与链表一致。

D. ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间。//正确，因为ArrayList空间的增长率为1.5倍，所以，最后很可能留下一部分空间是没有用到的，因此，会造成浪费的情况。对于LInkedList的话，由于每个节点都需要额外的指针

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

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

解释：函数式编程和面向对象编程是两个主流的编程范式，函数式编程特性：数据不可变、惰性求值，而面向对象编程特性：继承、多态等。

120.关于Java内存区域下列说法不正确的有哪些（）

• 程序计数器是一块较小的内存空间，它的作用可以看做是当前线程所执行的字节码的信号指示器，每个线程都需要一个独立的程序计数器.
• Java虚拟机栈描述的是java方法执行的内存模型，每个方法被执行的时候都会创建一个栈帧，用于存储局部变量表、类信息、动态链接等信息
• Java堆是java虚拟机所管理的内存中最大的一块，每个线程都拥有一块内存区域，所有的对象实例以及数组都在这里分配内存。
• 方法区是各个线程共享的内存区域，它用于存储已经被虚拟机加载的常量、即时编译器编译后的代码、静态变量等数据。

解释：