面试题答案解析copy

10.24-10.30

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

A.public void example(int m){...}
B.public int example(){..}
C.public void example2(){..}
D.public int example(int m,float f){...}

函数方法名必须相同，看参数列表即可，无关返回值。

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

ABDC

只要是被子类重写的方法，不被super调用都是调用子类方法

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 Base {    public void methodOne()    {       System.out.print("A");3       methodTwo();4    }    public void methodTwo()7    {       System.out.print("B");8    } } public class Derived extends Base {    public void methodOne()1    {       super.methodOne();2       System.out.print("C");10    }    public void methodTwo()5    {       super.methodTwo();6       System.out.print("D");9    } }

在jdk 1.7中，以下说法正确的是（    A）。

A.Java中所有的非抽象方法都必须在类内定义
B.Java中主方法可以不在类内定义，其他方法都必须定义在类内
C.Java中主方法必须定义在类内，其他方法可以不必定义在类内
D.Java中所有方法都不必在类内定义

jdk1.8之后，接口才允许default、static的方法实现，1.7接口中的方法只能是抽象方法，即Java中所有的非抽象方法都必须在类内定义

以下描述错误的一项是（C ）？

A.程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行  到了第几行，是线程隔离的
B.原则上讲，所有的对象都是在堆区上分配内存，是线程之间共享的
C.方法区用于存储JVM加载的类信息、常量、静态变量，即使编译器编译后的代码等数据，是线程隔离的
D.Java方法执行内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的

堆和方法区都是线程共享的

 对于abstract声明的类，下面说法正确的是  E

A.可以实例化
B.不可以被继承
C.子类为abstract
D.只能被继承
E.可以被抽象类继承

A,抽象类不能实例化，因为有抽象方法未实现

B,可以被继承。派生类可以实现抽象方法

C，子类可以是抽象的，也可以非抽象的

D，只能被继承说法太肯定，不正确

E，可以被抽象类继承，也可以被非抽象类继承

下面属于jav

a包装类的是？ABCD

A.String
B.Long
C.Character
D.Short

---

包装类针对基本数据类型

Java 语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，在设计类时为每个基本数据类型设计了一个对应的类进行代表，即包装类。

Java共有六个包装类，分别是Boolean、Character、Integer、Long、Float和Double，从字面上我们就能够看出他们分别对应于 boolean、char、int、long、float和double。而String和Date本身就是类。所以也就不存在什么包装类的概念了。

switch语句中，x可以是哪些类型的数据

以java8为准，switch支持10种类型 基本类型：byte char short int 对于包装类 ：Byte,Short,Character,Integer enum 和 String 

基本类型byte char short 原因：这些基本数字类型可自动向上转为int

基本类型包装类Byte,Short,Character,Integer 原因：java的自动拆箱机制 可看这些对象自动转为基本类型

String 类型 原因：实际switch比较的string.hashCode值，它是一个int类型

enum类型 原因 ：实际比较的是enum的ordinal值（表示枚举值的顺序），它也是一个int类型 所以也可以说 switch语句只支持int类型

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

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

---

A: HashSet 它不是线程安全的，属于Set接口下的实现类，Set下的实现类特征就是无序，不允许存储相同的对象（唯一）

B: ConcurrentHashMap 它是线程安全的HashMap实现，特征也相似，其中存储的值对象可以重复，键对象不能重复

C: Collection接口是List接口和Set接口的父接口，通常情况下不被直接使用

D: ArrayList线程不安全的，底层是数组实现，允许存放重复对象

---

Set——>HashSet 无序 唯一 线程不安全

HashMap 键唯一 线程不安全

Collection——> Set，List

ArrayList 不唯一 线程不安全

list 有序 可重复 ArrayList 数组结构 方便查  LinkedList 链表结构 方便改

set HashSet用数组+链表+红黑树（jdk1.8）无序 不可重复  java.util.LinkedHashSet 链表和哈希表组合

 HashMap是基于哈希算法来确定元素的位置（槽），的会计算传入的Key的哈希值，并利用哈希值取余来确定槽的位置

下面哪些接口直接继承自Collection接口（）

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

关于HashMap和Hashtable正确的说法有（C）

A.都实现了Map接口
B.Hashtable类不是同步的，而HashMap类是同步的
C.Hashtable不允许null键或值
D.HashMap不允许null键或值

HashMap和Hashtable都是典型的Map实现，选项A正确。

HashTable使用监视器锁 synchronized 同步

