Java-基础选择题

标题

Java（一）
Java （二）
java（三）
Java（四）
Java （五）
Java（六）
Java（七）
Java(八）
Java（九）
Java(十）
Java（十一）
Java（十二）

Java（一）

1、若在某一个类定义中定义有如下的方法：abstract void performDial( ); 该方法属于（D） ?
A.本地方法
B.最终方法
C.静态方法
D.抽象方法
解析：
本地方法：简单地讲，一个native Method就是一个java调用非java代码的接口；native方法表示该方法要用另外一种依赖平台的编程语言实现。
最终方法：final void B(){},这样定义的方法就是最终方法，最终方法在子类中不可以被重写，也就是说，如果有个子类继承了这个最终方法所在的类，那么这个子类中不能出现void B(){}这样的方法。
最终类：final class A {},这样定义的类就是最终类，最终类不能被继承。
abstract修饰抽象类

2.在为传统面向对象语言的程序做单元测试的时候,经常用到mock对象。Mock对象通过反射数。请问反射最大程度破坏了面向对象的以下哪个特性？(A)
A.封装
B.多态
C.继承
D.抽象
解析：
A.封装
反射破坏代码的封装性，破坏原有的访问修饰符访问限制

3.以下程序的执行结果是：（A）
static boolean foo(char c) {
System.out.print©;
return true;
}

public static void main1(String[] args) {
int i = 0;
for (foo(‘A’); foo(‘B’) && (i < 2); foo(‘C’)) {
i++;
foo(‘D’);
}
}
A.ABDCBDCB
B.ABCDABCD
C.编译时出错
D.运行时抛出异常

4.一个完整的URL地址由(),(),端口和文件四部分组成。（B）
A.协议用户名
B.协议主机名
C.主机名 ip
D.以上都不正确
解析：
**URL(Uniform Resource Locator) **，统一资源定位符，能够对因特网的资源进行定位。
URL一般有四部分组成：<协议>://<主机>:<端口>/<路径>

现在最常用的<协议>为http协议。

<主机>是指主机在因特网上的域名。

http协议的默认<端口>为80（可以省略）。

<路径>是指要活的的文件的路径。

5.以下程序的输出结果是？（B）
public class Example {
String str = new String(“good”);
char[] ch = { ‘a’, ‘b’, ‘c’ };
public static void main(String args[]) {
Example ex = new Example();
ex.change(ex.str, ex.ch);
System.out.print(ex.str + " and ");
System.out.print(ex.ch);
}

public static void change(String str, char ch[])
{
str = “test ok”;
ch[0] = ‘g’;
}
}
A.good and abc
B.good and gbc
C.test ok and abc
D.test ok and gbc

解析：
考察值传递和引用传递。对于值传递，拷贝的值用完之后就会被释放，对原值没有任何影响，但是对于引用传递，拷贝的是对象的引用，和原值指向的同一块地址，即操作的是同一个对象，所以操作之间会相互影响
所以对于String str是值传递，操作之间互不影响，原值保持不变。而ch是数组，拷贝的是对象的引用，值发生了改变，因此选择B

6.下面有关servlet service描述错误的是？（B）
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 中实现的

7.以下代码运行输出的是©
public class Person{
private String name = “Person”;
int age=0;
}
public class Child extends Person{
public String grade;
public static void main(String[] args){
Person p = new Child();
System.out.println(p.name);
}
}
A.输出：Person
B.没有输出
C.编译出错
D.运行出错

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

8、在 myjsp.jsp 中，关于下面的代码说法错误的是：( A)
<%@ page language=“java” import=“java.util.*” errorPage=“error.jsp” isErrorPage=“false” %>
A.该页面可以使用 exception 对象 //当isErrorPage 为true时，才能用exception对象
B.该页面发生异常会转向 error.jsp
C.存在 errorPage 属性时，isErrorPage 是默认为 false
D.error.jsp 页面一定要有isErrorPage 属性且值为 true

解析：
exception是JSP九大内置对象之一，其实例代表其他页面的异常和错误。只有当页面是错误处理页面时，即isErroePage为true时，该对象才可以使用。对于C项，errorPage的实质就是JSP的异常处理机制,发生异常时才会跳转到errorPage指定的页面，没必要给errorPage再设置一个errorPage。所以当errorPage属性存在时， isErrorPage属性值为false

9.Java对象的初始化方式有（ ABC）
A.初始化块
B.构造器
C.定义变量时指定初始化值
D.其它各项都不对
//静态域最早加载，静态块之后加载
//对象的初始化方式：
1.new时初始化；
2.静态工厂 newInstance；
3.反射Class.forName()；
4.clone方式；
5.反序列化；

10.一个servlet的生命周期不包括方法？（B）
A.init()方法
B.invalidate()方法
C.service()方法
D.destroy()方法

//Servlet生命周期有三个阶段：
1、初始化阶段，调用init（）方法
2、响应客户请求，调用service（）方法
3、终止阶段，调用destroy（）方法

Java （二）

1、 HashMap的数据结构是怎样的？（C）
A.数组
B.链表
C.数组+链表
D.二叉树

//JDK8以后，HashMap的数据结构是数组+链表+红黑树

2、在 JAVA 编程中，Java 编译器会将 Java 程序转换为（ A）？
A.字节码
B.可执行代码
C.机器代码
D.以上都不对
//java源代码 ->编译器->jvm可执行的java字节码（即虚拟指令 class文件）->jvm->jvm中解释器->机器可执行的二进制机器码->程序运行。
编译器将Java源代码编译成字节码class文件
类加载到JVM里面后，执行引擎把字节码转为可执行代码
执行的过程，再把可执行代码转为机器码，由底层的操作系统完成执行。

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

运行时数据区包括：虚拟机栈区，堆区，方法区，本地方法栈，程序计数器

虚拟机栈区：也就是我们常说的栈区，线程私有，存放基本类型，对象的引用和 returnAddress ，在编译期间完成分配。

堆区：JAVA 堆，也称 GC 堆，所有线程共享，存放对象的实例和数组， JAVA 堆是垃圾收集器管理的主要区域。
-方法区：所有线程共享，存储已被虚拟机加载的类信息，常量，静态变量，即时编译器编译后的代码等数据。这个区域的内存回收目标主要是针对常量池的对象的回收和对类型的卸载。

程序计数器：线程私有，每个线程都有自己独立的程序计数器，用来指示下一条指令的地址。

4、JAVA中，下列语句哪一个正确（C）
A.class中的constructor不可省略
B.constructor必须与class同名，但方法不能与class同名
C.constructor在一个对象被new时执行
D.一个class只能定义一个constructor

解析：
A 省略构造函数,编译器会自动生成。
D 构造函数可以重载
B 方法是可以和类名同名的，和构造方法唯一的区别就是，构造方法没有返回值。

5.在JAVA中，假设A有构造方法A(int a)，则在类A的其他构造方法中调用该构造方法和语句格式应该为（B）
A.this.A(x)
B.this(x)
C.super(x)
D.A(x)

解析：
this的作用其中一个就是在一个构造方法中调用另一个构造方法，格式为this(参数)；
super是调用父类的方法；
A(a)这种形式是在new一个类时使用。

6.下列选项中属于面向对象程序设计语言特征的是（ABD）
A.继承性
B.多态性
C.相似性
D.封装性

7.以下哪个正确？(ACD)
A.abstract类只能用来派生子类，不能用来创建abstract类的对象。
B.final类不但可以用来派生子类，也可以用来创建final类的对象。
C.abstract不能与final同时修饰一个类。
D.abstract类定义中可以没有abstract方法。

解析：
1、abstract类不能用来创建abstract类的对象；
2、final类不能用来派生子类，因为用final修饰的类不能被继承；
3、如2所述，final不能与abstract同时修饰一个类，abstract类就是被用来继承的；
4、类中有abstract方法必须用abstract修饰，但abstract类中可以没有抽象方法，接口中也可以有abstract方法。

8、 JAVA反射机制主要提供了以下哪些功能？（ABCD）
A.在运行时判断一个对象所属的类
B.在运行时构造一个类的对象
C.在运行时判断一个类所具有的成员变量和方法
D.在运行时调用一个对象的方法

解析：
Java反射机制主要提供了以下功能：在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
因此，答案为：ABCD

9.以下关于Histroy对象的属性或方法描述正确的是（AD）
A.bcak回到浏览器载入历史URL地址列表的当前URL的前一个URL
B.go表示刷新当前页面
C.length保存历史URL地址列表的长度信息
D.forward转到浏览器载入历史URL地址列表的当前URL的下一个URL。

选A、D。考察的是浏览器的内置对象管理模型，简称BOM(Browser Object Model)中的Histroy属性和方法。

length 返回浏览器历史列表中的URL数量。所以C中表述的长度信息是错误的。

back() 加载 history列表中的前一个URL。

forward() 加载 history 列表中的下一个URL。

go() 加载history列表中的某个具体页面。所以B的表述刷新当前页面是错误的。

10、（EG）
public class NameList
{
private List names = new ArrayList();
public synchronized void add(String name)
{
names.add(name);
}
public synchronized void printAll() {
for (int i = 0; i < names.size(); i++)
{
System.out.print(names.get(i) + ””);
}
}
public static void main(String[]args)
{
final NameList sl = new NameList();
for (int i = 0; i < 2; i++)
{
new Thread()
{
public void run()
{
sl.add(“A”);
sl.add(“B”);
sl.add(“C”);
sl.printAll();
}
} .start();
}
}
}
Which two statements are true if this class is compiled and run?

A.An exception may be thrown at runtime.
B.The code may run with no output, without exiting.
C.The code may run with no output, exiting normally(正常地).
D.The code may rum with output “A B A B C C “, then exit.
E.The code may rum with output “A B C A B C A B C “, then exit.
F.The code may ruin with output “A A A B C A B C C “, then exit.
G.The code may ruin with output “A B C A A B C A B C “, then exit.

在每个线程中都是顺序执行的，所以sl.printAll();必须在前三句执行之后执行，也就是输出的内容必有（连续或非连续的）ABC。而线程之间是穿插执行的，所以一个线程执行 sl.printAll();之前可能有另一个线程执行了前三句的前几句。
E答案相当于线程1顺序执行完然后线程2顺序执行完。
G答案则是线程1执行完前三句add之后线程2插一脚执行了一句add然后线程1再执行 sl.printAll();输出ABCA。接着线程2顺序执行完输出ABCABC
输出加起来即为ABCAABCABC。

11、关于容器下面说法正确的是？(D )
A.列表(List)和集合(Set)存放的元素都是可重复的。
B.列表(List)和集合(Set)存放的元素都是不可重复的。
C.映射(Map)中key是可以重复的。
D.映射(Map)中value是可以重复的。

12.以下说法错误的是?（C）
A.数组是一个对象
B.数组不是一种原生类
C.数组的大小可以任意改变
D.在Java中，数组存储在堆中连续内存空间里

解析：
在java中,数组是一个对象,不是一种原生类,对象所以存放在堆中,又因为数组特性,是连续的,只有C不对

13.下列哪个修饰符可以使在一个类中定义的成员变量只能被同一包中的类访问？(B)
A.private
B.无修饰符
C.public
D.protected

	public	protected	defalut	private
同一个类	√	√	√	√
同一个包	√	√	√	×
其他包	√	√	×	×
其他	√	×	×	×

14.关于以下程序代码的说明正确的是?（D）
public class HasStatic {
private static int x = 100;
public static void main(String args[]) {
HasStatic hs1 = new HasStatic();
hs1.x++;
HasStatic hs2 = new HasStatic();
hs2.x++;
hs1 = new HasStatic();
hs1.x++;
HasStatic.x–;
System.out.println(“x=” + x);
}
}
A.程序通过编译，输出结果为：x=103
B.10行不能通过编译，因为x是私有静态变量
C.5行不能通过编译，因为引用了私有静态变量
D.程序通过编译，输出结果为：x=102

static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。
static变量在第一次使用的时候初始化，但只会有一份成员对象。
所以这里不仅可以调用，而且每一次调用都确实修改了x的值，也就是变化情况是这样的：
x=101
x=102
x=103
x=102

15.如何放掉一个指定占据的内存空间？（D）
A.调用free()方法
B.代用system.gc()方法
C.赋值给该项对象的引用为null
D.程序员无法明确强制垃圾回收器运行

解析：
在《java虚拟机》一书中明确讲了，释放掉占据的内存空间是由gc完成，但是程序员无法明确强制其运行，该空间在不被引用的时候不一定会立即被释放，这取决于GC本身，无法由程序员通过代码控制。

16.一般情况下，以下哪个选项不是关系数据模型与对象模型之间匹配关系？（D）
A.表对应类
B.记录对应对象
C.表的字段对应类的属性
D.表之间的参考关系对应类之间的依赖关系

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

17.下列关于Java并发的说法中正确的是（B）
A.CopyOnWriteArrayList适用于写多读少的并发场景
B.ReadWriteLock适用于读多写少的并发场景
C.ConcurrentHashMap的写操作不需要加锁，读操作需要加锁
D.只要在定义int类型的成员变量i的时候加上volatile关键字，那么多线程并发执行i++这样的操作的时候就是线程安全的了

解析：
A，CopyOnWriteArrayList适用于写少读多的并发场景
B，ReadWriteLock即为读写锁，他要求写与写之间互斥，读与写之间互斥，读与读之间可以并发执行。在读多写少的情况下可以提高效率
C，ConcurrentHashMap是同步的HashMap，读写都加锁
D，volatile只保证多线程操作的可见性，不保证原子性

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

public class Test
{public static Test t1 = new Test();{System.out.println("blockA");}static{System.out.println("blockB");}public static void main(String[] args){Test t2 = new Test();}}
A.blockAblockBblockA
B.blockAblockAblockB
C.blockBblockBblockA
D.blockBblockAblockB

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

19.有关hashMap跟hashTable的区别，说法正确的是？(ABCD)

A.HashMap和Hashtable都实现了Map接口
B.HashMap是非synchronized，而Hashtable是synchronized
C.HashTable使用Enumeration，HashMap使用Iterator
D.HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。

A正确。Map是一个接口，hashtable,hashmap都是它的实现。
B正确。由于Hashtable是线程安全的也是synchronized，所以在单线程环境下它比HashMap要慢。如果你不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。
C正确。HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。所以当有其它线程改变了HashMap的结构（增加或者移除元素），将会抛出ConcurrentModificationException，但迭代器本身的remove()方法移除元素则不会抛出ConcurrentModificationException异常。但这并不是一个一定发生的行为，要看JVM。这条同样也是Enumeration和Iterator的区别。
D正确。哈希值的使用不同，HashTable直接使用对象的hashCode，代码是这样的：
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
而HashMap重新计算hash值，而且用与代替求模：
int hash = hash(k);
int i = indexFor(hash, table.length);

20.以下可以正确获取结果集的有?(AD)

A.Statement sta=con.createStatement();
ResultSet rst=sta.executeQuery(“select * from book”);B.Statement sta=con.createStatement(“select * from book”);ResultSet rst=sta.executeQuery();C.PreparedStatement pst=con.prepareStatement();
ResultSet rst=pst.executeQuery(“select * from book”);D.PreparedStatement pst=con.prepareStatement(“select * from book”);
ResultSet rst=pst.executeQuery();

解析：
A,D是正确的；创建Statement是不传参的，PreparedStatement是需要传入sql语句
说一下preparedStatement和statement的区别与联系：在JDBC应用中,如果你已经是稍有水平开发者,你就应该始终以PreparedStatement代替Statement.也就是说,在任何时候都不要使用Statement。
PreparedStatement 接口继承 Statement,PreparedStatement 实例包含已编译的 SQL 语句,所以其执行速度要快于Statement对象。Statement为一条Sql语句生成执行计划，如果要执行两条sql语句select colume from table where colume=1;select colume from table where colume=2; 会生成两个执行计划一千个查询就生成一千个执行计划！PreparedStatement用于使用绑定变量重用执行计划 select colume from table where colume=:x; 通过set不同数据只需要生成一次执行计划，可以重用

java（三）

1.下列InputStream类中哪个方法可以用于关闭流？(B)
A.skip（） //跳过字节
B.close（） //关闭流
C.mark（） //标记流
D.reset（） //复位流

2.下面语句正确的是（D）
A.x+1=5
B.i++=1
C.a++b=1
D.x+=1

解析：
选D，+=，-=，*=，/=最常见。
ABC都编译错误。

3.下面关于继承的描述正确的是？(A)
A.在Java中只允许单一继承
B.在Java中一个类只能实现一个接口
C.在Java中一个类不能同时继承一个类和实现一个接口
D.Java的单一继承使代码不可靠

4.下列哪种说法是正确的？©
A.实例方法可直接调用超类的实例方法
B.实例方法可直接调用超类的类方法
C.实例方法可直接调用本类的类方法
D.实例方法可直接调用其他类的实例方法

解析：
a.实例方法可以调用超类公有实例方法
b.实例方法可以直接调用超类的公有类方法
d.实例方法可以通过类名调用其他类的类方法

5.A派生出子类B，B派生出子类C，并且在java源代码中有如下声明：
1.A a0=new A();
2.A a1=new B();
3.A a2=new C();
以下哪个说法是正确的？(A)
A.第1行,第2行和第3行的声明都是正确的 //可以向上转型
B.第1,2,3行都能通过编译，但第2,3行运行时出错
C.第1,2行能通过编译，但第3行编译出错
D.只有第1行能通过编译

6.java中，静态变量static在不同线程的不同实例中地址是否一样？他们储存在什么区域？（C）
A.地址一样，在堆栈区。
B.地址不一样，在堆栈区。
C.地址一样，在全局区。 //static变量存储在方法区，线程共享，全局区是方法区的一部分
D.地址不一样，在全局区。

7.下面代码的输出结果是什么？（D）
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
解析：
1、inti = 100/ 0; 会出现异常，会抛出异常，System.out.print(i)不会执行，
2、catch捕捉异常，继续执行System.out.print(1);
3、当执行 thrownewRuntimeException(); 又会抛出异常，这时，除了会执行finally中的代码，其他地方的代码都不会执行

8.以下代码将打印出?(B)
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

解析：
collection类型的集合（ArrayList,LinkedList）只能装入对象类型的数据，该题中装入了0，是一个基本类型，但是JDK5以后提供了自动装箱与自动拆箱，所以int类型自动装箱变为了Integer类型。编译能够正常通过。
将list1的引用赋值给了list2，那么list1和list2都将指向同一个堆内存空间。instanceof是Java中关键字，用于判断一个对象是否属于某个特定类的实例，并且返回boolean类型的返回值。显然，list1.get(0)和list2.get(0)都属于Integer的实例

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

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

10.下面这三条语句
System.out.println(“is ”+ 100 + 5)；
System.out.println(100 + 5 +“ is”)；
System.out.println(“is ”+ (100 + 5))；
的输出结果分别是？(D )

A.is 1005, 1005 is, is 1005
B.is 105, 105 is, is 105
C.is 1005, 1005 is, is 105
D.is 1005, 105 is, is 105

解析：
1."is"说明后面的内容都会被强制转换为string，所以是最后结果是拼接起来的
2.100+5先得到105，然后与is拼接
3.先算括号内的

11.Given:
public class IfTest{
public static void main(string[]args){
int x=3;
int y=1;
if(x=y) //判断条件
System.out.println(“Not equal”);
else
System.out.println(“Equal”);
}
}
What is the result? ©
A.The output is “Equal”
B.The output in “Not Equal”
C.An error at line 5 causes compilation to fall.
D.The program executes but does not print a message.

答案：
C

解析：
这个题考查两个知识点。
1、Java中，赋值是有返回值的，赋什么值，就返回什么值。比如这题，x=y，返回y的值，所以括号里的值是1。
2、Java跟C的区别，C中赋值后会与0进行比较，如果大于0，就认为是true；而Java不会与0比较，而是直接把赋值后的结果放入括号。

12.在一个基于分布式的游戏服务器系统中，不同的服务器之间，哪种通信方式是不可行的（A）？
A.管道
B.消息队列
C.高速缓存数据库
D.套接字

解析：
管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。

13.下列程序的运行结果(A)
public void getCustomerInfo() {
try {
// do something that may cause an Exception
} catch (java.io.FileNotFoundException ex) {
System.out.print(“FileNotFoundException!”);
} catch (java.io.IOException ex) {
System.out.print(“IOException!”);
} catch (java.lang.Exception ex) {
System.out.print(“Exception!”);
}
}
A.IOException!
B.IOException!Exception!
C.FileNotFoundException!IOException!
D.FileNotFoundException!IOException!Exception!

解析：
题目说抛出一个异常，但是没说具体是什么异常，那么就要分情况了：
1.如果抛出一个FileNotFoundException(或其子类)，那么最终结果就打印FileNotFoundException
2.如果抛出一个IOException,或者IOException的子类(不包含FileNotFoundException及其子类)，那么最终结果就打印IOException
3.如果抛出一个Exception(不包含IOException及其子类),那么最终结果就打印Exception.
以上，所以3个皆有可能.但是，不管是哪一种情况，只会输出其中之一。
从答案上来看，B,C，D的输出情况是不存在的。因此选A

14.如下代码的输出结果是什么？（D）
public class Test {
public int aMethod(){
static int i = 0; //静态变量不能在方法中定义
i++;
return i;
}
public static void main(String args[]){
Test test = new Test();
test.aMethod();
int j = test.aMethod();
System.out.println(j);
}
}
A.0
B.1
C.2
D.编译失败

答案：
D

解析：
静态变量只能在类主体中定义，不能在方法中定义

15.下面有关servlet和cgi的描述，说法错误的是？（D）
A.servlet处于服务器进程中，它通过多线程方式运行其service方法
B.CGI对每个请求都产生新的进程，服务完成后就销毁
C.servlet在易用性上强于cgi，它提供了大量的实用工具例程，例如自动地解析和解码HTML表单数据、读取和设置HTTP头、处理Cookie、跟踪会话状态等
D.cgi在移植性上高于servlet，几乎所有的主流服务器都直接或通过插件支持cgi

解析：
选择D，servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。

16.下列关于构造方法的叙述中，错误的是（CD）
A.java语言规定构造方法名与类名必须相同
B.java语言规定构造方法没有返回值，但不同void声明
C.java语言规定构造方法不可以重载 //不能重写，但可以重载
D.java语言规定构造方法只能通过new自动调用 //本类通过this调用，父类通过super调用

17.What is Static Method in Java（ABC）
A.It is a method which belongs to the class and not to the object(instance)
B.A static method can access only static data. It can not access non-static data (instance variables)
C.A static method can call only other static methods and can not call a non-static method from it.
D.A static method can not be accessed directly by the class name and doesn’t need any object

解析：
A：静态方法是一个属于类而不属于对象(实例)的方法。（√）
B：静态方法只能访问静态数据。无法访问非静态数据(实例变量)。（√）
C：静态方法只能调用其他静态方法，不能从中调用非静态方法。（√）
D：静态方法不能通过类名直接访问，也不需要任何对象。（×）// 静态方法可以直接用类名访问。

18.下列哪种情况会调用拷贝构造函数（ACD）
A.用派生类的对象去初始化基类对象时
B.将类的一个对象赋值给该类的另一个对象时
C.函数的形参是类的对象，调用函数进行形参和实参结合时
D.函数的返回值是类的对象，函数执行返回调用时

解析：

复制构造函数被调用的三种情况

1.定义一个对象时，以本类另一个对象作为初始值，发生复制构造；

2.如果函数的形参是类的对象，调用函数时，将使用实参对象初始化形参对象，发生复制构造；

3.如果函数的返回值是类的对象，函数执行完成返回主调函数时，将使用return语句中的对象初始化一个临时无名对象，传递给主调函数，此时发生复制构造。

19.Java对象的初始化方式有（ABC ）
A.初始化块
B.构造器
C.定义变量时指定初始化值
D.其它各项都不对

对象的初始化方式：
1.new时初始化；
2.静态工厂 newInstance；
3.反射Class.forName()；
4.clone方式；
5.反序列化；

20.截止JDK1.8版本,java并发框架支持锁包括?(ABD)
A.读写锁
B.自旋锁
C.X锁
D.乐观锁
E.排他锁

解析：

1、自旋锁 ,自旋，jvm默认是10次吧，有jvm自己控制。for去争取锁
2、阻塞锁被阻塞的线程，不会争夺锁。
3、可重入锁多次进入改锁的域
4、读写锁
5、互斥锁锁本身就是互斥的
6、悲观锁不相信，这里会是安全的，必须全部上锁
7、乐观锁相信，这里是安全的。
8、公平锁有优先级的锁
9、非公平锁无优先级的锁
10、偏向锁无竞争不锁，有竞争挂起，转为轻量锁
11、对象锁锁住对象
12、线程锁
13、锁粗化多锁变成一个，自己处理
14、轻量级锁 CAS 实现
15、锁消除偏向锁就是锁消除的一种
16、锁膨胀 jvm实现，锁粗化
17、信号量使用阻塞锁实现的一种策略
18、排它锁：X锁，若事务T对数据对象A加上X锁，则只允许T读取和修改A，其他任何事务都不能再对A加任何类型的锁，直到T释放A上的锁。这就保证了其他事务在T释放A上的锁之前不能再读取和修改A。

Java（四）

1.编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为( B )。
A.java
B.class
C.html
D.exe
解析：
Java源程序的后缀名为“.java”,经过编译之后生成的字节码文件后缀名为“.class”

2、问以下哪个说法是正确的？（D）
A 派生出子类 B, B 派生出子类 C,并且在 java 源代码有如下声明：

A a0=new A();

A a1=new B();

A a2=new C();

A.只有第一行能通过编译
B.第1、2行能通过编译，但第3行编译出错
C.第1、2、3行能通过编译，但第2、3行运行时出错
D.第1行，第2行和第3行的声明都是正确的

解析：
这个题考了两个点：

继承的传递性。

多态，父类引用指向子类对象。

3.以下哪个接口的定义是正确的？（D ）
A.interface B{ void print() { } ;}
B.interface B{ static void print() ;}
C.abstract interface B extends A1, A2 { abstract void print(){ };} //A1、A2为已定义的接口 abstract和interface不能同时使用
D.interface B{ void print();}

解析：
A，接口中方法的默认修饰符时public abstract，抽象方法可是没有方法体的，没有大括号{}
B，JDK8中，接口中的方法可以被default和static修饰，但是！！！被修饰的方法必须有方法体。
C，注意一下，接口是可以多继承的。整个没毛病，和A选项一样，抽象方法不能有方法体

4.以下会产生信息丢失的类型转换是(B ）
A.float a=10
B.int a=（int）8846.0
C.byte a=10；int b=-a
D.double d=100

解析：
会产生信息丢失不如说丢失精度，这样可能更容易明白，而精度丢失只会发生在从大范围到小范围的转换。上面四个选项，只有 B 是从 double 到 int ，也就是从大范围到小范围。

5.以下代码的输出的正确结果是(D)
public class Test {
public static void main(String args[]) {
String s = “祝你考出好成绩！”;
System.out.println(s.length());
}
}
A.24
B.16
C.15
D.8

解析：
java的String底层是char数组，它的length()返回数组大小，而unicode中一个汉字是可以用一个char表示的。一个汉字等于一个字符字符是char，一个汉字也等于二个字节，字节是byte。

6.java中，StringBuilder和StringBuffer的区别，下面说法错误的是？©
A.StringBuffer是线程安全的
B.StringBuilder是非线程安全的
C.StringBuffer对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象。
D.效率比较String<StringBuffer<StringBuilder，但是在 String S1 = “This is only a” + “ simple” + “ test”时，String效率最高。
//String适合少量的字符串操作情况；
//StringBuilder 单线程下的字符缓冲区
//StringBuffer 多线程下的字符缓冲区

7.下列关于修饰符混用的说法，错误的是(D )
A.abstract不能与final并列修饰同一个类
B.abstract类中不应该有private的成员
C.abstract方法必须在abstract类或接口中
D.static方法中能直接调用类里的非static的属性

解析：
1、abstract不能与final并列修饰同一个类对的。
2、abstract类中不应该有private的成员对的：abstract类中可以有private 但是不应该有。
3、abstract方法必须在abstract类或接口中对的：若类中方法有abstract修饰的，该类必须abstract修改。接口方法默认public abstract。
4、static方法中能处理非static的属性错误：在JVM中static方法在静态区，静态区无法调用非静态区属性。

8.如下语句通过算术运算和逻辑运算之后i和 j的结果是（ D）
int i=0;
int j=0;
if((++i>0)||(++j>0)){
//打印出i和j的值。
}
A.i=0;j=0
B.i=1;j=1
C.i=0;j=1
D.i=1;j=0

解析：
考察的是短路逻辑的用法，即：当第一个逻辑表达式可以确定结果时，将不再进行剩余表达式的运算。

9.以下是java concurrent包下的4个类，选出差别最大的一个（C）
A.Semaphore
B.ReentrantLock
C.Future
D.CountDownLatch

解析：
A、Semaphore：类，控制某个资源可被同时访问的个数;
B、ReentrantLock：类，具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大；
C、Future：接口，表示异步计算的结果；
D、CountDownLatch：类，可以用来在一个线程中等待多个线程完成任务的类。

10.下面有关java实例变量,局部变量,类变量和final变量的说法，错误的是？（B）
A.实例变量指的是类中定义的变量，即成员变量，如果没有初始化，会有默认值。
B.局部变量指的是在方法中定义的变量，如果没有初始化，会有默认值 //局部变量没有默认值
C.类变量指的是用static修饰的属性
D.final变量指的是用final 修饰的变量

解析：
B.定义在类中的变量是类的成员变量，可以不进行初始化，Java会自动进行初始化，如果是引用类型默认初始化为null,如果是基本类型例如int则会默认初始化为0
局部变量是定义在方法中的变量，必须要进行初始化。
被static关键字修饰的变量是静态的，静态变量随着类的加载而加载，所以也被称为类变量
被final修饰的变量是常量

11.关于JAVA的垃圾回收机制，下面哪些结论是正确？（B）
A.程序可以任意指定释放内存的时间
B.JAVA程序不能依赖于垃圾回收的时间或者顺序
C.程序可明确地标识某个局部变量的引用不再被使用
D.程序可以显式地立即释放对象占有的内存

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

12.JSP分页代码中，哪个步骤次序是正确的？（A）
A.先取总记录数，得到总页数，最后显示本页的数据。
B.先取所有的记录，得到总页数，再取总记录数，最后显示本页的数据。
C.先取总页数，得到总记录数，再取所有的记录，最后显示本页的数据。
D.先取本页的数据，得到总页数，再取总记录数，最后显示所有的记录。

解析：
1、count(*)得到总记录数
2、计算总页数
3、获取所有记录(个人感觉这一步不需要，可以直接获取指定页数数据)
4、过滤显示本页数据

13.关于访问权限说法正确的是？( B)
A.外部类前面可以修饰public,protected和private
B.成员内部类前面可以修饰public,protected和private
C.局部内部类前面可以修饰public,protected和private
D.以上说法都不正确

解析：
(1)对于外部类而言，它也可以使用访问控制符修饰，但外部类只能有两种访问控制级别：public和默认。因为外部类没有处于任何类的内部，也就没有其所在类的内部、所在类的子类两个范围，因此 private 和 protected 访问控制符对外部类没有意义。
(2)内部类的上一级程序单元是外部类，它具有 4 个作用域：同一个类（ private ）、同一个包（ protected ）和任何位置（ public ）。
(3)因为局部成员的作用域是所在方法，其他程序单元永远不可能访问另一个方法中的局部变量，所以所有的局部成员都不能使用访问控制修饰符修饰。

14.以下代码执行的结果显示是多少（A ）？
public class Demo {
class Super{
int flag=1;
Super(){
test();
}
void test(){
System.out.println(“Super.test() flag=”+flag);
}
}
class Sub extends Super{
Sub(int i){
flag=i;
System.out.println(“Sub.Sub()flag=”+flag);
}
void test(){
System.out.println(“Sub.test()flag=”+flag);
}
}
public static void main(String[] args) {
new Demo().new Sub(5);
}
}
A.Sub.test() flag=1,Sub.Sub() flag=5
B.Sub.Sub() flag=5,Sub.test() flag=5
C.Sub.test() flag=0,Sub.Sub() flag=5
D.Super.test() flag=1,Sub.Sub() flag=5

解析：

在继承中代码的执行顺序为：
1.父类静态对象，父类静态代码块
2.子类静态对象，子类静态代码块
3.父类非静态对象，父类非静态代码块
4.父类构造函数
5.子类非静态对象，子类非静态代码块
6.子类构造函数
对于本题来说：在只想new Sub(5)的时候，父类先初始化了int flag=1，然后执行父类的构造函数Super（），父类构造函数中执行的test（）方法，因子类是重写了test（）方法的，因此父类构造函数中的test（）方法实际执行的是子类的test（）方法，所以输出为Sub.test() flag=1，接着执行子类构造函数Sub(5) 将flag赋值为5，因此输出结果Sub.Sub() flag=5。最终选择了A。

15.Java多线程有几种实现方法？（AB）
A.继承Thread类
B.实现Runnable接口
C.实现Thread接口
D.以上都不正确

解析：
AB.
多线程一共有三种实现方式
方式1：继承Thread类，并重写run()方法
方式2：实现Runnable接口，实现run()方法
方式3：实现Callable接口，线程结束后可以有返回值，但是该方式是依赖于线程池的。

16.在Jdk1.7中，下述说法中抽象类与接口的区别与联系正确的有哪些？（ABCD）
A.抽象类中可以有普通成员变量，接口中没有普通成员变量。
B.抽象类和接口中都可以包含静态成员常量。
C.一个类可以实现多个接口，但只能继承一个抽象类
D.抽象类中可以包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法。

解析：
总结一下

一个子类只能继承一个抽象类,但能实现多个接口

抽象类可以有构造方法,接口没有构造方法

抽象类可以有普通成员变量,接口没有普通成员变量

抽象类和接口都可有静态成员变量,抽象类中静态成员变量访问类型任意,接口只能public static final(默认)

抽象类可以没有抽象方法,抽象类可以有普通方法,接口中都是抽象方法

抽象类可以有静态方法,接口不能有静态方法

抽象类中的方法可以是public、protected;接口方法只有public

17.根据下面这个程序的内容，判断哪些描述是正确的：（CD ）
public class Test {
public static void main(String args[]) {
String s = “tommy”;
Object o = s;
sayHello(o); //语句1
sayHello(s); //语句2
}
public static void sayHello(String to) {
System.out.println(String.format(“Hello, %s”, to));
}
public static void sayHello(Object to) {
System.out.println(String.format(“Welcome, %s”, to));
}
}
A.这段程序有编译错误
B.语句1输出为:Hello, tommy
C.语句2输出为:Hello, tommy
D.语句1输出为:Welcome, tommy
E.语句2输出为:Welcome, tommy
F.根据选用的Java编译器不同，这段程序的输出可能不同

18.Java特性中,abstract class和interface有什么区别（ABD）
A.抽象类可以有构造方法，接口中不能有构造方法
B.抽象类中可以有普通成员变量，接口中没有普通成员变量
C.抽象类中不可以包含静态方法，接口中可以包含静态方法
D.一个类可以实现多个接口，但只能继承一个抽象类。

解析：
接口中的成员变量被隐式的声明为public static final ，jdk1.8后接口中可以有静态方法而且存在方法体

19.关于下面代码片段叙述正确的是（C）
代码片段：
byte b1=1,b2=2,b3,b6;
final byte b4=4,b5=6;
b6=b4+b5;
b3=(b1+b2);
System.out.println(b3+b6);
A.输出结果：13
B.语句：b6=b4+b5编译出错
C.语句：b3=b1+b2编译出错
D.运行期抛出异常

解析：
C.被final修饰的变量是常量，这里的b6=b4+b5可以看成是b6=10；在编译时就已经变为b6=10了。而b1和b2是byte类型，java中进行计算时候将他们提升为int类型，再进行计算，b1+b2计算后已经是int类型，赋值给b3，b3是byte类型，类型不匹配，编译不会通过，需要进行强制转换。Java中的byte，short，char进行计算时都会提升为int类型。

20.下列那些方法是线程安全的(所调用的方法都存在)（ACD）
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);
}
答案：
A C D

解析：
A：没有成员（没有共享资源），线程安全；
B：假设存在线程1和线程2，count初始值为0，当线程1执行count++中count+1（此时未写回最终计算值），这时线程2执行count++中读取count，发生数据错误，导致线程1线程2的结果都为1，而不是线程1的结果为1，线程2的结果为2，线程不安全；
C：成员私有，对成员的set get方法都加重量级锁，线程安全；D：volatile有两个作用：可见性（volatile变量的改变能使其他线程立即可见，但它不是线程安全的，参考B）和禁止重排序；这里是可见性的应用，类中方法对volatile修饰的变量只有赋值，线程安全；欢迎指正。

Java （五）

1.以下关于Integer与int的区别错误的是？（D）
A.int是java提供的8种原始数据类型之一
B.Integer是java为int提供的封装类
C.int的默认值为0
D.Integer的默认值为1

2.给定以下方法声明，调用执行mystery（1234）的输出结果？（B）
//precondition: x >=0
public void mystery (int x)
{
System.out.print(x % 10);

if ((x / 10) != 0)
{
mystery(x / 10);
}
System.out.print(x % 10);
}
A.1441
B.43211234
C.3443
D.12344321

解析：
递归调用

3.下面不是类及类成员的访问控制符的是(C )。（不考虑内部类的情况）
A.public
B.private
C.static
D.protected
解析：
访问权限控制符：public ，private， protected ，default

4.下列修饰符中与访问控制权限无关的是？（D ）
A.private
B.public
C.protected
D.final

解析：
private : 修饰私有变量
public : 修饰公有变量
protected: 修饰受保护变量
没有final, final用于保护变量不受改变

5.局部变量能否和成员变量重名？（A）
A.可以，局部变量可以与成员变量重名，这时可用“this”来指向成员变量
B.可以，这时可用“local”关键字来指向局部变量
C.不能，局部变量不能与成员变量重名
D.不能，在一个类中不能有重名变量，不管是成员变量还是函数中的局部变量

解析：
JAVA访问变量采用就近原则，局部变量与成员变量重名时，局部变量比较近，使用局部变量

6.下列说法正确的是(B)
A.在类方法中可用this来调用本类的类方法
B.在类方法中调用本类的类方法可直接调用
C.在类方法中只能调用本类的类方法
D.在类方法中绝对不能调用实例方法

解析：
在类方法中调用本类的类方法可直接调用。实例方法也叫做对象方法。
类方法是属于整个类的，而实例方法是属于类的某个对象的。
由于类方法是属于整个类的，并不属于类的哪个对象，所以类方法的方法体中不能有与类的对象有关的内容。即类方法体有如下限制：
(1) 类方法中不能引用对象变量；
(2) 类方法中不能调用类的对象方法；
(3) 在类方法中不能使用super、this关键字。
(4)类方法不能被覆盖。
如果违反这些限制，就会导致程序编译错误。
与类方法相比，对象方法几乎没有什么限制：
(1) 对象方法中可以引用对象变量，也可以引用类变量；
(2) 对象方法中可以调用类方法；
(3) 对象方法中可以使用super、this关键字。

7.关于依赖注入，下列选项中说法错误的是（C）？
A.依赖注入能够独立开发各组件，然后根据组件间关系进行组装
B.依赖注入提供使用接口编程
C.依赖注入使组件之间相互依赖，相互制约
D.依赖注入指对象在使用时动态注入

解析：
依赖注入目的是减少组件之间的耦合度，使开发变得简单。

8.运行下面代码，输出的结果是（A）
class A {
public A() {
System.out.println(“class A”);
}
{ System.out.println(“I’m A class”); }
static { System.out.println(“class A static”); }
}
public class B extends A {
public B() {
System.out.println(“class B”);
}
{ System.out.println(“I’m B class”); }
static { System.out.println(“class B static”); }
public static void main(String[] args) {
new B();
}
}
A.

class A static
class B static
I’m A class
class A
I’m B class
class B
B.

class A static
I’m A class
class A
class B static
I’m B class
class B
C.

class A static
class B static
class A
I’m A class
class B
I’m B class
D.

class A static
class A
I’m A class
class B static
class B
I’m B class
解析：
此题考虑 Java 中构造器、初始化块、静态初始化块的执行顺序。

静态初始化块 > 初始化块 > 构造器
父类 > 子类
综合下来顺序就是：

父类静态初始化块
子类静态初始化块
父类初始化块
父类构造器
子类初始化块
子类构造器
需要注意静态初始化块是在类第一次加载的时候就会进行初始化。

9.下面哪个标识符是合法的？（D）
A.“9HelloWorld”
B."_Hello World"
C.“Hello*World”
D.“Hell$World”

解析：
标识符是以字母开头的字母数字序列：
数字是指0~9，字母指大小写英文字母、下划线（_)和美元符号（World"∗∗答案：∗∗D∗∗解析：∗∗标识符是以字母开头的字母数字序列：数字是指0 9，字母指大小写英文字母、下划线（)和美元符号（），也可以是Unicode字符集中的字符，如汉字；
字母、数字等字符的任意组合，不能包含+、- 等字符；不能使用关键字；大小写敏感由此可以看出：A：不可以数字开头 B：用下划线开头符合，但是中间有空格 C:不能包含*
排除ABC，答案即是D

