牛客刷题记录

1.14

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

ceil 和 floor都返回double类型，ceil是>= 像上取整，floor是<=向下取整。
所以答案是 -0.0 -1.0

2. 字符串相关：
   针对下面的代码块,哪个equal为true:（）

String s1 = "xiaopeng" ;
String s2 = "xiaopeng" ;
String s3 =new String (s1);

字符串有两种创建方法：一种是直接赋值，另一种是new对象创建。
字符串是final修饰，直接赋值会将创建的变量放进字符串常量池，当再创建同样的字符串时，发现常量池中有则直接使用。
s3的创建对象创建字符串的方法是直接在堆中产生一个字符串“xiaopeng”，所以地址不一样。
equal是比较地址，==比较值。

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

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

java是完全的面向对象的语言，所有方法都必须定义在类中。
其中接口在1.8之后才允许定义default和static方法，1.9之后才可以定义private方法，在1.7之前都只能定义抽象方法，题目中写的是jdk1.7，所以A是对的。

一个容器类数据结构，读写平均，使用锁机制保证线程安全。如果要综合提高该数据结构的访问性能，最好的办法是___D___。

只对写操作加锁，不对读操作加锁 读操作不加锁
采用copyOnWrite的方式实现写操作
分区段加锁
无法做到

A 会导致脏读，读到脏数据（从目标中取出的数据已经过期、错误或者没有意义，这种数据就叫做脏数据。 脏读：读取出来脏数据就叫脏读。）
B CopyOnWrite的核心思想是利用高并发往往是读多写少的特性，对读操作不加锁，对写操作，先复制一份新的集合，在新的集合上面修改，然后将新集合赋值给旧的引用。这里读写平均，不适用
C 分段加锁，只在影响读写的地方加锁，锁可以用读写锁，可以提高效率

以下哪项陈述是正确的？E

垃圾回收线程的优先级很高，以保证不再使用的内存将被及时回收
垃圾收集允许程序开发者明确指定释放哪一个对象
垃圾回收机制保证了JAVA程序不会出现内存溢出
进入”Dead”状态的线程将被垃圾回收器回收
以上都不对

A GC的优先级很低
B 程序开发者只能建议回收哪一个对象
C 还是会出现内存溢出
D 进入DEAD的线程，它还可以恢复，GC不会回收

下列不是 Java 关键字的是 （ BD）

abstract
false
native
sizeof

48个关键字，2个保留字(goto,const），3个特殊直接量:true,false,null

1.16

1.重写和重载：
重载：编译时多态，参数列表必须不同，而返回值是否相同则没有要求。（不能通过返回值类型的相同与否判断是否重载，果两个方法只有返回值类型不同， 这两个方法在编译器看来还是同一个方法）
重写：运行时多态，用于继承中子类重写父类的方法，参数列表，方法名必须相同，方法的返回类型要是父类中返回类型的子类。

下列代码的运行结果：

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

考点：子类不能访问父类的私有变量、一个java文件中只能出现一个以public修饰的类。

下面代码运行结果是？
public class Test{
static{
int x=5;
}
static int x,y;
public static void main(String args[]){
x–;
myMethod( );
System.out.println(x+y+ ++x);
}
public static void myMethod( ){
y=x++ + ++x; }
}

考点：
++x和x++的区别：第一个是先加然后再使用x，后一个是先使用x再加。
静态变量x、y的初始值为0，静态代码块中的x是局部变量，对整个方法不影响。

若需要定义一个类，下列哪些修饰符是允许被使用的？（ ）
static、package、private、public

考点：
普通类，也就是外部类可以用public, abstract 和 final 修饰。
内部类，可以用 private, static, protected修饰

检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。
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 void change(String str, char ch[]){
str= “test ok”;
ch[0]= ‘g’; }
}

java 中String是 immutable的，也就是不可变，一旦初始化，其引用指向的内容是不可变的。
也就是说，String str = “aa”；str=“bb”；第二句不是改变“aa”所存储地址的内容，而是另外开辟了一个空间用来存储“bb”；同时由str指向
原来的“aa”，现在已经不可达，GC时会自动回收。
因此String作为参数传进来时候，str= “test ok”; 实际给副本引用str指向了新分配的地址，该地址存储“test ok”。
因此，原先的str仍然指向“good”

判断输出结果：

Boolean flag = false;
if(flag = true){
System.out.println("true");
}else{
System.out.println("false");
}

这里的 if 括号中表示赋值，实际判断的还是flag的值。

检查下列代码的错误：

public class While {
public void loop() {
int x= 10;
while ( x ) {
System.out.print("x minus one is " + (x - 1));
x -= 1;
}
}
}

考点java的while循环括号中的变量必须是布尔类型的，java中没有int类型变量大于0就是true的机制。

1.18

下面的输出结果是什么？
public class Demo {
public static void main(String args[])
{
String str=new String(“hello”);
if(str==“hello”)
{
System.out.println(“true”);
}
else {
System.out.println(“false”); } }
}

== 是用于地址比较，equals（）是值比较。

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

考点：
关于 try catch finally 中有return时的情况

如果try语句里有return，那么代码的行为如下：
1.如果有返回值，就把返回值保存到局部变量中
2.执行jsr指令跳到finally语句里执行
3.执行完finally语句后，返回之前保存在局部变量表里的值
如果try，finally语句里均有return，忽略try的return，而使用finally的return.

finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；

1.19

下列代码中的错误原因是（）

(1)   public class Test
(2)   {
(3)       public static void main(String [] args)
(4)       {
(5)           int i;
(6)           i+=1;
(7)       }
(8) }

考点：局部变量和成员变量

在方法内定义的变量在使用之前必须初始化，否则报错。

类变量（静态变量）在类加载过程的准备阶段会进行一次赋值，一般是空值或constantValue属性值，同时在初始化阶段会调用类构造器再进行一次赋值。而实例变量在创建对象时会调用实例构造器进行一次赋值。因此无论是类变量还是实例变量，在使用前都是非空的。而局部变量没有初始化过程，在使用前必须赋值。

局部变量的创建：当代码执行到该变量被赋值的代码时才被创建

try括号里有return语句， finally执行顺序
不执行finally代码
return前执行
return后执行
正确答案: B

“假设利用 return 语句从 try 语句块中退出。在方法返回前，finally子句的内容将被执行。如果 finally 子句中也有一个 return 语句，这个返回值将会覆盖原始的返回值。”

Java表达式"13 & 17"的结果是什么?（）
30
13
17
1

考点：
& 在java中是位运算符也是逻辑与，如果符号两边都是布尔类型，就是逻辑与；如果两边为数字，则是位运算，将十进制转换为二进制后从两个数的最高位进行与运算，两个都为真（1），结果才为真（1），否则为假（0）。
如这题：
13： 0 1101
17： 1 0001
位运算结果为 0 0001，所以结果为1

下面关于变量及其范围的陈述哪些是不正确的（）
实例变量是类的成员变量
实例变量用关键字static声明
在方法中定义的局部变量在该方法被执行时创建
局部变量在使用前必须被初始化
正确答案: B C

考点：成员变量和局部变量
成员变量包括 实例变量 和 静态变量（也是类变量）
他们两的区别就是是否有static修饰

正则表达式语法中 \d 匹配的是？

考点：正则表达式

\d 匹配一个数字字符。等价于[0-9]。
\D 匹配一个非数字字符。等价于[^0-9]。
\f 匹配一个换页符。等价于 \x0c 和 \cL。
\n 匹配一个换行符。等价于 \x0a 和 \cJ。
\r 匹配一个回车符。等价于 \x0d 和 \cM。
\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [\f\n\r\t\v]
\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t 匹配一个制表符。等价于 \x09 和 \cI。 \v 匹配一个垂直制表符。等价于 \x0b 和 \cK。
\w 匹配字母、数字、下划线。等价于’ [A-Za-z0-9_]'。
\W 匹配非字母、数字、下划线。等价于 ‘[^A-Za-z0-9_]’。

以下 _____ 不是 Object 类的方法
正确答案: D
clone（）
finalize()
toString()
hasNext()

考点：object类
这种类型的题一般考察点有两个：
1.Object中没有hasNext（） 方式，这个方法是迭代器中的
2.Object没有copy方法，但是有clone()方法， 用于创建并返回该对象的一个副本

下面有关Java的说法正确的是（ ）
正确答案: A C D F 你的答案: A C D F (正确)
一个类可以实现多个接口
抽象类必须有抽象方法
protected成员在子类可见性可以修改
通过super可以调用父类构造函数
final的成员方法实现中只能读取类的成员变量
String是不可修改的，且java运行环境中对string对象有一个对象池保存

