牛客网刷题笔记-java-2023.3.28

程序计数器：线程私有
栈：线程私有 局部变量（基本类型的变量名称和值 引用变量的变量名称）方法中的局部变量，存放在栈区
堆：线程共享 存放对象实例和数组 局部变量（引用变量的值） 类中的成员变量，存放在堆区
方法区：线程共享 类信息、常量、静态变量 （static 类，变量 final常量）

类变量在不设置初始值时，会进行默认值赋值，
局部方法中声明的变量则必须进行初始化，他不会进行默认值赋值。

接口中方法默认被public abstract修饰，抽象方法不可以有方法体，
默认修饰符是public（可以不写），不能使用其他修饰符。
JDK8中，接口中的方法可以被default和static修饰，但被修饰的方法必须有方法体。
在接口里面的变量默认都是public static final 的，它们是公共的,静态的,最终的常量.相当于全局常量，可以直接省略修饰符。
实现类可以直接访问接口中的变量

公式法：~n=-n-1 例n=10 ~10=-10-1=-11

父类静态代码块–>子类静态代码块–>父类普通代码块–>父类构造方法–>子类代码块–>子类构造方法；

List和set继承collection接口
List 有序 可重复
Set：无序、不可重复。没有索引
List接口常用的实现类有3个：ArrayList（线程不安全）、LinkedList（线程不安全）和Vector（线程安全）。
ArrayList底层是用数组实现的存储。 特点：查询效率高，增删效率低，线程不安全。我们一般使用它。
LinkedList底层用双向链表实现的存储。特点：查询效率低，增删效率高，线程不安全。
Vector底层是用数组实现的List，相关的方法都加了同步检查，因此“线程安全,效率低”。 比如，indexOf方法就增加了synchronized同步标记。
Vector支持线程的同步
Set常用的实现类有：HashSet、TreeSet等，我们一般使用HashSet。
HashSet：是采用哈希算法实现，底层实际是用HashMap实现的
TreeSet底层实际是用TreeMap实现的，支持排序
Map就是用来存储“键(key)-值(value) 对”的。 Map类中存储的“键值对”通过键来标识，所以“键对象”不能重复。
Map 接口的实现类有HashMap（线程不安全）、TreeMap、HashTable（线程安全）、Properties等。
HashMap: 线程不安全，效率高。允许key或value为null。HashMap底层实现采用了哈希表，要求键不能重复
HashTable: 线程安全，效率低。不允许key或value为null。HashTable类和HashMap用法几乎一样，底层实现几乎一样，只不过HashTable的方法添加了synchronized关键字确保线程同步检查，效率较低。
TreeMap底层：红黑二叉树，支持排序，效率比HashMap低

自动类型转换指的是容量小的数据类型可以自动转换为容量大的数据类型。如图2-6所示，黑色的实线表示无数据丢失的自动类型转换，而虚线表示在转换时可能会有精度的损失。

类型 占用存储空间 表数范围
byte 1字节 -27 ~   27-1（-128~127）
short 2字节 -215 ~   215-1（-32768~32767）
int 4字节 -231 ~   231-1 (-2147483648~2147483647)约21亿
long 8字节 -263 ~   263-1
float 4字节 -3.403E38~3.403E38
double 8字节 -1.798E308~1.798E308
char 2字节
boolean 不是一个字节，是1个内存

欲定义类字段或类方法（静态方法），应该使用下列哪一个修饰符修饰（）
A
public
B
static
C
protected
D
synchronized
正确答案：B

重写和重载：这两个都是多态的一种表现形式。

重载：指的是在一个类中定义了多个方法名相同，但参数个数、参数类型不同的方法（返回值、访问权限、抛出的异常可以不同）。（多态在编译期的表现形式）
重写(覆盖):指子类中的方法覆盖父类中的相同方法（方法名、参数、返回值、抛出的异常），即重写父类方法。
方法重写应遵循“三同一小一大”原则：
“三同”：即方法名相同，形参列表相同、返回值类型相同；
“一小“：子类方法声明抛出的异常比父类方法声明抛出的异常更小或者相等；
“一大”：子类方法的访问修饰符应比父类方法更大或者相等。

重写只发生在可见的实例方法中：
1、静态方法不存在重写，形式上的重写只能说是隐藏。
2、私有方法也不存在重写，父类中private的方法，子类中就算定义了，就是相当于一个新的方法。
3、静态方法和实例方法不存在相互重写。

Java的方法重载，就是在同一个类中可以创建多个方法，它们具有相同的名字，但具有不同的参数个数不同定义，调用方法时通过传递给它们的不同参数个数和类型来决定具体使用哪个方法。当方法同名时，至少需要下面之一不同: 1.参数个数不同 2.对应位置上的参数类型不同

下列外部类定义中，不正确的是：（ ）

A
class x { … }
B
class x extends y { … }
C
static class x implements y1,y2 { … }
D
public class x extends Applet { … }

C
static可以用来修饰内部类,但是不可以用来修饰外部类

static修饰的为类成员,会随着类的加载而加载,比如静态代码块,静态成员,静态方法(这里只是加载,并没有调用),可以想象一下,如果把一个Class文件中的外部类设为static,目的难道是让这个类随着应用的启动而加载吗？如果在这次使用过程中根本没有使用过这个类,那么是不是就会浪费内存。这样来说设计不合理,总而言之,设计不合理的地方,Java是不会让它存在的。
而为什么内部类可以使用static修饰呢,因为内部类算是类的成员了,如果没有使用静态来修饰,那么在创建内部类的时候就需要先有一个外部类的对象,如果我们一直在使用内部类,那么内存中就会一直存在外部类的引用,而我们有时候只需要使用内部类,不需要外部类,那么还是会浪费内存,甚至会造成内存溢出。使用static修饰内部类之后,内部类在创建对象时就不需要有外部类对象的引用了。

外部类的修饰符只能是public，abstract，final
内部类可以是静态static的，也可用public，default，protected和private修饰

从以下哪一个选项中可以获得Servlet的初始化参数?
A
Servlet
B
ServletContext
C
ServletConfig
D
GenericServlet
正确答案：C
参考答案：C 通过ServletConfig接口的getInitParameter(java.lang.String name)方法

servletContext 获取web全局参数
servletConfig，需要通过重写servlet的init的方法来获取，用于获取当前servlet的参数

servlet初始化参数是servletConfig.getInitParameter
servlet上下文初始化参数是servletContext.getInitParameter

· ServletConfig对象：servlet配置对象，主要把servlet的初始化参数封装到这个对象中。一个网站中可能会存在多个servletConfig对象，一个servletConfig对象就封装了一个servlet的配置信息。可以在web.xml中通过标签配置初始化参数，通过getInitParameter(String name)或getInitParameterNames()方法来获取初始化参数。注：初始化参数必须在当前的servlet程序中使用。
· ServletContext对象：servlet上下文对象。一个网站只会创建一个servletContext对象，代表的是整个网站的环境信息。可以在web.xml中通过标签配置全局参数，是通过servletConfig对象来获取servletContext对象的，调用的是getServletContext()方法。注：如果某个参数整个网站的程序都要使用，那么可将该参数设置为全局参数，因为可通过servletContext域对象去获取。在servlet中有三个域对象，分别为：ServletContext、HttpServletRequest和HttpSession。
7.
在Java中，HashMap中是用哪些方法来解决哈希冲突的？
A
开放地址法
B
二次哈希法
C
链地址法
D
建立一个公共溢出区
正确答案：C

1.基本概念
哈希算法：根据设定的哈希函数H（key）和处理冲突方法将一组关键字映象到一个有限的地址区间上的算法。也称为散列算法、杂凑算法。
哈希表：数据经过哈希算法之后得到的集合。这样关键字和数据在集合中的位置存在一定的关系，可以根据这种关系快速查询。
非哈希表：与哈希表相对应，集合中的 数据和其存放位置没任何关联关系的集合。
由此可见，哈希算法是一种特殊的算法，能将任意数据散列后映射到有限的空间上，通常计算机软件中用作快速查找或加密使用。
哈希冲突：由于哈希算法被计算的数据是无限的，而计算后的结果范围有限，因此总会存在不同的数据经过计算后得到的值相同，这就是哈希冲突。
2.解决哈希冲突的方法
解决哈希冲突的方法一般有：开放定址法、链地址法（拉链法）、再哈希法、建立公共溢出区等方法。
2.1 开放定址法
从发生冲突的那个单元起，按照一定的次序，从哈希表中找到一个空闲的单元。然后把发生冲突的元素存入到该单元的一种方法。开放定址法需要的表长度要大于等于所需要存放的元素。
在开放定址法中解决冲突的方法有：线行探查法、平方探查法、双散列函数探查法。
开放定址法的缺点在于删除元素的时候不能真的删除，否则会引起查找错误，只能做一个特殊标记。只到有下个元素插入才能真正删除该元素。
2.1.1 线行探查法
线行探查法是开放定址法中最简单的冲突处理方法，它从发生冲突的单元起，依次判断下一个单元是否为空，当达到最后一个单元时，再从表首依次判断。直到碰到空闲的单元或者探查完全部单元为止。
可以参考csdn上flash对该方法的演示：
http://student.zjzk.cn/course_ware/data_structure/web/flash/cz/kfdzh.swf
2.1.2 平方探查法
平方探查法即是发生冲突时，用发生冲突的单元d[i], 加上 1²、 2²等。即d[i] + 1²，d[i] + 2², d[i] + 3²…直到找到空闲单元。
在实际操作中，平方探查法不能探查到全部剩余的单元。不过在实际应用中，能探查到一半单元也就可以了。若探查到一半单元仍找不到一个空闲单元，表明此散列表太满，应该重新建立。
2.1.3 双散列函数探查法
这种方法使用两个散列函数hl和h2。其中hl和前面的h一样，以关键字为自变量，产生一个0至m—l之间的数作为散列地址；h2也以关键字为自变量，产生一个l至m—1之间的、并和m互素的数(即m不能被该数整除)作为探查序列的地址增量(即步长)，探查序列的步长值是固定值l；对于平方探查法，探查序列的步长值是探查次数i的两倍减l；对于双散列函数探查法，其探查序列的步长值是同一关键字的另一散列函数的值。
2.2 链地址法（拉链法）
链接地址法的思路是将哈希值相同的元素构成一个同义词的单链表，并将单链表的头指针存放在哈希表的第i个单元中，查找、插入和删除主要在同义词链表中进行。链表法适用于经常进行插入和删除的情况。
如下一组数字,(32、40、36、53、16、46、71、27、42、24、49、64)哈希表长度为13，哈希函数为H(key)=key%13,则链表法结果如下：
0 1 -> 40 -> 27 -> 53 2 3 -> 16 -> 42 4 5 6 -> 32 -> 71 7 -> 46 8 9 10 -> 36 -> 49 11 -> 24 12 -> 64
注：在java中，链接地址法也是HashMap解决哈希冲突的方法之一，jdk1.7完全采用单链表来存储同义词，jdk1.8则采用了一种混合模式，对于链表长度大于8的，会转换为红黑树存储。
2.3 再哈希法
就是同时构造多个不同的哈希函数：
Hi = RHi(key) i= 1,2,3 … k;
当H1 = RH1(key) 发生冲突时，再用H2 = RH2(key) 进行计算，直到冲突不再产生，这种方法不易产生聚集，但是增加了计算时间。
2.4 建立公共溢出区
将哈希表分为公共表和溢出表，当溢出发生时，将所有溢出数据统一放到溢出区。
发表于 2019-12-28 10:59

定义如下程序：
1
2
3
4
5
6 public static void main(String[] args){
    Double x=1.2; 
    long l = 1.2; 
    float f =  x/l;
    System.out.println(f);
}
程序执行结果是？ （）
A
1
B
1f
C
运行报错
D
编译报错
正确答案：D

Java基本数据类型转换：byte、short、char—>int—>long—>float—>double
由低精度到到精度可以自动转换，而高精度到低精度会损失精度，故需要强制转换。
故第三行，小数默认为double型（float型需要在数字后面加f），不强转编译出错。
第四行，Double到double可以自动拆箱，但向下还是需要强转，再加上 l 的类型错误，故编译出错。
第二行，包装类自动装箱，没问题。

下面关于JAVA的垃圾回收机制，正确的是（ ）
A
当调用“System.gc()”来强制回收时，系统会立即回收垃圾
B
垃圾回收不能确定具体的回收时间
C
程序可明确地标识某个局部变量的引用不再被使用
D
程序可以显式地立即释放对象占有的内存
B

java提供了一个系统级的线程，即垃圾回收器线程。用来对每一个分配出去的内存空间进行跟踪。当JVM空闲时，自动回收每块可能被回收的内存，GC是完全自动的，不能被强制执行。程序员最多只能用System.gc()来建议执行垃圾回收器回收内存，但是具体的回收时间，是不可知的。当对象的引用变量被赋值为null，可能被当成垃圾。

选C多半是认为置为null，但是置为null不一定就不会使用了啊~那我初始化的时候还置为null呢
况且，置为null只是被认为可以当垃圾回收了。不一定会马上回收
局部变量分为引用变量和基本类型变量，基本类型的变量名称和值都是存储在栈中。引用变量只存储引用在栈中，值在堆中，题目中说的是局部变量的引用，而要释放这个需要finalize()方法，这个方法即便使用了也不是一定立刻马上执行。一般局部变量都是随着方法执行结束而释放

如下代码的 结果是什么 ?

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

A
Base
B
BaseBase
C
编译失败
D
代码运行但没有输出
E
运行时抛出异常
正确答案：B
在执行new Alpha()时，会先执行父类的构造方法，在执行相应的子类的构造方法，所以此处会打印Base，在执行new Base()时，会直接执行Base中无参构造器的代码，再输出Base，所以选B

Java表达式"13 & 17"的结果是什么?（）
A
30
B
13
C
17
D
1
正确答案：D

13 =11+20+41+81 1101
17=1+20+40+8*0+16 10001
&在Java中是位运算符，如果相对应位都是1，则结果为1，否则为0。13和17都为单数，所以二进制后最后一位都是1，所以结果为1

00001 =1
速算小技巧，&运算结果一定比以前的值小，| 运算一定比以前的值大

关于异常的编程，以下描述错误的是：（ ）
A
在有除法存在的代码处，为了防止分母为零，必须抛出并捕获异常
B
int i=Integer.parseInt(”123a”);将产生NumberFormatException (数据格式异常)
C
int a[]=null; a[0]=1; 将产生NullPointerException（空指针异常）
D
输入输出流编程中，读和写时都要抛出IOException
正确答案：A

Java的异常分为两种，一种是运行时异常（RuntimeException），一种是非运行异常也叫检查式异常（CheckedException）。
1、运行时异常不需要程序员去处理，当异常出现时，JVM会帮助处理。常见的运行时异常有：
ClassCastException(类转换异常)
ClassNotFoundException
IndexOutOfBoundsException(数组越界异常)
NullPointerException(空指针异常)
ArrayStoreException(数组存储异常，即数组存储类型不一致)
还有IO操作的BufferOverflowException异常
2、非运行异常需要程序员手动去捕获或者抛出异常进行显示的处理，因为Java认为Checked异常都是可以被修复的异常。常见的异常有：
IOException
SqlException

下面有关JDK中的包和他们的基本功能，描述错误的是？
A
java.awt： 包含构成抽象窗口工具集的多个类，用来构建和管理应用程序的图形用户界面
B
java.io：　 包含提供多种输出输入功能的类
C
java.lang： 包含执行与网络有关的类，如URL，SCOKET，SEVERSOCKET
D
java.util：　 包含一些实用性的类
正确答案：C
参考答案：这个题选c
java.awt： 包含构成抽象窗口工具集的多个类，用来构建和管理应用程序的图形用户界面
java.lang： 提供java编成语言的程序设计的基础类
java.io：　 包含提供多种输出输入功能的类，
java.net：　 包含执行与网络有关的类，如URL，SCOKET，SEVERSOCKET，
java.applet： 包含java小应用程序的类
java.util：　 包含一些实用性的类

在上下文和头文件正常的情况下，代码
1 System.out.println(10%32);
将打印？
A
1
B
2
C
4
D
6
正确答案：B
参考答案：B %和是同一个优先级，从左到右运算 10%3=1 1*2=2
3.
Java Applet在被浏览器加载的时候首先被执行且在applet整个生命周期中被运行一次的方法是（）
A
init()
B
stop()
C
opreationcrawl()
D
reader()
正确答案：A

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

java中下面哪个能创建并启动线程（）
1
2
3
4
5 public class MyRunnable implements Runnable { 
     public void run() { 
         //some code here 
     } 
 }
A
new Runnable(MyRunnable).start()
B
new Thread(MyRunnable).run()
C
new Thread(new MyRunnable()).start()
D
new MyRunnable().start()
正确答案：C
官方解析：
创建并启动线程的过程为：定义线程->实例化线程->启动线程。
定义线程有两种方式，一种是继承java.lang.Thread类，一种是实现java.lang.Runnable接口。
这两种方式实例化线程区别在于，如果是继承了Thread类，直接new一个对象就可以了，
如果是实现了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两个选项实例化线程存在错误。B选项中new Runnable(MyRunnable)中的MyRunnable还没有实例化，会导致编译不通过，该选项无论后面是调用run()还是start()都是错误的。

在java7中，下列不能做switch()的参数类型是？
A
int型
B
枚举类型
C
字符串
D
浮点型
正确答案：D
参考答案：D switch语句后的控制表达式只能是short、char、int、long整数类型和枚举类型，不能是float，double和boolean类型。String类型是java7开始支持。

下面哪段程序能够正确的实现了GBK编码字节流到UTF-8编码字节流的转换：
1 byte[] src,dst;