Hashtable在实现Map接口时保证了线程安全性，而HashMap则是非线程安全的。所以，

Hashtable的性能不如HashMap，因为为了保证线程安全它牺牲了一些性能。因此选项B错误

Hashtable不允许存入null，无论是以null作为key或value，都会引发异常。

HashMap 允许 null 做键值。选项C正确，D错误。

以下关于final关键字说法错误的是（C）

A.final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性
B.final修饰的类不能被继承
C.final修饰的方法不能被重载
D.final修饰的变量不允许被再次赋值

• final修饰的类不能被继承
• 修饰的方法不能被重写
• 修饰的变量是常量,不能修改其值

重载，就是函数或者方法有相同的名称，但是参数列表不相同的情形

 

关于访问权限，说法正确的是？ ( A)

A.类A和类B在同一包中，类B有个protected的方法testB，类A不是类B的子类（或子类的子类），类A可以访问类B的方法testB
B.类A和类B在同一包中，类B有个protected的方法testB，类A不是类B的子类（或子类的子类），类A不可以访问类B的方法testB
C.访问权限大小范围：public > 包权限default > protected > private
D.访问权限大小范围：public > 包权限default  > private > protected

java中下面哪些是Object类的方法（ A B D  ）

        A.notify()
        B.notifyAll()
        C.sleep()
        D.wait()

---

sleep()是Thread类的方法

Java中的类都是Object类的子类

wait()称作线程在对象上的等待，作用是把当前的线程放入对象的等待集合中。

notify()将从该对象的等待集合中选择一个等待的线程唤醒，唤醒的线程将从等待集合中删除。

notifyAll()方法会将所有在等待集合中的线程唤醒，但由于所有的被唤醒的线程仍然要去争用synchronized锁，而synchronized锁具有排他性，最终只有一个线程获得该锁，进行执行状态，其他线程仍要继续等待。

---

以下关于Object类的说法正确的是（）

A.Java中所有的类都直接或间接继承自Object，无论是否明确的指明，无论其是否是抽象类。
B.Java中的接口(interface)也继承了Object类
C.利用“==”比较两个对象时，Java调用继承自Object的equals方法，判断是否相等。
D.如果类的定义中没有重新定义toString()方法，则该类创建的对象无法使用toStrig()方法。

正确答案：A

Object是所有类的直接或者间接父类。

接口没有继承Object类

public boolean equals(Object obj) {  return (this == obj); }

判断是否相等：Java调用继承自Object的equals方法中利用“==”比较两个对象。

都是Object的子类，肯定有Object的方法：hashCode、equals、toString、clone、notify、notifyall、wait、finalize、getClass

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

A.class Widget { Sprocket s; }
class Gadget extends Widget { Spring s; }

B.class Widget { }
class Gadget extends Widget { Spring s1; Sprocket s2; }

C.class Widget { Sprocket s1; Spring s2; }
class Gadget extends Widget { }

D.class Gadget { Spring s; }
class Widget extends Gadget{ Sprocket s; }

---

is-a 是继承关系
has-a 是组成（包含）关系

Gadget 要包含Sprocket 
并且 Gadget 要包含 Spring 
并且 Gadget 要继承 Widget 
并且 Widget 要包含 Sprocket 

同时满足以上这4个条件即可，并且要知道 子类可通过继承父类，得到父类的成员变量

class Widget { Sprocket s; }
class Gadget extends Widget { Spring s; }
↑选项A，满足

class Widget { }
class Gadget extends Widget { Spring s1; Sprocket s2; }
↑选项B，不行，父类Widget 没包含Sprocket 

class Widget { Sprocket s1; Spring s2; }
class Gadget extends Widget { }
↑选项C，满足

class Gadget { Spring s; }
class Widget extends Gadget{ Sprocket s; }
↑选项D，不行，首先父子关系就搞错了

---

jre 判断程序是否执行结束的标准是

正确答案: A   

A.所有的前台线程执行完毕
B.所有的后台线程执行完毕
C.所有的线程执行完毕
D.和以上都无关

---

    main()函数即主函数，是一个前台线程，前台进程是程序中必须执行完成的，而后台线程则是java中所有前台结束后结束，不管有没有完成，后台线程主要用与内存分配等方面。

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

A.context.getParameter()是获取POST/GET传递的参数值；
B.context.getInitParameter() 获取Tomcat的server.xml中设置Context的初始化参数
C.context.getAttribute() 是获取对象容器中的数据值；
D.context.getRequestDispatcher() 请求转发