考点：

• 解释一下c选项，意思是父类中的protected方法子类在重写的时候访问权限可以修改，其实就是重写的要素之一，换了个说法而已
• final 的成员方法除了能读取类的成员变量，还能读取类变量
• String 不可以修改，StringBuffer 和 StringBuilder 可以修改，String 只能改变指引，如果字符串常量池中没有正需要的串，就创建一 个新的字符串，然后让 String 对象指向它。

下列程序段的输出结果是：（ ）
public void complicatedexpression_r(){
int x=20, y=30;
boolean b;
b = x > 50 && y > 60 || x > 50 && y < -60 || x < -50 && y > 60 || x < -50 && y < -60;
System.out.println(b);
}

考点：运算符优先级。
题中符号的优先级排序是：‘>’，‘<’，‘&&’，‘||’。

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

使用泛型会使数据更加安全，和性能无关。

四月

1.假设有以下代码String s = “hello”；String t = “hello”；char c [ ] ={‘h’,‘e’,‘l’,‘l’,‘o’}；
下列选项中返回false的语句是？
A s.equals (t)；
B t.equals ( c )；
C s==t；
D t.equals (new String (“hello”))；

这题非常有代表性，首先考察了 == 和equals的区别，一个是地址比较，一个是值的比较；其次考察了 String 引用类型：如果直接通过 String s = “hello” 形式创建，是会先在常量池中进行查找的，如果找到值内容一样的，就不进行字符串的创建，引用已有的；
参考地址：https://www.nowcoder.com/discuss/846917?channel=-1&source_id=profile_follow_post_nctrack
正确答案：B

2.阅读如下代码。 请问，对语句行 test.hello(). 描述正确的有（）
package NowCoder;
class Test {
public static void hello() {
System.out.println(“hello”);
}
}
public class MyApplication {
public static void main(String[] args) {
// TODO Auto-generated method stub
Test test=null;
test.hello();
}
}
A、能编译通过，并正确运行
B、因为使用了未初始化的变量，所以不能编译通过
C、以错误的方式访问了静态方法
D、能编译通过，但因变量为null，不能正常运行

因为hello是一个静态方法，是随着类的产生而产生的，所以不受对象实例的影响。只要是使用到了Test类，都会加载静态hello方法！