A
dst=String.fromBytes(src，“GBK”).getBytes(“UTF-8”)
B
dst=new String(src，“GBK”).getBytes(“UTF-8”)
C
dst=new String(“GBK”，src).getBytes() （解码错误）
D
dst=String.encode(String.decode(src，“GBK”))，“UTF-8” )（）
正确答案：B
参考答案：选B，先通过GBK编码还原字符串，在该字符串正确的基础上得到“UTF-8”所对应的字节串。
操作步骤就是先解码再编码
用new String(src，“GBK”)解码得到字符串
用getBytes(“UTF-8”)得到UTF8编码字节数组
String类没有fromBytes()和encode以及decode方法！！

以下代码执行的结果是多少（）？
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         public class Demo {
    public static void main(String[] args) {
        Collection<?>[] collections =  {new HashSet(), new ArrayList(), new HashMap

A
Sub:collection Sub:collection Sub:collection
B
Sub:hashSet Sub:arrayList Sub:collection
C
Super:collection Super:collection Super:collection
D
Super:hashSet Super:arrayList Super:collection
正确答案：C
这是静态分派的过程，在编译时已经决定了使用super的方法，因为subToSuper 是指super对象，可是为什么会选择collection呢，for循环出来他们实际上指的是collection对象表示的，即类似于Collection  
 col = new  HashSet<>();这样传入方法getType（）中的参数就是col，左边是静态类型，右边是实际类型。由于重载实际上是使用静态分派的，重载时是通过参数的静态类型而不是实际类型作为判定依据的。详细参考深入理解java虚拟机248页解释。
编辑于 2017-08-18 22:59

考察点1：重载静态多分派——根据传入重载方法的参数类型，选择更加合适的一个重载方法
考察点2：static方法不能被子类覆写，在子类中定义了和父类完全相同的static方法，则父类的static方法被隐藏，Son.staticmethod()或new Son().staticmethod()都是调用的子类的static方法，如果是Father.staticmethod()或者Father f = new Son(); f.staticmethod()调用的都是父类的static方法。
考察点3：此题如果都不是static方法，则最终的结果是A. 调用子类的getType，输出collection

以下哪个不能用来处理线程安全
A
synchronized关键字
B
volatile关键字
C
Lock类
D
transient关键字
正确答案：BD
synchrozied关键字称作同步，主要用来给方法、代码块加锁，被加锁的代码段，同一时间内多线程同时访问同一对象的加锁方法/代码块时，只能有一个线程执行能执行方法/代码块中的代码，其余线程必须等待当前线程执行完以后才执行该方法/代码块。
volatile关键字.保证了不同线程对该变量操作的内存可见性.(当一个线程修改了变量,其他使用次变量的线程可以立即知道这一修改)。2.禁止了指令重排序.
Lock接口提供了与synchronized关键字类似的同步功能，但需要在使用时手动获取锁和释放锁。
transient关键字  简单地说，就是让某些被修饰的成员属性变量不被序列化。

valitale关键字也不能保证线程的安全性，因为它不具备原子性
transient，变量修饰符，如果用transient声明一个实例变量，当对象存储时，它的值不需要维持。当一个变量不希望被持久化的时候，比如说一些账号密码，就可以用transient关键字来表示该变量不参与序列化过程
9.
下面说法正确的是？（）

A
调用Thread的sleep()方法会释放锁，调用wait()方法不释放锁//sleep有锁，wait没有锁
B
一个线程调用yield方法，可以使具有相同优先级线程获得处理器
C
在Java中，高优先级的可运行的线程会抢占低优先级线程的资源
D
java中，线程可以调用yield方法使比自己低优先级的线程运行、、同级别
正确答案：BC
还记得马老师说过，yiled方法属于高风亮节的行为，这个坑位我不上了，后面跟我同级别的先上厕所。这样比较好记！
高优先级的就是你们的县长，县长要上厕所，对不起，你得出来，县长先上，县长上完了，CPU分配到你了，你才能继续拉X。

睡觉是抱着锁睡觉的

sleep()方法（休眠）是线程类（Thread）的静态方法，调用此方***让当前线程暂停执行指定的时间，将执行机会（CPU）让给其他线程，但是对象的锁依然保持，因此休眠时间结束后会自动恢复（线程回到就绪状态，请参考第66题中的线程状态转换图）。
wait()是Object类的方法，调用对象的wait()方法导致当前线程放弃对象的锁（线程暂停执行），进入对象的等待池（wait pool），只有调用对象的notify()方法（或notifyAll()方法）时才能唤醒等待池中的线程进入等锁池（lock pool），如果线程重新获得对象的锁就可以进入就绪状态。

wait()：等待时线程别人可以用。
sleep()：等待时线程还是自己的，别人不能用。
yield()：释放锁，同优先级的其他线程有机会获得锁。

java中 String str = "hello world"下列语句错误的是？
A
str+=’ a’
B
int strlen = str.length
C
str=100
D
str=str+100
正确答案：ABC

ABC在java中会报错，D可以正常运行, 所以答案是ABC.
A. ‘a’是字符,’ a’这个是空格和a，必须要用" a"才可以;
B.String有length()方法
C.int 无法直接转成String类型
D.尾部添加字符串”100“

构造方法用于创建类的实例对象，构造方法名应与类名相同，返回类型为void。
A
正确
B
错误
正确答案：B
构造方法和普通方法的区别，只有权限修饰和方法名（和类名相同），虽然没有返回值，但是它没有返回类型，包括void!

类的构造方法:（1）无返回值； （2）其名称与本类名称相同。

1 以下说法错误的是（）

A
数组是一个对象
B
数组不是一种原生类
C
数组的大小可以任意改变
D
在Java中，数组存储在堆中连续内存空间里
正确答案：C
参考答案：答案是C           在java中,数组是一个对象, 不是一种原生类,对象所以存放在堆中,又因为数组特性,是连续的,只有C不对

给定代码：
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++;//j=2
        case 5:j++;//j=3
        default:j++;//j=4
        }
        return j+x;//8
    }
}
第三行将输出什么？
A
value=6
B
value=8
C
value=3
D
value=5
E
value=4
正确答案：B
case条件是程序顺序执行的入口，只有当遇到break语句时才会跳出。
没有break，从case 4开始一直执行到最后，j自加3次变成了4,结果返回8
case的穿透性!!!
switch…case的三个规则：
（1）既无成功匹配，又无default子句，那么swtich语句块什么也不做；
（2）无成功匹配，但有default，那么swtich语句块做default语句块的事；
（3）有成功匹配，没有break，那么成功匹配后，一直执行，直到遇到break。

我们在程序中经常使用“System.out.println()”来输出信息，语句中的System是包名，out是类名，println是方法名。
A
对
B
错
正确答案：B
System是java.lang中的一个类，out是System内的一个成员变量，这个变量是一个java.io.PrintStream类的对象，println就是一个方法了。

运用下列哪个命令能够获取JVM的内存映像
A
jinfo
B
jmap
C
jhat
D
jstat
正确答案：B
1、jps：查看本机java进程信息。
2、jstack：打印线程的栈信息，制作线程dump文件。
3、jmap：打印内存映射，制作堆dump文件
4、jstat：性能监控工具
5、jhat：内存分析工具
6、jconsole：简易的可视化控制台
7、jvisualvm：功能强大的控制台

下列说法正确的有（）
A
能被java.exe成功运行的java class文件必须有main()方法//正确main方法是入口 
B
J2SDK就是Java API//J2SDK当然不仅仅包含java API
C
Appletviewer.exe可利用jar选项运行.jar文件//jar选项是java.exe 的选项
D
能被Appletviewer成功运行的java class文件必须有main()方法//Appletviewer是运行applet的， applet 不用main方法，继承applet类即可。

正确答案：A
java程序的种类
1.Application：Java应用程序，是可以由Java解释器直接运行的程序。
2.Applet：即Java小应用程序，是可随网页下载到客户端由浏览器解释执行的Java程序。
3.Servlet：Java服务器端小程序，由Web服务器(容器)中配置运行的Java程序。

j2sdk是JAVA的开发环境包它包含JDK(开发工具包，包含JRE)和JRE(运行时环境包)，简称JDK。J2SDK包含很多东西，比如Java language 、 Deployment等。 API只是其中很小的一部分。

Appletviewer.exe可利用java.exe选项运行.jar文件
Applet：即Java小应用程序，是可随网页下载到客户端由浏览器解释执行的Java程序
Appletviewer是运行applet的， applet 不用main方法，继承applet类即可。
平台的 JRE 2.appletviewer appletviewer 提供了一个Java运行环境，在其中可测试小应用程序Applet。appletviewer 读取包含小应用程序的HTML文件并在一个窗口中运行它们。