10.以下程序执行的结果是：（C）
class X{
Y y=new Y();
public X(){
System.out.print(“X”);
}
}
class Y{
public Y(){
System.out.print(“Y”);
}
}
public class Z extends X{
Y y=new Y();
public Z(){
System.out.print(“Z”);
}
public static void main(String[] args) {
new Z();
}
}
A.ZYXX
B.ZYXY
C.YXYZ
D.XYZX

解析：
1.父类静态代码块（java虚拟机加载类时，就会执行该块代码，故只执行一次）
2 .子类静态代码块（java虚拟机加载类时，就会执行该块代码，故只执行一次）

父类属性对象初始化
4.父类普通代码块（每次new,每次执行）

父类构造函数（每次new,每次执行）
6.子类属性对象初始化
7.子类普通代码块（每次new,每次执行）
8.子类构造函数（每次new,每次执行）

11.以下声明合法的是（B）
A.default String s
B.public final static native int w( )
C.abstract double d
D.abstract final double hyperbolicCosine( )

解析：
A：java的访问权限有public、protected、private和default的，default不能修饰变量
C：普通变量不能用abstract修饰，abstract一般修饰方法和类
D：被定义为abstract的类需要被子类继承，但是被修饰为final的类是不能被继承和改写的心存疑问可以实验一下，看是否能通过编译.