3.已知 boolean result = false，则下面哪个选项是合法的：(多选)
result=1
result=true;
if(result!=0) {//so something…}
if(result) {//do something…}

这题我觉得对我的考点是，在java中false就是false，不等同于0或1，不要和其他语言混淆。

4.指出下列程序运行的结果：
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

这题的知识点也是考察 String 类型，因为String类型是特殊的，特殊在它不可以被改变，是不变的，目的是保证安全性，所以java特地为 String 开辟了一个常量池，但是char数组是可变的，所以最后的结果是 str没有改变，但是ch改变了。
同时这里方法的变量都是传入的引用类型，所以是引用传递。

5.关于Java中参数传递的说法，哪个是错误的？
A、在方法中，修改一个基础类型的参数不会影响原始参数值
B、在方法中，改变一个对象参数的引用不会影响到原始引用
C、在方法中，修改一个对象的属性会影响原始对象参数
D、在方法中，修改集合和Maps的元素不会影响原始集合参数

这题的考点还是参数的传递方式：
A 选项是对的，因为java是值传递。

public static void main(String []args){
    int i = 5;   
    func(i);
    System.out.println(i);
}
static void func(int j){
    j = 10;
}

//输出结果
5

B 这个答案写的很懵，“改变一个对象参数的引用”什么意思呢？下面是我在评论区看见的代码示例：

public static void main(String []args){
    User rabbiter = new User();
    rabbiter.setName("rabbiter");
    func(rabbiter);
    System.out.println(rabbiter.getName());
}
static void func(User user){
    user = new User();
    user.setName("zhangsan");
}

//输出结果
rabbiter

通过代码示例一看，我们就很清楚的了解到，是不会改变原对象的属性的。
C 选项直接修改对象的属性当然会对原对象的属性进行修改，因为对象也是一个引用类型，所以可以被修改。
D选项集合和Maps都是对象 , 所以此项跟C选项的解析一致。

6 有关静态初始化块说法正确的是？
正确答案: A B C
A 无法直接调用静态初始化块
B 在创建第一个实例前或引用任何静态成员之前，将自动调用静态初始化块来初始化
C 静态初始化块既没有访问修饰符，也没有参数
D 在程序中，用户可以控制何时执行静态初始化块

java对象初始化顺序
先说结论：
父类静态代码块，父类静态成员变量（同级，按代码顺序执行）
子类静态代码块，子类静态成员变量（同级，按代码顺序执行）
父类普通代码块，父类普通成员变量（同级，按代码顺序执行）
父类构造方法
子类普通代码块，子类普通成员变量（同级，按代码顺序执行）
子类构造方法
注意点：
静态内容只在类加载时执行一次，之后不再执行。
默认调用父类的无参构造方法，可以在子类构造方法中利用super指定调用父类的哪个构造方法。

7 多选题下面关于变量及其范围的陈述哪些是不正确的（）
A 实例变量是类的成员变量
B 实例变量用关键字static声明
C 在方法中定义的局部变量在该方法被执行时创建
D 局部变量在使用前必须被初始化

这里的疑问点在C ，方法中定义的局部变量是在局部变量被赋值就是初始化的时候才被创建的，如果一个方法中有个局部变量只是被定义了没有被赋值，那底层是不会创建这个局部变量的。
正确答案: B C

4.20

1.有如下4条语句：()
Integer i01=59;
int i02=59;
Integer i03=Integer.valueOf(59);
Integer i04=new Integer(59);

以下输出结果为false的是:
A System.out.println(i01== i02);
B System.out.println(i01== i03);
C System.out.println(i03== i04);
D System.out.println(i02== i04);

这道题的考点是：自动拆装箱和容量池的问题，Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值小于等于127并且大于等于-128时才可使用常量池，说明 i01 和 i03都指向的是常量池中同一个数组，所以相同。
因为 i02是int类型，Integer类型和int类型相比较时，Integer类型会进行自动拆箱的过程变为int，所以为true。
所以C不对， i04是创建出来的对象，和i03 从常量池中指向的数值肯定不相等。

4.21

判断题：
1.用户不能调用构造方法，只能通过new关键字自动调用。（）

这道题是基础题，在类内部可以使用this关键字调用本类的构造方法（this.构造方法）；子类可以使用super关键字调用父类的构造方法（super.构造方法）；可以通过反射的方法获取构造方法。

2.对于如下代码段
class A{
public A foo() {
return this;
}
}
class B extends A {
public A foo(){
return this;
}
}
class C extends B {
_______
}
可以放入到横线位置，使程序正确编译运行，而且不产生错误的选项是（ ）
A public void foo(){}
B public int foo(){return 1;}
C public A foo(B b){return b;}
D public A foo(){return A;}

这题考了重写，因为还未复习，先放这放着。

3.下列代码执行结果为（）
public static void main(String args[])throws InterruptedException{
Thread t=new Thread(new Runnable() {
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.print(“2”);
}
});
t.start();
t.join();
System.out.print(“1”);
}
A 21
B 12
C 可能为12，也可能为21
D 以上答案都不对

已经复习过线程的知识点了为什么还会错呢？对join方法的含义一点印象都没有了，join方法是指将指定的线程加入到当前线程。因为是调用的是 t的join方法，因为子线程 t 有一个休眠2s的时间，可能在子线程休眠中时主线程就已经执行完了，就是要让t 线程先执行，等 t 线程的打印 2 的结束后，再执行主线程打印 1 的操作。

4.以下哪些方法是Object类中的方法
A clone()
B toString()
C wait()
D finalize()

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

4.22

1.关于Float，下列说法错误的是()
A Float是一个类
B Float在java.lang包中
C Float a=1.0是正确的赋值方法
D Float a= new Float(1.0)是正确的赋值方法

A选项：所有的包装类都是一个类，对应的基础数据类型不是
C选项：小数后如果不加 f 都默认是double类型的数值，并且double无法向float隐式转换。
D选项：这样是可以的，但是1.5后版本引入自动装箱后idea会提示这是不必要的装箱的警告，通常直接使用Float f=1.0f.

2.下列哪个选项是正确计算42度（角度）的余弦值？
double d = Math.cos(42)
double d = Math.cosine(42)
double d = Math.cos(Math.toRadians(42))
double d = Math.cos(Math.toDegrees(42))

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

3.DK提供的用于并发编程的同步器有哪些？
正确答案: A B C
Semaphore
CyclicBarrier
CountDownLatch
Counter

同步器是一些使线程能够等待另一个线程的对象，允许它们协调动作。最常用的同步器是CountDownLatch和Semaphore，不常用的是Barrier 和Exchanger

4.JVM内存不包含如下哪个部分( )
正确答案: D
Stacks
PC寄存器
Heap
Heap Frame

1.关于对象成员占用内存的说法哪个正确？（ ）
同一个类的对象共用同一段内存
同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间
对象的方法不占用内存
以上都不对

当你创建一个新的实例对象时，它会得到一块新的内存空间。但是类中的静态成员变量是所有对象共有的，也就是在一片属于类的存储空间中，被所有对象共有。

2.下面的程序输出的结果是( )
public class A implements B{
public static void main(String args[]){
int i;
A a1=new A();
i =a1.k;
System.out.println(“i=”+i);
}
}
interface B{
int k=10；
}
A i=0
B i=10
C 程序有编译错误
D i=true

这题是纯基础题，但我还是选错了，说明对接口的知识并不熟练，接口中的变量默认是 public static final 进行修饰的，所以接口中的变量都是静态的常量，其子类都可以直接使用。

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

java.lang包是java语言的核心包，lang是language的缩写
java.lang包定义了一些基本的类型，包括Integer,String之类的，是java程序必备的包，有解释器自动引入，无需手动导入
system是属于java.lang.sysytem

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

这也是一道基础题，考的是this关键字，语法格式应为：this（参数）

5.下列哪些操作会使线程释放锁资源？
sleep()
wait()
join()
yield()

1.sleep会使当前线程睡眠指定时间，不释放锁
2.yield会使当前线程重回到可执行状态，等待cpu的调度，不释放锁
3.wait会使当前线程回到线程池中等待，释放锁，当被其他线程使用notify，notifyAll唤醒时进入可执行状态
4.当前线程调用 某线程.join（）时会使当前线程等待某线程执行完毕再结束，底层调用了wait，释放锁

4.23

1.int i = 3;
String result = new String();
switch (i) {
case 1:
result = result + "him ";
case 2:
result = result + "her ";
case 3:
result = result + "it ";
default:
result = result + "me ";
}
System.out.println(result);
A it me
B him her it me
C him her
D me

这题也是一道基础题很简单，但我却记混了知识点，因为没有break跳出循环，会产生穿透，从满足条件的case开始执行到底。

2.如果int x=20, y=5，则语句System.out.println(x+y +“”+(x+y)+y); 的输出结果是（）
A 2530
B 55
C 2052055
D 25255

这题看似简单，却蕴含陷阱，按道理说x和y都是int类型的数值，两值相加应该是数值相加的结果，这里有括号，先算括号内的内容即 （x+y），再按照从左向右的顺序计算结果：首先计算 x+y 结果为25，但是中间出现了“”，代码默认将“”后面的变成了字符串相拼接，所以结果就是 25+25+5 为 25255。

3.关于Java语言中的final关键字的使用，下列说法正确的是（）
A 在使用final关键字定义的方法里面必须使用final关键字定义变量。
B 使用final关键字定义变量，必须在变量定义的同时给定变量的具体数值，完成变量初始化。
C final关键字可以用来修饰方法，表明此方法不可以被子类重写。
D 使用final关键字定义变量，必须同时使用static关键字。

A选项：没有要求必须使用final关键字定义变量
B选项：可以定义变量，在构造方法中对变量进行赋值和初始化
C选项：final修饰的方法可以重载不可以被子类重写
D选项：没有这样的要求

4.要在控制台界面下接收用户从键盘输入，需要import的包是：（ ）
java.lang包
java.awt包
java.io包
java.applet包

这题我首先想到了 scanner，scanner是在java.util包下的，System.in 就是返回控制台输入字符的InputStream对象，所以必须要导入java.io包，不管是控制台（图形界面）还是字符界面（命令行）输入，都需要使用 InputStream 方法。

5.假定Base b = new Derived（）; 调用执行b.methodOne（）后，输出结果是什么？
public class Base
{
public void methodOne()
{
System.out.print(“A”);
methodTwo();
}
public void methodTwo()
{
System.out.print(“B”);
}
}
public class Derived extends Base
{
public void methodOne()
{
super.methodOne();
System.out.print(“C”);
}
public void methodTwo()
{
super.methodTwo();
System.out.print(“D”);
}
}
ABDC
AB
ABCD
ABC

这题考的是多态和继承关系，我对这个一直都理的不是很清楚，这题有两个点：
1.向上转型：父类只能调用父类方法或者子类覆写后的方法,而子类中的单独方法则是无法调用的。
2.只要是被子类重写的方法，不被super调用都是调用子类方法

6.判断题：This调用语句必须是构造函数中的第一个可执行语句。

这句话看似简单，却暗藏陷阱：
1.当使用this（）调用本类的构造方法时，必须确保this方法是此构造函数中第一行可执行语句。但是使用this.方法的形式调用其他方法则不需要在第一行。
2.构造器中第一行默认是super()，一旦直接父类的构造器中没有无参的，那么必须显式调用父类的某个有参构造。
3.因为 super（）和this（）都必须放在第一行，所以两者不能同时出现。
4.super、this 和 super（）、this（）的含义不一样，一个表示的是父类或类本身，一个表示调用构造方法。

7.以下多线程对int型变量x的操作，哪个不需要进行同步（ ）
x=y;
x++;
++x;
x=1;

什么时候需要同步：要进行读写两项操作就需要同步，就是B/C选项
什么操作不需要同步：原子操作不需要加锁，比如D。
什么是原子性操作：指该操作不能再继续划分为更小的操作。
Java中的原子操作包括：
1、除long和double之外的基本类型的赋值操作
2、所有引用reference的赋值操作
3、java.concurrent.Atomic.* 包中所有类的一切操作
所以A选项的操作不行，因为还可以进行拆分

8.已知x >= y and y >= z 为真，那么x > z or y = z 值为
真
假
无法确定
x y z同为正数时为真

这又是个陷阱题，= 是赋值语句，==才是比较语句

9.关于java集合下列说法不正确的有哪些（）
A HashSet 它是线程安全的，不允许存储相同的对象
B ConcurrentHashMap 它是线程安全的，其中存储的键对象可以重复，值对象不能重复
C Collection接口是List接口和Set接口的父接口，通常情况下不被直接使用
D ArrayList线程安全的，允许存放重复对象

基本上我们平常用到的都是非线程安全的集合类，因为要使线程安全，是要加锁来实现的，势必造成性能降低。如hashset、hashmap、arraylist、linkedlist、treemap、treeset、stringbulider等都不是线程安全的。
像stringbuhffer、vector、hashtable这些都是专用于多线程的，再者以concurrent（意为：同时发生的）为前缀的集合类大多是线程安全的。

4.24

1.在Web应用程序的文件与目录结构中，web.xml是放置在( )中。
A WEB-INF目录
B conf目录
C lib目录
D classes目录

web.xml文件是用来初始化配置信息，web.xml是放置在WEB-INF目录中
classes目录是放程序用到的自定义类（.class），包括包结构。
lib目录放的是jar文件

2.下列关于异常处理的描述中，错误的是()。
A 程序运行时异常由Java虚拟机自动进行处理
B 使用try-catch-finally语句捕获异常
C 可使用throw语句抛出异常
D 捕获到的异常只能在当前方法中处理，不能在其他方法中处理

这题很好选，D选项捕获的异常可以抛给上一层解决，例如我们在一个类中创建了其他类的对象，如果这个其他类需要抛出异常，那这个类也需要将这个异常抛出。
其他答案：
编译时异常必须显示处理，运行时异常交给虚拟机。
运行时异常可以不处理。当出现这样的异常时，总是由虚拟机接管。比如我们从来没有人去处理过Null Pointer Exception异常，它就是运行时异常，并且这种异常还是最常见的异常之一。出现运行时异常后，系统会把异常一直往上层抛，一直遇到处理代码。如果没有处理块，到最上层，如果是多线程就由Thread.run()抛出，如果是单线程就被main()抛出。抛出之后，如果是线程，这个线程也就退出了。如果是主程序抛出的异常，整个程序也就退出了。运行时异常是Exception的子类，也有一般异常的特点，是可以被Catch块处理的。只不过往往不对它处理罢了。也就是说，如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终止。

3.java中下面哪个能创建并启动线程（）
public class MyRunnable implements Runnable {
public void run() {
//some code here
}
}
A new Runnable(MyRunnable).start()
B new Thread(MyRunnable).run()
C new Thread(new MyRunnable()).start()
D new MyRunnable().start()

这道题考的是线程的启动，可惜我与答案失之交臂。
线程的开启是通过 Thread类的 start 方法进行启动的，基础的只有这一个启动方法，所以D错误；
因为这个类是实现的Runnable接口，所以需要创建一个Thread类对象并用构造方法的形式将此类注入进去，并调用其start方法；
如果是一个实现了Thread类的方法，则直接new此类然后调用其start方法即可。

4.关于java编译和运行命令叙述不正确的是？ ( )
A 运行“java Scut.class”
B 运行“java Scut”
C 编译 Scut.java文件，使用“javac Scut.java”命令的输出文件是Scut.class
D java这个命令的运行对象是Scut.class

又是一道基础题，考的是java中的命令
java命令的运行对象是字节码文件，但当我们在命令行中输入的格式 是java+文件名，会省略后面的.class后缀，所以A不对。
javac命令的运行对象是java文件，结果是将java文件编译为字节码文件，格式是 javac + 文件名.java

4.25

1.下面代码的运行结果是（ ）
public class Arraytest{
int a[] = new int[6];
public static void main ( String arg[] ) {
System.out.println ( a[0] );
}
}
A null
B 0
C 编译出错
D 运行出错

这题真的很基础，但是不注意就会错，因为main是静态方法，静态方法只能调用静态变量，但是a数组不是静态的，所以会编译出错。然后数组的初始值为0不是null。

2.下面这条语句一共创建了多少个对象：String s=“welcome”+“to”+360;
A 1
B 2
C 3
D 4

别人的答案：

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

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

3.Integer a = 1;
Integer b = 1;
Integer c = 500;
Integer d = 500;
System.out.print(a == b);
System.out.print(c == d);
上述代码返回结果为：
true、true
true、false
false、true
false、false

这题很简单，考的是包装类的缓存问题，首先会调用Integer.valuesOf(int)方法把int类型变量转换为包装类，在-128到127的范围之间会直接从常量池就是缓存中搜索，超过128将会重新创建一个Integer对象，也就是new一个对象出来，当然地址就不同了。

4.给定以下方法声明，调用执行mystery（1234）的输出结果？
//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

这题的考点是递归，难点在中间的递归部分，中间有三次递归，要等三次递归都结束了，再分别运行每次递归最后的那个输出语句。
1.先输出x % 10，为4
2.x为1234，x/10不为0，将x=123进入循环，先输出x % 10为3
3.再次进入递归循环，先输出x % 10为2
4.再次进入递归循环，先输出x % 10为1，不满足递归条件，跳出递归，执行最后一行(x % 10)，此时输出1
5.执行上一次递归的最后一行，输出2
6.执行上一次递归的最后一行，输出3
7.执行第一次的最后一行，输出4

4.26

1.Java的Daemon线程，setDaemon( )设置必须要？
在start之前
在start之后
前后都可以

java中线程分为两种类型：
1：用户线程。通过Thread.setDaemon(false)设置为用户线程；
2：守护线程。通过Thread.setDaemon(true)设置为守护线程，如果不设置，默认用户线程；
守护线程是服务用户线程的线程，在它启动之前必须先set。
daemon线程: daemon线程是为我们创建的用户线程提供服务的线程,比如说jvm的GC等等,这样的线程有一个非常明显的特征: 当用户线程运行结束的时候,daemon线程将会自动退出.(由此我们可以推出下面关于daemon线程的几条基本特点)

2.代码片段：
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 运行期抛出异常

首先b4和b5是属于final常量类型，不可改变所以相加后还是byte类型的数据，但是b1、b2不是，他们相加会自动升为int类型，但是b3是byte类型，int类型的值不能直接赋给byte类型的值，需要强制转换。
表达式的数据类型自动提升, 关于类型的自动提升，注意下面的规则。
①所有的byte,short,char型的值将被提升为int型；
②如果有一个操作数是long型，计算结果是long型；
③如果有一个操作数是float型，计算结果是float型；
④如果有一个操作数是double型，计算结果是double型；

4.27

1. A,B,C,D 中哪些是 setvar的重载？
   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;}