在java中，下列对继承的说法，正确的是（ ）
A
子类能继承父类的所有成员
B
子类继承父类的非私有方法和状态( 权限从小到大 private(同类))、默认（同包） 、protected（同包+不同包子类）、public（不同包））
C
子类只能继承父类的public方法和状态 //受保护的 也可以继承
D
子类只能继承父类的方法 //子类也有他自己的方法
正确答案：A
你的答案：B
官方解析：
Constructors, static initializers, and instance initializers are not members and
therefore are not inherited.(构造器、静态初始化块、实例初始化块不继承）
我们有时候会分不清继承和访问权限的问题。子类可以继承父类所有的成员，但是对private这样的，没有访问权。

B选项应该有问题，不在同一个包下的子类不能继承父类的默认修饰符修饰的方法

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

哪个正确
A
abstract类只能用来派生子类，不能用来创建abstract类的对象。
B
final类不但可以用来派生子类，也可以用来创建final类的对象。//final不能用来派生子类，final的类不可以被继承
C
abstract不能与final同时修饰一个类。//final的类不可以被继承，abstract类是用来被继承的，所以不能修饰一个类
D
abstract类定义中可以没有abstract方法。 //类中有abstract方法必须用abstract修饰，但abstract类可以没有抽象方法，接口中也可以有abstract方法
正确答案：ACD
1.包含抽象方法的类必须是抽象的，但是，可以定义一个不包含抽象方法的抽象类（一般用于多个子类的基类，不可被new）
2.即使子类的父类是具体的，这个子类也可以是抽象的。
1、abstract类不能用来创建abstract类的对象；
2、final类不能用来派生子类，因为用final修饰的类不能被继承；
3、如2所述，final不能与abstract同时修饰一个类，abstract类就是被用来继承的；
4、类中有abstract方法必须用abstract修饰，但abstract类中可以没有抽象方法，接口中也可以有abstract方法。

多选题
10.
class A {}
class B extends A {}
class C extends A {}
class D extends B {}
下面的哪4个语句是正确的？
A
The type Listis assignable to List. 点–范围 对
B
The type Listis assignable to List. 点–点 错
C
The type Listis assignable to List<?>. 点–范围 对
D
The type Listis assignable to List<?extends B>. 点 --范围 对
E
The type List<?extends A>is assignable to List. 范围–点 错
F
The type Listis assignable to any List reference. 点到–不认识 List只是一个点 错
G
The type List<?extends B>is assignable to List<?extends A>. 范围–范围 ，因为b是ad的子类，所以小于b的范围<小于a的范围

正确答案：ACDG

来源：牛客网
耐心看完，保证能懂这道题！

1. 只看尖括号里边的！！明确点和范围两个概念
2. 如果尖括号里的是一个类，那么尖括号里的就是一个点，比如List,List,List
3. 如果尖括号里面带有问号，那么代表一个范围，<? extends A> 代表小于等于A的范围，<? super A>代表大于等于A的范围，<?>代表全部范围
4. 尖括号里的所有点之间互相赋值都是错，除非是俩相同的点
5. 尖括号小范围赋值给大范围，对，大范围赋值给小范围，错。如果某点包含在某个范围里，那么可以赋值，否则，不能赋值
6. List<?>和List 是相等的，都代表最大范围

---

7.补充：List既是点也是范围，当表示范围时，表示最大范围

下面贴代码：（本来用的Eclipse截图的，结果好像网站出来Bug，不能传图了o(╯□╰)o）
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 public static void main(String[] args) {
        List a;
        List list;
        list = a;   //A对，因为List就是List<?>，代表最大的范围，A只是其中的一个点，肯定被包含在内         List b;         a = b;      //B错，点之间不能相互赋值         List<?> qm;
        List o;
        qm = o;     //C对，List<?>代表最大的范围，List只是一个点，肯定被包含在内
        List d;
        List<? extends B> downB;
        downB = d;  //D对，List<? extends B>代表小于等于B的范围，List是一个点，在其中
        List<?extends A> downA;
        a = downA;  //E错，范围不能赋值给点
        a = o;      //F错，List只是一个点
        downA = downB;  //G对，小于等于A的范围包含小于等于B的范围，因为B本来就比A小，B时A的子类嘛
    }

B：List和List没有继承关系

java语言的下面几种数组复制方法中，哪个效率最高？
A
for 循环逐一复制
B
System.arraycopy
C
Array.copyOf
D
使用clone方法
正确答案：B

复制的效率System.arraycopy>clone>Arrays.copyOf>for循环，
这个有兴趣自己测试一下就知道了。
这里面在System类源码中给出了arraycopy的方法，是native方法，也就是本地方法，肯定是最快的。
而Arrays.copyOf(注意是Arrays类，不是Array)的实现，在源码中是调用System.copyOf的，多了一个步骤，肯定就不是最快的。
前面几个说System.copyOf的不要看，System类底层根本没有这个方法，自己看看源码就全知道了。

下面有关Java的说法正确的是（    ）
A
一个类可以实现多个接口
B
抽象类必须有抽象方法//抽象类中不一定包含抽象方法，但包含抽象方法的类一定是抽象类
C
protected成员在子类可见性可以修改
D
通过super可以调用父类构造函数
E
final的成员方法实现中只能读取类的成员变量//final 的成员方法除了能读取类的成员变量，还能读取类变量
F
String是不可修改的，且java运行环境中对string对象有一个对象池保存
正确答案：ACDF
抽象类能继承一个普通类（或抽象类），实现多个接口。
抽象类和普通类相比只是不能被实例化，只能作为子类的超类。
抽象类是用来捕捉子类的通用特性的，被用来创建继承层级里子类的模板。
可以有默认的方法实现。
抽象类可以有构造方法。
可以有main方法。
不必须有抽象方法，但是包含抽象方法的类一定是抽象类。
 
=接口=
接口能实现多个其他接口。
接口是抽象方法的集合，一个类实现了某个接口就必须实现抽象方法。
接口抽象方法默认修饰符是public（可以不写），不能使用其他修饰符。
java 8中接口可以包含具体的方法实现，方法实现必须default修饰。

以下哪种JAVA的变量表达式使得变量a和变量b具有相同的内存引用地址(  )
A
String a = “hello”; String b = “hello”;
B
Integer a; Integer b = a;
C
int a = 1; Integer b = new Integer(1);
D
int a = 1; Integer b = 1;
正确答案：AB

内存引用地址，是指栈中存放的地址，来指向堆中的某个位置。
int 是基本类型，数据直接存放在栈中，不存在内存引用地址的说法

A对  指向常量池里的"hello"。
B对  题中没说声明的a是局部变量。
C错  int a =1;并不指向堆中，它只有值，没有引用地址，Integer b =new Integer(1);指向堆中地址为1的位置。
D错  原因同C

首先结论：
（1）int与Integer、new Integer()进行比较时，结果永远为true
（2）Integer与new Integer()进行比较时，结果永远为false
（3）Integer与Integer进行==比较时，看范围；在大于等于-128小于等于127的范围内为true，在此范围外为false。

下面是解析过程：
1.Integer与int比较时，Integer会有拆箱的过程，我们可以看看拆箱的代码：

直接返回的就是value，因此int与Integer以及new Integer()进行  ==比较时结果都是true。
2.Integer a=n时，如果n大于等于-128小于等于127时，会直接从IntegerCache中取，不在这个范围内，会new一个对象，所以Integer与new Integer进行 ==比较时，结果都是false。
3.Integer与Integer比较，需要看范围，如果在-128~127(包含-128，不包含127)范围内，因为都是从IntegerCache中取值，所以相等；若不在这个范围内，则都要去new一个对象，所以结果为false。

通过以下哪些方法可反射获取到User对象中static属性的值？
A
User. class. getDeclaredField (“name”). get (null);
B
User. class. getField (“name”). get (null);
C
User user=new User(); return user. getClass(). getField (“name”)．get (user);
D
User user=new User(): return user. getClass(). getDeclaredField (“name”）. get (user);
正确答案：ABCD

参考资料
getDeclaredField：查找该Class所有声明属性(静态/非静态)，但是他不会去找实现的接口/父类的属性
getField：只查找该类public类型的属性，如果找不到则往上找他的接口、父类，依次往上，直到找到或者已经没有接口/父类

getField 方***获取自己包括父类里面声明的public字段（先去找自己的，自己没有的才会去找父类的）.
getDeclaredField 只会找本class中的所有的非私有字段（不管是static还是非static的）。

以下哪种方式实现的单例是线程安全的
A
枚举
B
静态内部类
C
双检锁模式
D
饿汉式
正确答案：ABCD
单列模式的6种实现方式。
目录：

一、单例模式的定义
定义： 确保一个类只有一个实例，并提供该实例的全局访问点。
这样做的好处是：有些实例，全局只需要一个就够了，使用单例模式就可以避免一个全局使用的类，频繁的创建与销毁，耗费系统资源。
二、单例模式的设计要素
一个私有构造函数 （确保只能单例类自己创建实例）
一个私有静态变量 （确保只有一个实例）
一个公有静态函数 （给使用者提供调用方法）
简单来说就是，单例类的构造方法不让其他人修改和使用；并且单例类自己只创建一个实例，这个实例，其他人也无法修改和直接使用；然后单例类提供一个调用方法，想用这个实例，只能调用。这样就确保了全局只创建了一次实例。
三、单例模式的6种实现及各实现的优缺点
（一）懒汉式（线程不安全）
实现：
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14 public class Singleton {
     private static Singleton uniqueInstance;
 
     private Singleton() {
 
    }
 
    public static Singleton getUniqueInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
}
说明： 先不创建实例，当第一次被调用时，再创建实例，所以被称为懒汉式。
优点： 延迟了实例化，如果不需要使用该类，就不会被实例化，节约了系统资源。
缺点： 线程不安全，多线程环境下，如果多个线程同时进入了 if (uniqueInstance == null) ，若此时还未实例化，也就是uniqueInstance == null，那么就会有多个线程执行 uniqueInstance = new Singleton(); ，就会实例化多个实例；
（二）饿汉式（线程安全）
实现：
1
2
3
4
5
6
7
8
9
10
11
12 public class Singleton {
 
    private static Singleton uniqueInstance = new Singleton();
 
    private Singleton() {
    }
 
    public static Singleton getUniqueInstance() {
        return uniqueInstance;
    }
 
}
说明： 先不管需不需要使用这个实例，直接先实例化好实例 (饿死鬼一样，所以称为饿汉式)，然后当需要使用的时候，直接调方法就可以使用了。
优点： 提前实例化好了一个实例，避免了线程不安全问题的出现。
缺点： 直接实例化好了实例，不再延迟实例化；若系统没有使用这个实例，或者系统运行很久之后才需要使用这个实例，都会操作系统的资源浪费。
（三）懒汉式（线程安全）
实现：
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14 public class Singleton {
    private static Singleton uniqueInstance;
 
    private static singleton() {
    }
 
    private static synchronized Singleton getUinqueInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
 
}
说明： 实现和 线程不安全的懒汉式 几乎一样，唯一不同的点是，在get方法上 加了一把 锁。如此一来，多个线程访问，每次只有拿到锁的的线程能够进入该方法，避免了多线程不安全问题的出现。
优点： 延迟实例化，节约了资源，并且是线程安全的。
缺点： 虽然解决了线程安全问题，但是性能降低了。因为，即使实例已经实例化了，既后续不会再出现线程安全问题了，但是锁还在，每次还是只能拿到锁的线程进入该方***使线程阻塞，等待时间过长。
（四）双重检查锁实现（线程安全）
实现：
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 public class Singleton {
 
    private volatile static Singleton uniqueInstance;
 
    private Singleton() {
    }
 
    public static Singleton getUniqueInstance() {
        if (uniqueInstance == null) {
            synchronized (Singleton.class) {
                if (uniqueInstance == null) {
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    } 
}
说明: 双重检查数相当于是改进了 线程安全的懒汉式。线程安全的懒汉式 的缺点是性能降低了，造成的原因是因为即使实例已经实例化，依然每次都会有锁。而现在，我们将锁的位置变了，并且多加了一个检查。 也就是，先判断实例是否已经存在，若已经存在了，则不会执行判断方法内的有锁方法了。 而如果，还没有实例化的时候，多个线程进去了，也没有事，因为里面的方法有锁，只会让一个线程进入最内层方法并实例化实例。如此一来，最多最多，也就是第一次实例化的时候，会有线程阻塞的情况，后续便不会再有线程阻塞的问题。
为什么使用 volatile 关键字修饰了 uniqueInstance 实例变量 ？
uniqueInstance = new Singleton(); 这段代码执行时分为三步：
1.为 uniqueInstance 分配内存空间
2.初始化 uniqueInstance
3.将 uniqueInstance 指向分配的内存地址
正常的执行顺序当然是 1>2>3 ，但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1>3>2。
单线程环境时，指令重排并没有什么问题；多线程环境时，会导致有些线程可能会获取到还没初始化的实例。
例如：线程A 只执行了 1 和 3 ，此时线程B来调用 getUniqueInstance()，发现 uniqueInstance 不为空，便获取 uniqueInstance 实例，但是其实此时的 uniqueInstance 还没有初始化。
解决办法就是加一个 volatile 关键字修饰 uniqueInstance ，volatile 会禁止 JVM 的指令重排，就可以保证多线程环境下的安全运行。
优点： 延迟实例化，节约了资源；线程安全；并且相对于 线程安全的懒汉式，性能提高了。
缺点： volatile 关键字，对性能也有一些影响。
（五）静态内部类实现（线程安全）
实现：
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14 public class Singleton {
 
    private Singleton() {
    }
 
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
 
    public static Singleton getUniqueInstance() {
        return SingletonHolder.INSTANCE;
    }
 
}
说明： 首先，当外部类 Singleton 被加载时，静态内部类 SingletonHolder 并没有被加载进内存。当调用 getUniqueInstance() 方法时，会运行 return SingletonHolder.INSTANCE; ，触发了 SingletonHolder.INSTANCE ，此时静态内部类 SingletonHolder 才会被加载进内存，并且初始化 INSTANCE 实例，而且 JVM 会确保 INSTANCE 只被实例化一次。
优点： 延迟实例化，节约了资源；且线程安全；性能也提高了。
（六）枚举类实现（线程安全）
实现：
复制代码
1
2
3
4
5
6
7
8
9
10 public enum Singleton {
 
    INSTANCE;
 
    //添加自己需要的操作
    public void doSomeThing() {
 
    }
 
}
说明： 默认枚举实例的创建就是线程安全的，且在任何情况下都是单例。
优点： 写法简单，线程安全，天然防止反射和反序列化调用。
防止反序列化
序列化：把java对象转换为字节序列的过程；
反序列化： 通过这些字节序列在内存中新建java对象的过程；
说明： 反序列化 将一个单例实例对象写到磁盘再读回来，从而获得了一个新的实例。
我们要防止反序列化，避免得到多个实例。
枚举类天然防止反序列化。
其他单例模式 可以通过 重写 readResolve() 方法，从而防止反序列化，使实例唯一重写 readResolve() :
复制代码
1
2
3 private Object readResolve() throws ObjectStreamException{
        return singleton;
}
四、单例模式的应用场景
应用场景举例：
网站计数器。
应用程序的日志应用。
Web项目中的配置对象的读取。
数据库连接池。
多线程池。
…
使用场景总结：
频繁实例化然后又销毁的对象，使用单例模式可以提高性能。
经常使用的对象，但实例化时耗费时间或者资源多，如数据库连接池，使用单例模式，可以提高性能，降低资源损坏。
使用线程池之类的控制资源时，使用单例模式，可以方便资源之间的通信。

有关线程的叙述正确的是()
A
可以获得对任何对象的互斥锁定
B
通过继承Thread类或实现Runnable接口，可以获得对类中方法的互斥锁定
C
线程通过使用synchronized关键字可获得对象的互斥锁定
D
线程调度算法是平台独立的
正确答案：CD
A，“任何对象”锁定，太绝对了，你能锁住你没有权限访问的对象吗？
B，前半句话讲的是创建线程的方式，后半句讲的是锁定，驴头不对马嘴。
C，正确。
D，线程调度分为协同式调度和抢占式调度，Java使用的是抢占式调度，也就是每个线程将由操作系统来分配执行时间，线程的切换不由线程本身来决定（协同式调度）。这就是平台独立的原因

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

A
class
B
static
C
public
D
final
正确答案：B
能被类直接调用，说明是静态的，随着类的加载而加载
为static 为：可以不实例化就可以直接使用

static关键字：针对多个对象共有的成员变量值时所提出的。
特点：
1、随着类的加载而加载；   
2、优先于对象存在；   
3、被类的所有对象共享；       
4、可以通过类名直接调用。
注意事项：1.在静态方法中是没有this关键字的；       
2.静态方法只能访问静态的成员变量和静态的成员方法。

基本的Java语言函数存储在以下哪个java包中？（）
A
java.lang
B
java.io
C
java.net
D
java.util
正确答案：A
java.lang包包含
包装类
String 类
Math 类     ——    包含函数
Class 类
Object 类

java.lang   提供java基础类，例如：Object\Math\String\StringBuffer\System\Tread等，这是我们最常用的包包，但是我们并不常见到她，因为我们不需要将她手动导入；
java.util     提供包括集合框架、事件模型、日期时间、等等的使用工具类；
java.io       提供通过文件系统、数据流和序列化提供系统的输入输入；
java.net     提供实时网络应用和开发的类；
java.sql     提供使用java语言访问并处理存储在数据源中的数据API；
java.awt  和  java.swing  提供了GUI开发与设计的类，awt提供了创建界面和绘制图形图像的所有类，swing包提供了一组“轻量级”的组件，尽量让这些组件在所有平台上的工作方式相同；
java.text    提供了与自然语言无关的方式来处理文本日期、数字和消息的类和接口。

如果一个接口Cow有个public方法drink()，有个类Calf实现接口Cow，则在类Calf中正确的是？  ( )

A
void drink() { …}
B
protected void drink() { …}
C
public void drink() { …}
D
以上语句都可以用在类Calf中
正确答案：C
官方解析： Java接口中的方法默认被public abstract修饰，而重写的其中一个要求就是重写方法的访问级别不小于原方法。
重写接口中的方法，访问权限一定是public因此，答案中只有C选项符合。

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

A
Set中至多只能有一个空元素
B
List中至多只能有一个空元素
C
List和Set都可以包含重复元素的有序集合
D
List和Set都是有序集合
正确答案：A
Set 不能有重复的元素，且是无序的，要有空值也就只能有一个。因为它不允许重复。
L ist 可以有重复元素，且是有序的，要有空值也可以有多个，因为它可重复

下面叙述那个是正确的？（）
A
java中的集合类（如Vector）可以用来存储任何类型的对象，且大小可以自动调整。但需要事先知道所存储对象的类型，才能正常使用。
B
在java中，我们可以用违例（Exception）来抛出一些并非错误的消息，但这样比直接从函数返回一个结果要更大的系统开销
//因为函数调用是入栈出栈，栈是在寄存器之下的速度最快，且占的空间少，而自定义异常是存在堆中，肯定异常的内存开销大。
C
java接口包含函数声明和变量声明。// 权限从小到大 private(同类))、默认（同包） 、protected（同包+不同包子类）、public（不同包））错误（函数声明 public abstract）(变量public final static 静态常量 声明时必须初始化)
//可以在接口中定义一个常量，但是不能声明，也就是说，必须给他赋一个初值。

D
java中，子类不可以访问父类的私有成员和受保护的成员。// 权限从小到大 private(同类))、默认（同包） 、protected（同包+不同包子类）、public（不同包）） 子类不能访问私有的，可以访问受保护的
正确答案：B

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

c选项，错就错在，java接口只能有常量定义和方法定义（抽象方法），且所有定义的访问权限一定是public。

以下Java程序运行的结果是:
1
2
3
4
5
6
7
8
9
10
11
12 public class Tester{
public static void main(String[] args){
   Integer var1=new Integer(1);
   Integer var2=var1;
   doSomething(var2);
   System.out.print(var1.intValue());
   System.out.print(var1==var2);
}
public static void doSomething(Integer integer){
    integer=new Integer(2);
    }
}
A
1true
B
2true
C
1false
D
2false
正确答案：A
java中引用类型的实参向形参的传递，只是传递的引用，而不是传递的对象本身。
自己画的图，而且没有visio！直接画图画的！

以下集合对象中哪几个是线程安全的（）
A
LinkedList
B
ArrayList
C
Vector
D
Hashtable
正确答案：CD

简单记忆线程安全的集合类：
 喂！SHE！
 喂是指  vector，
S是指 stack，
 H是指    hashtable，
E是指：Eenumeration
linkedList、ArrayList都不是线程安全的，Vector是线程安全的，但是效率很低，现在很少用
Hashtable和Hashmap功能差不多，但Hashtables是线程安全的
8.
下面哪些情况下该类一定为抽象类？
A
当一个类的一个或多个方法是抽象方法时
B
当类是一个抽象类的子类，并且不能为任何抽象方法提供任何实现细节或方法体时
C
当一个类实现多个接口时//普通的类也可以实现多个接口
D
当一个类实现一个接口，并且不能为任何抽象方法提供实现细节或方法体时
正确答案：ABD
抽象方法的题是很容易做错，所以它是感染性极强的病毒（Abs病毒）。

A：当一个类有一个抽象方法，就表示它被Abs病毒感染了，所以整个类就被感染了（这个类必须是abstract的）。--  一个类有一个抽象方法或多个抽象方法就必须是abstract的

B：如果一个类继承了一个抽象类，则必须实现它所有的方法（解析Abs病毒所有DNA，制定对策），如果有一个抽象方法没实现，就是表示某个病毒体没被破解成功，这个子类同样会被Abs病毒感染，必须标志abstract。-- 当类是一个抽象类的子类，必须所有抽象方法被实现，有一个抽象方法没实现，子类就是abstract的。

C：普通类本来就可以实现多个接口，接口可以多实现，但是类不能多继承，
除了接口本身可以多继承接口，接口也不能被多继承，抽象类也不可以！！

D：一个类实现一个接口，要知道接口就是抽象类的更抽象的一种东西，所以其变量都是public abstract static final的，方法都是public abstract static的（jdk1.8以后有非抽象方法了，default和static方法。。略坑），这就是为什么接口里只能定义接口而不能实现的原因了！

抽象类：
1、用 abstract 修饰，抽象类中可以没有抽象方法，但抽象方法肯定在抽象类中，且抽象方法定义时不能有方法体；
2、抽象类不可以实例化只能通过继承在子类中实现其所有的抽象方法；
3、抽象类如果不被继承就没有任何意义；
4、抽象类为子类定义了一个公共类型，封装了子类中的重复内容。
接口:
1、用Interface关键字定义接口，是特殊的抽象类，因为类中只包含抽象方法；
2、接口中不能定义成员变量可以定义常量；
3、 接口是其通过其他类使用 implements 关键字定义实现类，一个类一旦实现接口就必须实现其中的所有抽象方法，一个类可以实现多个接口，接口名之间用逗号隔开即可；
4、一个接口可以通过 extends 关键字继承另一个接口，与此同时继承了父类中的所有方法。

关于OutOfMemoryError，下面说法正确的是（）？
A
java.lang.OutOfMemoryError: PermGen space 增加-XX:MaxPermSize这个参数的值的话，这个问题通常会得到解决。
//运行时常量池导致的溢出,设置-XX：MaxPermSize可以解决这个问题
B
java.lang.OutOfMemoryError: Requested array size exceeds VM limit当你正准备创建一个超过虚拟机允许的大小的数组时，这条错误将会出现
//属于堆空间不足导致的错误
C
java.lang.OutOfMemoryError: Java heap space 一般情况下解决这个问题最快的方法就是通过-Xmx参数来增加堆的大小
//java堆内存问题，如果可以继续调大，可以设置-Xmx解决问题

D
java.lang.OutOfMemoryError: nativeGetNewTLA这个异常只有在jRockit虚拟机时才会碰到
//nativeGetNewTLA指当虚拟机不能分配新的线程,本地空间(Thread Local Area）的时候错误信息，此错误是线程申请一个新的TLA时产生的，这个异常一般只会发生在jRockit虚拟机
正确答案：ABCD

关于此题，《深入理解java虚拟机》有关于OOM（OutOfMemory）问题的解释
A：属于运行时常量池导致的溢出，设置-XX：MaxPermSize可以解决这个问题，
B：属于堆空间不足导致的错误，问题比较少见，解决方式和C相同，
C：属于java堆内存问题，一般的手段是通过内存映像分析工具，对Dump出来的堆转储存快照进行分析，重点是确认内存中的对象是否是有必要的，也就是要判断是出现了内存泄漏，还是出现了内存溢出，如果是内存列楼，通过工具检查泄露对象打GC Roots的引用链信息，可以准确的确定出泄露代码的位置，不存在泄露，就应该检查虚拟机的堆参数，如果可以继续调大，可以设置-Xmx解决问题
D：java.lang.OutOfMemoryError: nativeGetNewTLA指当虚拟机不能分配新的线程本地空间(Thread Local Area）的时候错误信息，此错误是线程申请一个新的TLA时产生的，这个异常一般只会发生在jRockit虚拟机，只有过于绝对。

.
以下哪些类是线程安全的（）
A
Vector
B
HashMap
C
ArrayList
D
StringBuffer
E
Properties
正确答案：ADE
参考答案：答案：ADE
A，Vector相当于一个线程安全的List
B，HashMap是非线程安全的，其对应的线程安全类是HashTable
C，Arraylist是非线程安全的，其对应的线程安全类是Vector D，
D，StringBuffer是线程安全的，相当于一个线程安全的StringBuilder
E，Properties实现了Map接口，是线程安全的
知识点：

以下哪个区域不属于新生代？
A
eden区
B
from区
C
元数据区
D
to区
C

eden : from : to =8:1:1，用于新生代垃圾回收。 元数据区是用来替换永久代的，大概那个意思。

java 中的堆是 JVM 所管理的最大的一块内存空间，主要用于存放各种类的实例对象。
在 Java 中，堆被划分成两个不同的区域：新生代 ( Young )、老年代 ( Old )。新生代 ( Young ) 又被划分为三个区域：Eden、From Survivor、To Survivor。
这样划分的目的是为了使 JVM 能够更好的管理堆内存中的对象，包括内存的分配以及回收。

堆大小 = 新生代 + 老年代。其中，堆的大小可以通过参数 –Xms、-Xmx 来指定。
本人使用的是 JDK1.6，以下涉及的 JVM 默认值均以该版本为准。
默认的，新生代 ( Young ) 与老年代 ( Old ) 的比例的值为 1:2 ( 该值可以通过参数 –XX:NewRatio 来指定 )，即：新生代 ( Young ) = 1/3 的堆空间大小。
老年代 ( Old ) = 2/3 的堆空间大小。其中，新生代 ( Young ) 被细分为 Eden 和 两个 Survivor 区域，这两个 Survivor 区域分别被命名为 from 和 to，以示区分。
默认的，Edem : from : to = 8 : 1 : 1 ( 可以通过参数 –XX:SurvivorRatio 来设定 )，即： Eden = 8/10 的新生代空间大小，from = to = 1/10 的新生代空间大小。
JVM 每次只会使用 Eden 和其中的一块 Survivor 区域来为对象服务，所以无论什么时候，总是有一块 Survivor 区域是空闲着的。
因此，新生代实际可用的内存空间为 9/10 ( 即90% )的新生代空间。

我是一个普通的Java对象，我出生在Eden区，在Eden区我还看到和我长的很像的小兄弟，我们在Eden区中玩了挺长时间。有一天Eden区中的人实在是太多了，我就被迫去了Survivor区的“From”区，自从去了Survivor区，我就开始漂了，有时候在Survivor的“From”区，有时候在Survivor的“To”区，居无定所。直到我18岁的时候，爸爸说我成人了，该去社会上闯闯了。于是我就去了年老代那边，年老代里，人很多，并且年龄都挺大的，我在这里也认识了很多人。在年老代里，我生活了20年(每次GC加一岁)，然后被回收。（CSDN）

垃圾回收过程：
    1、新创建的对象，绝大多数都会存储在Eden中，
    2、当Eden满了（达到一定比例）不能创建新对象，则触发垃圾回收（GC），将无用对象清理掉，
           然后剩余对象复制到某个Survivor中，如S1，同时清空Eden区
    3、当Eden区再次满了，会将S1中的不能清空的对象存到另外一个Survivor中，如S2，
          同时将Eden区中的不能清空的对象，也复制到S1中，保证Eden和S1，均被清空。
    4、重复多次(默认15次)Survivor中没有被清理的对象，则会复制到老年代Old(Tenured)区中，
    5、当Old区满了，则会触发一个一次完整地垃圾回收（FullGC），之前新生代的垃圾回收称为（minorGC）

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

在运行时，由java解释器自动引入，而不用import语句引入的包是()。
A
java.lang//自动导入
B
java.system//system是属于java.lang.sysytem
C
java.io//手动导入
D
java.util//手动导入

正确答案：A
你的答案：B
参考答案：答案：A java.lang包是java语言的核心包，lang是language的缩写 java.lang包定义了一些基本的类型，包括Integer,String之类的，是java程序必备的包，有解释器自动引入，无需手动导入

java.lang包是java语言包，是自动导入的。
java.util包是java的工具包，需要手动导入。
java.sql包，JDBC接口类，需要手动导入。
java.io;各种输入输入流，需要手动导入。

一个Java源程序文件中定义几个类和接口，则编译该文件后生成几个以.class为后缀的字节码文件。
A
正确
B
错误
正确答案：B
牛逼啊，原来是我没有理解题目意思，这个题目是说一个Java源程序中有n个类和接口，就会生成n个以.class为后缀名的文件，但是它忽略了在类和接口里面还可以定义内部类和匿名内部类，这个时候就不仅仅是n个了，还需要加上定义了多个内部类和匿名内部类。
    比如说在一个Java源程序中定义了1个接口，1个类，而在这个接口里面定义了一个内部类，在这个类中定义了一个匿名内部类，这样就是不是2个class文件，而是4个class文件。

What is the result of compiling and executing the following fragment of code://编译和执行以下代码片段的结果
1
2
3
4
5
6
7
8
9 Boolean flag = false;
if (flag = true)
{
    System.out.println(“true”);
}
else
{
    System.out.println(“false”);
}

A
The code fails to compile at the “if” statement.代码在if语句编译失败
B
An exception is thrown at run-time at the “if” statement.运行在if处抛出异常
C
The text“true” is displayed. 显示为true
D
The text“false”is displayed. 显示为false
E
Nothing is displayed. 没有显示任何内容
正确答案：C
我忍不住要写解析啦，我看懂了原理是这样的：
1、首先定义了一个Boolean包装型的变量flag，先初始化赋值，指向false；
2、其次if(flag=true)  中，相当于对变量flag进行了一次赋值，即flag=true（也即flag指向装有true的布尔值的箱子）；
3、if（）执行过程中会对里面进行解析，由于是包装型，需要先解析转换成基本数据类型才能参与if条件句，即进行拆箱，当然拆完该箱子值为true啦；
4、接下来就正常运算就OK啦，
我也是结合上面大家评论总结出最正确的原理来的，嘿嘿
我自己也是学习了，第一次遇到~~
其实这题的关键核心就是if()条件句括号里面只针对基本数据类型运算，以后大家都记住了就行了

出题的目的是考验if中的表达式，如果是boolean类型。flag=true则这个表达式整体的值为true所以进入if分支执行，重点看if条件中整个表达式的值是否为逻辑表达式

我觉得在
if(flag=true){
}
中，只是一个赋值语句=======》隐含条件为
if((flag=true)==true){
}

因为boolean 类型的变量可以用if（）进行判断，但是如果是基本的数据类型 if（int/float/double=值）是不被允许的。

下面哪些写法能在 java8 中编译执行（）
A
dir.listFiles((File f)->f.getName().endsWith(“.Java”));
B
dir.listFiles((File f)=>f.getName().endsWith(“.Java”));//)=>错了
C
dir.listFiles((_.getName().endsWith(“.Java”)));
D
dir.listFiles( f->f.getName().endsWith(“.Java”));
正确答案：AD
Lanbda表达式的主要作用就是代替匿名内部类的繁琐语法， 它由三部分组成：
（1） 形参列表。形参列表允许省略形参类型。如果形参列表中只有一个参数，甚至连形参列表的圆括号也可以省略。
（2） 箭头（→）。必须通过英文中画线和大于符号组成。
（3）代码块。如果代码块只包含一条语句，Lambda表达式允许省略代码块的花括号，那么那条语句就不要用花括号表示语句结束。Lambda代码块只有一条return语句，甚至可以省略return关键字。Lambda表达式需要返回值，而它的代码块中仅有一套省略了return的语句。Lambda表达式会自动返回这条语句的值。
由此可见，应该是A和D正确。

A答案，如果"file f"为"File f"则是正确的。
D答案，是A答案参数类型可推导下的省略写法。

局部内部类可以用哪些修饰符修饰？
A
public
B
private
C
abstract
D
final
正确答案：CD
局部内部类是放在代码块或方法中的，不能有访问控制修饰符，且不能用static修饰

成员内部类定义在类中，可以看成成员变量，可以有public，protected，public，static修饰。

以下哪几种方式可用来实现线程间通知和唤醒：( )
A
Object.wait/notify/notifyAll
B
ReentrantLock.wait/notify/notifyAll
C
Condition.await/signal/signalAll
D
Thread.wait/notify/notifyAll
正确答案：AC
官方解析：
 在Java中，常用的线程通信方式有两种，分别是利用Monitor实现线程通信、利用Condition实现线程通信。
线程同步是线程通信的前提，所以究竟采用哪种方式实现通信，取决于线程同步的方式。
如果是采用synchronized关键字进行同步，则需要依赖Monitor（同步监视器）实现线程通信，Monitor就是锁对象。
在synchronized同步模式下，锁对象可以是任意的类型，所以通信方法自然就被定义在Object类中了，
这些方法包括：wait()、notify()、notifyAll()。
一个线程通过Monitor调用wait()时，它就会释放锁并在此等待。当其他线程通过Monitor调用notify()时，则会唤醒在此等待的一个线程。当其他线程通过Monitor调用notifyAll()时，则会唤醒在此等待的所有线程。

JDK 1.5新增了Lock接口及其实现类，提供了更为灵活的同步方式。
如果是采用Lock对象进行同步，则需要依赖Condition实现线程通信，
Condition对象是由Lock对象创建出来的，它依赖于Lock对象。
Condition对象中定义的通信方法，与Object类中的通信方法类似，它包括await()、signal()、signalAll()。
通过名字就能看出它们的含义了，当通过Condition调用await()时当前线程释放锁并等待，当通过Condition调用signal()时唤醒一个等待的线程，当通过Condition调用signalAll()时则唤醒所有等待的线程。

以下代码段执行后的输出结果为
1
2
3
4
5
6
7 public class Test {
    public static void main(String args[]) {
        int x = -5;
        int y = -12;
        System.out.println(y % x);
    }
}

A
-1
B
2
C
1
D
-2
正确答案：D
官方解析：
模运算余数的符号跟被除数符号相同，本题中：
-12=(-5)*2+(-2)，余数为-2，答案选D

如下代码的输出是
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 package Test;
public class Test {
    private static void test(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            try {
                if (arr[i] % 2 == 0) {
                    throw new NullPointerException();
                } else {
                    System.out.print(i);
                }
            } finally {
                System.out.print(“e”);
            }
        }
    }
 
    public static void main(String[]args) {
        try {
            test(new int[] {0, 1, 2, 3, 4, 5});
        } catch (Exception e) {
            System.out.print(“E”);
        }
    }
 
}
可以得到的结论是（ ）
A
编译出错
B
eE
C
Ee
D
eE1eE3eE5
E
Ee1Ee3Ee5
正确答案：B
你的答案：D
参考答案：答案:B 由于arr[0] =0,所以在进入 test()方法里面会在第一个if 上抛出一个 NullPointerException,接着会执行 finally 的语句, (finally语句先于 return 和 throw语句执行)，输出一个’e，然后回到 main方法中，由于捕捉到异常，所以进入到catch语句中，然后打印一个’E’,所以最终结果为"eE"

以下程序的运行结果是：(    )
1
2
3
4
5
6
7
8
9
10 TreeSet set = new TreeSet();
TreeSet subSet = new TreeSet();
for(int i=606;i<613;i++){
    if(i%2==0){
     set.add(i);
     }
 }
subSet = (TreeSet)set.subSet(608,true,611,true);
set.add(609);
System.out.println(set+" "+subSet);

A
编译失败
B
发生运行时异常
C
[606, 608, 609，610, 612] [608, 609，610]
D
[606, 608, 609，610, 612] [608, 610]
正确答案：C

1. subSet是指向原数据的，原数据修改，subSet也跟着修改。
2. subset(form，true，to，true)是Treeset的非静态方法，该方法返回从form元素到to元素的一个set集合，两个boolean类型是确认是否包含边境值用的。

subset方法是求set的范围内的子集
最后加的是609，指向，选c，如果家的是666，那就是选d

在JDK1.7中，下述说法中抽象类与接口的区别与联系正确的有哪些？
A
抽象类中可以有普通成员变量，接口中没有普通成员变量。
B
抽象类和接口中都可以包含静态成员常量。//接口中默认是public static final，不可以有普通的成员变量，抽象类可以有普通成员变量，也可以有静态的成员常量
C
一个类可以实现多个接口，但只能继承一个抽象类//一个类可以实现多个接口，但只能继承一个抽象类
D
抽象类中可以包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法。//接口中所有方法必须是抽象的，但是抽象类中可以有非抽象的普通方法
正确答案：ABCD
接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。
接口中的方法定义默认为public abstract类型，
接口中的成员变量类型默认为public static final。
另外，接口和抽象类在方法上有区别：    
1.抽象类可以有构造方法，接口中不能有构造方法。  
2.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
3.抽象类中可以有普通成员变量，接口中没有普通成员变量 
4. 抽象类中的抽象方法的访问类型可以是public，protected和默认类型
5. 抽象类中可以包含静态方法，接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型
7. 一个类可以实现多个接口，但只能继承一个抽象类。二者在应用方面也有一定的区别：接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用，例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的Servlet都继承这个抽象基类，在抽象基类的service方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码。

一个文件中的数据要在控制台上显示，首先需要（ ）。
A
System.out.print (buffer[i]);
B
FileOutputStream fout = new FileOutputStream(this.filename);
C
FileInputStream fin = new FileInputStream(this.filename);。
D
System.in.read(buffer)。
正确答案：C
一个文件中的数据要在控制台显示，首先需要获取文件中的内容，使用FileInputStream fin = new FileInputStream(this.filename);

java如何返回request范围内存在的对象？
A
request.getRequestURL()
B
request.getAttribute()
C
request.getParameter()
D
request.getWriter()
正确答案：B

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

做的时候也是很纠结
后来直接：参数===>Parameter
     属性===>Attribute

执行如下程序，输出结果是（ ）
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
33
34
35
36
37
38
39 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();
     }
 }
A
0 22 44 6
B
2 42 42 4
C
2 24 46 6
D
4 44 46 6
正确答案：C
官方解析：
t1,t2,t3线程使用同一个对象mv,
synchronized(mv) 对象锁（实例锁）
当多个并发线程访问同步synchronized（this）同步代码块时， 某一时刻仅能有一个线程能执行同步，其他线程必须等待。也就是说虽然不能确认t1、t2、t3哪一个线程先执行，但它确实是排队执行的，不会出现变量的覆盖。所以输出结果为分别为2 2、4 4、6 6。正确答案为C。

下列哪个选项是正确计算42度（角度）的余弦值？
A
double d = Math.cos(42)
B
double d = Math.cosine(42)
C
double d = Math.cos(Math.toRadians(42))
D
double d = Math.cos(Math.toDegrees(42))
正确答案：C
你的答案：B
参考答案：答案：C Math.cos为计算弧度的余弦值，Math.toRadians函数讲角度转换为弧度

计算余弦值使用Math类的cos()方法
toRadians()是将角度转换为弧度
toDegrees()是将弧度转换为角度

Java Math.abs() 获取绝对值
Java Math.round() 四舍五入
Java Math.random() 获取随机数
java Math.pow()计算次方
Java Math.ceil() 取整
Java Math.sqrt() 计算平方根
Java Math.log() 计算对数
Java Number类
Java Math类
Java Math所有方法
Java Math.floor() 取整
Java Math.toDegrees()弧度转换成角度
Java Math.toRadians()角度转换为弧度
Java Math.sin() 计算正弦
Java Math.asin() 计算反正弦
Java Math.tan()/Math.tanh() 计算正切/双曲正切
Java Math.atan() 计算反正切

已知 boolean result = false，则下面哪个选项是合法的：
A
result=1
B
result=true;
C
if(result!=0) {//so something…}
D
if(result) {//do something…}
正确答案：BD
对于boolean类型变量result的值只能是true或false
第一项错误很明显，不能将数值类型赋值给boolean类型变量，并且结尾没有分号
第二项正确
第三项不能将boolean类型与数值类型作比较
第四项正确

哪个正确
A
abstract类只能用来派生子类，不能用来创建abstract类的对象。//bstract修饰的类A不能被实例化，即不能创建该类的对象
B
final类不但可以用来派生子类，也可以用来创建final类的对象。//2.final修饰的类不能被继承，即该类没有子类;
C
abstract不能与final同时修饰一个类。//abstact必须有子类，final必须没有子类
D
abstract类定义中可以没有abstract方法。//对的
正确答案：ACD
选 ACD
A，抽象类和接口都不可以实例化。
B，final类不能被继承。
C，abstract不能和final共用修饰类。
D，抽象类中可以没有抽象方法，有抽象方法的类一定是抽象类。
注意：abstract是用来修饰类和方法的：
    1. 修饰方法：abstract不能和private、final、static共用。
    2. 修饰外部类：abstract不能和final、static共用。（外部类的访问修饰符只能是默认和public）
3. 修饰内部类：abstract不能和final共用。（内部类四种访问修饰符都可以修饰）

外部类的修饰符只能是public，abstract，final
成员内部类可以是静态static的，也可用public，default，protected和private修饰

static可以用来修饰内部类,但是不可以用来修饰外部类
局部内部类是放在代码块或方法中的，不能有访问控制修饰符，且不能用static修饰

下列那些方法是线程安全的(所调用的方法都存在)
A
public class MyServlet implements Servlet { public void service (ServletRequest req, ServletResponse resp) { BigInteger I = extractFromRequest(req); encodeIntoResponse(resp,factors); } }
B
public class MyServlet implements Servlet { private long count =0; public long getCount() { return count; } public void service (ServletRequest req, ServletResponse resp) { BigInteger I = extractFromRequest(req); BigInteger[] factors = factor(i); count ++; encodeIntoResponse(resp,factors); } }
C
public class MyClass { private int value; public synchronized int get() { return value; } public synchronized void set (int value) { this.value = value; } }
D
public class Factorizer implements Servlet { private volatile MyCache cache = new MyCache(null,null); public void service(ServletRequest req, ServletResponse resp) { BigInteger i = extractFromRequest(req); BigInteger[] factors = cache.getFactors(i); if (factors == null) { factors = factor(i); cache = new MyCache(i,factors); } encodeIntoResponse(resp,factors); }
正确答案：ACD

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

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///byte -->自动成int
b6=b4+b5;    /语句2/
b8=(b1+b4);  /语句3/
b7=(b2+b5);  /语句4/
System.out.println(b3+b6);
下列代码片段中，存在编译错误的语句是()
A
语句2 正确 有final --。不自动上升 还是byte

B
语句1 错误 没有final 自动上升 成为int 左侧是final 格式不对
C
语句3 错误 有一个自动上升 格式不对
D
语句4 错误 final的不可以改动
正确答案：BCD
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修饰，即只可赋值一次，便不可再改变。

执行下列代码的输出结果是( )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 public class Demo{
　public static void main(String args[]){
　　　int num = 10;
　　　System.out.println(test(num));
}
public static int test(int b){
　　　try
　　　{
　　　　b += 10;
　　　　return b;
　　　}
　　　catch(RuntimeException e)
　　　{
　　　}
　　　catch(Exception e2)
　　　{
　　　}
　　　finally
　　　{
　　　　b += 10;
　　　　return b;
　　　}
　　}
}
A
10
B
20
C
30
D
40
正确答案：C
官方解析：如果finally块中有return语句的话，它将覆盖掉函数中其他return语句。

下面有关java实例变量,局部变量,类变量和final变量的说法，错误的是？
A
实例变量指的是类中定义的变量，即成员变量，如果没有初始化，会有默认值。
B
局部变量指的是在方法中定义的变量，如果没有初始化，会有默认值
C
类变量指的是用static修饰的属性
D
final变量指的是用final 修饰的变量
正确答案：B
参考答案：B，局部变量必须有初始值。
定义在类中的变量是类的成员变量，可以不进行初始化，Java会自动进行初始化，如果是引用类型默认初始化为null,如果是基本类型例如int则会默认初始化为0
局部变量是定义在方法中的变量，必须要进行初始化，否则不同通过编译
被static关键字修饰的变量是静态的，静态变量随着类的加载而加载，所以也被称为类变量
被final修饰变量是常量

在Java中，以下数据类型中,需要内存最多的是()
A
byte
B
long
C
Object
D
int
正确答案：B
链接：
long        8字节
double    8字节
float        4字节
int           4字节
short       2字节
char        2字节
object是引用类型，引用类型站4个字节

JAVA语言中定义了8种基本的数据类型，来保存变量。JAVA要求程序中的每一个变量都规定自己的类型。正因为如此，JAVA属于强类型语言，从而不同于JavaScript这样的弱类型脚本语言。

对象在声明时，不会创建实例，不会占用空间。一定要注意理解。

以下说法错误的是（ ）
A
final修饰的方法不能被重载
B
final可以修饰类、接口、抽象类、方法和属性//final不可以修饰抽象类和接口
C
final修饰的方法也不能被重写
D
final修饰的属性是常量，不可以修改
正确答案：AB
首先大家要知道final的意思为最终的，然后我来给大家细讲一下
A.final修饰方法后，方法是不可被重写的，因为它已经是“最终形态”了。但不会影响重载
B.final修饰类标志此类不可被继承。如果final可以标志抽象类和接口，抽象类不能继承？接口不准实现?
那还要来什么意义，所以final不能修饰抽象类和接口
C.题目中这个也字就是来误导人的，同A一样解释过了，final修饰的方法不可重写
D.这道题不能太钻牛角尖，final确实是修饰变量，只不过被修饰过的变量不能再变了，既然变量不能再变了我们就可以把它当做常量。

以下哪些表达式返回为真（）
1
2
3
4 String a=“My field1”;
String b=“My field1”;
    String c=new String(“My field1”);
    String d=new String(“My field1”);

A
ab
B
ac
C
c=d
D
a.equals(b)
E
a.equals©
正确答案：ADE

==，如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等; 如果作用于引用类型的变量，则比较的是所指向的对象的地址 　
equals方法，注意：equals方法不能作用于基本数据类型的变量。
①Object类中，equals方法是用来比较两个对象的引用是否相等，即是否指向同一个对象。 ②String类对equals方法进行了重写，用来比较指向的字符串对象所存储的字符串是否相等。其他的一些类诸如Double，Date，Integer等，都对equals方法进行了重写用来比较指向的对象所存储的内容是否相等

下列有关java构造函数叙述正确的是（）
A
构造器的返回值为void类型
B
如果一个源文件中有多个类，那么构造器必须与公共类同名
C
构造器可以有0个，1个或一个以上的参数
D
每个类可以有一个以上的构造器
正确答案：CD

（1）A构造函数无返回值，错误；
（2）B中多个类时构造函数不一定与公共类同名，因为每个类都可以有构造函数，函数名同所属类，错误；
（3）C构造器可以有任意个参数，对的；
（4）D一个类可以定义多个构造方法，每个类都默认有一个构造函数，对的

构造方法是一种特殊的方法，具有以下特点。
（1）构造方法的方法名必须与类名相同。
（2）构造方法没有返回类型，也不能定义为void，在方法名前面不声明方法类型。
（3）构造方法的主要作用是完成对象的初始化工作，它能够把定义对象时的参数传给对象的域。
（4）一个类可以定义多个构造方法，如果在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认构造器，这个构造器不执行任何代码。
（5）构造方法可以重载，以参数的个数，类型，顺序。

CMS垃圾回收器在那些阶段是没用用户线程参与的
A
初始标记
B
并发标记
C
重新标记
D
并发清理
正确答案：AC
官方解析：
CMS收集器是一种以获取最短回收停顿时间为目标的收集器，它是基于标记清除算法实现的，它的运作过程相对于其他收集器来说要更复杂一些，整个过程分为四个步骤，包括：初始标记、并发标记、重新标记、并发清除。其中初始标记、重新标记这两个步骤需要暂停整个JVM。
初始标记仅仅只是标记一下GC Roots能直接关联到的对象，速度很快。（没有用户进程）
并发标记阶段就是从GC Roots的直接关联对象开始遍历整个对象图的过程，这个过程耗时较长但是不需要停顿用户线程，可以与垃圾收集线程一起并发运行。（有用户进程）
重新标记阶段则是为了修正并发标记期间，因用户程序继续运作而导致标记产生变动的那一部分对象的标记记录，这个阶段的停顿时间通常会比初始标记阶段稍长一些，但也远比并发标记阶段的时间短。（没有用户进程）
并发清除阶段，清理删除掉标记阶段判断的已经死亡的对象，由于不需要移动存活对象，所以这个阶段也是可以与用户线程同时并发的。（有用户进程）
1.
示意图如下：

综上所述，答案选择A C。

下面有关 Java ThreadLocal 说法正确的有？
A
ThreadLocal存放的值是线程封闭，线程间互斥的，主要用于线程内共享一些数据，避免通过参数来传递
B
线程的角度看，每个线程都保持一个对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal 实例是可访问的；在线程消失之后，其线程局部实例的所有副本都会被垃圾回收
C
在Thread类中有一个Map，用于存储每一个线程的变量的副本。
D
对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式
正确答案：ABCD
官方解析：
ThreadLocal类用于创建一个线程本地变量
在Thread中有一个成员变量ThreadLocals，该变量的类型是ThreadLocalMap,也就是一个Map，它的键是threadLocal，值就是变量的副本，
ThreadLocal为每一个使用该变量的线程都提供了一个变量值的副本，每一个线程都可以独立地改变自己的副本，是线程隔离的。
通过ThreadLocal的get()方法可以获取该线程变量的本地副本，在get方法之前要先set,否则就要重写initialValue()方法。
ThreadLocal不是用来解决对象共享访问问题的，而主要是提供了保持对象的方法和避免参数传递的方便的对象访问方式。一般情况下，通过ThreadLocal.set() 到线程中的对象是该线程自己使用的对象，其他线程是不需要访问的，也访问不到的。各个线程中访问的是不同的对象。

下列哪个选项是Java调试器？如果编译器返回程序代码的错误，可以用它对程序进行调试。
A
java
B
javadoc
C
jdb
D
javaprof
正确答案：C
你的答案：D
参考答案：C：java调试器jdb.exe

给定includel.isp文件代码片段，如下：
  <% pageContext.setAttribute(“User”,”HAHA”);%>
______ // 此处填写代码
  给定include2.jsp文件代码片段如下：
  <%=pageContext.getAttribute(“User”)%>
  要求运行include1.jsp时，浏览器上输出：HAHA
A
<jsp:include page=”include2.jsp” flash=”true”>
B
<%@include file=”include2.jsp”%>
C
<jsp:forward page=”include2.jsp”>
D
<% response.sendRedirect(“include2.jsp”); %>
正确答案：B
参考答案：答案：B B选项是静态包含，相当于不include2.jsp页面内容拷贝到此处，因此可以输出User属性值
D选项是转发重定向，转发的时候pageContent内的属性值不能被传递，因此得不到User属性值

链接：JSP 共有以下 6 种基本动作：
jsp:include：在页面被请求的时候引入一个文件；
jsp:useBean：寻找或者实例化一个JavaBean。；
jsp:setProperty：设置 JavaBean 的属性。；
jsp:getProperty：输出某个 JavaBean 的属性；
jsp:forward：把请求转到一个新的页面；
jsp:plugin：根据浏览器类型为 Java 插件生成 OBJECT 或 EMBED 标记。

多选题
7.
在java语言中，如果你编写一个多线程序，可以使用的方法是（）
A
扩展类Thread
B
实现Runnable接口
C
扩展类 Runnable
D
实现接口Thread
正确答案：AB
Java多线程实现方式主要有四种：
继承Thread类、
实现Runnable接口、
实现Callable接口通过FutureTask包装器来创建Thread线程、
使用ExecutorService、Callable、Future实现有返回结果的多线程。
其中前两种方式线程执行完后都没有返回值，后两种是带返回值的。

关于Java以下描述正确的有(      )
A
Class类是Object类的超类//class类是Object的派生类

B
Object类是一个final类//每个类都使用Object类作为超类，而final修饰的类不能被继承

C
String类是一个final类
D
Class类可以装载其它类
正确答案：CD
A.class类是Object的派生类
B.每个类都使用Object类作为超类，而final修饰的类不能被继承
C.
D.Class类中的forName()方法返回与带有给定字符串名的类或接口相关联的Class对象（装载其他类）

常用的servlet包的名称是？
A
java.servlet
B
javax.servlet
C
servlet.http
D
javax.servlet.http
正确答案：BD

关于抽象类与接口，下列说法正确的有？
A
为了降低模块的耦合性，应优先选用接口，尽量少用抽象类
B
抽象类可以被声明使用，接口不可以被声明使用//接口和抽象类都可以被声明使用
C
抽象类和接口都不能被实例化。
D
以上说法都不对
正确答案：AC
你的答案：ABC
官方解析：
A选项，接口体现的是一种规范和实现分离的设计哲学，代码编写过程中充分利用接口可以很大程度的降低程序各个模块之间的耦合，从而提高系统的可扩展性和可维护性。基于这一原则，很多软件架构更提倡面向接口编程而不是实现类编程。
接口和抽象类都可以被声明使用，因此B选项错误。
C选项，抽象类到底能不能被实例化是初学者很容易犯的错误，抽象类确实有构造方法，但这个构造方法是用来被子类调用的，因为任何子类都必须调用从Object开始的所有父亲的构造方法，才算完成初始化工作。如果抽象类被实例化，就会报错，编译无法通过。而接口里不包含构造器，自然无法被实例化。选项C正确。
由于AC选项是正确的，所以选项D不正确。

以下关于JAVA语言异常处理描述正确的有？
A
throw关键字可以在方法上声明该方法要抛出的异常。//throws关键字可以在方法上声明该方法要抛出的异常,然后在方法内部通过throw抛出异常对象
B
throws用于抛出异常对象。//throw用于抛出异常
C
try是用于检测被包住的语句块是否出现异常，如果有异常，则捕获异常，并执行catch语句。
D
finally语句块是不管有没有出现异常都要执行的内容。
E
在try块中不可以抛出异常//try可以抛出异常
正确答案：CD
参考答案：Java语言中的异常处理包括声明异常、抛出异常、捕获异常和处理异常四个环节。
throw用于抛出异常。
throws关键字可以在方法上声明该方法要抛出的异常，然后在方法内部通过throw抛出异常对象。
try是用于检测被包住的语句块是否出现异常，如果有异常，则抛出异常，并执行catch语句。
cacth用于捕获从try中抛出的异常并作出处理。
finally语句块是不管有没有出现异常都要执行的内容。

关于下面一段代码，以下说法正确的是： ()
1
2
3
4
5
6
7
8
9
10
11
12
13
14 public class Test {
    private synchronized void a() {//this对象
    }
    private void b() {
        synchronized (this) {
        }
    }
    private synchronized static void c() {//class对象
    }
    private void d() {
        synchronized (Test.class) {
        }
    }
}

A
同一个对象，分别调用方法a和b，锁住的是同一个对象
B
同一个对象，分别调用方法a和c，锁住的是同一个对象
C
同一个对象，分别调用方法b和c，锁住的不是同一个对象
D
同一个对象，分别调用方法a、b、c，锁住的不是同一个对象
正确答案：AC
修饰非静态方法 锁的是this 对象
修饰静态方法 锁的是class对象

下列说法正确的是（）
A
在类方法中可用this来调用本类的类方法
B
在类方法中调用本类的类方法时可直接调用
C
在类方法中只能调用本类中的类方法
D
在类方法中绝对不能调用实例方法//在类方法中可以通过创建实例对象调用类的实例方法
正确答案：B
你的答案：A
参考答案：在类方法中不能有this关键字，，直接调用类方法即可，A错误，B正确，在类方法中可以通过创建实例对象调用类的实例方法，

下列Java代码中的变量a、b、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
静态区、栈区、栈区
正确答案：C
你的答案：D
参考答案：答案是C
a是类中的成员变量，存放在堆区
b、c都是方法中的局部变量，存放在栈区

下面是jdbc（JDBC）连接数据库5个步骤：
1）加载驱动（这是第三方数据库给连接数据库的标准驱动）
2）建立连接（连接好数据库）
3）创建statement对象（创建执行者）
4）执行SQL（执行命令）语句，返回sql语句的执行结果
5）关闭数据库（关闭数据库连接，并且释放资源）

单选题
7.
下列Java代码中的变量a、b、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
静态区、栈区、栈区
正确答案：C
你的答案：D
参考答案：答案是C a是类中的成员变量，存放在堆区 b、c都是方法中的局部变量，存放在栈区
知识点：Java
查看128条题目讨论
多选题
8.
下面说法正确的是？（）
A
调用Thread的sleep()方法会释放锁，调用wait()方法不释放锁
B
一个线程调用yield方法，可以使具有相同优先级线程获得处理器
C
在Java中，高优先级的可运行的线程会抢占低优先级线程的资源
D
java中，线程可以调用yield方法使比自己低优先级的线程运行
正确答案：BC
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、C++工程师、算法工程师
查看50条题目讨论
多选题
9.
下面哪些描述是正确的：（  ）
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;
    …
    }
}

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

有关finally语句块说法正确的是（ ）
A
不管catch是否捕获异常，finally语句块都是要被执行的
B
在try语句块或catch语句块中执行到System.exit(0)直接退出程序
C
finally块中的return语句会覆盖try块中的return返回
D
finally 语句块在 catch语句块中的return语句之前执行
正确答案：ABC

结论：
1、不管有木有出现异常，finally块中代码都会执行；
2、当try和catch中有return时，finally仍然会执行；
3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；
4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

举例：

情况1：try{} catch(){}finally{} return;
显然程序按顺序执行。

情况2:try{ return; }catch(){} finally{} return;
程序执行try块中return之前（包括return语句中的表达式运算）代码；
再执行finally块，最后执行try中return;
finally块之后的语句return，因为程序在try中已经return所以不再执行。

情况3:try{ } catch(){return;} finally{} return;
程序先执行try，如果遇到异常执行catch块，
有异常：则执行catch中return之前（包括return语句中的表达式运算）代码，再执行finally语句中全部代码，
最后执行catch块中return. finally之后也就是4处的代码不再执行。
无异常：执行完try再finally再return.

情况4:try{ return; }catch(){} finally{return;}
程序执行try块中return之前（包括return语句中的表达式运算）代码；
再执行finally块，因为finally块中有return所以提前退出。

情况5:try{} catch(){return;}finally{return;}
程序执行catch块中return之前（包括return语句中的表达式运算）代码；
再执行finally块，因为finally块中有return所以提前退出。

情况6:try{ return;}catch(){return;} finally{return;}
程序执行try块中return之前（包括return语句中的表达式运算）代码；
有异常：执行catch块中return之前（包括return语句中的表达式运算）代码；
则再执行finally块，因为finally块中有return所以提前退出。
无异常：则再执行finally块，因为finally块中有return所以提前退出。

最终结论：任何执行try 或者catch中的return语句之前，都会先执行finally语句，如果finally存在的话。
如果finally中有return语句，那么程序就return了，所以finally中的return是一定会被return的，
编译器把finally中的return实现为一个warning。

下列说法哪个正确(    )
A
不需要定义类，就能创建对象//没有模板，怎么可能创建对象，创建对象必须先要定义类，常识
B
对象中必须有数据域和方法//对象中的数据域和方法取决于该对象的类，类里面有就有，没有就没有

C
数据域可以是基本类型变量，也可以是一个对象//.数据域不一定是基本类型，也可以是引用类型
D
数据域必须是基本类型变量
C Java数据域就是成员变量

查看23条题目讨论
单选题
3.
关于以下application,说法正确是什么？
1
2
3
4
5
6
7
8
9 public class Test {
    static int x=10;
    static {x+=5;}
    public static void main(String[] args) //4
        {
        System.out.println(“x=”+x);
    }
    static{x/=3;};
}//9
A
4行与9行不能通过编译，因为缺少方法名和返回类型
B
编译通过，执行结果是：x=5
C
编译通过，执行结果是：x=3
D
9行不能通过编译，因为只能有一个静态初始化器
正确答案：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 class A{
    static {
        System.out.println(“父类静态代码块”);
    }
    public A(){
        System.out.println(“父类构造方法”);
    }
    {
        System.out.println(“父类初始化块”);
    }
}
public class B extends A{
    static{
        System.out.println(“子类静态代码块”);
    }
    public B(){
        System.out.println(“子类构造方法”);
    }
    {
        System.out.println(“子类初始化块”);
    }
    public static void main(String[] args){
        new B();
    }
}
父类静态代码块–>子类静态代码块–>父类普通代码块–>父类构造方法–>子类代码块–>子类构造方法；

执行以下程序后的输出结果是（）
1
2
3
4
5
6
7
8
9
10
11 public class Test {
    public static void main(String[] args) {
        StringBuffer a = new StringBuffer(“A”); 
        StringBuffer b = new StringBuffer(“B”); 
        operator(a, b); 
        System.out.println(a + “,” + b); 
    } 
    public static void operator(StringBuffer x, StringBuffer y) { 
        x.append(y); y = x; 
    }
}

A
A,A
B
A,B
C
B,B
D
AB,B
正确答案：D

因为方法执行完毕，局部变量消除。 有内存中的状态,可以知道最后的结果

以下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”);
    }
}
A
HelloSogou
B
SogouHello
C
Hello
D
结果不确定
正确答案：B
参考答案：答案：B 这里调用 t.run(); 并没有启动一个新的线程，启动一个新线程要用t.start(); 所以执行顺序是先执行run（），再执行 System.out.print(“HELLO”);

如果改成t.start().由于main线程占有锁，t线程会处于锁等待状态。最终的结果是HelloSougou

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

A
java和C++都保留了指针//Java没有指针，只有引用
B
java和C++都有三个特征：封装、继承和多态
C
java的垃圾回收机制是指程序结束时系统自动回收内存//并不是程序结束的时候进行GC，GC的时间是不确定的，且GC的过程需要经过可达性分析，一个对象只有被标记两次才会被GC
D
以上说法都不正确
正确答案：B

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

（）运算符把其操作数中所有值为0和所有值为1的位分别在结果的相应中设置1和0
A
&
B
|
C
！
D
~ 按位取反
正确答案：D
&按位与
|按位或
~按位取反
^按位异或

右移

无符号右移
<<左移
逻辑取反：将所有非0的数值都看做1，将1变为0，将0变为1。
按位取反：将二进制数值的每一位的0变为1，1变为0。

面向对象方法的多态性是指（）
A
一个类可以派生出多个特殊类 //理解是继承 不是多态
B
一个对象在不同的运行环境中可以有不同的变体
C
针对一消息，不同的对象可以以适合自身的方式加以响应//同一操作作用于不同的对象，有不同的解释，不同的结果，就是多态。
D
一个对象可以是由多个其他对象组合而成的
正确答案：C
9.
关于JSP生命周期的叙述，下列哪些为真?
A
JSP会先解释成Servlet源文件，然后编译成Servlet类文件
B
每当用户端运行JSP时，jsp init()方法都会运行一次//init方法：负责初始化Servlet对象。在Servlet的整个生命周期类，init（）方法只被调用一次。
C
每当用户端运行JSP时，jsp service()方法都会运行一次
D
每当用户端运行JSP时，jsp destroy()方法都会运行一次//destroy方法：销毁Servlet对象，释放占用的资源，Servlet要被卸载时调用

正确答案：AC

以下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”));
     }
}
A
Fred
B
True//使用匿名内部类重写了Object的equals（）方法，使其在传入任何类型的变量都输出true
C
编译错误
D
运行时抛出异常
正确答案：B
5.
Which method you define as the starting point of new thread in a class from which n thread can be execution?
下列哪一个方法你认为是新线程开始执行的点，也就是从该点开始线程n被执行。
A
public void start()
B
public void run()
C
public void int()
D
public static void main(String args[])
E
public void runnable()
正确答案：B
你的答案：A
参考答案：答案：B 要写一个线程类，可以继承Thread方法，然后override他的run（）方法 另一种方法是实现Runable接口，即为实现run（）方法。 A，start（）是启动一个线程的方法