12.java用（D）机制实现了进程之间的同步执行
A.虚拟机
B.多个CPU
C.异步调用
D.监视器

解析：
同步执行，需要监视器，即锁。

13.What is displayed when the following is executed;（A）
double d1=-0.5;
System.out.println(“Ceil d1=”+Math.ceil(d1));
System.out.println(“floor d1=”+Math.floor(d1));
A.Ceil d1=-0.0 floor d1=-1.0
B.Ceil d1=0.0 floor d1=-1.0
C.Ceil d1=-0.0 floor d1=-0.0
D.Ceil d1=0.0 floor d1=0.0
E.Ceil d1=0 floor d1=-1

解析：

14.有关下述Java代码描述正确的选项是_F_。
public class TestClass {
private static void testMethod(){
System.out.println(“testMethod”);
}
public static void main(String[] args) {
((TestClass)null).testMethod();
}
}
A.编译不通过
B.编译通过，运行异常，报NullPointerException
C.编译通过，运行异常，报IllegalArgumentException
D.编译通过，运行异常，报NoSuchMethodException
E.编译通过，运行异常，报Exception
F.运行正常，输出testMethod

解析：
1）此处是类对方法的调用，不是对象对方法的调用。
2）方法是static静态方法，直接使用"类.方法"即可，因为静态方法使用不依赖对象是否被创建。null可以被强制类型转换成任意类型（不是任意类型对象），于是可以通过它来执行静态方法。
3）非静态的方法用"对象.方法"的方式，必须依赖对象被创建后才能使用，若将testMethod()方法前的static去掉，则会报空指针异常。此处也验证了2）的观点
当然，不管是否静态方法，都是已经存在的，只是访问方式不同。