以下说法错误的是（BCD）

A.其他选项均不正确
B.java线程类优先级相同
C.Thread和Runnable接口没有区别
D.如果一个类继承了某个类，只能使用Runnable实现线程

B选项，在java中线程是有分优先等级的所以优先级不能相同，错误

实现线程的方式有：继承Thread类，重写run()方法；

                                 实现Runable接口，实现run()方法；

                                 实现Callable接口，线程结束后有返回值。

        首先test.equals(testB)，Test类并没有重写equals方法，那么在比较时，调用的依然是Object类的equals()方法，比较的是两个对象在内存中的地址，结果为false。

        test.name.equals(testB.name)比较name字符串是否相等，二者都是"abc"，结果返回true。

        name成员变量并没有被static关键字修饰，那么每个Test类的对象被创建时，都会先执行private String name = "abc";（注意这里使用了直接赋值的方式，没有使用new关键字）。在test对象初始化时，JVM会先检查字符串常量池中是否存在该字符串的对象，此时字符串常量池中并不存在"abc"字符串对象，JVM会在常量池中创建这一对象。当testB被创建时，同样会执行private String name = "abc";，那么此时JVM会在字符串常量池中找到test对象初始化时创建的"abc"字符串对象，那么JVM就会直接返回该字符串在常量池中的内存地址，而不会新建对象。

也就是说test.name和testB.name指向的内存是同一个，那么test.name == testB.name返回true。本题正确选项为false，true，true。题目要求选出错误选项，答案为A B C。

根据以下代码段，下列说法中正确的是(    )。

public class Parent {

    private void m1(){}

    void m2(){}

    protected void m3(){}

    public static void m4(){}

}

A.子类中一定能够继承和覆盖Parent类的m1方法
B.子类中一定能够继承和覆盖Parent类的m2方法
C.子类中一定能够继承和覆盖Parent类的m3方法
D.子类中一定能够继承和覆盖Parent类的m4方法

正确答案：C

私有方法只能在本类中可见，故不能继承

.缺省访问修饰符只在本包中可见，在外包中不可见

.static修饰的成员属于类成员，父类字段或方法只能被子类同名字段或方法遮蔽，不能被继承覆盖

CMS垃圾回收器在那些阶段是没用用户线程参与的 AC

A.初始标记
B.并发标记
C.重新标记
D.并发清理

CMS收集器是一种以获取最短回收停顿时间为目标的收集器，它是基于标记清除算法实现的，它的运作过程相对于其他收集器来说要更复杂一些，整个过程分为四个步骤，包括：初始标记、并发标记、重新标记、并发清除。其中初始标记、重新标记这两个步骤需要暂停整个JVM。

1. 初始标记仅仅只是标记一下GC Roots能直接关联到的对象，速度很快。

2. 并发标记阶段就是从GC Roots的直接关联对象开始遍历整个对象图的过程，这个过程耗时较长但是不需要停顿用户线程，可以与垃圾收集线程一起并发运行。

3. 重新标记阶段则是为了修正并发标记期间，因用户程序继续运作而导致标记产生变动的那一部分对象的标记记录，这个阶段的停顿时间通常会比初始标记阶段稍长一些，但也远比并发标记阶段的时间短。

4. 并发清除阶段，清理删除掉标记阶段判断的已经死亡的对象，由于不需要移动存活对象，所以这个阶段也是可以与用户线程同时并发的。

下列有关java构造函数叙述正确的是（）

A.构造器的返回值为void类型
B.如果一个源文件中有多个类，那么构造器必须与公共类同名
C.构造器可以有0个，1个或一个以上的参数
D.每个类可以有一个以上的构造器

构造方法是一种特殊的方法，具有以下特点。

（1）构造方法的方法名必须与类名相同。

（2）构造方法没有返回类型，也不能定义为void，在方法名前面不声明方法类型。

（3）构造方法的主要作用是完成对象的初始化工作，它能够把定义对象时的参数传给对象的域。

（4）一个类可以定义多个构造方法，如果在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认构造器，这个构造器不执行任何代码。

（5）构造方法可以重载，以参数的个数，类型，顺序。

下面几个关于Java里queue的说法哪些是正确的（AC）？

A.LinkedBlockingQueue是一个可选有界队列，不允许null值
B.PriorityQueue，LinkedBlockingQueue都是线程不安全的
C.PriorityQueue是一个无界队列，不允许null值，入队和出队的时间复杂度是O（log(n)）
D.PriorityQueue，ConcurrentLinkedQueue都遵循FIFO原则