下列说法正确的有（ ）
A
构造方法的方法名必须与类名相同
B
构造方法也没有返回值，但可以定义为void
C
在子类构造方法中调用父类的构造方法，super() 必须写在子类构造方法的第一行，否则编译不通过
D
一个类可以定义多个构造方法，如果在定义类时没有定义构造方法，则编译系统会自动插入一个默认的构造方法，这个构造方法不执行任何代码
正确答案：ACD

关于equals和hashCode描述正确的是    ()
A
两个obj，如果equals()相等，hashCode()一定相等（符合代码规范的情况下）//obj相等，一定相等
B
两个obj，如果hashCode()相等，equals()不一定相等 //哈希冲突
C
两个不同的obj， hashCode()可能相等//哈希冲突
D
其他都不对
正确答案：ABC

“”：作用是判断两个对象的地址是否相等，
即，判断两个对象是不是同一个对象，
如果是基本数据类型，则比较的是值是否相等。
“equal”：作用是判断两个对象是否相等，但一般有两种使用情况
1.类没有覆盖equals()方法,则相当于通过“”比较
2.类覆盖equals()方法，一般，我们都通过equals()方法来比较两个对象的内容是否相等，相等则返回true,如String

地址比较是通过计算对象的哈希值来比较的，hashcode属于Object的本地方法，对象相等（地址相等），hashcode相等，对象不相等，hashcode()可能相等，哈希冲突