考点是要区分重载和重写，可以理解记忆为 构造方法的重载和继承关系中子类对父类方法的重写。
重载：类名相等，返回值类型可以不同，参数一定不同（可以体现在顺序、数量、类型等性质的不同），访问权限可以不同，在编译期。
重写：类名相同，子类方法返回值类型应比父类方法返回值类型更小或相等，参数一定相同，访问权限只能和父类的相等或比父类的小，在运行期。
注：在重写中如果方法的返回类型是 void 和基本数据类型，则返回值重写时不可修改；如果返回值类型时引用类型，重写时是可以返回该引用类型的子类的。

2.下面论述正确的是（）？
A 如果两个对象的hashcode相同，那么它们作为同一个HashMap的key时，必然返回同样的值
B 如果a,b的hashcode相同，那么a.equals(b)必须返回true
C 对于一个类，其所有对象的hashcode必须不同
D 如果a.equals(b)返回true，那么a,b两个对象的hashcode必须相同

hashCode方法本质就是一个哈希函数，这是Object类的作者说明的。Object类的作者在注释的最后一段的括号中写道：将对象的地址值映射为integer类型的哈希值。但hashCode()并不完全可靠的，有时候不同的对象他们生成的hashcode也会一样，因此hashCode()只能说是大部分时候可靠。
因此我们也需要重写equals()方法，但因为重写的equals()比较全面比较复杂，会造成程序效率低下，而利用hashCode()进行对比，则只要生成一个hash值进行比较就可以了，效率很高。因此，正常的操作流程是先用hashCode()去对比两个对象，如果hashCode()不一样，则表示这两个对象肯定不相等，直接返回false,如果hashCode()相同，再对比他们的equals()。
综上所述：
equals()相等的两个对象hashCode()一定相等。
hashCode()相等的两个对象equal()不一定相等。
因此选项D正确。

3.下面有关java final的基本规则，描述错误的是？
A final修饰的类不能被继承
B final修饰的成员变量只允许赋值一次，且只能在类方法赋值
C final修饰的局部变量即为常量，只能赋值一次。
D final修饰的方法不允许被子类覆盖

final修饰的类不能被继承、final修饰的方法不允许被子类覆盖、final修饰的变量，不能改变值、final修饰的引用类型，不能再指向别的东西，但是可以改变其中的内容。
final所修饰的成员变量只能赋值一次，可以在类方法中赋值，也可以在声明的时候直接赋值，而final修饰的局部变量可以在声明的时候初始化，也可以在第一次使用的通过方法或者表达式给它赋值。

4.abstract和final可以同时作为一个类的修饰符。（ ）
A 正确
B 错误

因为final修饰的类不可以被继承，但是abstract修饰一个类，这个类一定可以被继承，所以两者不能一起修饰类。

4.28

1.ResultSet中记录行的第一列索引为？
A -1
B 0
C 1
D 以上都不是

结果集(ResultSet)是数据中查询结果返回的一种对象，可以说结果集是一个存储查询结果的对象，但是结果集并不仅仅具有存储的功能，他同时还具有操纵数据的功能，可能完成对数据的更新等。
ResultSet跟普通的数组不同，索引从1开始而不是从0开始

2.Java的集合框架中重要的接口java.util.Collection定义了许多方法。选项中哪个方法是Collection接口所定义的（ ）
int size()
boolean containsAll(Collection c)
compareTo(Object obj)
boolean remove(Object obj)

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

3多选.Java是一门支持反射的语言,基于反射为Java提供了丰富的动态性支持，下面关于Java反射的描述，哪些是错误的：( )
A Java反射主要涉及的类如Class, Method, Filed,等，他们都在java.lang.reflet包下
B 通过反射可以动态的实现一个接口，形成一个新的类，并可以用这个类创建对象，调用对象方法
C 通过反射，可以突破Java语言提供的对象成员、类成员的保护机制，访问一般方式不能访问的成员
DJava反射机制提供了字节码修改的技术，可以动态的修剪一个类
EJava的反射机制会给内存带来额外的开销。例如对永生堆的要求比不通过反射要求的更多
FJava反射机制一般会带来效率问题，效率问题主要发生在查找类的方法和字段对象，因此通过缓存需要反射类的字段和方法就能达到与之间调用类的方法和访问类的字段一样的效率
正确答案: A D F