15.下面哪些具体实现类可以用于存储键，值对，并且方法调用提供了基本的多线程安全支持：(AE)
A.java.util.ConcurrentHashMap
B.java.util.Map
C.java.util.TreeMap
D.java.util.SortMap
E.java.util.Hashtable
F.java.util.HashMap

解析：

ConcurrentHashMap简称CHM,CHM 允许并发的读和线程安全的更新操作。在执行写操作时，CHM 只锁住部分的 Map，并发的更新是通过内部根据并发级别将 Map 分割成小部分实现的，高的并发级别会造成时间和空间的浪费，低的并发级别在写线程多时会引起线程间的竞争，CHM 的所有操作都是线程安全，CHM 返回的迭代器是弱一致性， fail-safe 并且不会抛出ConcurrentModificationException 异常，CHM不允许null的键值。可以使用 CHM 代替 HashTable，但要记住 CHM 不会锁住整个 Map

除了Hashtable，其他是非线性安全的。

16.JavaWEB中有一个类，当会话种邦定了属性或者删除了属性时，他会得到通知，这个类是：( A)
A.HttpSessionAttributeListener
B.HttpSessionBindingListener
C.HttpSessionObjectListener
D.HttpSessionListener;
E.HttpSession
F.HttpSessionActivationListener

解析：
HttpSessionAttributeListener：可以实现此侦听器接口获取此web应用程序中会话属性列表更改的通知；
HttpSessionBindingListener：当该对象从一个会话中被绑定或者解绑时通知该对象，这个对象由HttpSessionBindingEvent对象通知。这可能是servlet程序显式地从会话中解绑定属性的结果，可能是由于会话无效，也可能是由于会话超时；
HttpSessionObjectListener：没有该接口API；
HttpSessionListener：当web应用程序中的活动会话列表发生更改时通知该接口的实现类，为了接收该通知事件，必须在web应用程序的部署描述符中配置实现类；
HttpSessionActivationListener：绑定到会话的对象可以侦听容器事件，通知它们会话将被钝化，会话将被激活。需要一个在虚拟机之间迁移会话或持久会话的容器来通知所有绑定到实现该接口会话的属性。

