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
//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类必须与文件名相同。而且这些类和写在多个文件中没有区别。
7.关于Float，下列说法错误的是© ？
A.Float是一个类
B.Float在java.lang包中
C.Float a=1.0是正确的赋值方法
D.Float a= new Float(1.0)是正确的赋值方法
解析：
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[/]www[.]tensorflow[.]org[/]
C.[htps]+://www.tensorflow.org/
D.[a-zA-Z.]+
答案： B
解析： >
[/],这是个很明显的陷阱。[ ] 里面是不重复的，所以等价于[]
如果[ ]后面没有带+号的话，是不会贪婪匹配的，就只能匹配到://中的其中一个
11.关于sleep和wait,以下描述错误的是？
A.sleep是线程类的方法，wait是object的方法
B.sleep不释放对象锁，wait放弃对象锁
C.sleep暂停线程，但监控状态依然保持，结束后会自动恢复
D.wait进入等待锁定池，只有针对此对象发出notify方法获得对象锁进入运行状态
答案： D
解析：
D选项最终是进入就绪状态，而不是运行状态。
12.以下描述正确的是
A.CallableStatement是PreparedStatement的父接口
B.PreparedStatement是CallableStatement的父接口
C.CallableStatement是Statement的父接口
D.PreparedStatement是Statement的父接口
答案： B
解析：
CallableStatement继承自PreparedSatement，PreparedStatement继承自Statement
13.volatile关键字的说法错误的是
A.能保证线程安全
B.volatile关键字用在多线程同步中，可保证读取的可见性
C.JVM保证从主内存加载到线程工作内存的值是最新的
D.volatile能禁止进行指令重排序
答案： A
解析：
出于运行速率的考虑，java编译器会把经常经常访问的变量放到缓存（严格讲应该是工作内存）中，读取变量则从缓存中读。但是在多线程编程中,内存中的值和缓存中的值可能会出现不一致。volatile用于限定变量只能从内存中读取，保证对所有线程而言，值都是一致的。但是volatile不能保证原子性，也就不能保证线程安全。
14.以下表达式中，正确的是（）
A.byte i=128
B.boolean i=null
C.long i=0xfffL
D.double i=0.9239d
答案： C D
解析： null表示没有地址；null可以赋值给引用变量，不能将null赋给基本类型变量，例如int、double、float、boolean
15.常用的servlet包的名称是？
A.java.servlet
B.javax.servlet
C.servlet.http
D.javax.servlet.http
答案： B D
解析：
JEE5.0中的Servlet相关的就下面这几个包:
javax.servlet
javax.servlet.jsp
java.servlet.jsp.el
java.servlet.jsp.tagext
而最用得多的就是
javax.servlet
javax.servlet.http
这两个包了.
16.Java的体系结构包含（ ）。
A.Java编程语言
B.Java类文件格式
C.Java API
D.JVM
答案： A B C D
解析： 略
17.对于代码 var a = 10.42; 取出 a 的整数部分，以下代码哪些是正确的？
A.parseInt(a);
B.Math.floor(a);
C.Math.ceil(a);
D.a.split(’.’)[0];
答案： A B
解析： >Math.ceil(); ceiling（天花板） 所以向上取整
Math.floor();floor（地板）所以向下取整
split是对字符串的分割，而10.42编译器自动类型推断中应该是double类型的，所以d错误
18.判断一块内存空间是否符合垃圾收集器收集的标准有哪些？
A.给对象赋予了空值null,以下再没有调用过
B.对象重新分配了内存空间
C.给对象赋予了空值null
D.给对象赋予了新值
答案： A B D
解析：
在java语言中，判断一块内存空间是否符合垃圾收集器收集标准的标准只有两个：
1.给对象赋值为null，以下没有调用过。
2.给对象赋了新的值，重新分配了内存空间。
19.局部内部类可以用哪些修饰符修饰？
A.public
B.private
C.abstract
D.final
答案： C D
解析：
局部内部类是放在代码块或方法中的，不能有访问控制修饰符，且不能用static修饰
20.Java.Thread的方法resume()负责重新开始被以下哪个方法中断的线程的执行（）。
A.stop
B.sleep
C.wait
D.suspend
答案： D
解析：
suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的 resume() 被调用，才能使得线程重新进入可执行状态
Java（九）
1.下面所示的java代码，运行时，会产生（）类型的异常 ？
int Arry_a[] = new int[10];
System.out.println(Arry_a[10]);
A.ArithmeticException
B.NullPointException
C.IOException
D.ArrayIndexOutOfBoundsException
答案：
D
解析：
定义的数组长度为10，角标即为0-9,访问数组角标10会出现数组角标越界异常
2.下面关于继承的描述正确的是?
A.在Java中只允许单一继承
B.在Java中一个类只能实现一个接口
C.在Java中一个类不能同时继承一个类和实现一个接口
D.Java的单一继承使代码不可靠
答案：
A
解析：
略
- Java 源程序文件的扩展名为（）
A…java
B…class
C…exe
D…jar
答案：
A
解析：
略
4.Java 语言用以下哪个类来把基本类型数据封装为对象（）
A.包装类
B.Class
C.Math
D.Object
答案：
A
解析：
略
- 下列代码的执行结果是（）
public class Test {
public static int a = 1;
public static void main(String[] args) {
int a = 10;
a++; Test.a++;
Test t=new Test();
System.out.println(“a=” + a + " t.a=" + t.a);
}
}
A.a=10 t.a=3
B.a=11 t.a=2
C.a=12 t.a=1
D.a=11 t.a=1
答案：
B
解析：
值为1的a属于类变量也叫作成员变量，值为10的a是局部变量 首先a＋＋时就近原则，用局部变量10来加，Text.a直接用类名调用成员变量的情况，只能是static 修饰的成员变量1来加，然后又实例化了对象，在输出中第一个a＝ 用就近原则输出11，第二个t.a 对象只能调用类变量输出2
6.下面有关java classloader说法错误的是?
A.Java默认提供的三个ClassLoader是BootStrap ClassLoader，Extension ClassLoader，App ClassLoader
B.ClassLoader使用的是双亲委托模型来搜索类的
C.JVM在判定两个class是否相同时，只用判断类名相同即可，和类加载器无关
D.ClassLoader就是用来动态加载class文件到内存当中用的
答案：
C
解析：
JVM在判定两个class是否相同时，不仅要判断两个类名是否相同，而且要判断是否由同一个类加载器实例加载的。
7.以下那个数据结构是适用于"数据必须以相反的顺序存储然后检索" ? （）
A.Stack
B.Queue
C.List
D.Link List
答案：
A
解析：
栈-先进后出(比喻:坐电梯) 队列-先进先出(水管) list-链表(怎么存就怎么取)
- 在 main() 方法中给出的整型数组，如果将其写到一个文件中，需要（ ）。
A.System.out.print (buffer[i]);
B.DataOutputStream dout = new DataOutputStream(new FileOutputStream(this.filename));
C.DataInputStream din = new DataInputStream(new FileInputStream(this.filename));。
D.System.in.read(buffer)。
答案：
B
解析：
input和output指的是对于程序而言。input是从文件读取进来，output是输出到文件。
9.Please write the output result 。
public class Test
{
public static void changeStr(String str)
{
str = “welcome”;
}
public static void main(String[] args)
{
String str = “1234”;
changeStr(str);
System.out.println(str);
}
}
A.1234
B.welcome
C.空
D.不确定
答案：
A
解析：
string的值是不可改变的，所有试图更改String的行为都会创建一个新的String.
10.关于String，StringBuilder以及StringBuffer，描述错误的是（）
A.对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象
B.StringBuffer是线程安全
C.StringBuilder是线程安全
D.可以修改StringBuilder和StringBuffer的内容
答案：
C
解析：
A，java中的字符串存储在字符串常量区，不会改变，发生改变是会新创建一个对象
B，StringBuffer是线程安全的StringBuilder
C，StringBuilder跟StringBuffer功能相同，区别是StringBuilder不是线程安全的
D，StringBuilder和StringBuffer底层都是以字符数组存放的，可以修改内容
11.以下哪个不属于JVM堆内存中的区域（）？
A.survivor区
B.常量池
C.eden区
D.old区
答案：
B
解析：
jvm堆分为：新生代（一般是一个Eden区，两个Survivor区），老年代（old区）。
常量池属于 PermGen（方法区）
12.运行下面代码，输出的结果是
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
答案：
A
解析：
①父类静态变量和静态代码块(按照声明顺序)；
②子类静态变量和静态代码块(按照声明顺序)；
③父类成员变量和代码块(按照声明顺序)；
④父类构造器；
⑤子类成员变量和代码块(按照声明顺序)；
⑥子类构造器。
13.下列语句正确的是：？
A.形式参数可被字段修饰符修饰
B.形式参数不可以是对象
C.形式参数为方法被调用时真正被传递的参数
D.形式参数可被视为local variable
答案：
D
解析：
14.以下程序输出结果是？
String str =
“”;
System.out.print(str.split(",").length);
A.0
B.1
C.出现异常
答案：
B
解析：
略
15.public class contained in a Java program file must have the same name as the file, except for the extension “.java”.
A.FALSE
B.TRUE
答案：
A
解析：
题目的意思是：除去扩展名.java的部分，包含在java文件里的Java里的公共类必须与文件的名字相同。
但是公共的内部类是不需要和文件的名字相同的。
16.其中"c.getDeclaredMethods"的作用是:
import java.lang.reflect.Method;
public class DumpMethods{
public static void main(String[] args) {
try {
Class c=Class.forName(args[0]);
Method m[]=c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
} catch (Throwable e) {
System.err.println(e);
}
}
}
A.取得类的公有方法对象
B.取得类的所有公有方法名称
C.取得类的所有方法对象
D.选项都不正确
答案：
D
解析：
public Method[] getMethods()返回某个类的所有公用（public）方法包括其继承类的公用方法，包括它所实现接口的方法。
public Method[] getDeclaredMethods()对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。包括它所实现接口的方法。
17.运行代码，输出的结果是（）
public class P {
public static int abc = 123;
static{
System.out.println(“P is init”);
}
}
public class S extends P {
static{
System.out.println(“S is init”);
}
}
public class Test {
public static void main(String[] args) {
System.out.println(S.abc);
}
}
A.P is init 123
B.S is init P is init 123
C.P is init S is init 123
D.S is init 123
答案：
A
解析：
属于被动引用不会出发子类初始化
1.子类引用父类的静态字段，只会触发子类的加载、父类的初始化，不会导致子类初始化
2.通过数组定义来引用类，不会触发此类的初始化
3.常量在编译阶段会进行常量优化，将常量存入调用类的常量池中， 本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。
18.java中Hashtable, Vector, TreeSet, LinkedList哪些线程是安全的？
A.Hashtable
B.Vector
C.TreeSet
D.LinkedList
答案：
AB
解析：
HashMap是线程安全的HashMap
Vector是线程安全的ArrayList
TreeSet和LinkedList都不是线程安全的
19.下面哪些赋值语句是正确的（）
A.long test=012
B.float f=-412
C.int other =(int)true
D.double d=0x12345678
E.byte b=128
答案：
A B D
解析：
A和B中long和float，正常定义需要加l和f，但是long和float属于基本类型，会进行转化，所以不会报出异常。AB正确
boolean类型不能和任何类型进行转换，会报出类型异常错误。所以C错。
D选项可以这样定义，D正确。
E选项中，byte的取值范围是-128—127。报出异常：cannot convert from int to byte.所以E选项错误。
20.Thread. sleep()是否会抛出checked exception?
A.会
B.不会
答案：
A
解析：
Thread.sleep() 和 Object.wait(),都可以抛出 InterruptedException。这个异常是不能忽略的,因为它是一个检查异常(checked exception)
Java(十）
1.Java中所有类的父类是（ ）?
A.Father
B.Dang
C.Exception
D.Object
答案：
D
解析：
D，java中Object是所有类的父亲,所有类的对象都是Class的实例。
2.在 main() 方法中给出数组buffer和下标i，如果将此下标中的元素显示到控制台上，需要使用（ ）。
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)。
答案：
A
解析：
在main中已经给出字节数组，直接System.out.print();输出即可。BC都是文件输出输入流，D是标准输入流，所以不符合题意。
- “先进先出”的容器是：( )
A.堆栈(Stack)
B.队列（Queue）
C.字符串(String)
D.迭代器(Iterator)
答案：
B
解析：
堆栈(Stack) ：如子弹入弹夹一样 先进后出
队列（Queue）：如排队过隧道 先进先出
4.下面关于静态方法说明正确的是？
A.在静态方法中可用this来调用本类的类方法
B.在静态方法中调用本类的静态方法时可直接调用
C.在静态方法中只能调用本类中的静态方法
D.在静态方法中绝对不能调用实例方法
答案：
B
解析：
解释一下D.可以通过在静态方法中创建对象，通过对象.调用非静态方法
5.以下定义一维数组的语句中，正确的是：（）？
A.int a [10]
B.int a []=new [10]
C.int a[] int a []=new int [10]
D.int a []={1,2,3,4,5}
答案：
D
解析：
1.int a[10]是错误的,声明的时候不能初始化容量,只有new的时候才可以
2.正确的是int a[]=new int[10];
3.不能两个声明连在一起
4.是正确的
6.有如下代码：请写出程序的输出结果。
public class Test
{
public static void main(String[] args)
{
int x = 0;
int y = 0;
int k = 0;
for (int z = 0; z < 5; z++) {
if ((++x > 2) && (++y > 2) && (k++ > 2))
{
x++;
++y;
k++;
}
}
System.out.println(x + ”” +y + ”” +k);
}
}
A.432
B.531
C.421
D.523
答案：
B
解析：
每次循环z,x,y,k对应数值为：
0,1,0,0
1,2,0,0
2,3,1,0
3,4,2,0
4,5,3,1
执行完这次以后，z++为5，不再进入for循环。
7.BufferedReader的父类是以下哪个？
A.FilterReader
B.InputStreamReader
C.PipedReader
D.Reader
答案：
D
解析：
图片
io流
8.以下代码在编译和运行过程中会出现什么情况 ?
public class TestDemo{
private int count;
public static void main(String[] args) {
TestDemo test=new TestDemo(88);
System.out.println(test.count);
}
TestDemo(int a) {
count=a;
}
}
A.编译运行通过，输出结果是88
B.编译时错误，count变量定义的是私有变量
C.编译时错误，System.out.println方法被调用时test没有被初始化
D.编译和执行时没有输出结果
答案：
A
解析：
private是私有变量，只能用于当前类中，题目中的main方法也位于当前类，所以可以正确输出
9.类方法中可以直接调用对象变量。（ ）
A.正确
B.错误
答案：
B
解析：
静态方法中不能调用对象的变量，因为静态方法在类加载时就初始化，对象变量需要在新建对象后才能使用
10.内部类（也叫成员内部类）可以有4种访问权限。（ ）？
A.正确
B.错误
答案：
A
解析：
把内部类理解成类的成员，成员有4种访问权限吧，内部类也是！分别为private、protected、public以及默认的访问权限
11.关于以下application,说法正确是什么？
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
解析：
父类静态代码块–>子类静态代码块–>父类普通代码块–>父类构造方法–>子类代码块–>子类构造方法；
12.java程序内存泄露的最直接表现是（ ）
A.频繁FullGc
B.jvm崩溃
C.程序抛内存控制的Exception
D.java进程异常消失
答案：
C
解析：
首先理解一下内存泄漏的概念，内存泄漏就是对象引用消失了，对象内存却没有被回收。
A答案：FullGC 是老年代内存空间不足的时候，才会触发的，老年代一般是生命周期较长的对象或者大对象，频繁的 FullGC 不会可能会影响程序性能（因为内存回收需要消耗CPU等资源），但是并不会直接导致内存泄漏。
B 答案：JVM奔溃的可能是内存溢出引起的，也可能是其他导致 JVM崩溃的操作，例如设置了错误的JVM参数等。
C 答案：内存异常，最常见的 就是 StackOverFlow 了把，内存溢出，其实内存泄漏的最终结果就是内存溢出。所以，基本上C是对的答案。
D 答案：Java 进程异常消失，这个明显不对的。
13.以下程序运行后的输出结果是（）?
int main()
{
int a=1,b=2,m=0,n=0,k;
k=(n=b
return 0;
}
A.0,0
B.0,1
C.1,0
D.1,1
答案：
A
解析：
14.下面这条语句一共创建了多少个对象：String s=“welcome”+“to”+360;
A.1
B.2
C.3
D.4
答案：
A
解析：
略，可以参考我的其他文字关于对String的介绍.
15.下面这段程序的输出结果是（）
public class Main {
public static void main(String[] args) {
split(12);
}
public static int split(int number) {
if (number > 1) {
if (number % 2 != 0) System.out.print(split((number + 1) / 2));
System.out.print(split(number / 2));
}
return number;
}
}
A.12136
B.63121
C.61213
D.11236
答案：
A
解析：
考察方法进栈与出栈的顺序。先进后出
16.关于Java以下描述正确的有( )？
A.Class类是Object类的超类
B.Object类是一个final类
C.String类是一个final类
D.Class类可以装载其它类
答案：
C D
解析：
A.class类是Object的派生类
B.每个类都使用Object类作为超类，而final修饰的类不能被继承
17.以下哪几种是java的基本数据类型。
A.String
B.int
C.boolean
D.Double
答案：
BC
解析：
Double在java.lang包，是double的一个包装类，不是基本数据类型
- Java程序的种类有（ ）
A.类（Class）
B.Applet
C.Application
D.Servlet
答案：
BCD
解析：
Java程序的种类有：
（a）内嵌于Web文件中，由浏览器来观看的_Applet
（b）可独立运行的 Application
（c）服务器端的 Servlets
19.关于java中的数组，下面的一些描述，哪些描述是准确的：（）?
A.数组是一个对象，不同类型的数组具有不同的类
B.数组长度是可以动态调整的
C.数组是一个连续的存储结构
D.一个固定长度的数组可类似这样定义：int array[100]
E.两个数组用equals方法比较时，会逐个便利其中的元素，对每个元素进行比较
F.可以二维数组，且可以有多维数组，都是在java中合法的。
答案：
A C F
解析：
1.数组其实也是一个对象
2.定义一个一维数组的方式是：type[] arrayname或者type arrayname[];
3.一维数组的初始化：
（1）静态初始化
1）int[] arr = new int[]{1, 2, 3}
2）int[] arr = {1, 2, 3}
（2）动态初始化
int[] arr = new int[3];
4.可以定义多维数组
20.假如某个JAVA进程的JVM参数配置如下：
-Xms1G -Xmx2G -Xmn500M -XX:MaxPermSize=64M -XX:+UseConcMarkSweepGC -XX:SurvivorRatio=3,
请问eden区最终分配的大小是多少？
A.64M
B.500M
C.300M
D.100M
答案：
C
解析：
java -Xmx2G -Xms1G -Xmn500M -Xss128k
-Xmx2G：设置JVM最大可用内存为2G。
-Xms1G：设置JVM初始内存为1G。此值可以设置与-Xmx相同，以避免每次垃圾回收完成后JVM重新分配内存。
-Xmn500M：设置年轻代大小为2G。整个JVM内存大小=年轻代大小 + 年老代大小 + 持久代大小。
-XX:SurvivorRatio=3:新生代中又会划分为 Eden 区，from Survivor、to Survivor 区。
其中 Eden 和 Survivor 区的比例默认是 8:1:1，当然也支持参数调整 -XX:SurvivorRatio=3的话就是3:1:1。
故该题为500*（3/5）=300M.
Java（十一）
1.下面的方法，当输入为2的时候返回值是多少？
public static int getValue(int i) {
int result = 0;
switch (i) {
case 1:
result = result + i;
case 2:
result = result + i * 2;
case 3:
result = result + i * 3;
}
return result;
}
A.0
B.2
C.4
D.10
答案：
D
解析：
没有break，发生case穿透现象，程序会继续向下执行，直到遇到break或者结束switch语句的大括号为止。
2.Java是从（）语言改进重新设计
A.Ada
B.C++
C.Pascal
D.BASIC
答案：
B
解析：
ava是类C语言，从C++改进而来 去掉了指针和多继承，采用自动垃圾回收等
3.一个以". java"为后缀的源文件，哪些说法是正确的？
A.只能包含一个类，类名必须与文件名相同
B.只能包含与文件名相同的类，以及其中的内部类
C.只能有一个与文件名相同的类，可以包含其他类
D.可以包含任意类
答案：
C
解析：
C。一个与文件名相同的public的类敏感词类可随意多个。
4.在JAVA中，下面关于String类和StringBuffer类的描述正确的是那一个？
A.StringBuffer类的对象调用toString（）方法将返回String类型的结果
B.两个类都有append（）方法
C.可以直接将字符串“test”赋值给声明的String类和StringBuffer类的变量
D.两个类的实例的值都能够被改变
答案：
A
解析：
A. StringBuffer类调用toString（）方法后将转换为String类型 正确
B. String类型中没有append（）方法，要追加字符串”+“即可，也没有必要 append
C. 可以直接将字符串“test”复制给声明的Stirng类的变量，而StringBuffer类的不行
D. String 实例 是不可变的
String 对象/实例 是不可以被改变的。
当new一个String对象时，JVM会在内存中创建一个String对象，当另外一个String对象值与它一样时，会将该对象直接指向对应的地址。
- 下列关于构造方法不正确的是：（ ）
A.类的构造方法和类同名
B.一个类可以有多个构造方法
C.在实例化对象时必须调用类的构造方法
D.构造方法可以和该类其他方法一样被该类对象调用
答案：
D
解析：
1.构造方法也是类的方法，可以在创建对象时为成员变量赋值
2.构造方法可以进行重载，但是参数列表必须不相同，不以返回值和访问级别进行区分
3.构造方法没有返回值
4.构造方法一定要与定义为public的类同名
5.构造方法不能被对象调用，只会创建对象，使用new关键字
6.根据下面的程序代码，哪些选项的值返回true？
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
解析：
a = new Square(42L);
b = new Square(42L);
这里new了两个对象，所以a,b不是同一个引用a!=b ,s的类型跟a,b不同类型，所以s!=a,s!=b
c = b; 这里b，c是同一个对象的引用，所以b==c是true
7.根据以下代码段,执行new Child(“John”, 10); 要使数据域data得到10，则子类空白处应该填写( )。
class Parent {
private int data;
public Parent(int d){ data = d; }
}
class Child extends Parent{
String name;
public Child(String s, int d){
___________________
name = s;
}
}
A.data = d;
B.super.data = d;
C.Parent(d);
D.super(d);
答案：
D
解析：
1.子父类存在同名成员时，子类中默认访问子类的成员，可通过super指定访问父类的成员，格式：super.xx (注：xx是成员名)；
2.创建子类对象时，默认会调用父类的无参构造方法，可通过super指定调用父类其他构造方法，格式：s uper(yy) (注：yy是父类构造方法需要传递的参数)
8.Given the following code:() What is the result?
public class Test {
private static int j = 0;
private static Boolean methodB(int k) {
j += k;
return true;
}
public static void methodA(int i) {
boolean b;
b = i < 10 | methodB(4);
b = i < 10 || methodB(8);
}
public static void main(String args[]) {
methodA(0);
System.out.println(j);
}
}
A.The program prints”0”
B.The program prints”4”
C.The program prints”8”
D.The program prints”12”
E.The code does not complete.
答案：
B
解析：
选 B
在main函数中先调用methodA（0）
在methodA中，第二行
b = i < 10 | methodB(4); //中间为与计算符，执行完methodB(4)后，j = 4
methodA中，第三行
b = i < 10 || methodB(8);//中间为或计算符，因为i < 10 已成立，不需要后续计算
所以最后结果输出为4
9.一个文件中的字符要写到另一个文件中，首先需要（ ）？
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);
- 阅读以下 foo 函数，请问它的时间复杂度是：
int foo(intarray[], int n, int key){
int n1=0,n2=n-1,m;
while(n1<=n2){
m=(n1+n2)/2;
if(array[m]==key)
return m;
if(array[m]>key)
n2=m-1;
else
n1=m+1;
}
return -1;
}
A.O(n2)
B.O(n3)
C.O(log(n))
D.O(n)
答案：
C
解析：
二分查找时间复杂度为O（logn） ，关注我的微信公众号，里面有关于时间复杂度和空间复杂度介绍的文章。
11.下列关于管道（Pipe）通信的叙述中，正确的是（）？
A.进程对管道进行读操作和写操作都可能被阻塞
B.一个管道只能有一个进程或一个写进程对其操作
C.一个管道可实现双向数据传输
D.管道的容量仅受磁盘容量大小限制
答案：
A
解析：
A.正确，因为管道为空，读操作会被阻塞；管道满了，写操作会被阻塞
B.可以有多个进程对其读；也可以有多个进程写，只不过不能同时写。并且题目没有说“同时”，B不对
C.匿名管道只能单向；命名管道可以双向；所以C过于绝对
D.管道是内存中的，所以D不对
12.要导入java/awt/event下面的所有类，叙述正确的是？()
A.import java.awt.和import java.awt.event.都可以
B.只能是import java.awt.*
C.只能是import java.awt.event.*
D.import java.awt.和import java.awt.event.都不可以
答案：
C
解析：
导包只可以导到当前层，不可以再导入包里面的包中的类
13.对于JVM内存配置参数：
-Xmx10240m -Xms10240m -Xmn5120m -XXSurvivorRatio=3
,其最小内存值和Survivor区总大小分别是（）
A.5120m，1024m
B.5120m，2048m
C.10240m，1024m
D.10240m，2048m
答案：
D
解析：
-Xmx：最大堆大小
-Xms：初始堆大小
-Xmn: 年轻代大小
-XXSurvivorRatio：年轻代中Eden区与Survivor区的大小比值
年轻代5120m， Eden：Survivor=3，Survivor区大小=1024m（Survivor区有两个，即将年轻代分为5份，每个Survivor区占一份），总大小为2048m。
-Xms初始堆大小即最小内存值为10240m
14.URL u =new URL(“http://www.123.com”);。如果www.123.com不存在，则返回__。
A.http://www.123.com
B.””
C.null
D.抛出异常
答案：
A
解析：
new URL()时必须捕获检查异常，但这个异常是由于字符串格式和URL不符导致的，与网址是否存在无关。URL的toString方法返回字符串，无论网址是否存在
15.存根（Stub）与以下哪种技术有关
A.交换
B.动态链接
C.动态加载
D.磁盘调度
答案：
B
解析：
理解为适配器模式，继承该类则不需要实现一个接口全部方法。
16.Java中的集合类包括ArrayList、LinkedList、HashMap等类，下列关于集合类描述正确的是（）
A.ArrayList和LinkedList均实现了List接口
B.ArrayList的访问速度比LinkedList快
C.添加和删除元素时，ArrayList的表现更佳
D.HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值
答案：
A B D
解析：
关于D,值对象可以允许null
17.下列说法正确的是（）？
A.我们直接调用Thread对象的run方法会报异常，所以我们应该使用start方法来开启一个线程
B.一个进程是一个独立的运行环境，可以被看做一个程序或者一个应用。而线程是在进程中执行的一个任务。Java运行环境是一个包含了不同的类和程序的单一进程。线程可以被称为轻量级进程。线程需要较少的资源来创建和驻留在进程中，并且可以共享进程中的资源
C.synchronized可以解决可见性问题，volatile可以解决原子性问题
D.ThreadLocal用于创建线程的本地变量，该变量是线程之间不共享的
答案：
B D
解析：
volatile与synchronized的区别：
volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的,需要从主存中读取,synchronized则是锁定当前变量,只有当前线程可以访问该变量,其他线程被阻塞住.
volatile仅能使用在变量级别,synchronized则可以使用在变量,方法.
volatile仅能实现变量的修改可见性,但不具备原子特性,而synchronized则可以保证变量的修改可见性和原子性.
volatile不会造成线程的阻塞,而synchronized可能会造成线程的阻塞.
volatile标记的变量不会被编译器优化,而synchronized标记的变量可以被编译器优化.
18.对于构造方法，下列叙述正确的是（ ）。
A.构造方法的优先级一般比代码块低。
B.构造方法的返回类型只能是void型。
C.构造方法的主要作用是完成对类的对象的初始化工作。
D.一般在创建新对象时，系统会自动调用构造方法。
答案：
A C D
解析：
A：静态成员变量或静态代码块>main方法>非静态成员变量或非静态代码块>构造方法
B：think in java中提到构造器本身并没有任何返回值。
C: 构造方法的主要作用是完成对类的对象的初始化工作。
D: 一般在创建(new)新对象时，系统会自动调用构造方法。
19.下列有关JAVA异常处理的叙述中正确的是（）
A.finally是为确保一段代码不管是否捕获异常都会被执行的一段代码
B.throws是用来声明一个成员方法可能抛出的各种非运行异常情况
C.final用于可以声明属性和方法，分别表示属性的不可变及方法的不可继承
D.throw是用来明确地抛出一个异常情况
答案：
A B D
解析：
C根本就跟异常处理没有关系，所以不选。
20.character流和byte流的区别不包括（）
A.每次读入的字节数不同
B.前者带有缓冲，后者没有。
C.前者是字符读入，后者是字节读入。
D.二者没有区别，可以互换。
答案：
A B D
解析：
字符流和字节流每次读入的字节数是不确定的，可能相同也可能不相同
例FileInputStream 的read() 方法每次读入一个字节，read(byte b[]) 每次读入b.length个字节
FileReader 的read()方法每次读入一个字符，read(char cbuf[], int offset, int length)每次读入length个字符
另外，字符流和字节流读入一个ASCII字符，字节数是相同的
例UTF-8字符编码中一个汉字占三个字节，数字1占一个字节，用字符流读入的数字1长度为一个字节，用字节流读入的数字1长度也为一个字节
Java（十二）
1.（C#、JAVA）扩展方法能访问被扩展对象的public成员
A.能
B.不能
答案：
A
解析：
翻译一下，子类方法是否能够访问父类中的public成员。
2.如果子类要调用父类的构造函数，则通过super（）调用来实现。
A.正确
B.错误
答案：
A
解析：
super关键字在子类内部使用，代表父类对象。访问父类的属性 super.属性名 访问父类的方法 super.方法名() 子类构造方法需要调用父类的构造方法时，在子类的构造方法体里最前面的位置：super()
3.下列关于Java语言中String和char的说法，正确的是（）
A.String是Java定义的一种基本数据类型。
B.String是以“\0”结尾的char类型的数组char[]。
C.使用equals()方法比较两个String是否内容一样（即字符串中的各个字符都一样）。
D.Char类型在Java语言里面存储的是ASCII码。
答案：
C
解析：
A 基本数据类型包括byte，short，int，long，float，double，char，boolean，所以A错。
B,C语言当中是这样，java不是， String内部是用char[]数组实现的，不过结尾不用\0。
C 对，字符串内容比较用equals方法。
D char存储的unicode码，不进可以存储ascII码，汉字也可以。
4.关于JAVA堆，下面说法错误的是（）？
A.所有类的实例和数组都是在堆上分配内存的
B.堆内存由存活和死亡的对象，空闲碎片区组成
C.数组是分配在栈中的
D.对象所占的堆内存是由自动内存管理系统回收
答案：
C
解析：
C应该改为，数组的引用存在栈内存中，而数组对象保存在堆里面。
- java 接口的修饰符可以为（）
A.private
B.protected
C.final
D.abstract
答案：
D
解析：
接口是通用的，用来描述方法是干什么用的，方法的默认修饰符为public abstract.不可以为final 是因为方法要被重写， 描述符如果为private或者protected，那么子类重写的方法的描述符也可以为private或者protected，这样就是有了访问显示，不符合接口所要达到的的任何人都可以使用了
6.指出下来程序运行的结果是
图片
代码
A.good and abc
B.good and gbc
C.test ok and abc
D.test ok and gbc
答案：
B
解析：
实参和形参的问题。"ex.change(ex.str, ex.ch)"语句调用"change"方法时，将ex.str变量（实参）的值赋给了"change"方法中的str变量（形参），而将ex.ch（实参）的地址赋给了"change"方法中的ch（形参）。"change"方法运行时，第一条语句改变的是方法中形参的值，对实参没影响，第二条语句由于是直接改变的ch所指地址的值，所以把实参也进行了改变。
- A 是抽象父类或接口， B ， C 派生自 A ，或实现 A ，现在 Java 源代码中有如下声明：问以下哪个说法是正确的？（ ）
- A a0=new A();
- A a1 =new B();
- A a2=new C();
A.第1行不能通过编译
B.第1、2行能通过编译，但第3行编译出错
C.第1、2、3行能通过编译，但第2、3行运行时出错
D.第1行、第2行和第3行的声明都是正确的
答案：
A
解析：
抽象类和接口不能实例化
8.try块后必须有catch块。（）
A.正确
B.错误
答案：
B
解析：
catch可以省略，try的形式有三种：
try-catch
try-finally
try-catch-finally
但catch和finally语句不能同时省略！
- 以下 _ 不是 Object 类的方法
A.clone（）
B.finalize()
C.toString()
D.hasNext()
答案：
D
解析：
略
10.指出下列程序运行的结果：
public class Example{
String str=new String(“tarena”);
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 void change(String str,char ch[]){
//引用类型变量，传递的是地址，属于引用传递。
str=“test ok”;
ch[0]=‘g’;
}
}
A.tarena and abc
B.tarena and gbc
C.test ok and abc
D.test ok and gbc
答案：
B
解析：
与第六题类似。
11.以下代码段执行后的输出结果为
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.下面有关webservice的描述，错误的是？
A.Webservice是跨平台，跨语言的远程调用技术
B.Webservice通信机制实质就是json数据交换
C.Webservice采用了soap协议（简单对象协议）进行通信
D.WSDL是用于描述 Web Services 以及如何对它们进行访问
答案：
B
解析：
Webservice是跨平台，跨语言的远程调用技术;它的通信机制实质就是xml数据交换;它采用了soap协议（简单对象协议）进行通信
13.关于ASCII码和ANSI码，以下说法不正确的是（）？
A.标准ASCII只使用7个bit
B.在简体中文的Windows系统中，ANSI就是GB2312
C.ASCII码是ANSI码的子集
D.ASCII码都是可打印字符
答案：
D
解析：
A、标准ASCII只使用7个bit，扩展的ASCII使用8个bit。
B、ANSI通常使用 0x00~0x7f 范围的1 个字节来表示 1 个英文字符。超出此范围的使用0x80~0xFFFF来编码，即扩展的ASCII编码。不同 ANSI 编码之间互不兼容。在简体中文Windows操作系统中，ANSI 编码代表 GBK 编码；在繁体中文Windows操作系统中，ANSI编码代表Big5；在日文Windows操作系统中，ANSI 编码代表 Shift_JIS 编码。
C、ANSI通常使用 0x00~0x7f 范围的1 个字节来表示 1 个英文字符，即ASCII码
D、ASCII码包含一些特殊空字符
- Test.main() 函数执行后的输出是（）
public class Test {
public static void main(String [] args){
System.out.println(new B().getValue());
}
static class A{
protected int value;
public A(int v) {
setValue(v);
}
public void setValue(int value){
this.value = value;
}
public int getValue(){
try{
value++;
return value;
} catch(Exception e){
System.out.println(e.toString());
} finally {
this.setValue(value);
System.out.println(value);
}
return value;
}
}
static class B extends A{
public B() {
super(5);
setValue(getValue() - 3);
}
public void setValue(int value){
super.setValue(2 * value);
}
}
}
A.11 17 34
B.22 74 74
C.6 7 7
D.22 34 17
答案：
D
解析：
略
15.final、finally和finalize的区别中，下述说法正确的有？
A.final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
B.finally是异常处理语句结构的一部分，表示总是执行。
C.finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源的回收，例如关闭文件等。
D.引用变量被final修饰之后，不能再指向其他对象，它指向的对象的内容也是不可变的。
答案：
A B
解析：
A，D考的一个知识点，final修饰变量，变量的引用（也就是指向的地址）不可变，但是引用的内容可以变（地址中的内容可变）。
B，finally表示总是执行。但是其实finally也有不执行的时候，但是这个题不要扣字眼。
在try中调用System.exit(0)，强制退出了程序，finally块不执行。
在进入try块前，出现了异常，finally块不执行。
C，finalize方法，这个选项错就错在，这个方法一个对象只能执行一次，只能在第一次进入被回收的队列，而且对象所属于的类重写了finalize方法才会被执行。第二次进入回收队列的时候，不会再执行其finalize方法，而是直接被二次标记，在下一次GC的时候被GC。
放一张图吧
图片
15
16.关于equals和hashCode描述正确的是()
A.两个obj，如果equals()相等，hashCode()一定相等（符合代码规范的情况下）
B.两个obj，如果hashCode()相等，equals()不一定相等
C.两个不同的obj， hashCode()可能相等
D.其他都不对
答案：
A B C
解析：
地址比较是通过计算对象的哈希值来比较的，hashcode属于Object的本地方法，对象相等（地址相等），hashcode相等，对象不相等，hashcode()可能相等，哈希冲突
17.下面有关java类加载器，说法正确的是？
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来使用
答案：
ABCD
解析：
jvm classLoader architecture :
a、Bootstrap ClassLoader/启动类加载器
主要负责jdk_home/lib目录下的核心 api 或 -Xbootclasspath 选项指定的jar包装入工作.
B、Extension ClassLoader/扩展类加载器
主要负责jdk_home/lib/ext目录下的jar包或 -Djava.ext.dirs 指定目录下的jar包装入工作
C、System ClassLoader/系统类加载器
主要负责java -classpath/-Djava.class.path所指的目录下的类与jar包装入工作.
B、 User Custom ClassLoader/用户自定义类加载器(java.lang.ClassLoader的子类)
在程序运行期间, 通过java.lang.ClassLoader的子类动态加载class文件, 体现java动态实时类装入特性.
18.下面哪项技术可以用在WEB开发中实现会话跟踪实现？
A.session
B.Cookie
C.地址重写
D.隐藏域
答案：
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)方法将对象捆绑到一个会话
19.下面有关forward和redirect的描述，正确的是() ？
A.forward是服务器将控制权转交给另外一个内部服务器对象，由新的对象来全权负责响应用户的请求
B.执行forward时，浏览器不知道服务器发送的内容是从何处来，浏览器地址栏中还是原来的地址
C.执行redirect时，服务器端告诉浏览器重新去请求地址
D.forward是内部重定向，redirect是外部重定向
E.redirect默认将产生301 Permanently moved的HTTP响应
答案：
B C D
解析：
1.从地址栏显示来说
forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,所以它的地址栏还是原来的地址.
redirect是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL.
2.从数据共享来说
forward:转发页面和转发到的页面可以共享request里面的数据.
redirect:不能共享数据.
3.从运用地方来说
forward:一般用于用户登陆的时候,根据角色转发到相应的模块.
redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站等.
4.从效率来说
forward:高.
redirect:低.
20.下面关于volatile的功能说法正确的是哪个
A.原子性
B.有序性
C.可见性
D.持久性
答案：
B C
解析：
synchronized保证三大性，原子性，有序性，可见性，volatile保证有序性，可见性，不能保证原子性