Class类是在lang包下的；
可以通过动态代理的模式实现一个接口，动态代理底层就是反射。
通过反射可以获得私有对象和方法；
反射不可以动态修建一个类；

4.29

1、以下表达式的类型和值（注意整数除法）是（）
-5 + 1/4 + 2*-3 + 5.0
A int -3
B int -4
C double -5.5
D double -6.0

int类型的加减乘除是直接省略掉小数位数，直接取整数位，然后因为式子中有个 5.0，为double类型的值，会直接向上转型为double类型。

2.下面有关JAVA异常类的描述，说法错误的是？
A 异常的继承结构：基类为Throwable，Error和Exception继承Throwable，RuntimeException和IOException等继承Exception
B 非RuntimeException一般是外部错误(非Error)，其一般被 try{}catch语句块所捕获
C Error类体系描述了Java运行系统中的内部错误以及资源耗尽的情形，Error不需要捕捉
D RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等，必须被 try{}catch语句块所捕获

异常的基类为Throwable，其下有 Error类和 Exception类
1.Exception类是指程序可以处理的异常，分为两种：checked Exception和unchecked Exception；前一种是可被检查出来的异常，是非RunnableException以及其子类的其他 Exception类和其子类，可以被catch捕获，比如有classnotfound异常、io异常、sql异常等；后一种是不可以被检查出来的异常，是RunnableException以及其子类，我们即使不处理不受检查异常也可以正常通过编译。比如有空指针异常、数组下标越界异常、类型转换异常等。
2.Error类是指程序无法处理的错误，不推荐使用catch捕获，当遇到这些错误时jvm虚拟机会直接终止线程。

3.String str = “”;
System.out.print(str.split(“,”).length);
输出结果为：
A 0
B 1
D 出现异常

首先str.split(“,”)方法是将对应字符串根据参数进行分割，比如题目中就是按逗号进行分割，如果没有找到分隔符，会把整个字符串当成一个长度为1的字符串数组返回到结果， 所以此处结果就是1。

4.下面的switch语句中，x可以是哪些类型的数据：()
switch(x)
{
default:
System.out.println(“Hello”);
}
A long
B char
C float
D byte
E double
F String

在Java7之前，switch只能支持 byte、short、char、int或者其对应的封装类以及Enum类型。在Java7中，也支持了String类型
String byte short int char Enum 类型

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

A选项，Object是一切类的父类，Java中所有的类都直接或间接继承自Object。
B选项，继承了Object类一定是一个类，不是接口。
C选项，说反了，equals方法中使用了 ==。
D选项，类都可以使用Object中的方法比如：hashCode方法、toString方法、equals方法、getClass方法

6.非抽象类实现接口后，必须实现接口中的所有抽象方法，除了abstract外，方法头必须完全一致.
正确
错误

实际上这道题考查的是两同两小一大原则：方法名相同，参数类型相同
子类返回类型小于等于父类方法返回类型，
子类抛出异常小于等于父类方法抛出异常，
子类访问权限大于等于父类方法访问权限。

多选7.Java的体系结构包含（ ）。
Java编程语言
Java类文件格式
Java API
JVM

Java体系结构包括四个独立但相关的技术：
Java程序设计语言
Java.class文件格式
Java应用编程接口（API）
Java虚拟机
我们再在看一下它们四者的关系：
当我们编写并运行一个Java程序时，就同时运用了这四种技术，用Java程序设计语言编写源代码，把它编译成Java.class文件格式，然后再在Java虚拟机中运行class文件。当程序运行的时候，它通过调用class文件实现了Java API的方法来满足程序的Java API调用

多选 8.下列描述正确的是（ ）
类不可以多继承而接口可以多实现
抽象类自身可以定义成员而接口不可以
抽象类和接口都不能被实例化
一个类可以有多个直接基类和多个基接口

A java不可以多继承
B 抽象类可以定义普通成员变量而接口不可以，但是抽象类和接口都可以定义静态成员变量，只是接口的静态成员变量要用static final public 来修饰。
C 接口没有构造方法，不可以被直接实例化

多选9.以下哪几种方式可用来实现线程间通知和唤醒：( )
Object.wait/notify/notifyAll
ReentrantLock.wait/notify/notifyAll
Condition.await/signal/signalAll
Thread.wait/notify/notifyAll

在Java中，常用的线程通信方式有两种，分别是利用Monitor实现线程通信、利用Condition实现线程通信。线程同步是线程通信的前提，所以究竟采用哪种方式实现通信，取决于线程同步的方式。
如果是采用synchronized关键字进行同步，则需要依赖Monitor（同步监视器）实现线程通信，Monitor就是锁对象。在synchronized同步模式下，锁对象可以是任意的类型，所以通信方法自然就被定义在Object类中了，这些方法包括：wait()、notify()、notifyAll()。一个线程通过Monitor调用wait()时，它就会释放锁并在此等待。当其他线程通过Monitor调用notify()时，则会唤醒在此等待的一个线程。当其他线程通过Monitor调用notifyAll()时，则会唤醒在此等待的所有线程。
JDK 1.5新增了Lock接口及其实现类，提供了更为灵活的同步方式。如果是采用Lock对象进行同步，则需要依赖Condition实现线程通信，Condition对象是由Lock对象创建出来的，它依赖于Lock对象。Condition对象中定义的通信方法，与Object类中的通信方法类似，它包括await()、signal()、signalAll()。通过名字就能看出它们的含义了，当通过Condition调用await()时当前线程释放锁并等待，当通过Condition调用signal()时唤醒一个等待的线程，当通过Condition调用signalAll()时则唤醒所有等待的线程。

4.30

1.Which of the following statements are valid array declaration?
(A) int number();
(B) float average[];
© double[] marks;
(D) counter int[];
选项：(B) & ( C )
(A)
(A) & ( C )
(D)

java中数组有两种命名方式：一种是int[ ] xxx另一种是 int xxx[ ]。

2.枚举（enum）属于基本数据类型（primitive type）。
正确
错误

枚举是一个特殊的类，可以有自己的成员变量和方法

3.java语言的下面几种数组复制方法中，哪个效率最高？
for 循环逐一复制
System.arraycopy
Array.copyOf
使用clone方法

1.System.arraycopy()：native方法+JVM手写函数，在JVM里预写好速度最快
2.clone()：native方法，但并未手写，需要JNI转换，速度其次
3.Arrays.copyof()：本质是调用1的方法
4.for()：全是深复制，并且不是封装方法，最慢情有可原

4.以下哪一个不是赋值符号？
+=
<<=
<<<=
‘> >> =

<<表示左移位
‘’>>表示带符号右移位
‘’>>>表示无符号右移
但是没有<<<运算符

5.设有下面两个赋值语句：
a = Integer.parseInt(“1024”);
b = Integer.valueOf(“1024”).intValue();
下述说法正确的是（）
a是整数类型变量，b是整数类对象。
a是整数类对象，b是整数类型变量。
a和b都是整数类对象并且它们的值相等。
a和b都是整数类型变量并且它们的值相等。

intValue()是把Integer对象类型变成int的基础数据类型；
parseInt()是把String 变成int的基础数据类型；
Valueof()是把String 转化成Integer对象类型；（现在JDK版本支持自动装箱拆箱了。）
本题：parseInt得到的是基础数据类型int，valueof得到的是装箱数据类型Integer，然后再通过valueInt转换成int，所以选择D

五月

1./…/中可以嵌套//注释，也能嵌套/…/注释。
正确
错误

在Java中规定，多行注释可以嵌套单行注释，但是不能嵌套多行注释。 不太能理解原因的朋友不妨这样想，如果多行注释/A//B/完全可以将内部的A//B作为普通字符串来理解，没有所谓单行不单行之说，所以可以嵌套单行注释。 但是如果是嵌套多行注释呢可以看看/A/B/C/，到编译器遇到多行注释的时候会以’/A/B/’来作为匹配的字符串，从而C/会被理解为程序语句，而C*/显然不符合程序语法，因此这样想就能理解为什么不能多行注释嵌套多行注释了

2.What is the result of compiling and executing the following fragment of code:
Boolean flag = false;
if (flag = true)
{
System.out.println(“true”);
}
else
{
System.out.println(“false”);
}
The code fails to compile at the “if” statement.
An exception is thrown at run-time at the “if” statement.
The text“true” is displayed.
The text“false”is displayed.
Nothing is displayed.