17.在java中重写方法应遵循规则的包括（BC）
A.访问修饰符的限制一定要大于被重写方法的访问修饰符
B.可以有不同的访问修饰符
C.参数列表必须完全与被重写的方法相同
D.必须具有不同的参数列表

答案：
B C

解析：
方法重写

参数列表必须完全与被重写方法的相同；

返回类型必须完全与被重写方法的返回类型相同；

访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。

父类的成员方法只能被它的子类重写。

声明为final的方法不能被重写。

声明为static的方法不能被重写，但是能够被再次声明。

子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。

子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。

重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。

构造方法不能被重写。

如果不能继承一个方法，则不能重写这个方法。
方法重载

被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；

被重载的方法可以改变返回类型；

被重载的方法可以改变访问修饰符；

被重载的方法可以声明新的或更广的检查异常；

方法能够在同一个类中或者在一个子类中被重载。

无法以返回值类型作为重载函数的区分标准。

18.What might cause the current thread to stop or pause executing(ABE)
A.An InterruptedException is thrown. //抛出异常
B.The thread executes a wait() call.//线程执行出现等待
C.The thread constructs a new Thread.//有一个新的线程出现
D.A thread of higher priority becomes ready. //更高级的线程在准备
E.The thread executes a waitforID()call on a MediaTracker. //在等待