在使用super和this关键字时，以下描述错误的是（）
A
在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过
B
super()和this()不一定要放在构造方法内第一行//必须放到第一行
C
this()和super()可以同时出现在一个构造函数中//super()和this()必须在构造函数第一行，所以这一点也表明他俩不能在一个构造函数中
D
this()和super()可以在static环境中使用，包括static方法和static语句块//this()和super()都指的是对象，所以，均不可以在static环境中使用
正确答案：BCD
官方解析：
 A选项正确，B选项，
super()必须在第一行的原因是: 子类是有可能访问父类对象的, 比如在构造函数中使用父类对象的成员函数和变量, 在成员初始化使用了父类, 在代码块中使用了父类等等, 所以为保证在子类可以访问父类对象之前，一定要完成对父类对象的初始化。　　
super()表示调用父类构造函数、this()调用自己的构造函数，而自己的构造函数第一行要使用super()调用父类的构造函数，所以这俩不能在一个构造函数中会出现重复引用的情况

关于Java内存区域下列说法不正确的有哪些
A
程序计数器是一块较小的内存空间，它的作用可以看做是当前线程所执行的字节码的信号指示器，每个线程都需要一个独立的程序计数器
//程序计数器的内存空间是线程私有的.
B
Java虚拟机栈描述的是java方法执行的内存模型，每个方法被执行的时候都会创建一个栈帧，用于存储局部变量表、类信息、动态链接等信息
//java虚拟机栈：线程私有
用于存储局部变量表、操作数栈、动态链接、方法出口等信息。 没有类信息，类信息是在方法区中