这题的第一个坑是Boolean是包装类，第二个坑是if中的是“=”，是赋值语句，但因为布尔类型值的特殊性：if的语句比较，除boolean外的其他类型都不能使用赋值语句，否则会提示无法转成布尔值。而返回值是等号左侧变量的引用，(flag = true)返回true，(flag = false)返回的就是false。但是如果是基本的数据类型 if（int/float/double=值）是不被允许的。

3.下列哪个说法是正确的（）
ConcurrentHashMap使用synchronized关键字保证线程安全
HashMap实现了Collction接口
Array.asList方法返回java.util.ArrayList对象
SimpleDateFormat是线程不安全的

A JDK1.8 的 ConcurrentHashMap 采用CAS+Synchronized保证线程安全。 JDK1.7 及以前采用segment的分段锁机制实现线程安全，其中segment继承自ReentrantLock，因此采用Lock锁来保证线程安全。
B HashMap应该实现的是Map接口。
C Array.asList方法返回的是java.utill.Arrays类的一个内部类ArrayList。

4.下面代码运行结果是？
class Value{
public int i=15;
}
public class Test{
public static void main(String argv[]){
Test t=new Test( );
t.first( );
}
public void first( ){
int i=5;
Value v=new Value( );
v.i=25;
second(v,i);
System.out.println(v.i);
}
public void second(Value v,int i){
i = 0;
v.i = 20;
Value val = new Value( );
v = val;
System.out.println(v.i+" "+i);
}
}
15 0 20
15 0 15
20 0 20
0 15 20

这题考察的是值传递与引用传递，Java中原始数据类型都是值传递，传递的是值得副本，形参的改变不会影响实际参数的值， 引用传递传递的是引用类型数据，包括String,数组，列表, map,类对象等类型，形参与实参指向的是同一内存地址，因此形参改变会影响实参的值。
因为这一题中参数传入的是对象，所以对象的值是会变化的。第一个first函数中，将Value对象中的i变为了25，再进入second方法中，将Value对象中的i变为了20，再通过v = val;赋值， System.out.println(v.i+" "+i);此时输出的 v.i 应该是一个新的val对象的i的初始值 15，i是0。回退到first方法
second(v, i);是将v指向的地址传递给方法内的临时变量v，使其指向传递外部的那个对象，因此，在v = val;中只是将改变此方法中临时变量的指向，不会影响外部的v。而v.i = 20;则是修改指向的对象的变量的值。

5.将下列哪个代码（A、B、C、D）放入程序中标注的【代码】处将导致编译错误？
class A{
public float getNum(){
return 3.0f;
}
}
public class B extends A{
【代码】
}
A public float getNum(){return 4.0f;}
B public void getNum(){}
C public void getNum(double d){}
D public double getNum(float d){return 4.0d;}

注意，重载的范围是同一类，重写的范围是父子类，所以这里很明显的是重写；重写要求参数名相同，参数列表不变，返回值类型要比父类的小或者相等，发生阶段是在运行期间。
⭐️ 关于 重写的返回值类型 这里需要额外多说明一下，上面的表述不太清晰准确：如果方法的返回类型是 void 和基本数据类型，则返回值重写时不可修改。
所以A是标准的重写，B是错误的重写方式，因为原方法的返回值类型是基本数据类型，不能修改原返回值类型。C,D是不同的同名方法。

6.以下关于对象序列化描述正确的是
使用FileOutputStream可以将对象进行传输
使用PrintWriter可以将对象进行传输
使用transient修饰的变量不会被序列化
对象序列化的所属类需要实现Serializable接口

声明为static和transient类型的成员数据不能被序列化。因为static代表类的状态， transient代表对象的临时数据。所以答案是C、D

7.下列正确的有（）
call by value不会改变实际参数的数值
call by reference能改变实际参数的参考地址
call by reference不能改变实际参数的参考地址
call by reference能改变实际参数的内容

这些单词是值传递和引用传递的意思。
选ACD。该题考察的是值传递和引用传递参数的调用。
值传递是将变量的一个副本传递到方法中，方法中如何操作该变量副本，都不会改变原变量的值。
引用传递是将变量的内存地址传递给方法，方法操作变量时会找到保存在该地址的变量，对其进行操作。会对原变量造成影响。

8.volatile关键字的说法错误的是
能保证线程安全
volatile关键字用在多线程同步中，可保证读取的可见性
JVM保证从主内存加载到线程工作内存的值是最新的
volatile能禁止进行指令重排序

volatile是java中的一个类型修饰符。它是被设计用来修饰被不同线程访问和修改的变量。如果不加入volatile，基本上会导致这样的结果：要么无法编写多线程程序，要么编译器 失去大量优化的机会。

1，可见性

可见性指的是在一个线程中对该变量的修改会马上由工作内存（Work Memory）写回主内存（Main Memory），所以会马上反应在其它线程的读取操作中。顺便一提，工作内存和主内存可以近似理解为实际电脑中的高速缓存和主存，工作内存是线程独享的，主存是线程共享的。

2，禁止指令重排序优化

禁止指令重排序优化。大家知道我们写的代码（尤其是多线程代码），由于编译器优化，在实际执行的时候可能与我们编写的顺序不同。编译器只保证程序执行结果与源代码相同，却不保证实际指令的顺序与源代码相同。这在单线程看起来没什么问题，然而一旦引入多线程，这种乱序就可能导致严重问题。volatile关键字就可以从语义上解决这个问题。

注意，禁止指令重排优化这条语义直到jdk1.5以后才能正确工作。此前的JDK中即使将变量声明为volatile也无法完全避免重排序所导致的问题。所以，在jdk1.5版本前，双重检查锁形式的单例模式是无法保证线程安全的。因此，下面的单例模式的代码，在JDK1.5之前是不能保证线程安全的。

什么是有序性？
程序执行的顺序按照代码的先后顺序执行

1
2
int a = 0; //1
int b = 2; //2

像这2句代码1会比2先执行，但是jvm在正真执行时不一定是1在2之前，这里涉及一个概念叫做指令重排，处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。比如上面的代码语句1和语句2谁先执行对最终的程序结果并没有影响，那么就有可能在执行过程中，语句2先执行而语句1后执行。
在指令重排时会考虑指令之间的数据依赖性，比如2依赖了1的数值，那么处理器会保证1在2之前执行。
但是在多线程的情况下，指令重排就会有影响了。

5.2

1.运行代码，输出的结果是（）
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);
}
}
P is init 123
S is init P is init 123
P is init S is init 123
S is init 123

我们知道，父子类的初始化顺序是先初始化父类的静态代码块和静态成员变量，再初始化子类的静态代码块和成员变量。从这就可以应该先打印 Pisinit 然后是123。这里的考点是不会去初始化子类，因为属于第一种情况：子类引用父类的静态字段，只会触发子类的加载、父类的初始化，不会导致子类初始化。
不会初始化子类的几种
1.调用的是父类的static方法或者字段
2.调用的是父类的final方法或者字段
3.通过数组来引用

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

string本质上来说底层是char数组，它的length()返回数组大小，而unicode中一个汉字是可以用一个char表示的，一个汉字等于一个字符，字符 是char ，一个汉字也等于二个字节，字节 是byte。

3.假定Base b = new Derived（）; 调用执行b.methodOne（）后，输出结果是什么？
public class Base
{
public void methodOne()
{
System.out.print(“A”);
methodTwo();
}
public void methodTwo()
{
System.out.print(“B”);
}
}
public class Derived extends Base
{
public void methodOne()
{
super.methodOne();
System.out.print(“C”);
}
public void methodTwo()
{
super.methodTwo();
System.out.print(“D”);
}
}

这题是错题重写，依旧写错了，再理一遍知识点：在多态中，即使类型是父类类型，调用方法时还是会先调用子类的重写的方法，如果子类方法中使用了super关键字调用父类方法，才会调用父类的方法。所以这题的顺序是：先调用子类的methodOne方法，因为有super关键字，所以调用父类的methodOne方法，输出A，此时又进入了methodTwo方法，先进入子类的methodTwo方法，因为使用了super关键字，所以进入父类方法输出B，在输出D，最后结束子类方法输出C。

4.下列哪个语句语法正确？（ ）
byte y = 11; byte x = y +y;
String x = new Object();
Object x = new String(“Hellow”);
int a [11] = new int [11];