19.下列说法错误的有（ABCD ）
A.Java面向对象语言容许单独的过程与函数存在
B.Java面向对象语言容许单独的方法存在
C.Java语言中的非静态方法属于类中的成员（member）
D.Java语言中的方法必定隶属于某一类（对象），调用方法与C语言的过程或C++语言的函数相同

解析：
Java的静态方法属于类的成员，实例方法属于对象的成员。

20.下列流当中，属于处理流的是：（CD）
A.FilelnputStream
B.lnputStream
C.DatalnputStream
D.BufferedlnputStream

解析：
此题考察对于java流的理解
节点流是实际工作的流，
处理流（我们叫包装流可能容易理解一点）设计的目的是让对流中数据的操作，转化成我们能更简单明了的看懂的数据（而不是二进制的字节等）的操作，但实际上增加了很多类，是io流变的更复杂
字节流必是一个接点流，字符流就是一个操作流
使用时，必须是有一个结点流，然后才能用操作流来包装结点流，即把结点流当参数传个操作流

Java（六）

1.在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数个数、类型或顺序各不相同，传回的值也可以不相同。这种面向对象程序的特性称为?（C）
A.隐藏
B.覆盖
C.重载
D.Java不支持此特性

2.编译 Java 源程序文件产生的字节码文件的扩展名为（B）？
A.java
B.class
C.html
D.exe

3.以下程序的运行结果是（B）？
public class Increment
{
public static void main(String args[])
{
int a;
a = 6;
System.out.print(a);
System.out.print(a++);
System.out.print(a);
}
}
A.666
B.667
C.677
D.676

解析：
a++很好记的，表示先用后+，而++a表示先+后用。看+在前在后，也决定第一步。

4.有以下程序片段且Interesting不是内部类，下列哪个选项不能插入到行1。（ D）
1.
2.public class Interesting{
3. // 省略代码
4.}
A.import java.awt.*;
B.package mypackage;
C.class OtherClass{ }
D.public class MyClass{ }

解析：
在同一个java原文件中，可以有多个class类，但是只有有一个公共的 public class

5.Math.round(11.5) 等于多少 (). Math.round(-11.5) 等于多少 ( C)?
A.11 ,-11
B.11 ,-12
C.12 ,-11
D.12 ,-12

解析：

floor:意为地板，指向下取整，返回不大于它的最大整数

ceil:意为天花板，指向上取整，返回不小于它的最小整数

round:意为大约，表示“四舍五入”，而四舍五入是往大数方向入。

Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11而不是-12。

6.一个以“.java”为后缀的源文件（C）
A.只能包含一个public类，类名必须与文件名相同
B.只能包含与文件名相同的public类以及其中的内部类
C.只能有一个与文件名相同的public类，可以包含其他非public类（不考虑内部类）
D.可以包含任意public类

解析：
.java文件可以包含多个类，唯一的限制就是：一个文件中只能有一个public类，并且此public类必须与文件名相同。而且这些类和写在多个文件中没有区别。

解析：
1.Float是类，float不是类.
2.查看JDK源码就可以发现Byte，Character，Short，Integer，Long，Float，Double，Boolean都在java.lang包中.
3.Float正确复制方式是Float f=1.0f,若不加f会被识别成double型,double无法向float隐式转换.
4.Float a= new Float(1.0)是正确的赋值方法，但是在1.5及以上版本引入自动装箱拆箱后，会提示这是不必要的装箱的警告，通常直接使用Float f=1.0f.

8.子类要调用继承自父类的方法，必须使用super关键字。（B）
A.正确
B.错误

解析：
1、子类构造函数调用父类构造函数用super
2、子类重写父类方法后，若想调用父类中被重写的方法，用super
3、未被重写的方法可以直接调用。

9.下列属于容器的组件有（B）？
A.JButton
B.JPanel
C.Thread
D.JTextArea

解析：
JPanel是Java图形用户界面（GUI）工具包中的面板容器类，包含在javax.swing包中，是一种轻量级容器，可以加入到JFrame窗体中。JPanel默认的布局管理器是FlowLayout，其自身可以嵌套组合，在不同子容器中可包含其他组件(component),如JButton、JTextArea、JTextField等，功能是对对窗体上的这些控件进行组合，相当于C++和C#中的Panel类。

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

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

11.正则表达式中，表示匹配非数字字符的字符是（D）？
A.\b
B.\d
C.\B
D.\D

解析：
大写表示“非”，d表示digit数字。非数字就是\D, w表示word，非单词就是\W

12.对于以下代码段，4个输出语句中输出true的个数是( C )。
class A{}
class B extends A{}
class C extends A{}
class D extends B{}
A obj = new D();
System.out.println(obj instanceof B);
System.out.println(obj instanceof C);
System.out.println(obj instanceof D);
System.out.println(obj instanceof A);
A.1
B.2
C.3
D.4