C
Java堆是java虚拟机所管理的内存中最大的一块，每个线程都拥有一块内存区域，所有的对象实例以及数组都在这里分配内存。
//线程共享，主要是存放对象实例和数组，不是每个线程狗友

D
方法区是各个线程共享的内存区域，它用于存储已经被虚拟机加载的常量、即时编译器编译后的代码、静态变量等数据。
//属于共享内存区域，存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
正确答案：BC
A.程序计数器是一块较小的内存空间，它的作用可以看做是当前线程所执行的字节码的信号指示器（偏移地址），Java编译过程中产生的字节码有点类似编译原理的指令，程序计数器的内存空间存储的是当前执行的字节码的偏移地址，每一个线程都有一个独立的程序计数器（程序计数器的内存空间是线程私有的），因为当执行语句时，改变的是程序计数器的内存空间，因此它不会发生内存溢出 ，并且程序计数器是jvm虚拟机规范中唯一一个没有规定 OutOfMemoryError 异常 的区域；

B.java虚拟机栈：线程私有，生命周期和线程一致。描述的是 Java 方法执行的内存模型：每个方法在执行时都会床创建一个栈帧(Stack Frame)用于存储局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法从调用直至执行结束，就对应着一个栈帧从虚拟机栈中入栈到出栈的过程。  没有类信息，类信息是在方法区中

C.java堆：对于绝大多数应用来说，这块区域是 JVM 所管理的内存中最大的一块。线程共享，主要是存放对象实例和数组

D.方法区：属于共享内存区域，存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

jvm中垃圾回收分为scanvenge gc和full GC，其中full GC触发的条件可能有哪些
A
栈空间满
B
年轻代空间满
C
老年代满
D
持久代满
E
System.gc()
正确答案：CDE

对接口的描述正确的是()
A
一个类可以实现多个接口
B
接口可以有非静态的成员变量//接口中成员变量只能是静态常量，它默认被public static final修饰。

C
在jdk8之前，接口可以实现方法//JDK8之后，接口中才可以定义有具体实现的方法，但它要么是使用default修饰的默认方法要么是static修饰的类方法。

D
实现接口的任何类，都需要实现接口的方法//所有实现接口的的普通类都需要实现接口的方法，但如果实现接口的是抽象类则不需要实现所有方法
正确答案：A