这题考的知识点也是之前学习过的，主要在A上，后一半两个byte类型的变量相加时会自动转换为int类型的相加，结果也是int类型，需要强制转换；前面的赋值没有问题是因为本来byte的类型是小于127，所以没有问题。

5.3

1.假设num已经被创建为一个ArrayList对象，并且最初包含以下整数值：[0，0，4，2，5，0，3，0]。 执行下面的方法numQuest()，数组num会变成？
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++;
}
}
[3, 5, 2, 4, 0, 0, 0, 0]
[0, 0, 0, 0, 4, 2, 5, 3]
[0, 0, 4, 2, 5, 0, 3, 0]
[0, 4, 2, 5, 3]

这题有个注意事项，就是remove后数组的size会自动减1，就是说在删除第一个0时，此时的数组为[0, 4, 2, 5, 0, 3, 0]，这是k为1直接比较了下标为1的4，跳过了第二位的0，所以答案中第一位是0.

2.关于下面的程序Test.java说法正确的是( )。
public class Test {
static String x=“1”;
static int y=1;
public static void main(String args[]) {
static int z=2;
System.out.println(x+y+z);
}
}
3
112
13
程序有编译错误

这题真的很坑,这题考点在于：1.字符串的拼接，因为x是string类型的，所以用+连接他们实际上是字符串的拼接 2.局部变量不能使用static修饰，因为局部变量是属于方法的

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

A 抽象类可以实现接口和继承抽象类，但是接口不行，接口只能继承接口。
C 抽象类是指被 abstract 修饰的类，可以不包括抽象方法。
D 抽象类和接口都不可以被实例化

4.list是一个ArrayList的对象，哪个选项的代码填到//todo delete处，可以在Iterator遍历的过程中正确并安全的删除一个list中保存的对象？（）
Iterator it = list.iterator();
int index = 0;
while (it.hasNext())
{
Object obj = it.next();
if (needDelete(obj)) //needDelete返回boolean，决定是否要删除
{
//todo delete
}
index ++;
}
it.remove();
list.remove(obj);
list.remove(index);
list.remove(obj,index);

这题考察的是如果直接调用ArrayList集合的remove方法，集合的长度会随着元素的remove而变化，但是如果调用迭代器的remove方法，则不会有问题，Iterator 支持从源集合中安全地删除对象。

5.下列说法正确的是（）
在类方法中可用this来调用本类的类方法
在类方法中调用本类的类方法时可直接调用
在类方法中只能调用本类中的类方法
在类方法中绝对不能调用实例方法

这里有个要注意的点，选项中说的是类方法即static修饰的方法是属于类的，this指代的是当前对象，所以在静态方法中无法使用this调用本类的静态方法，静态方法直接方法名调用即可，非静态方法使用new 对象的方法进行调用。

6.Which lines of the following will produce an error?
byte a1 = 2, a2 = 4, a3;
short s = 16;
a2 = s;
a3 = a1 * a2;
A Line 3 and Line 4
B Line 1 only
C Line 3 only
D Line 4 only

Line3的s是short类型，a2是byte类型，转换出错。
byte类型的数据加减乘除时最后结果是int类型。

5.4

1.When is the text “Hi there” displayedpublic 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();
}
}
Never.
Each time a new object of type StaticTest is created.
Once when the class is loaded into the Java virtual machine.
Only when the main() method is executed.

这题的考点是，static静态代码块是随着类的加载而加载，并且只会加载一次。

2.如下代码的输出是
package Test;
public class Test {
private static void test(int[] arr) {
for (int i = 0; i < arr.length; i++) {
try {
if (arr[i] % 2 == 0) {
throw new NullPointerException();
} else {
System.out.print(i);
}
} finally {
System.out.print(“e”);
}
}
}
public static void main(String[]args) {
try {
test(new int[] {0, 1, 2, 3, 4, 5});
} catch (Exception e) {
System.out.print(“E”);
}
}
}
编译出错
eE
Ee
eE1eE3eE5
Ee1Ee3Ee5

这题的考点是：当catch捕获到异常并执行完final后，程序会自动结束运行，所以其实这段代码只执行到了 arr[0] 的部分，然后就退出程序了。

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

内部类是定义在一个类中的类，一个静态内部类可以访问外部类中的静态代码块，不可以访问非静态数据；一个非静态内部类可以访问非静态代码和私有代码。和静态数据和静态私有数据。

4.对文件名为Test.java的java代码描述正确的是()
class Person {
String name = “No name”;
public Person(String nm) {
name = nm;
}
}
class Employee extends Person {
String empID = “0000”;
public Employee(String id) {
empID = id;
}
}
public class Test {
public static void main(String args[]) {
Employee e = new Employee(“123”);
System.out.println(e.empID);
}
}
输出：0000
输出：123
编译报错
输出：No name

这题的考点在于，父类中没有无参的构造方法，在继承时需要子类显示的调用父类的有参构造，需要在子类的构造方法的第一行添加super(“nm”);，否则会报错。

5.5

1.下列叙述中，错误的是（ ）
File类能够存储文件属性
File类能够读写文件
File类能够建立文件
File类能够获取文件目录信息

file类可以操作文件本身，但不能对文件内容进行修改，对文件内容进行修改的是io流部分。

2.以下说法错误的是（）
其他选项均不正确
java线程类优先级相同
Thread和Runnable接口没有区别
如果一个类继承了某个类，只能使用Runnable实现线程

B 线程是有优先级的
C 一个是类一个接口，肯定是有区别的
D错在 不是只能使用Runable实现线程
实现线程的方式有：继承Thread类，重现run()方法；
实现Runable接口，实现run()方法；
实现Callable接口，线程结束后有返回值。

3.关于下面一段代码，以下说法正确的是： ()
public class Test {
private synchronized void a() {
}
private void b() {
synchronized (this) {
}
}
private synchronized static void c() {
}
private void d() {
synchronized (Test.class) {
}
}
}
同一个对象，分别调用方法a和b，锁住的是同一个对象
同一个对象，分别调用方法a和c，锁住的是同一个对象
同一个对象，分别调用方法b和c，锁住的不是同一个对象
同一个对象，分别调用方法a、b、c，锁住的不是同一个对象

这题考的是加锁的作用范围，synchronized 修饰方法，锁住的是对象；修饰代码块的话可以锁住任意对象，因为B中锁的是this代表本类对象，所以和A锁的是一个对象。其中C是静态方法，给静态方法加锁锁的是类class文件。因为D中也是锁修饰的代码块，但是指定了class对象，所以C和D锁的是同一个。

4.Java数据库连接库JDBC用到哪种设计模式?
生成器
桥接模式
抽象工厂
单例模式

桥接模式：
定义 ：将抽象部分与它的实现部分分离，使它们都可以独立地变化。
意图 ：将抽象与实现解耦。
桥接模式所涉及的角色
1.Abstraction ：定义抽象接口，拥有一个Implementor类型的对象引用
2.RefinedAbstraction ：扩展Abstraction中的接口定义
3.Implementor ：是具体实现的接口，Implementor和RefinedAbstraction接口并不一定完全一致，实际上这两个接口可以完全不一样Implementor提供具体操作方法，而Abstraction提供更高层次的调用
4.ConcreteImplementor ：实现Implementor接口，给出具体实现
Jdk中的桥接模式：JDBC
JDBC连接 数据库 的时候，在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不动，原因就是JDBC提供了统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了

5.下列Java代码中的变量a、b、c分别在内存的____存储区存放。
class A {
private String a = “aa”;
public boolean methodB() {
String b = “bb”;
final String c = “cc”;
}
}
堆区、堆区、堆区
堆区、栈区、堆区
堆区、栈区、栈区
堆区、堆区、栈区
静态区、栈区、堆区
静态区、栈区、栈区

a是类中的成员变量，存放在堆区
b、c都是方法中的局部变量，存放在栈区

5.6

1.关于以下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
4行与9行不能通过编译，因为缺少方法名和返回类型
编译通过，执行结果是：x=5
编译通过，执行结果是：x=3
9行不能通过编译，因为只能有一个静态初始化器