A、LinkedBlockingQueue是一个基于节点链接的可选是否有界的阻塞队列，不允许null值。
B、LinkedBlockingQueue是一个线程安全的阻塞队列，实现了先进先出等特性。
C、PriorityQueue是一个无界队列，不允许null值，入队和出队的时间复杂度是O（log(n)）。
D、PriorityQueue是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。ConcurrentLinkedQueue是一个基于链接节点的***线程安全队列，该队列的元素遵循FIFO原则。

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

A.原子性
B.有序性
C.可见性
D.持久性

关于volatile:有序性,可见性

volatile用与修饰实例变量和类变量,是一种维护线程安全的手段,作用是实现共享资源的可见性

线程以串行的方式经过,效率太低.容易阻塞,而且保持原子性,只要线程进去就无法被打断,而volatile不会阻塞.不保证原子性

有序性的意思:

jvm和处理器在编译Java代码的时候,出于性能考虑,会对原有的代码进行重排序,(也就是指令重排)我们写好的代码都有顺序,在我们执行的时候由ＪＶＭ内存模型里的程序计数器标记的,保证线程安全的时候，一般都会禁止指令重排即保证有序性

volatile关键字禁止JVM编译器已及处理器对其进行重排序,

synchronized保证顺序性是串行化的结果，但同步块里的语句是会发生指令从排。

10.31

 命令javac-d参数的用途是：A

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

11月

11.01

往OuterClass类的代码段中插入内部类声明, 哪一个是错误的: ABCD

1 2 3 4

public class OuterClass{     private float f=1.0f;     //插入代码到这里 }

A.class InnerClass{
        public static float func(){return f;}
}
B.abstract class InnerClass{
        public abstract float func(){}
}
C.static class InnerClass{
        protected static float func(){return f;}
}
D.public class InnerClass{
        static float func(){return f;}
}

1.静态内部类才可以声明静态方法 AD 应该在类加上static

2.静态方法不可以使用非静态变量 ACD

3.抽象方法不可以有函数体 B

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

A.sleep()
B.wait()
C.join()
D.yield()

1.sleep会使当前线程睡眠指定时间，不释放锁

2.yield会使当前线程重回到可执行状态，等待cpu的调度，不释放锁

3.wait会使当前线程回到线程池中等待，释放锁，当被其他线程使用notify，notifyAll唤醒时进入可执行状态

4.当前线程调用 B.join()时会使当前线程等待B执行完毕再结束，底层调用了wait，释放锁

join()插队 

yield()礼让 等待cpu的调度优先级高抢占资源

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

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

synchronized 同步，主要用来给方法、代码块加锁，被加锁的代码段

volatile 保证当前线程对该变量操作的可见性 

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