以下对选择语句描述错误的是(）
A
根据某一条件重复执行一部分代码直到满足终止条件为止// 循环语句
B
可以根据条件控制程序流程，改变程序执行的顺序
C
选择语句可以嵌套使用
D
当条件满足时就会执行相应的语句
正确答案：A

java的4类流程控制语句
1.循环语句：while，for，do while
2.选择语句（分支语句）：if,switch
3.跳转语句：break,continue,break,label
4.异常处理语句：try catch finally，throw

Java中所有类的父类是（ ）。
A
Father
B
Dang
C
Exception
D

正确答案：D
参考答案：D，java中Object是所有类的父亲,所有类的对象都是Class的实例。

为AB类的一个无形式参数无返回值的方法method书写方法头，可以用AB.method()方式调用，该方法头的形式为(    )。
A
static void method( )
B
public void method( )
C
final void method( )
D
abstract void method( )
正确答案：A
1:AB为一个类,可以不创建对象,直接使用AB.method  ("类名.方法名"的方式)
  ---------------所以method是static修饰的静态方法
2:其次method无返回值
----------------所以method是void类型的方法.
所以选B   static void method();

以下哪个接口的定义是正确的？（ ）
A
interface B { void print() { } ;}//接口中方法默认被public abstract修饰，抽象方法不可以有方法体。A错误。

B
interface B { static void print() ;}//：JDK8中，接口中的方法可以被default和static修饰，但被修饰的方法必须有方法体。B错误。

C
abstract interface B extends A1, A2 //A1、A2为已定义的接口 { abstract void print(){ };}
//接口的确是可以继承的，但C选项错误的原因和继承没关系。它错在抽象方法不可以有方法体。
D
interface B { void print();}//没有方法体，默认public abstract
正确答案：D

try块后必须有catch块。（）
A
正确
B
错误
正确答案：B
你的答案：A
参考答案：选B，catch可以省略
try的形式有三种：
try-catch
try-finally
try-catch-finally
但catch和finally语句不能同时省略！

根据下面的程序代码，哪些选项的值返回true？
1
2
3
4
5
6
7
8
9
10
11
12
13 public class Square {  
    long width;  
    public Square(long l) {   
        width = l;  
    }  
    public static void main(String arg[]) {   
        Square a, b, c;  
        a = new Square(42L);   
        b = new Square(42L);   
        c = b;   
        long s = 42L;  
    } 
}

A
a == b
B
s == a
C
b == c
D
a.equals(s)
正确答案：C
参考答案：答案：C
a = new Square(42L);     b = new Square(42L);    这里new了两个对象，所以a,b不是同一个引用
a和b是引用类型，指向地址 所以A错误
s的类型跟a,b不同类型，所以s!=a,s!=b  c = b;
这里b，c是同一个对象的引用，所以b==c是true

这题考的是引用和内存。
//声明了3个Square类型的变量a, b, c
//在stack中分配3个内存，名字为a, b, c
Square a, b, c;
//在heap中分配了一块新内存，里边包含自己的成员变量width值为48L，然后stack中的a指向这块内存
a = new Square(42L);
//在heap中分配了一块新内存，其中包含自己的成员变量width值为48L，然后stack中的b指向这块内存
b = new Square(42L);
//stack中的c也指向b所指向的内存
c = b;
//在stack中分配了一块内存，值为42
long s = 42L;

以下代码将打印出
1
2
3
4
5
6
7 public static void main(String args[]) {
      List  Listlist1 = new ArrayList();
      Listlist1.add(0);
      List Listlist2 = Listlist1;
      System.out.println(Listlist1.get(0) instanceof Integer);
      System.out.println(Listlist2.get(0) instanceof Integer);
}
A
编译错误
B
true true
C
true false
D
false false
正确答案：B
你的答案：A
官方解析：
JDK5之后提供的自动拆箱和自动装箱实现了将基本数据类型存入collection类型的集合（ArrayList,LinkedList）。
例如题目中向ArrayList存入了基本类型0，int类型会自动装箱变为Integer类型存入集合中，使编译正常通过。
将list1的引用赋值给了list2，那么list1和list2都将指向同一个堆内存空间。
instanceof关键字在Java中用于判断一个对象是否属于某个特定类的实例，并且返回boolean类型的返回值。
显然，list1.get(0)和list2.get(0)都属于Integer的实例。答案选择B。

下面有关jdbc statement的说法错误的是？
A
JDBC提供了Statement、PreparedStatement 和 CallableStatement三种方式来执行查询语句，其中 Statement 用于通用查询， PreparedStatement 用于执行参数化查询，而 CallableStatement则是用于存储过程
B
对于PreparedStatement来说，数据库可以使用已经编译过及定义好的执行计划，由于 PreparedStatement 对象已预编译过，所以其执行速度要快于 Statement 对象”
C
PreparedStatement中，“?” 叫做占位符，一个占位符可以有一个或者多个值//c错误

并且一个占位符只能对应一个值，如果能对应多个就会引起混淆

D
PreparedStatement可以阻止常见的SQL注入式攻击
正确答案：C

1.Statement、PreparedStatement和CallableStatement都是接口(interface)。 
2.Statement继承自Wrapper、PreparedStatement继承自Statement、CallableStatement继承自PreparedStatement。 
3. 
Statement接口提供了执行语句和获取结果的基本方法； 
PreparedStatement接口添加了处理 IN 参数的方法； 
CallableStatement接口添加了处理 OUT 参数的方法。 
4. 
a.Statement: 
普通的不带参的查询SQL；支持批量更新,批量删除; 
b.PreparedStatement: 
可变参数的SQL,编译一次,执行多次,效率高; 
安全性好，有效防止Sql注入等问题; 
支持批量更新,批量删除; 
c.CallableStatement: 
继承自PreparedStatement,支持带参数的SQL操作; 
支持调用存储过程,提供了对输出和输入/输出参数(INOUT)的支持;

Statement每次执行sql语句，数据库都要执行sql语句的编译 ， 
最好用于仅执行一次查询并返回结果的情形，效率高于PreparedStatement。

PreparedStatement是预编译的，使用PreparedStatement有几个好处

1. 在执行可变参数的一条SQL时，PreparedStatement比Statement的效率高，因为DBMS预编译一条SQL当然会比多次编译一条SQL的效率要高。

2. 安全性好，有效防止Sql注入等问题。 
   3.  对于多次重复执行的语句，使用PreparedStament效率会更高一点，并且在这种情况下也比较适合使用batch； 
   4.  代码的可读性和可维护性。

下面的程序 编译运行后，在屏幕上显示的结果是（）
1
2
3
4
5
6
7
8
9 public class Test {
 
    public static void main(String args[]) {
        int x, y;
        x = 5 >> 2;
        y = x >>> 2;
        System.out.println(y);
    }
}

A
0
B
2
C
5
D
80
正确答案：A
参考答案：
5 >> 2 相当于 5除于2的平方，等于1 ，

表示无符号 右移，高位用0 填充，0001 右移两位 0000，所以答案选 A

Java 中，以下不是修饰符 final 作用的是( )。
A
修饰常量
B
修饰不可被继承的类
C
修饰不可变类
D
修饰不可覆盖的方法
正确答案：C
final的作用：
    1. 修饰变量，变量的引用地址不可变，但是地址中的内容可以变。
    2. 修饰方法，方法不可被重写，但是还是可以重载
    3. 修饰类，类不可继承。

不可变类，说的是一个类一旦被实例化，就不可改变自身的状态。
常见的比如String和基本数据类型的包装类，
对于这种不可变类，一旦在进行引用传递的时候，形参一开始就和实际参数指向的不是一个地址，所以在方法中对形参的改变，并不会影响实际参数。

关于Java语言中的final关键字的使用，下列说法正确的是（）
A
在使用final关键字定义的方法里面必须使用final关键字定义变量。//错误，在 final 定义的方法里，不是必须要用 final 定义变量。
B
使用final关键字定义变量，必须在变量定义的同时给定变量的具体数值，完成变量初始化。//错误， final 定义的变量，可以在不是必须要在定义的同时完成初始化，也可以在构造方法中完成初始化
C
final关键字可以用来修饰方法，表明此方法不可以被子类重写。//正确，final修饰方法，不能被子类重写（子类），但是可以被重载（单个类）。
D
使用final关键字定义变量，必须同时使用static关键字。//错误，可以用static，也可以不用
正确答案：C

下列说法正确的是()
A
WebLogic中开发消息Bean的non－persistent 方式可以保证消息的可靠
B
EJB容器发生错误，non－persistent方式下JMS容器仍然会将消息发送
C
EJB容器发生错误，persistent方式下JMS容器仍然会将消息发送
D
EJB容器发生错误，两种方式下JMS容器仍会在MDB可用的时候将消息发送
正确答案：C
参考答案：选C。
weblogic中开发消息Bean时的persistent与non-persisten的差别：
persistent方式的MDB可以保证消息传递的可靠性,也就是如果EJB容器出现问题而JMS服务器依然会将消息在此MDB可用的时候发送过来。
non－persistent方式的消息将被丢弃。

socket编程中，以下哪个socket的操作是不属于服务端操作的（）？
A
accept
B
recieve
C
getInputStream
D
close
正确答案：C

服务器端，首先是服务器初始化Socket，然后是与端口进行绑定(blind()),端口创建ServerSocket进行监听(listen()),然后调用阻塞(accept()),等待客户端连接。与客户端发生连接后，会进行相关的读写操作(read(),write())，最后调用close()关闭连接。博客上看的，不知道全面不全面，大神轻喷。

TCP客户端： 
1.建立连接套接字，设置Ip和端口监听，socket()
2.建立连接 connect
3.write() 获取网络流对象 发送数据
4.read()获取网络流对象 接收数据
5.关闭套接字

TCP服务器端
1.建立端口监听 socket()
2.绑定指定端口 bind()
3.listen 进行端口监听
4.accept() 阻塞式 直到有客户端访问
5.read()获取客户端发送数据
6.write()发送返回数据
7.close关闭端口监听

下面代码的运行结果是（ ）
1
2
3
4
5
6 public class Arraytest{
    int a[] = new int[6];
    public static void main ( String arg[] ) {
        System.out.println ( a[0] );
    }
}

A
null
B
0
C
编译出错
D
运行出错
正确答案：C
在static方法中是不能访问非静态变量 a 的，需要将 a 声明为static，答案才会是 0 ，否则是编译出错

ServletConfig接口默认是哪里实现的？
A
Servlet
B
GenericServlet
C
HttpServlet
D
用户自定义servlet
选B

GenericServlet类的实现接口中包括了ServletConfig接口，

以下哪几个是java中的集合类型？
A
Vector
B
Set
C
String
D
List
正确答案：ABD

以下集合对象中哪几个是线程安全的（）
A
LinkedList
B
ArrayList
C
Vector
D
Hashtable
正确答案：CD
线程安全; 喂！SHE！  喂是指  vector，S是指 stack， H是指    hashtable，E是指：Eenumeration

下面的类哪些可以处理Unicode字符?
A
InputStreamReader
B
BufferedReader
C
Writer
D
PipedInputStream
正确答案：ABC
后缀是Stream的都是字节流，其他的都是字符流。

以下关于对象序列化描述正确的是
A
使用FileOutputStream可以将对象进行传输//将对象进行传输 使用ObjectOutputStream和 ObjectInputStream

B
使用PrintWriter可以将对象进行传输//将对象进行传输 使用ObjectOutputStream和 ObjectInputStream

C
使用transient修饰的变量不会被序列化//对的， 声明为static和transient类型的成员数据不能被序列化
D
对象序列化的所属类需要实现Serializable接口//对的
正确答案：CD

对于构造方法，下列叙述正确的是（ ）。
A
构造方法的优先级一般比代码块低。
B
构造方法的返回类型只能是void型。
C
构造方法的主要作用是完成对类的对象的初始化工作。
D
一般在创建新对象时，系统会自动调用构造方法。
正确答案：ACD

在你面前有一个n阶的楼梯，你一步只能上1阶或2阶。请问，当N=11时，你可以采用多少种不同的方式爬完这个楼梯（）,当N=9时呢呢（）？
A
11
B
144
C
27.
在你面前有一个n阶的楼梯，你一步只能上1阶或2阶。请问，当N=11时，你可以采用多少种不同的方式爬完这个楼梯（）,当N=9时呢呢（）？
A
11
B
144
C
55
D
89
正确答案：BC
链接：https://www.nowcoder.com/questionTerminal/db34a72925124e2b8483154a4934a19b
来源：牛客网
你需要爬11楼的时候，你倒回去一步只能待在第10楼或者第9楼。换句话说就是到达第9楼的方法次数加上第10楼的方法次数。
如果你待在第10楼，就得待在第9楼或者第8楼
如果你待在第9楼，就得待在第8楼或者第7楼
…
如果你待在第3楼，就得待在第1楼或者第2楼
爬1楼一种方法，
爬2楼两种方法。
爬3楼就是爬1楼方法次数加2楼的方法次数。
用数学表达就是：
a（11）=a（10）+a（9）=144
a（10）=a（9）+a（8）=89
a（9）=a（8）+a（7）=55
a（8）=a（7）+a（6）=34
a（7）=a（6）+a（5）=21
a（6）=a（5）+a（4）=13
a（5）=a（4）+a（3）=8
a（4）=a（3）+a（2）=5
a（3）=a（2）+a（1）=3
a（2）=2
a（1）=1

下面哪些赋值语句是正确的（）
A
long test=012
B
float f=-412
C
int other =(int)true
D
double d=0x12345678
E
byte b=128
正确答案：ABD
参考答案：选ABD
A和B中long和float，正常定义需要加l和f，但是long和float属于基本类型，会进行转化，所以不会报出异常。AB正确
boolean类型不能和任何类型进行转换，会报出类型异常错误。所以C错。
D选项可以这样定义，D正确。
E选项中，byte的取值范围是-128—127。报出异常： cannot convert from int to byte.所以E选项错误。

关于运行时常量池，下列哪个说法是正确的
A
运行时常量池大小受栈区大小的影响
B
运行时常量池大小受方法区大小的影响
C
存放了编译时期生成的各种字面量
D
存放编译时期生成的符号引用
正确答案：BCD

关于volatile关键字，下列描述不正确的是？
A
用volatile修饰的变量，每次更新对其他线程都是立即可见的。
B
对volatile变量的操作是原子性的。//volatile并不提供原子性的保证
C
对volatile变量的操作不会造成阻塞。
D
不依赖其他锁机制，多线程环境下的计数器可用volatile实现。//多线程下计数器必须使用锁保护。
正确答案：BD
12.
When is the text “Hi there” displayed?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 public class StaticTest
{
    static
    {
        System.out.println(“Hi there”);
    }
 
    public void print()
    {
        System.out.println(“Hello”);
    }
 
    public static void main(String args[])
    {
        StaticTest st1 = new StaticTest();
        st1.print();
        StaticTest st2 = new StaticTest();
        st2.print();
    }
}

A
Never.
B
Each time a new object of type StaticTest is created.
C
Once when the class is loaded into the Java virtual machine.
D
Only when the main() method is executed.
正确答案：C
你的答案：B
参考答案：答案:C 类中静态语句块仅在类加载时被执行一次

下面代码的输出结果是什么？
1
2
3
4
5
6
7
8
9
10
11
12
13
14 public class ZeroTest {
    public static void main(String[] args) {
     try{
       int i = 100 / 0;
       System.out.print(i);
      }catch(Exception e){
       System.out.print(1);
       throw new RuntimeException();
      }finally{
       System.out.print(2);
      }
      System.out.print(3);
     }
 }
A
3
B
123
C
1
D
12
正确答案：D
你的答案：B
参考答案：1、inti = 100/ 0; 会出现异常，会抛出异常，System.out.print(i)不会执行
2、catch捕捉异常，继续执行System.out.print(1); 3、当执行 thrownewRuntimeException();  又会抛出异常，这时，除了会执行finally中的代码，其他地方的代码都不会执行

下面哪个Set类是按元素排好序的？
A
LinkedHashSet
B
TreeSet
C
HashSet
D
AbstractSet
正确答案：B
官方解析：
TreeSet使用二叉树对元素进行排序，故B正确

下列代码编译和运行的结果是：（）
1
2
3
4
5
6
7
8
9
10
11
12
13
14 public class Threads4{
     public static void main(String[] args){
         new Threads4().go();
     }
     public void go(){
         Runnable r=new Runnable(){
             public void run(){
                 System.out.print(“foo”);
             }
         };
     Thread t=new Thread®;
     t.start();
     }
 }

A
编译错误
B
抛出运行时异常
C
foo
D
代码正常运行，但是无输出
正确答案：C

创建go()方法，在go()方法中实现Runnable接口创建线程并重写run()方法，然后创建Thread实例，用start()方法开启线程。
这一切都合情合理，所以只要调用go()方法，就可以异步执行该线程。

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

执行语句“int a= ’ 2 ’ ”后，a的值是（ ）
A
2
B
50
C
49
D
0
正确答案：B
你的答案：A
官方解析：
题中int  a = ‘2’,这种定义与int  a = 2是完全不同的
int  a = '2’中的数字2使用单引号来表示字符2，字符2对用的ascii码值是50，因此这种情况下，a的值是50
int a = 2中的数字2表示了数字本身，这种情况下，a的值是2

A=65
Z=90
a=97
z=122
a0=48
a9=57
2对应50

判断对错。在java的多态调用中，new的是哪一个类就是调用的哪个类的方法。
A
对
B
错
正确答案：B
你的答案：A
参考答案：B 错 java多态有两种情况：重载(本方法)和覆写（子类） 在覆写中，运用的是动态单分配，是根据new的类型确定对象，从而确定调用的方法； 在重载中，运用的是静态多分派，即根据静态类型确定对象，因此不是根据new的类型确定调用的方法

关于Java以下描述正确的有(      )
A
native关键字表名修饰的方法是由其它非Java语言编写的//正确，native是由调用本地方法库（如操作系统底层函数），可以由C，C++实现
B
能够出现在import语句前的只有注释语句//包也可以
C
接口中定义的方法只能是public//错误，default也可以
接口方法的修饰符可以是：public，abstract，default，static（后两者需要有{}）
D
构造方法只能被修饰为public或者default//构造方法可以用private，protected，default，D错误

正确答案：A

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

A
交换
B
动态链接
C
动态加载
D
磁盘调度
正确答案：B

下列关于容器集合类的说法正确的是？
A
LinkedList继承自List //linkedlist类是实现了List接口，而不是继承
B
AbstractSet继承自Set //AbstractSet类实现Set接口
C
HashSet继承自AbstractSet//HashSet继承 AbstractSet类，同时也实现set
D
WeakMap继承自HashMap//WeakMap是js里面的玩意儿吧
正确答案：C
你的答案：B
参考答案：选c a选项linkedlist类是实现了List接口，而不是继承 b选项AbstractSet类实现Set接口 c选项HashSet继承 AbstractSet类，同时也实现set d选项WeakMap是js里面的玩意儿吧

以下程序的输出结果为
1
2
3
4
5
6
7
8
9
10
11
12
13 class Base{
    public Base(String s){
        System.out.print(“B”);
    }
}
public class Derived extends Base{
    public Derived (String s) {
        System.out.print(“D”);
    }
    public static void main(String[] args){
        new Derived(“C”);//创建了子类的对象，执行子类构造函数之前需要执行父类的，父类是有参的构造函数，需要显示的调用，所以错误。两种情况正确，一种是父类没有构造函数，自动生成一个默认无参构造函数，一种是父类显示 调用
    }
}

A
BD
B
DB
C
C
D
编译错误
正确答案：D
你的答案：A
参考答案：子类构造方法在调用时必须先调用父类的，由于父类没有无参构造，必须在子类中显式调用，修改子类构造方法如下即可： public Derived(String s){ super(“s”); System.out.print(“D”); }

解析：父类中有有参构造函数，故，jvm不会自动为该类加上一个默认的构造器，即无参构造器。而，子类初始化时，会先初始化其父类，由于子类 Dervired 并没有显式的调用其父类Base的有参构造器（用super(“String”)，并且放在构造器的第一行），所以导致编译时出错。提示为：There is no default constructor available in ‘Base’.

Java语言中，下面哪个语句是创建数组的正确语句？(     )
A
float f[][] = new float[6][6];
B
float []f[] = new float[6][6];
C
float f[][] = new float[][6];
D
float [][]f = new float[6][6];
E
float [][]f = new float[6][];
正确答案：ABDE

代码String str=”123456a”；int i=Integer.parseInt(str);会报异常的是（）
A
java.lang.NullPoninterException空指针异常(变量未被初始化、对象未赋值、对象为空)
B
java.lang.NumberFormatException数据格式转换失败（integer的取值范围为：-128~127，超过范围都会访问false）

C
java.lang.RuntimeException(运行时异常
)
D
java.lang.ArrayindexOutOfBoundsException(数组下标越界)
正确答案：B

有以下程序片段，下列哪个选项不能插入到第一行 。（ ）。
1.
2.public  class  A{
3.//do sth
4. }
A
public class MainClass{ }
B
package mine;
C
class ANotherClass{ }
D
import java.util.*;
正确答案：A
Java一个源程序只能有一个public类存在，且类名与文件名相同。Java程序是从main方法开始执行的，public为类加载器提供入口，然后找到public类中的main方法开始执行。如果存在多个public类，程序将不知道该从哪里执行。
注意，内部类可以是public的，因为内部类是作为外部类的成员存在的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 public boolean returnTest()
{
    try
    {
        return true;
    }
    catch (Exception e)
    {
 
    }
    finally
    {
        return false;
    }
}
以上代码返回值是什么？
A
true
B
false
正确答案：B

一旦在finally块中使用了return或throw语句，将会导致try块，catch块中的return，throw语句失效

关于JDK1.8中Java的抽象类、接口，以下描述错误的是？
A
抽象类不一定含有抽象方法，接口中的方法都是抽象方法//对的，接口中的方法默认修饰符有public abstract。

B
一个类只能继承一个抽象类，但可以实现多个接口；一个接口可以继承多个接口//对的，Java里类是单继承的，接口是可以多继承的，用关键字extends。

C
抽象类和接口中的方法都没有方法体//错误，抽象类是可以有方法体的，且jdk1.8以后，接口中的放大也可以有方法体，用default关键字修饰方法
D
抽象类可以含有私有成员变量，接口不含有私有成员变量//正确，接口中的成员变量都是public static final的，一般用作常量
正确答案：C

判断对错。List，Set，Map都继承自继承Collection接口。
A
对
B
错
正确答案：B
参考答案：答案：B List，Set等集合对象都继承自Collection接口 Map是一个顶层结果，不继承自Collection接口

在java中，无论在何处调用，使用静态属性必须以类名做前缀。
A
正确
B
错误
正确答案：B

1如果是本类使用，可以直接就用静态变量名。
2如果是其他类使用，可以使用类名来调用，也可以创建一个实例对象来调用。
3如果静态变量所在的类是静态类，那么不管在本类里或者在其他外部类，都可以直接使用静态变量名。

下列哪个是合法的 Java 标识符？（ ）
A
Tree&Glasses 不能有&特殊字符
B
FirstJavaApplet
C
FirstApplet
D
273.5 不能以数字开头
正确答案 b
使用标识符时，需要遵守几条规则：
 1.  标识符可以由字母、数字、下划线（）、美元符（$）组成，但不能包含 @、%、空格等其它特殊字符，不能以数字开头。譬如：123name 就是不合法滴
 2.  标识符不能是 Java 关键字和保留字（ Java 预留的关键字，以后的升级版本中有可能作为关键字），但可以包含关键字和保留字。如：不可以使用 void 作为标识符，但是 Myvoid 可以
 3.  标识符是严格区分大小写的。 所以涅，一定要分清楚 imooc 和 IMooc 是两个不同的标识符哦！
 4.  标识符的命名最好能反映出其作用，做到见名知意。
Java 语言中有一些具有特殊用途的词被称为关键字。
Java 中常用关键字：

以下哪个事件会导致线程销毁？（）
A
调用方法sleep() //让线程进入睡眠状态—睡眠指定的时间后再次执行； 抱着锁睡觉
B
调用方法wait() //让线程进入等待状态 ----等待别的线程执行notify()或notifyAll()唤醒后继续执行；
C
start()方法的执行结束 //start方法只是让线程进入就绪状态而不是销毁 让线程进入就绪状态—得到CPU时间就执行线程；
D
run()方法的执行结束 .//run()方法是线程的具体逻辑方法，执行完，线程就结束。
正确答案：D

ArrayList和Vector主要区别是什么？
A
Vector与ArrayList一样，也是通过数组实现的，不同的是Vector支持线程的同步//Vector是线程安全的，也就是说是同步的
B
Vector与ArrayList一样，也是通过数组实现的，不同的是ArrayList支持线程的同步//ArrayList 是线程不安全的，不是同步的
C
Vector是通过链表结构存储数据，ArrayList是通过数组存储数据//Vector和ArrayList底层都是数组
D
上述说法都不正确
正确答案：A
参考答案：答案：A Vector支持线程的同步，也就是内部加锁的 但是效率低，因此在新版jdk中加入线程不安全的Arraylist

下面程序的运行结果：()
1
2
3
4
5
6
7
8
9
10
11
12
13 public static void main(String args[]) {
        Thread t=new Thread(){
        public void  run(){
            dianping();
             
        }
    };
    t.start();
    System.out.print(“dazhong”);
    }
    static void dianping(){
        System.out.print(“dianping”);
}
A
dazhongdianping
B
dianpingdazhong
C
a和b都有可能
D
dianping循环输出，dazhong夹杂在中间
正确答案：B
你的答案：A
官方解析： 本题中，线程t并没有启动，只是调用了run()方法，程序中运行的线程依然只有一个，那么程序会按照顺序执行，即先运行run(),run()方法调用dianping()方法输出"dianping"，程序继续向下执行输出"dazhong"。
如果本题中t线程调用start()方法，就会出现C选项的情况。

答案错了把，有start（），选c

java中将ISO8859-1字符串转成GB2312编码，语句为 ？  
A
new String(“字符串”.getBytes(“ISO8859-1”),“GB2312”)
B
new String(String.getBytes(“GB2312”）, ISO8859-1)
C
new String(String.getBytes(“ISO8859-1”))
D
new String(String.getBytes(“GB2312”))
正确答案：A

下列关于异常处理的描述中，错误的是()。
A
程序运行时异常由Java虚拟机自动进行处理//编译时异常必须显示处理，运行时异常交给虚拟机。

B
使用try-catch-finally语句捕获异常
C
可使用throw语句抛出异常
D
捕获到的异常只能在当前方法中处理，不能在其他方法中处理//捕获到的异常不仅可以在当前方法中处理，还可以将异常抛给调用它的上一级方法来处理。
正确答案：D

19.Line外部类 point内部类（局部内部类） 外部类.内部类 变量名=new 外部类.new 内部类
10. class Line {
11. public class Point { public int x,y;}
12. public Point getPoint() { return new Point(); }
13. }
14. class Triangle {
15. public Triangle() {
16. // insert code here
17. }
18. }
在第16行插入哪段代码可以获得一个Point对象的坐标?(  )
A
Point p = Line.getPoint();
B
Line.Point p = Line.getPoint();
C
Point p = (new Line()).getPoint();
D
Line.Point p = (new Line()).getPoint();
正确答案：D
(1)把类定义在另一个类的内部，该类就被称为内部类。
举例：把类B定义在类A中，类B就被称为内部类。
(2)内部类的访问规则
A:可以直接访问外部类的成员，包括私有
B:外部类要想访问内部类成员，必须创建对象
(3)内部类的分类
A:成员内部类
B:局部内部类
C:匿名内部类
(4)成员内部类访问规则
成员内部类不是静态的：
外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
成员内部类是静态的：
外部类名.内部类名 对象名 = new 外部类名.内部类名();
(5)局部内部类
A:局部内部类访问局部变量必须加final修饰。
B:为什么呢?
因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。
所以，堆内存还是用该变量，而改变量已经没有了。
为了让该值还存在，就加final修饰。
通过反编译工具我们看到了，加入final后，堆内存直接存储的是值，而不是变量名。
(6)匿名内部类(掌握)
A:是局部内部类的简化形式
B:前提
存在一个类或者接口
C:格式:
new 类名或者接口名() {
重写方法;
}
D:本质：
其实是继承该类或者实现接口的子类匿名对象

根据以下代码段，下列说法中正确的是(    )。
public class Parent {
    private void m1(){}
    void m2(){}
    protected void m3(){}
    public static void m4(){}
}

A
子类中一定能够继承和覆盖Parent类的m1方法//private 本类，子类不行
B
子类中一定能够继承和覆盖Parent类的m2方法/、默认 本包 子类不行
C
子类中一定能够继承和覆盖Parent类的m3方法//protect 本包+子类 子类可以
D
子类中一定能够继承和覆盖Parent类的m4方法//public 本包+其他包均可，但在多态情况下，父类存在同名静态函数访问的是父类，子类并不能覆盖父类的方法
正确答案：C

java用（）机制实现了线程之间的同步执行
A
监视器 //也叫做锁
B
虚拟机
C
多个CPU
D
异步调用
正确答案：A
参考答案：我的答案是A  首先jvm中没有进程的概念 ，但是jvm中的线程映射为操作系统中的进程，对应关系为1：1。那这道题的问的就是jvm中线程如何异步执行 。  在jvm中 是使用监视器锁来实现不同线程的异步执行，  在语法的表现就是synchronized  。

以下哪一个正则表达式不能与字符串“https://www.tensorflow.org/”（不含引号）匹配？（）
A
[a-z]+://[a-z.]+/ //a到z一次以上，：//匹配，a-z.任意匹配 一次以上 最后匹配/
B
https[😕/]www[.]tensorflow[.]org[/] [😕/]是匹配1个字符，错误
C
[https]+://www.tensorflow.org/
D
[a-zA-Z.😕]+ +代表1次以上 []代表匹配中括号中其中任一个字符
正确答案：B
正则表达式的规则

1. 任意一个字符表示匹配任意对应的字符，如a匹配a，7匹配7，-匹配-。

2. []代表匹配中括号中其中任一个字符，如[abc]匹配a或b或c。

3. -在中括号里面和外面代表含义不同，如在外时，就匹配-，如果在中括号内[a-b]表示匹配26个小写字母中的任一个；[a-zA-Z]匹配大小写共52个字母中任一个；[0-9]匹配十个数字中任一个。

4. ^{在中括号里面和外面含义不同，如在外时，就表示开头，如}7[0-9]表示匹配开头是7的，且第二位是任一数字的字符串；如果在中括号里面，表示除了这个字符之外的任意字符(包括数字，特殊字符)，如[^abc]表示匹配出去abc之外的其他任一字符。

5. .表示匹配任意的字符。

6. \d表示数字。

7. \D表示非数字。
   8. \s表示由空字符组成，[ \t\n\r\x\f]。
   9. \S表示由非空字符组成，[^\s]。
   10. \w表示字母、数字、下划线，[a-zA-Z0-9_]。
   11. \W表示不是由字母、数字、下划线组成。
   12. ?: 表示出现0次或1次。
   13. +表示出现1次或多次。
   14. *表示出现0次、1次或多次。
   15. {n}表示出现n次。
   16. {n,m}表示出现n~m次。
   17. {n,}表示出现n次或n次以上。
   18. XY表示X后面跟着Y，这里X和Y分别是正则表达式的一部分。
   19. X|Y表示X或Y，比如"food|f"匹配的是foo（d或f），而"(food)|f"匹配的是food或f。
   20. (X)子表达式，将X看做是一个整体

下面代码运行结果是？
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;
public static void main(String args[]){
   x–;
   myMethod( );
   System.out.println(x+y+ ++x);
}
public static void myMethod( ){
  y=x++ + ++x;
 }
}

A
compiletime error
B
prints:1
C
prints:2
D
prints:3
E
prints:7
F
prints:8
正确答案：D
参考答案：D
1.静态语句块中x为局部变量，不影响静态变量x的值
2. 2.x和y为静态变量，默认初始值为0，属于当前类，其值得改变会影响整个类运行。
3. 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

Java网络程序设计中,下列正确的描述是（）
A
Java网络编程API建立在Socket基础之上
B
Java网络接口只支持tcP以及其上层协议 //只不对
C
Java网络接口只支持UDP以及其上层协议 //只不对

D
Java网络接口支持IP以上的所有高层协议
正确答案：AD
29.
下面的对象创建方法中哪些会调用构造方法 （）？
A
new语句创建对象//调用了构造函数
B
调用Java.io.ObjectInputStream的readObject方法 // readObject （）对象反序列化 没有调用构造函数
C
java反射机制使用java.lang.Class或java.lang.reflect.Constructor的newInstance()方法//调用了构造函数
D
调用对象的clone()方法 //没有调用构造函数
正确答案：AC

对于线程局部存储TLS(thread local storage)，以下表述正确的是
A
解决多线程中的对同一变量的访问冲突的一种技术
B
TLS会为每一个线程维护一个和该线程绑定的变量的副本
C
每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了
D
Java平台的java.lang.ThreadLocal是TLS技术的一种实现
正确答案：ABD
你的答案：A
参考答案：ABD C：同一全局变量或者静态变量每个线程访问的是同一变量，多个线程同时访存同一全局变量或者静态变量时会导致冲突，尤其是多个线程同时需要修改这一变量时，通过TLS机制，为每一个使用该全局变量的线程都提供一个变量值的副本，每一个线程均可以独立地改变自己的副本，而不会和其它线程的副本冲突。

servlet周期包含哪些：
A
初始化 init()  --> 初始化
B destory () --> 销毁（停止）
销毁
C
请求处理 service()  -->  处理请求
D
开始
正确答案：ABC

inputstream的close方法用来关闭流
skip()用来跳过一些字节
mark（）用来标记流
reset（）复位流

若有定义语句： int a=10 ; double b=3.14 ; 则表达式 ‘A’+a+b 值的类型是（）
A
char
B
int
C
double
D
float
正确答案：C
你的答案：A
参考答案：选C，double类型，因为按照类型大的与类型小的运算，强制转换类型小的进行运算的规则，double>int>char，因此结果是double类型。

Math.floor(-8.5)=( )
A
(float)-8.0
B
(long)-9
C
(long)-8
D
(double)-9.0
正确答案：D
你的答案：B
参考答案：D  Math.floor(x) 返回小于等于x的最接近整数，类型为double

从以下四个选项选出不同的一个。
A
LVS //Linux Virtual Server的简写，意即Linux虚拟服务器
B
Nginx//性能的 HTTP 和 反向代理 服务器
C
Lighttpd//源Web服务器软件
D
Apache//Web服务器软件
正确答案：A

关于Float，下列说法错误的是()
A
Float是一个类
B
Float在java.lang包中 //Byte，Character，Short，Integer，Long，Float，Double，Boolean都在java.lang包中
C
Float a=1.0是正确的赋值方法 //1.0默认double,double无法隐形转化成float
D
Float a= new Float(1.0)是正确的赋值方法

1
2
3
4
5
6 static String str0=“0123456789”;
static String str1=“0123456789”;
String str2=str1.substring(5);
String str3=new String(str2);
String str4=new String(str3.toCharArray());
str0=null;
假定str0,…,str4后序代码都是只读引用。
Java 7中，以上述代码为基础，在发生过一次FullGC后，上述代码在Heap空间（不包括PermGen）保留的字符数为（）
A
5
B
10
C
15
D
20
正确答案：C
你的答案：D
参考答案：应该是C substring实际是new，5字符 str3和4也都是new，每个5字符 分别都会创建新的对象 常量池是PermGen的 因此应该是一共15字符

以下程序段执行后将有（）个字节被写入到文件afile.txt中。 int 4个字节 char2个字节
1
2
3
4
5
6
7
8 try {
    FileOutputStream fos = new FileOutputStream(“afile.txt”);
    DataOutputStream dos = new DataOutputStream(fos);
    dos.writeInt(3);
    dos.writeChar(1);
    dos.close();
    fos.close();
} catch (IOException e) {}

A
3
B
5
C
6
D
不确定，与软硬件环境相关
正确答案：C

在Java中，对于不再使用的内存资源，如调用完成的方法，“垃圾回收器”会自动将其释放。（  ）

A
正确
B
错误
正确答案：B
方法调用时，会创建栈帧在栈中，调用完是程序自动出栈释放，而不是gc释放

下面有关 java 类加载器,说法正确的是?()
A
引导类加载器(bootstrap class loader):它用来加载 Java 的核心库,是用C++来实现的
B
扩展类加载器(extensions class loader):它用来加载 Java 的扩展库。
C
系统类加载器(system class loader):它根据 Java 应用的类路径(CLASSPATH)来加载 Java 类
D
tomcat 为每个 App 创建一个 Loader,里面保存着此 WebApp 的 ClassLoader。需要加载 WebApp 下的类时,就取出 ClassLoader 来使用
正确答案：BCD

在J2EE中，使用Servlet过滤器，需要在web.xml中配置（）元素
A

B

C

D

正确答案：AB
你的答案：C
参考答案：答案：AB
Servlet过滤器的配置包括两部分：
第一部分是过滤器在Web应用中的定义，由元素表示，包括和两个必需的子元素
第二部分是过滤器映射的定义，由元素表示,可以将一个过滤器映射到一个或者多个Servlet或JSP文件，也可以采用url-pattern将过滤器映射到任意特征的URL。

下面有关servlet的层级结构和常用的类，说法正确的有?
A
GenericServlet类：抽象类，定义一个通用的、独立于底层协议的Servlet。
B
大多数Servlet通过从GenericServlet或HttpServlet类进行扩展来实现
C
ServletConfig接口定义了在Servlet初始化的过程中由Servlet容器传递给Servlet得配置信息对象
D
HttpServletRequest接口扩展ServletRequest接口，为HTTP Servlet提供HTTP请求信息
正确答案：ABCD

JAVA反射机制主要提供了以下哪些功能？
A
在运行时判断一个对象所属的类
B
在运行时构造一个类的对象
C
在运行时判断一个类所具有的成员变量和方法
D
在运行时调用一个对象的方法
正确答案：ABCD
你的答案：BD
参考答案：Java反射机制主要提供了以下功能：
在运行时判断任意一个对象所属的类；
在运行时构造任意一个类的对象；

在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态***。 因此，答案为：ABCD

下面有关值类型和引用类型描述正确的是（）？
A
值类型的变量赋值只是进行数据复制，创建一个同值的新对象，而引用类型变量赋值，仅仅是把对象的引用的指针赋值给变量，使它们共用一个内存地址。
B
值类型数据是在栈上分配内存空间，它的变量直接包含变量的实例，使用效率相对较高。而引用类型数据是分配在堆上，引用类型的变量通常包含一个指向实例的指针，变量通过指针来引用实例。
C
引用类型一般都具有继承性，但是值类型一般都是封装的，因此值类型不能作为其他任何类型的基类。
D
值类型变量的作用域主要是在栈上分配内存空间内，而引用类型变量作用域主要在分配的堆上。 //成员变量 基础类型 作用域 堆
正确答案：ABC

执行如下程序代码
1
2
3
4 char chr = 127;
int sum = 200;
chr += 1;
sum += chr;
后，sum的值是（）
备注：同时考虑c/c++和Java的情况的话
A
72
B
99
C
328
D
327
正确答案：AC
c/c++语言来说, char是一个字节, 会发生溢出, 对127加一发生溢出,  0111 1111 --> 1000 0000, 1000 0000为补码-128, 所以结果为200-128=72

java中只有byte, boolean是一个字节, char是两个字节, 所以对于java来说127不会发生溢出, 输出328

下面有关java hashmap的说法错误的是？
A
HashMap 的实例有两个参数影响其性能：“初始容量” 和 “加载因子”。
B
HashMap 的实现不是同步的，意味着它不是线程安全的
C
HashMap通过开放地址法解决哈希冲突
D
HashMap中的key-value都是存储在Entry数组中的
正确答案：C

解决hash冲突有3种方法：
1,开放定址法 当哈希地址p冲突时，再以p为基础产生一个哈希地址，直至不冲突
2,链地址法 相同的哈希地址构成单链表，头指针存在哈希表中，适用于经常插入删除的情况
3,再哈希法 多个哈希函数，不易聚集，增加了计算时间

AccessViolationException异常触发后，下列程序的输出结果为（      ）
1
2
3
4
5
6
7
8
9
10
11
12
13 static void Main(string[] args)  
{  
    try  
    {  
        throw new AccessViolationException();  
        Console.WriteLine(“error1”);  
    }  
    catch (Exception e)  
    {  
        Console.WriteLine(“error2”);  
    }  
    Console.WriteLine(“error3”);  
}

A
error2
error3
B
error3
C
error2
D
error1
正确答案：A
你的答案：未作答
官方解析：try…catch，catch捕获到异常，有抛出异常语句(throw)，不影响后续程序，errror3执行
如果没有抛出异常，影响后续程序，error3不执行，本题答案选A。

关于抽象类与最终类，下列说法错误的是？
A
抽象类能被继承，最终类只能被实例化。
B
抽象类和最终类都可以被声明使用//抽象类和最终类(final)都可以被声明使用。这里只是说“声明”，并没有说“实例化”；如果只是声明是可以的

C
抽象类中可以没有抽象方法，最终类中可以没有最终方法//抽象类中可以有抽象方法，也可以没有抽象方法,最终类中可以有最终方法也可以没有
D
抽象类和最终类被继承时，方法可以被子类覆盖//最终类不可以被子类重写
正确答案：D
最终类就是被final修饰的类，最终方法就是被final修饰的方法。最终类不能被继承，最终方法不能被重写。

在jdk1.5之后，下列 java 程序输出结果为______。
1
2
3
4 int i=0;
Integer j = new Integer(0);
System.out.println(ij);
System.out.println(j.equals(i));
A
true,false
B
true,true
C
false,true
D
false,false
E
对于不同的环境结果不同
F
程序无法执行
正确答案：B
1、基本型和基本型封装型进行“”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；
2、两个Integer类型进行“”比较，如果其值在-128至127，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关，这里不进行赘述。
3、两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true
4、基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。
int a=257;
Integer b=257;
Integer c=257;
Integer b2=57;
Integer c2=57;
System.out.println(ab); true
//System.out.println(a.equals(b));  编译出错，基本型不能调用equals()
System.out.println(b.equals(257.0)); false
System.out.println(bc);false
System.out.println(b2c2);true

已知x >= y and y >= z 为真，那么x > z or y = z 值为
A
真
B
假
C
无法确定
D
x y z同为正数时为真
正确答案：C
你的答案：未作答
参考答案：答案应该是C  y=z是赋值

下面属于JSP内置对象的是？
A
out对象
B
response对象
C
application对象
D
page对象
正确答案：ABCD

JSP内置对象有：
1.request对象      客户端的请求信息被封装在request对象中，通过它才能了解到客户的需求，然后做出响应。它是HttpServletRequest类的实例。 2.response对象      response对象包含了响应客户请求的有关信息，但在JSP中很少直接用到它。它是HttpServletResponse类的实例。 3.session对象    
 session对象指的是客户端与服务器的一次会话，从客户连到服务器的一个WebApplication开始，直到客户端与服务器断开连接为止。它是HttpSession类的实例.
4.out对象      out对象是JspWriter类的实例,是向客户端输出内容常用的对象
5.5.page对象      page对象就是指向当前JSP页面本身，有点象类中的this指针，它是java.lang.Object类的实例 6.application对象      
6.application对象实现了用户间数据的共享，可存放全局变量。它开始于服务器的启动，直到服务器的关闭，在此期间，此对象将一直存在；这样在用户的前后连接或不同用户之间的连接中，可以对此对象的同一属性进行操作；在任何地方对此对象属性的操作，都将影响到其他用户对此的访问。服务器的启动和关闭决定了application对象的生命。它是ServletContext类的实例。
7. 7.exception对象    exception对象是一个例外对象，当一个页面在运行过程中发生了例外，就产生这个对象。如果一个JSP页面要应用此对象，就必须把isErrorPage设为true，否则无法编译。他实际上是java.lang.Throwable的对象
8. 8.pageContext对象 pageContext对象提供了对JSP页面内所有的对象及名字空间的访问，也就是说他可以访问到本页所在的SESSION，也可以取本页面所在的application的某一属性值，他相当于页面中所有功能的集大成者，它的本 类名也叫pageContext。
9. 9.config对象 config对象是在一个Servlet初始化时，JSP引擎向它传递信息用的，此信息包括Servlet初始化时所要用到的参数（通过属性名和属性值构成）以及服务器的有关信息（通过传递一个ServletContext对象）

下列关于while循环、do-while循环和for循环说法错误的是
A
while循环先执行条件判断，do-while循环执行循环体
B
do-while循环结束的条件是关键字while后的条件表达式成立//do-while循环结束的条件是关键字while后的条件表达式不成立
C
for循环结构中的3个表达式缺一不可
D
while循环能够实现的操作，for循环也能实现
正确答案：BC

for循环中的"单次表达式"、"条件表达式"和"循环体语句"都是选择项, 即可以缺省成只剩下“；”的空语句, ";"不能缺省的原因是编译格式如此，缺省了编译器不认识而会报错。
省略了用来初始化的单次表达式时, 表示不对循环控制变量赋初值。
省略了条件表达式, 若不做其它处理则成为死循环。
省略了所有循环体， 则for语句不被其它形式处理时不产生任何作用。

下列哪些情况下会导致线程中断或停止运行（      ）
A
抛出InterruptedException异常//A 选项：Interrupt 确实会导致线程中断，但是既然捕获到异常就代表线程不会中断和停止
B
线程调用了wait方法//B 选项：线程调用 wait（）方法，释放了锁，会强制导致当前正在执行的线程中断，需要 notify（）或 notifyall（）来“唤醒“
C
当前线程创建了一个新的线程//当线程创建一个新的线程时，CPU 时间片不会剥夺当前线程运行的“权利”
D
高优先级线程进入就绪状态//选项：当高优先级线程进入就绪状态，也需要等待当前线程的运行结束才可以继续运行，此时当前线程处于运行中 RUBBABLE 状态中的 READY 就绪态

正确答案：B