这题的考点在静态代码块是优先于主方法的，静态代码块的执行顺序按照出现顺序执行

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

		public class Demo {
	public static void main(String[] args) {
		Collection<?>[] collections = 
{new HashSet<String>(), new ArrayList<String>(), new HashMap<String, String>().values()};
				Super subToSuper = new Sub();
				for(Collection<?> collection: collections) {
	System.out.println(subToSuper.getType(collection));
}
}
abstract static class Super {
	public static String getType(Collection<?> collection) {
		return “Super:collection”;
}
public static String getType(List<?> list) {
		return “Super:list”;
}
public String getType(ArrayList<?> list) {
		return “Super:arrayList”;
}
public static String getType(Set<?> set) {
		return “Super:set”;
}
public String getType(HashSet<?> set) {
		return “Super:hashSet”;
}
}
static class Sub extends Super {
	public static String getType(Collection<?> collection) {
            return "Sub"; }
}
}

A Sub:collection Sub:collection Sub:collection
B Sub:hashSetSub:arrayList Sub:collection
C Super:collection Super:collection Super:collection
D Super:hashSet Super:arrayList Super:collection

这题考察的是静态方法在重写中的应用，如果父类的方法是静态方法，子类重写了这个方法后，按照一般的多态重写的思路，在使用多态调用此方法时，在没有super关键字的前提下是默认调用子类的重写方法的。
但是这里父类的方法是静态方法，static方法不能被子类覆写，在子类中定义了和父类完全相同的static方法，则父类的static方法被隐藏，Son.staticmethod()或new Son().staticmethod()都是调用的子类的static方法，如果是Father.staticmethod()或者Father f = new Son(); f.staticmethod()调用的都是父类的static方法。

下列关于序列化和反序列化描述正确的是：
序列化是将数据转为n个 byte序列的过程
反序列化是将n个 byte转换为数据的过程
将类型int转换为4 byte是反序列化过程
将8个字节转换为long类型的数据为序列化过程

序列化：将我们看的懂的转换为我们看不懂但是机器看的懂的，将数据结构转换称为二进制数据流或者文本流的过程。
反序列化：我们看不懂但是机器看的懂的转换为我们看的懂的，将二进制数据流或者文本流转换称为易于处理和阅读的数据结构的过程。

5.7

1.往OuterClass类的代码段中插入内部类声明, 哪一个是错误的:
public class OuterClass{
private float f=1.0f;
//插入代码到这里
}
A class InnerClass{
public static float func(){return f;}
}
B abstract class InnerClass{
public abstract float func(){}
}
C static class InnerClass{
protected static float func(){return f;}
}
D public class InnerClass{
static float func(){return f;}
}

A,C 错误原因是因为静态方法不能调用非静态变量，B中的抽象方法不应该有方法体，D中的一个java文件中只能有一个public修饰的类class。

2.定义有StringBuffer s1=new StringBuffer(10);s1.append(“1234”)，则s1.length()和s1.capacity()分别是多少?
A 4 10
B 4 4
C 10 10
D 10 4

StringBuffer s1=new StringBuffer(10) 是初始化一个StringBuffer，大小为10，然后使用append方法对此进行拼接，length方法获得的是 StringBuffer 的真实长度即4，而capacity是容量的意思，这个方法获得的是 StringBuffer 的容量大小，即为10.如果StringBuffer 内的值超过了原始容量大小10，则需要进行扩容。

3.下列代码输出结果为（ ）
class Animal{
public void move(){
System.out.println(“动物可以移动”);
}
}
class Dog extends Animal{
public void move(){
System.out.println(“狗可以跑和走”);
}
public void bark(){
System.out.println(“狗可以吠叫”);
}
}
public class TestDog{
public static void main(String args[]){
Animal a = new Animal();
Animal b = new Dog();
a.move();
b.move();
b.bark();
}
}
A 动物可以移动
狗可以跑和走
狗可以吠叫
B 动物可以移动
动物可以移动
狗可以吠叫
C 运行错误
D 编译错误

这个题我忽略了一点，就是多态中父类对象不能调用子类独有而父类没有的对象。

4.以下程序段的输出结果为：
public class EqualsMethod
{
public static void main(String[] args)
{
Integer n1 = new Integer(47);
Integer n2 = new Integer(47);
System.out.print(n1 == n2);
System.out.print(“,”);
System.out.println(n1 != n2);
}
}
false，false
false，true
true，false
true，true

这题是做的老掉牙的题目了，不应该做错，看到Integer我第一时间想到了缓存池，但是这里使用对象的形式调用的，不管有没有缓存池，他们都是对象，而==比较的就是存储的地址。

5.有一个源代码，只包含import java.util.* ; 这一个import语句，下面叙述正确的是？ ( )
只能写在源代码的第一句
可以访问java/util目录下及其子目录下的所有类
能访问java/util目录下的所有类，不能访问java/util子目录下的所有类
编译错误

这题我们可以设想，如果先调用的类和其子类中有同名函数，那就不知道调用的是哪个包下的函数，所以在使用import引用时不能访问其子目录下的所有类。

6.给定代码：
public class SwitchTest{//1
public static void main(String[] args) {//2
System.out.println(“value=”+switchit(4));//3
}//4
public static int switchit(int x) {
int j=1;
switch (x) {
case 1:j++;
case 2:j++;
case 3:j++;
case 4:j++;
case 5:j++;
default:j++;
}
return j+x;
}
}
value=6
value=8
value=3
value=5
value=4

这个switch cash没有break，所以会从进入switch的地方开始一直执行到结尾，这题我写错的原因是我不知道default代码块这块要不要运行。

5.8

1.关于Java中的数组，下面的一些描述，哪些描述是准确的：（ ）
A 数组是一个对象，不同类型的数组具有不同的类
B 数组长度是可以动态调整的
C 数组是一个连续的存储结构
D 一个固定长度的数组可类似这样定义: int array[100]
E 两个数组用equals方法比较时，会逐个遍历其中的元素，对每个元素进行比较
F 可以二维数组，且可以有多维数组，都是在Java中合法的

D错是因为Java语言中，数组是一种引用类型的变量，使用它定义变量时，这个引用变量还没有指向任何有效的内存空间，因此定义数组时不能指定数组的长度。而由于这个引用变量并没有指向任何有效的内存空间，所以没有空间来存储任何元素，只有当对数组初始化后，才可以使用这个数组。D选项正确的定义方式为int[] array =new int[100]。
E错是因为数组没有重写过object类中的equals方法，没有重写过的equals方法和==差不多，使用Arrays.equals() 是比较两个数组中的内容。
正确答案: A C F

2.下面哪些赋值语句是正确的（）
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进行了类型转换，C的boolean类型不能和任何类型进行转换，D可以进行这样的定义，E中的128超出了byte的范围。

3.对以下代码，哪些选项执行后是true的：（）
class CompareReference{
public static void main(String [] args){
float f=42.0f;
float f1[]=new float[2];
float f2[]=new float[2];
float[] f3=f1;
long x=42;
f1[0]=42.0f;
}
}
f1== f2
x== f1[0]
f1== f3
f2== f1[1]

基本类型之间的比较，应该会将低精度类型自动转为高精度类型再比较。
java核心卷I中43页有如下表述：两个数值进行二元操作时，会有如下的转换操作：
如果两个操作数其中有一个是double类型，另一个操作就会转换为double类型。
否则，如果其中一个操作数是float类型，另一个将会转换为float类型。
否则，如果其中一个操作数是long类型，另一个会转换为long类型。
否则，两个操作数都转换为int类型。
B选项：x == f1[0] ，x是long类型，与float类型对比属于低精度，所以x要向高精度的float类型转型再比较，故相等；
C选项：f1 == f3，f3没有new创建，而是由f1赋值，所以f3地址是指向f1的，f1值改变，相当于改变f3值，所以相等。
正确答案: B C

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

局部内部类可以看成一个局部变量，局部变量是不需要访问修饰符的，最多只需要final修饰所以C有问题。
A呢因为private只能访问本类的内容，外部类不需要private修饰。

5.下列哪种异常是检查型异常，需要在编写程序时声明？
NullPointerException
ClassCastException
FileNotFoundException
IndexOutOfBoundsException

正确答案: C

6.观察以下代码：
class Car extends Vehicle
{
public static void main (String[] args)
{
new Car(). run();
}
private final void run()
{
System. out. println (“Car”);
}
}
class Vehicle
{
private final void run()
{
System. out. println(“Vehicle”);
}
}
下列哪些针对代码运行结果的描述是正确的？
Car
Vehicle
Compiler error at line 3
Compiler error at line 5
Exception thrown at runtime

首先final声明的方法是不能被覆盖的，但是这里并不错误，因为方法是private的，也就是子类没有继承父类的run方法，因此子类的run方法跟父类的run方法无关，并不是覆盖。new Car().run()也是调用子类的run方法。
正确答案: A