 transient 让某些被修饰的成员属性变量不被序列化——反序列化

  

可见性：

　　可见性是一种复杂的属性，因为可见性中的错误总是会违背我们的直觉。通常，我们无法确保执行读操作的线程能适时地看到其他线程写入的值，有时甚至是根本不可能的事情。为了确保多个线程之间对内存写入操作的可见性，必须使用同步机制。

　　可见性，是指线程之间的可见性，一个线程修改的状态对另一个线程是可见的。也就是一个线程修改的结果。另一个线程马上就能看到。比如：用volatile修饰的变量，就会具有可见性。volatile修饰的变量不允许线程内部缓存和重排序，即直接修改内存。所以对其他线程是可见的。但是这里需要注意一个问题，volatile只能让被他修饰内容具有可见性，但不能保证它具有原子性。比如 volatile int a = 0；之后有一个操作 a++；这个变量a具有可见性，但是a++ 依然是一个非原子操作，也就是这个操作同样存在线程安全问题。

　　在 Java 中 volatile、synchronized 和 final 实现可见性。

原子性：

　　原子是世界上的最小单位，具有不可分割性。比如 a=0；（a非long和double类型） 这个操作是不可分割的，那么我们说这个操作时原子操作。再比如：a++； 这个操作实际是a = a + 1；是可分割的，所以他不是一个原子操作。非原子操作都会存在线程安全问题，需要我们使用同步技术（sychronized）来让它变成一个原子操作。一个操作是原子操作，那么我们称它具有原子性。java的concurrent包下提供了一些原子类，我们可以通过阅读API来了解这些原子类的用法。比如：AtomicInteger、AtomicLong、AtomicReference等。

　　在 Java 中 synchronized 和在 lock、unlock 中操作保证原子性。

有序性：

　　Java 语言提供了 volatile 和 synchronized 两个关键字来保证线程之间操作的有序性，volatile 是因为其本身包含“禁止指令重排序”的语义，synchronized 是由“一个变量在同一个时刻只允许一条线程对其进行 lock 操作”这条规则获得的，此规则决定了持有同一个对象锁的两个同步块只能串行执行。

以下哪些jvm的垃圾回收方式采用的是复制算法回收 AD

A.新生代串行收集器
B.老年代串行收集器
C.并行收集器
D.新生代并行回收收集器
E.老年代并行回收收集器
F.cms收集器

• Serial New收集器是针对新生代的收集器，采用的是复制算法
• Parallel New（并行）收集器，新生代采用复制算法，老年代采用标记整理
• Parallel Scavenge（并行）收集器，针对新生代，采用复制收集算法
• Serial Old（串行）收集器，新生代采用复制，老年代采用标记整理
• Parallel Old（并行）收集器，针对老年代，标记整理
• CMS收集器，基于标记清理
• G1收集器：整体上是基于标记 整理 ，局部采用复制

综上：新生代基本采用复制算法，老年代采用标记整理算法。cms采用标记清理。

• 标记清理：一块区域，标记可达对象（可达性分析），然后回收不可达对象，会出现碎片，那么引出
• 标记-整理算法：多了碎片整理，整理出更大的内存放更大的对象
• 复制算法：两个区域A和B，初始对象在A，继续存活的对象被转移到B。此为新生代最常用的算法

• 新生代：初始对象，生命周期短的
• 永久代：长时间存在的对象

整个java的垃圾回收是新生代和年老代的协作，这种叫做分代回收。

存根（Stub）与以下哪种技术有关

B

A.交换
B.动态链接
C.动态加载
D.磁盘调度

在java7中,下列哪个说法是正确的:  D

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

hashMap在单线程中使用大大提高效率，在多线程的情况下使用hashTable来确保安全。hashTable中使用synchronized关键字来实现安全机制，但是synchronized是对整张hash表进行锁定即让线程独享整张hash表，在安全同时造成了浪费。concurrentHashMap使用segment来分段加锁来确保安全

将一个数组转化为一个List对象，这个方***返回一个ArrayList类型的对象， 这个ArrayList类并非java.util.ArrayList类，而是Arrays类的静态内部类！

Java1.8之后，Java接口的修饰符可以为（D）

A.private
B.protected
C.final
D.abstract

A.抽象方法没有方法体,是用来被继承的,所以不能用 private修饰

B.protected访同修饰符也不能使用,因为接口可以让所有的类去实现(非继承),不只是其子类

C.接口被final修饰，就代表不能被继承 

D.  only public & abstract 可省略are permitted

 装箱、拆箱操作发生在: (C)

A.类与对象之间
B.对象与对象之间
C.引用类型与值类型之间
D.引用类型与引用类型之间

int基本数据类型是值 Integer包装类是引用类型

11.2 11.6

 

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

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

A.6 7 7
B.22 34 17
C.22 74 74
D.11 17 34

package com.example.webExample.lizi;

class Test {
    public static void main(String[] args) {
        System.out.println(new B().getValue()); //1.   10.调用getValue() 因为子类没有重写该方法，需要调用父类
        // 14. 打印第一个数 ：17
    }
    static class A {
        protected int value;
        public A (int v) {
            setValue(v);  //3.父类的构造函数又调用了setValue()方法 子类中的方法覆盖父类的方法以后 由于向上转型，父类调用的方法实际上是子类的
        }
        public void setValue(int value) {
            this.value= value;
        }
        public int getValue() {//6.    //11.
            try {
                value ++;  //7. =11    //12. =17
                return value;
            } finally {
                //如果finally里面有return，则数据跟随finally改变
                //没有return，则原数据不跟随finally里改变的数据改变。
                this.setValue(value); //8.由于此时正在初始化的是B类的一个对象（运行时多态），因此调用B类的setValue()方法。
                                    //8. 执行子类方法11*2 = 22   //13. 17*2=34
                System.out.println(value);  //打印第一个数 ：22   //打印第二个数：34
                // finally没有return 原数据不改变 A类的getValue()方法将之前暂存的value=11返回。
            }
        }
    }
    static class B extends A {
        public B () {
            super(5); //2.调用了父类带有参数的构造函数
            setValue(getValue()- 3); //5. 先执行getValue()- 3 B类中并没有重写该方法，这里需要调用父类的getValue()方法
            //9.setValue(11- 3);  执行子类方法8*2 = 16
        }
        public void setValue(int value) {  //4. 但是子类覆盖父类方法后向上转型 所以还是使用子类 2*5=10
            super.setValue(2 * value); //又使用super关键字调用了父类的setValue()方法
        }
    }
}

下列Java代码中的变量a、b、c分别在内存的__C__存储区存放。

1 2 3 4 5 6 7

class A {     private String a = “aa”;     public boolean methodB() {         String b = “bb”;         final String c = “cc”;     } }

A.堆区、堆区、堆区
B.堆区、栈区、堆区
C.堆区、栈区、栈区
D.堆区、堆区、栈区
E.静态区、栈区、堆区
F.静态区、栈区、栈区

a是类中的成员变量，存放在堆区

b、c都是方法中的局部变量，存放在栈区

1	关于下面的程序Test.java说法正确的是(  D  )。

1 2 3 4 5 6 7 8

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

A.3
B.112
C.13
D.程序有编译错误

被static修饰的变量称为静态变量，静态变量属于整个类，而局部变量属于方法，只在该方法内有效，所以static不能修饰局部变量

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

A.0
B.1
C.2
D.以上都不是

向上转型 1.0f / 2.0f = 0.5f

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  // 调用构造方法用this关键词
w=d;z=c;
}}
在代码说明// assignment x=a, y=b处写入如下哪几个代码是正确的？（C D）