解析：
D属于B,D属于A,D属于D,D不属于C.所以选C

13.在Java中，HashMap中是用哪些方法来解决哈希冲突的？（C）
A.开放地址法
B.二次哈希法
C.链地址法
D.建立一个公共溢出区

解析：
以上方法都是解决哈希填冲突的策略，但是在java.util.HashMap中，总体来说是使用的链地址法来解决冲突的。
当然了，使用链地址法会导致get的效率从o（1）降至o（n），所以在Java8中，使用的是平衡树来解决提高效率的。

14.、关于匿名内部类叙述正确的是？( B)
A.匿名内部类可以继承一个基类，不可以实现一个接口
B.匿名内部类不可以定义构造器
C.匿名内部类不能用于形参
D.以上说法都不正确

解析：
由于构造器的名字必须与类名相同，而匿名类没有类名，所以匿名类不能有构造器。

15.下下面哪一项不是加载驱动程序的方法？（A）
A.通过DriverManager.getConnection方法加载
B.调用方法 Class.forName
C.通过添加系统的jdbc.drivers属性
D.通过registerDriver方法注册

解析：
DriverManager.getConnection方法返回一个Connection对象，这是加载驱动之后才能进行的

16.关于以下代码的说明，正确的是（C）？
1． class StaticStuff
2． {
3． static int x=10；
4． static { x+=5；}
5． public static void main（String args[ ]）
6． {
7． System.out.println(“x=” + x);
8． }
9． static { x/=3;}
10. }
A.4行与9行不能通过编译，因为缺少方法名和返回类型
B.9行不能通过编译，因为只能有一个静态初始化器
C.编译通过，执行结果为：x=5
D.编译通过，执行结果为：x=3

解析：

先执行：
1 static int x = 10；
再执行两个静态块：
1 static { x+=5; }
2 static { x/=3; }
最后执行main()：
1 System.out.println(“x=” + x);

所以x = 10 -> x = x +5 = 15 -> x = x / 3 = 5 打印x=5

17.以下集合对象中哪几个是线程安全的（CD）？
A.LinkedList
B.ArrayList
C.Vector
D.Hashtable

解析：

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

18.下面哪些可能是重载的基本条件（ABD）（注意：是可能为重载的基本条件）
A.参数的类型不同
B.参数的顺序不同
C.函数的返回值类型不同
D.参数的个数不同

解析：

重载的概念是：
方法名称相同，参数个数、次序、类型不同
因此重载对返回值没有要求，可以相同，也可以不同
但是如果参数的个数、类型、次序都相同，方法名也相同，仅返回值不同，则无法构成重载

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

解析：
类的加载是由类加载器完成的，类加载器包括：根加载器(BootStrap)、扩展加载器(Extension)、系统加载器(System)和用户自定义类加载器（ java.lang.ClassLoader 的子类）。从 Java 2 (JDK 1.2)开始，类加载过程采取了父亲委托机制（ PDM ）。PDM 更好的保证了 Java 平台的安全性，在该机制中， JVM 自带的 Bootstrap 是根加载器，其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载，父类加载器无能为力时才由其子类加载器自行加载。JVM 不会向 Java 程序提供对 Bootstrap 的引用。下面是关于几个类加载器的说明：

Bootstrap ：一般用本地代码实现，负责加载 JVM 基础核心类库（ rt.jar ）；

Extension ：从 java.ext.dirs 系统属性所指定的目录中加载类库，它的父加载器是 Bootstrap ；

system class loader：又叫应用类加载器，其父类是Extension。它是应用最广泛的类加载器。它从环境变量 classpath 或者系统属性 java.class.path 所指定的目录中记载类，是用户自定义加载器的默认父加载器。
用户自定义类加载器：java.lang.ClassLoader 的子类
-父类委托机制是可以修改的，有些服务器就是自定义类加载器优先的。

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

解析：
A:Java中所有错误和异常的父类是java.lang.Throwable
B：基本数据类型不是对象，不能用new的方法获取，但是每个基本数据类型都对应着封装类型，这些封装类型为了解决基本数据类型面向对象用的。
C:Java垃圾回收器负责回收无用对象占据的内存资源,但对象没有使用new获取了一块特殊区域，这块特殊区域的回收使用finallize（）
D：Java跨平台是因为有JVM的存在，Java的三个版本的运行需要各自不同的环境。

Java（七）

1.下列程序执行后结果为(A )?
class A {
public int func1(int a, int b) {
return a - b;
}
}
class B extends A {
public int func1(int a, int b) {
return a + b;
}
}
public class ChildClass {
public static void main(String[] args) {
A a = new B();
B b = new B();
System.out.println(“Result=” + a.func1(100, 50));
System.out.println(“Result=” + b.func1(100, 50));
}
}
A.Result=150Result=150
B.Result=100Result=100
C.Result=100Result=150
D.Result=150Result=100

解析：
其实很简单，涉及转型的题目，分为向上或者向下转型。
关键的来了，不论向上或者向下转型，都是一句话，“编译看左边，运行看右边”。也就是编译时候，会看左边引用类型是否能正确编译通过，运行的时候是调用右边的对象的方法。就本题来说，编译时候会发现左边满足条件所以编译通过，运行时候又会调用右边也就是 class B 的方法，所以答案都是150。

2.下列哪个类的声明是正确的？(B）
A.protected private number;
B.public abstract class Car{}
C.abstract private move(){}
D.abstract final class HI{}

解析：
抽象类的目的就是为了让子类实现他本身的方法
final修饰的东西不能被更改或继承
abstract存在的意义是为了让子类实现方法而存在，final的意义是不让子类进行修改。两者存在互斥关系

3.关于抽象类叙述正确的是？( B)
A.抽象类不能实现接口
B.抽象类必须有“abstract class”修饰
C.抽象类必须包含抽象方法
D.抽象类也有类的特性，可以被实例化

解析：
A.抽象类是可以实现接口的，而且抽象类也可以继承自抽象类
B.对
C.抽象类指有abstract修饰的class，其可以包含抽象方法，也可以不包含
D.抽象类和接口都是不能被实例化的，只有具体的类才可以被实例化

4.若有定义语句：int a=10 ; double b=3.14 ; 则表达式 ‘A’+a+b 值的类型是（C）
A.char
B.int
C.double
D.float

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

5.When is the text “Hi there”displayed?（C）
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.

解析：
类中静态语句块仅在类加载时被执行一次

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

解析：
泛型仅仅是java的一颗语法糖，它不会影响java虚拟机生成的汇编代码，在编译阶段，虚拟机就会把泛型的类型擦除，还原成没有泛型的代码，顶多编译速度稍微慢一些，执行速度是完全没有什么区别的。

7.以下说法中正确的有？（AD）
A.StringBuilder是线程不安全的
B.Java类可以同时用 abstract和final声明
C.HashMap中，使用 get(key)==null可以判断这个Hasmap是否包含这个key
D.volatile关键字不保证对变量操作的原子性

解析：
String最慢的原因：
String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是可以更改的。
String：适用于少量的字符串操作的情况
StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况
在线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的

8.下面关于Java package的描述，哪个是正确的:（B）
A.包不提供将所有类名分区为更易管理的块的机制.
B.包提供可见性控制机制.
C.包的一个重要属性是包内定义的所有类都可以通过该包外的代码访问
D.声明为包的一部分的类的.class文件可以存储在多个目录中.

解析：

包的作用:
1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
Java使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

9.下面代码执行后的结果为（ C）？
nt main()
{
int sum=0;
int i=0,j=0;
for(j=0;j<6;j++)
{
if(j%2)continue;
sum++;
}
printf(“sum=%d”,sum);
return 0;
}
A.sum=1
B.sum=2
C.sum=3
D.其他几项都不对

解析：
吐槽点：1.Java题出现C语言的题目。2.定义变量i 等等（既然出现在360大厂的笔试题中，那么我们抛开吐槽点，我们来看下这道题的考点。）
考点：
1.continue:continue语句的作用是跳过本次循环体中余下尚未执行的语句，立即进行下一次的循环条件判定，可以理解为仅结束本次循环。
2.if(j%2)（包含：if以及取模运算）：也就是求j除以2的余数（取模），if(j%3)判断j对3取余以后是否为0，如果不是0，执行if下面的语句,
如果是0，执行另外的语句(例如else下面的语句)
做题：
1.j=0,0%2=0 sum=1
2.j=1,1%2=1 sum=1
3.j=2,2%2=0 sum=2
4.j=3,3%2=1 sum=2
5.j=4,4%2=0 sum=3
6.j=5,5%2=1 sum=3

10.、关于static说法不正确的是（ D）？
A.可以直接用类名来访问类中静态方法(public权限)
B.静态块仅在类加载时执行一次
C.static方法中不能有用this调用的方法
D.不可以用对象名来访问类中的静态方法(public权限)

解析：
this表示当前类的对象，由static修饰的方法是由类直接调用，不需要创建对象，所以在static里不能用this.

11.访问权限控制从最大权限到最小权限依次为：public、包访问权限、protected和private （B）？
A.正确
B.错误

解析：
应该是：public>protected>默认(包访问权限)>private，因为protected除了可以被同一包访问，还可以被包外的子类所访问

12.函数（C）把文件位置重定位到文件中的指定位置
A.fseek
B.fread
C.fopen
D.fgets

13.关于spring说法错误的是（D）？
A.spring是一个轻量级JAVA EE的框架集合
B.spring是“依赖注入”模式的实现
C.使用spring可以实现声明事务
D.spring提供了AOP方式的日志系统

解析：
spring没有提供AOP方式的日志系统
AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。
Spring通过对AOP的支持，借助log4j等Apache开源组件实现了日志系统。

14.、以下JAVA程序代码的输出是?（B）
public static void main(String args[]) {
System.out.println(14^3);
}
A.2744
B.13
C.17
D.11

答案：
B

解析：
位运算中的异或运算，将14和3分别表示成二进制，即1110和0011做异或。得出结果为1101，转成十进制即为13

15.下列哪一项的实现不可以添加为 TextField 对象的监听器（C）？
A.MouseMotionListener
B.FocusListener
C.WindowsListener
D.ActionListener

解析：
SWinng的内容。
在单行文本输入区(Textfield)构件上可能发生的事件包括FocusEvent焦点事件，所对应的事件监听器是FocusListener；ActionEvent动作事件，所对应的事件监听器是ActionListener；MouseEvent鼠标事件，所对应的事件监听器是MouseMotionListener；

16、 jre 判断程序是否执行结束的标准是（A）？
A.所有的前台线程执行完毕
B.所有的后台线程执行完毕
C.所有的线程执行完毕
D.和以上都无关

解析：
后台线程：指为其他线程提供服务的线程，也称为守护线程。JVM的垃圾回收线程就是一个后台线程。
前台线程：是指接受后台线程服务的线程，其实前台后台线程是联系在一起，就像傀儡和幕后操纵者一样的关系。傀儡是前台线程、幕后操纵者是后台线程。由前台线程创建的线程默认也是前台线程。可以通过isDaemon()和setDaemon()方法来判断和设置一个线程是否为后台线程。

17.根据下面的代码，String s = null;会抛出NullPointerException异常的有（AC）。
A.if( (s!=null) & (s.length()>0) )
B.if( (s!=null) && (s.length()>0) )
C.if( (s==null) | (s.length()0) )
D.if( (snull) || (s.length()==0) )

解析：

逻辑运算符：&&和|| 是按照“短路”方式求值的。如果第一个操作数已经能够确定表达式的值，第二个操作数就不必计算了
位移运算符：&和| 运算符应用于布尔值，得到的结果也是布尔值，不按“短路”方式计算。即在得到计算结果之前，一定要计算两个操作数的值。

18.A,B,C,D 中哪些是 setvar的重载？（ACD）
public class methodover
{
public void setVar(int a, int b, float c) {}
}
A.private void setVar(int a， float c， int b){}
B.protected void setVar(int a， int b， float c){}
C.public int setVar(int a， float c， int b){return a;}
D.public int setVar(int a， float c){return a;}

解析：
重载是在同一个类中，有多个方法名相同，参数列表不同(参数个数不同，参数类型不同),与方法的返回值无关，与权限修饰符无关，B中的参数列表和题目的方法完全一样了。

19.下面有关java的引用类型，说法正确的有？
A.对于一个对象来说，只要有强引用的存在，它就会一直存在于内存中
B.如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
C.如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存
D.一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的空间

答案：
A B C D

解析：
1、强引用：一个对象赋给一个引用就是强引用，比如new一个对象，一个对象被赋值一个对象。
2、软引用：用SoftReference类实现，一般不会轻易回收，只有内存不够才会回收。
3、弱引用：用WeekReference类实现，一旦垃圾回收已启动，就会回收。
4、虚引用：不能单独存在，必须和引用队列联合使用。主要作用是跟踪对象被回收的状态。

20.以下类型为Final类型的为（BC）？
A.HashMap
B.StringBuffer
C.String
D.Hashtable

解析：
StringBuilder , StringBuffer ,String都是 final

Java(八）

以下关于构造函数的描述错误的是（）
A.每个类有且只能有一个构造函数。
B.构造函数是类的一种特殊函数，它的方法名必须与类名相同
C.构造函数的主要作用是完成对类的对象的初始化工作
D.一般在创建新对象时，系统会自动调用构造函数

答案： A

解析：
类除了无参构造方法，还有有参构造方法，有参构造方法还可以通过重载写出多参的构造方法（2参，3参，4参）
方法重载：同一个类中方法名称相同，而参数的类型或个数不同

2.在面向对象编程里，经常使用is-a来说明对象之间的继承关系，下列对象中不具备继承关系的是？
A.手机与小米手机
B.企业家与雷军
C.编程语言与Java
D.中国与北京

答案： D
解析：
小米手机是一个手机/雷军是一个企业家/java是一个编程语言/北京是一个中国吗？

3.以下程序运行后的输出结果是（）?
main()
{
int m=12,n=34;

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

printf("%d%d\n",n++,++m);
}
A.12353514
B.12353513
C.12343514
D.12343513

答案： A
解析： >m++ 先输出在自加，++m 先自加在输出

4.下列关于功能性注释不正确的说法是()?
A.功能性注释嵌在源程序中，用于说明程序段或语句的功能以及数据的状态
B.注释用来说明程序段，需要在每一行都要加注释
C.可使用空行或缩进，以便很容易区分注释和程序
D.修改程序也应修改注释

答案： B
解析：略

5.下面有关java和c++的描述，错误的是？
A.java是一次编写多处运行，c++是一次编写多处编译
B.c++和java支持多继承
C.Java不支持操作符重载，操作符重载被认为是c++的突出特征
D.java没有函数指针机制，c++支持函数指针

答案： B
解析：
JAVA没有指针的概念，被封装起来了，而C++有;JAVA不支持类的多继承，但支持接口多继承，C++支持类的多继承;C++支持操作符重载，JAVA不支持;JAVA的内存管理比C++方便，而且错误处理也比较好;C++的速度比JAVA快。
C++更适用于有运行效率要求的情况，JAVA适用于效率要求不高，但维护性要好的情况。

6.应用程序的main方法中有以下语句，则输出的结果( )
String s1=new String（ ” xyz ” ）;
String s2=new String（ ” xyz ” ）;
Boolean b1=s1.equals(s2);
Boolean b2=(s1==s2);
System .out.print(b1+ ” ” +b2);
A.true false
B.false true
C.true true
D.false false

答案： A
解析： >
String s1=new String（ ” xyz ” ）; //创建了String类型的内容为xyz的s1对象
String s2=new String（ ” xyz ” ）; //创建了String类型的内容为xyz的s2对象
Boolean b1=s1.equals(s2); //比较s1对象和s2对象的内容相等，返回true。
Boolean b2=(s1==s2); //比较s1和s2两个对象的存储地址是否相等，明显两者分别存储在不同的地址，所以返回：false。
故答案为：true false

7.执行如下程序，输出结果是（）?
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
解析：

Test mv =newTest()声明并初始化对data赋默认值
使用synchronized关键字加同步锁线程依次操作m()
t1.start();使得result=2,data=2,输出即为2 2
t2.start();使得result=4,data=4,输出即为4 4
t3.start();使得result=6,data=6,输出即为6 6
System.out.print(result +" "+ data);是print()方法不会换行,输出结果为2 24 46 6

在 main() 方法中给出的字节数组，如果将其显示到控制台上，需要（）。
A.标准输出流System.out.println()。
B.建立字节输出流。
C.建立字节输入流。
D.标准输入流System.in.read()。

答案： A
解析：略

9.假设num已经被创建为一个ArrayList对象，并且最初包含以下整数值：[0，0，4，2，5，0，3，0]。执行下面的方法numQuest(),最终的输出结果是什么？
private List nums;

//precondition: nums.size() > 0
//nums contains Integer objects
public void numQuest() {
int k = 0;
Integer zero = new Integer(0);
while (k < nums.size()) {
if (nums.get(k).equals(zero))
nums.remove(k);
k++;
}
}
A.[3, 5, 2, 4, 0, 0, 0, 0]
B.[0, 0, 0, 0, 4, 2, 5, 3]
C.[0, 0, 4, 2, 5, 0, 3, 0]
D.[0, 4, 2, 5, 3]

答案： D
解析：略，一步一步来就能算出

10.以下哪一个正则表达式不能与字符串“https://www.tensorflow.org/”（不含引号）匹配？（）
A.[a-z]+://[a-z.]+/
B.https[