A.Base(a,b);
B.x=a, y=b;  逗号
C.x=a; y=b;  
D.this(a,b);

构造函数不能直接调用

我们在程序中经常使用“System.out.println()”来输出信息，语句中的System是包名，out是类名，println是方法名。  错

对
错

System是java.lang中的一个类，out是System内的一个成员变量，这个变量是一个java.io.PrintStream类的对象，println就是一个方法了。

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

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

A.public String NAME="default";
B.public static String NAME="default";
C.public static final String NAME="default";
D.private String NAME="default";

接口中的变量默认是public static final 的  (常量

方法默认是public abstract 的

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

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

public class Test {       public static int aMethod(int i)throws Exception     {         try{             return i/10;  //2. 0/10 正常执行         }         catch (Exception ex)         {             throw new Exception("exception in a aMethod");         }finally{       System.out.printf("finally"); //3.         } }      public static void main(String[] args){         try         {             aMethod(0);  //1.         }         catch (Exception ex)         {              System.out.printf("exception in main"); //aMethod()调用成功         }         System.out.printf("finished");  //4.      } }

A.exception in main finished
B.finallyfinished
C.exception in main finally
D.finally exception in main finally

有以下类定义：

1 2 3 4 5 6 7 8 9 10 11

abstract class Animal{     abstract void say(); } public class Cat extends Animal{     public Cat(){         System.out.printf("I am a cat");     }     public static void main(String[] args) {         Cat cat=new Cat();     } }

运行后：

A.I am a cat
B.Animal能编译，Cat不能编译  对
C.Animal不能编译，Cat能编译
D.编译能通过，但是没有输出结果

类Cat 没有实现抽象类中的抽象方法    cat要加abstract 抽象类不能创建对象

当一个类继承一个抽象类的时候，必须实现抽象类的方法

下面有关SPRING的事务传播特性，说法错误的是？B

A.PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行
B.PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就抛出异常C.PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起D.PROPAGATION_NESTED：支持当前事务，新增Savepoint点，与当前事务同步提交或回滚

PROPAGATION_REQUIRED

表示当前方法必须运行在一个事务中，如果当前存在一个事务，那么该方法运行在这个事务中，否则，将创建一个新的事务

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

A.session 使用 setAttribute(String str,Object obj)方法将对象捆绑到一个会话
B.Cookie 用 SET-Cookie 头标将它作为 HTTP
响应的一部分传送到客户端，
C.地址重写 URL 可以在后面附加参数
D.隐藏域  隐藏表单域：<input type="hidden">，

四种方法可以实现会话跟踪技术：URL重写、隐藏表单域、Cookie、Session。

下面叙述错误的是 (C )

A.一个类可以有多个构造方法
B.最终类不能派生子类，最终方法不能被覆盖
C.如果一个类中没有定义构造方法，则Java在生成这个类的实例时不会调用构造方法。
D.数组一旦创建之后，就不能再改变其长度

A.一个类可以有多个构造方法，实际上就是方法的重载，正确

B.用final修饰的类不能被继承，方法不能被覆盖，正确

C.如果没有构造方法，编译器会自动添加一个空参构造方法，错误

D.由源码可知，数组内部采用字符数组存储，该字符数组用final修饰，长度一旦确定不可再变，正确

11.7

下列说法正确的是（AB）？

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

B 成员内部类必须依托于外部类才能存在，也就是说必须先创建外部类的对象才能创建内部类，因此内部类可以访问外部类的所有东西（此时外部类的所有成员已经都存在了）；

C、错。匿名内部类用法与局部内部类不一致，首先从定义上就不一样，匿名类用在任何允许存在表达式的地方，而局部内部类用于在任何允许出现局部变量的地方出现。
还有更重要的是匿名类只能使用一次，而局部类则可以在自己的定义域内多次使用。

D、错。静态内部类不能直接访问外部类的非静态成员，但可以通过new外部类（）.成员的方式访问。

以下哪几种方式可用来实现线程间通知和唤醒：( AC)

A.Object.wait/notify/notifyAll
B.ReentrantLock.wait/notify/notifyAll
C.Condition.await/signal/signalAll
D.Thread.wait/notify/notifyAll

wait()、notify()和notifyAll()是 Object类 中的方法是final方法，无法被重写

Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作

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

A.HashMap
B.ArrayList
C.Vector
D.Iterator

1 2 3 4

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

A.com. jd
B.com/jd/MyClass.class
C.///MyClass.class 
D.com.jd.MyClass

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

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

复制代码

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

public class Test {     public static Test t1 = new Test();    //(1)     {   //构造块          System.out.println("blockA");    一  三     }     static  //静态块     {         System.out.println("blockB");   //(2)  二     }     public static void main(String[] args)     {         Test t2 = new Test();     //(3)        }  }

A.blockAblockBblockA
B.blockAblockAblockB
C.blockBblockBblockA
D.blockBblockAblockB

在执行(1)时创建了一个Test对象，在这个过程中会执行非静态代码块和缺省的无参构造函数，在执行非静态代码块时就输出了blockA；然后执行(2)输出blockB；执行(3)的过程同样会执行非静态代码块和缺省的无参构造函数，在执行非静态代码块时输出blockA。因此，最终的结果为

blockA
blockB
blockA

静态块：用static申明，JVM加载类时执行，仅执行一次
构造块：类中直接用{}定义，每一次创建对象时执行
执行顺序优先级：静态块>main()>构造块>构造方法
静态块按照申明顺序执行，先执行Test t1 = new Test();
所有先输出blockA，然后执行静态块，输出blockB，最后执行main
方法中的Test t2 = new Test();输出blockA。

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

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

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

10 没有break，发生case穿透现象，程序会继续向下执行，直到遇到break或者结束switch语句的大括号为止。

11.10之前

 

1.将下列（A、B、C、D）哪个代码替换下列程序中的【代码】不会导致编译错误？A

1 2 3 4 5 6 7

interface Com{     int M=200;     int f(); } class ImpCom implements Com{     【代码】 }

A.public int f(){return 100+M;}   
B.int f(){return 100;}  没有public 默认则是为default
C.public double f(){return 2.6;}  返回类型与接口不一致
D.public abstract int f();  没有实现全部方法

接口实现类相当于子类，子类的访问权限是不能比父类小的。

必须实现接口中所有的方法。

实现类可以获取接口中的属性。

Java的集合框架中重要的接口java.util.Collection定义了许多方法。选项中哪个方法是Collection接口所定义的（    ABD   ）

A.int size()
B.boolean containsAll(Collection c)
C.compareTo(Object obj)
​​​​​​​D.boolean remove(Object obj)'

compareTo是接口Comparable<T> 接口里的方法

Collection 接口常用的方法

• size():返回集合中元素的个数
• add(Object obj):向集合中添加一个元素
• addAll(Colletion coll):将形参coll包含的所有元素添加到当前集合中
• isEmpty():判断这个集合是否为空
• clear():清空集合元素
• contains(Object obj):判断集合中是否包含指定的obj元素
  ① 判断的依据：根据元素所在类的equals()方法进行判断
  ②明确：如果存入集合中的元素是自定义的类对象，要去：自定义类要重写equals()方法
• constainsAll(Collection coll):判断当前集合中是否包含coll的所有元素
• rentainAll(Collection coll):求当前集合与coll的共有集合，返回给当前集合
• remove(Object obj):删除集合中obj元素，若删除成功，返回ture否则
• removeAll(Collection coll):从当前集合中删除包含coll的元素
• equals(Object obj):判断集合中的所有元素 是否相同
• hashCode():返回集合的哈希值
• toArray(T[] a):将集合转化为数组
  ①如有参数，返回数组的运行时类型与指定数组的运行时类型相同。
• iterator():返回一个Iterator接口实现类的对象,进而实现集合的遍历。
• 数组转换为集合：Arrays.asList(数组)

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

1 2 3 4 5 6

boolean isOdd = false; for(int i=1;i<=2;++i){     if(i%2==1)isOdd = true;     else isOdd = false;     a+=i*(isOdd?1:-1); }

A.-1
B.-2
C.0
D.1

第一次循环： 1 两次 -2+1 = -1  

1.A线程进行完+1,-2 最后结果为-1

2.A线程进行完+1,被B线程抢占+1,最后进行-2，结果为0

3.A线程进行+1未完成，B线程抢占-2完成，结果为-2

 

 

不管怎样线程对a的操作就是+1后-2

1.线程A执行完再线程B执行，1-2+1-2=-2  

2.线程1和2同时+1，再-2不同时，1-2-2=-3

3.线程1和2不同时+1，同时-2，1+1-2=0

4.线程1和2既同时+1又同时-2，1-2=-1

没有结果为1的情况

 

++i 先判断++i是否满足条件，满足，进入循环体后再加；不满足，直接跳出

程序文件名必须与公共外部类的名称完全一致（包括大小写）. 对

下面有关servlet service描述错误的是？

正确答案: B   你的答案: D (错误)

A.不管是post还是get方法提交过来的连接，都会在service中处理
B.doGet/doPost 则是在 javax.servlet.GenericServlet 中实现的
C.service()是在javax.servlet.Servlet接口中定义的
D.service判断请求类型，决定是调用doGet还是doPost方法

doGet/doPost 则是在 javax.servlet.http.HttpServlet 中实现的

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

正确答案: C   你的答案: A (错误)

A.accept
B.recieve
C.getInputStream
D.close

socket编程过程 服务器端先初始化socket（），然后进行bind（）绑定端口，接着listen（）监听该端口，之后便是accept（）就是接收客户端，当然在没有客户端接入的情况下，线程会阻塞挂起直到有客户端接入，如果等到了就和客户端交互read（）,write（）当最后读到客户端关闭后，服务器端变close（）

 

面代码运行结果是？

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

public class Test{ static{    int x=5; } static int x,y; //0 public static void main(String args[]){    x--; //x=-1    myMethod( ); //y=0 x=1    System.out.println(x+y+ ++x); 1+ 2=3 } public static void myMethod( ){   y=x++ + ++x; // x++ x=0是后加 ++x x=0+1=1 y =-1+1 =0  } }

正确答案: D   你的答案: A (错误)

A.compiletime error
B.prints:1
C.prints:2
D.prints:3
E.prints:7
F.prints:8

1.静态语句块中x为局部变量，不影响静态变量x的值

2.x和y为静态变量，默认初始值为0，属于当前类，其值得改变会影响整个类运行。

3.java中自增操作非原子性的 

main方法中：

• 执行x--后 x=-1
• 调用myMethod方法，x执行x++结果为-1(后++)，但x=0，++x结果1，x=1 ，则y=0
• x+y+ ++x,先执行x+y，结果为1，执行++x结果为2，得到最终结果为3

从以下哪一个选项中可以获得Servlet的初始化参数?

正确答案: C   你的答案: D (错误)

A.Servlet
B.ServletContext
C.ServletConfig
​​​​​​​D.GenericServlet

通过ServletConfig接口的getInitParameter(java.lang.String name)方法

当编译并运行下面程序时会发生什么结果（）

1 2 3 4 5 6 7 8 9 10 11

public class Bground extends Thread{//没有重写run方法     public static void main(String argv[]){         Bground b = new Bground();         b.run();     }     public void  start(){//从new变成runnable         for(int i=0;i<10;i++){             System.out.println("Value of i = "+i);         }     } }

正确答案: D   你的答案: C (错误)

A.编译错误
B.运行错误
C.编译通过并输出0到9
D.编译通过，但无输出

对于线程而言，start是让线程从new变成runnable。run方法才是执行体的入口。

但是在Thread中，run方法是个空方法，没有具体实现。

继承Thread中需要重写run方法

Bground继承了Thread，但是没有重写run方法，那么调用run方法肯定是无输出。