牛客网Java专项训练选择题错题解析
public static void main(String[] args) {
int num = 0;
int count = 0;
for (int i = 0; i <=100; i++) {
num = num + i;
count = count++;
}
System.out.println(num * count);
}答案解析：count = count++;的意思是先将count初始化的值0暂时缓存起来，然后执行count自加1变成1，最后将暂存的值0再赋值给count，整个循环过程中count都为0.
第二题：下面论述正确的是（）？
如果两个对象的hashcode相同，那么它们作为同一个HashMap的key时，必然返回同样的值
如果a,b的hashcode相同，那么a.equals(b)必须返回true
对于一个类，其所有对象的hashcode必须不同
如果a.equals(b)返回true，那么a,b两个对象的hashcode必须相同
答案解析：本题主要考查Java中的“==”，equals()和hashcode之间的区别，详细参考：
http://blog.csdn.net/tiantiandjava/article/details/46988461
在java中：
==是运算符，用于比较两个变量的值是否相等；
equals()是Objec类的方法，用于比较两个对象是否相等，默认Object类的equals方法是比较两个对象的地址，跟==的结果一样。Object的equals方法如下：
public boolean equals(Object obj) {
return (this == obj);
}hashCode也是Object类的一个方法。返回一个离散的int型整数。在集合类操作中使用，为了提高查询速度。（HashMap，HashSet等）
java中的数据类型，可分为两类：
基本数据类型:byte,short,char,int,long,float,double,boolean 它们之间使用“==”比较时，比的是两个变量的值；
复合数据类型(类) ：使用“==”比较时，比的是在内存中的存放地址。Java中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址。Object的equals方法也是用双等号（==）进行比较的，所以比较后的结果跟双等号（==）的结果相同。如果两个对象根据equals()方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。如果两个对象根equals()方法比较是不相等的，那么调用这两个对象中任意一个对象的hashCode方法，则不一定要产生相同的整数结果。从而在集合操作的时候有如下规则：将对象放入到集合中时，首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等，如果不相等直接将该对象放入集合中。如果hashcode值相等，然后再通过equals方法判断要放入对象与集合中的任意一个对象是否相等，如果equals判断不相等，直接将该元素放入到集合中，否则不放入。
hashcode和equals的约定关系如下：1、如果两个对象相等，那么他们一定有相同的哈希值（hash code）。2、如果两个对象的哈希值相等，那么这两个对象有可能相等也有可能不相等。（需要再通过equals来判断）。
第三题：执行如下程序，输出结果是（ ）
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();
}
}答案解析：new出三个线程对象，所以调用的方法是同一个对象中的方法，三个线程所访问的数据data和result都是同一个堆上的内容。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输出结果为2 24 46 6
第四题：如下代码，执行test()函数后，屏幕打印结果为（）
public class Test2
{
public void add(Byte b)
{
b = b++;
}
public void test()
{
Byte a = 127;
Byte b = 127;
add(++a);
System.out.print(a + " ");
add(b);
System.out.print(b + "");
}
}答案解析：参考https://www.nowcoder.com/test/question/done?tid=14031459&qid=16022#summary
包装类的值都是final 不可变的，对于++b 或者b++ ，只是新创建了一个对象，然后把引用传给了原对象句柄，在函数中操作，只是形参的临时句柄改变了指向，实参的句柄还是指向原来的对象。所以即使不是b = b++ 这种，b的值在add之后也是不会变的。相当于局部引用变量重新指向了一个对象。基本类型的值是保存在栈内存里面的，每个方法都有自己的栈内存，所以add(++a)里面的操作对test()里面的a并没有什么影响，++a会溢出，++a的结果本来是1000 0000 又因为最高为为符号位，1表示负数，java用补码来表示负数，所以它的值应该要-1再取反，-1:0111 1111 再取反 1000 0000 所以表示的是-128；add(b)操作对test()里面的b值没影响，所以b = 127。
第五题：关于Java中关键字的基础知识点具体请参照：
http://download.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
第六题： 针对以下代码，哪些说法是正确的?
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;
}
}第六题：在try的括号里面有return一个值，那在哪里执行finally里的代码？
答案解析：https://www.nowcoder.com/test/question/done?tid=14035545&qid=4344#summary
第七题：对于子类的构造函数说明，下列叙述中错误的是（ ）。
子类可以继承父类的构造函数。
子类中调用父类构造函数不可以直接书写父类构造函数，而应该用super();。
用new创建子类的对象时，若子类没有带参构造函数，将先执行父类的无参构造函数，然后再执行自己的构造函数。
子类的构造函数中可以调用其他函数。
答案解析：java继承中对构造函数是不继承的，只是显式或者隐式调用；
第八题：下面哪个修饰符修饰的变量是所有同一个类生成的对象共享的（ ）
public
private
static
final
答案解析：static表示静态变量，归类所有，该类的所有对象公用。static修饰某个字段时，会改变字段创建的方式（每个被static修饰的字段对于每一个类来说只有一份存储空间，而非static修饰的字段对于每一个对象来说都有一个存储空间）static属性是属于类的，所以对象共同拥有，所以既可以通过类名.变量名进行操作，又可以通过对象名.变量名进行操作。
第九题：有时为了避免某些未识别的异常抛给更高的上层应用，在某些接口实现中我们通常需要捕获编译运行期所有的异常， catch 下述哪个类的实例才能达到目的：（）
Error
Exception
RuntimeException
Throwable
答案解析：error是系统出错，catch是无法处理的，难以修复的，RuntimeException不需要程序员进行捕获处理，error和exception都是throwable的子类，我们只需要对exception的实例进行捕获即可。
第十题：关于 JAVA 堆,下面说法错误的是()
所有类的实例和数组都是在堆上分配内存的
对象所占的堆内存是由自动内存管理系统回收
堆内存由存活和死亡的对象,空闲碎片区组成
数组是分配在栈中的
答案解析：
Java把内存分成两种，一种叫做栈内存，一种叫做堆内存。
在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量分配的内存空间，该内存空间可以立刻被另作他用。
堆内存用于存放由new创建的对象和数组。在堆中分配的内存，由java虚拟机自动垃圾回收器来管理。在堆中产生了一个数组或者对象后，还可以在栈中定义一个特殊的变量，这个变量的取值等于数组或者对象在堆内存中的首地址，在栈中的这个特殊的变量就变成了数组或者对象的引用变量，以后就可以在程序中使用栈内存中的引用变量来访问堆中的数组或者对象，引用变量相当于为数组或者对象起的一个别名，或者代号。
引用变量是普通变量，定义时在栈中分配内存，引用变量在程序运行到作用域外释放。而数组＆对象本身在堆中分配，即使程序运行到使用new产生数组和对象的语句所在地代码块之外，数组和对象本身占用的堆内存也不会被释放，数组和对象在没有引用变量指向它的时候（比如先前的引用变量x=null时），才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。这个也是java比较占内存的主要原因。 以上段落来自于某一本Java程序设计的书中，实际上，栈中的变量指向堆内存中的变量，这就是Java中的指针。总结起来就是
对象存储在堆内存，引用变量存储在栈内存。栈内存指向堆内存。
第十一题：Which keyword can protect a class in a package from accessibility by the classes outside the package but not package inside ?
private
protected
final
don't use any keyword at all (make it default) ？
答案解析：
第十二题：在java7中，下列不能做switch()的参数类型是？
整型
枚举类型
字符串
浮点型
答案解析：在switch（expr1）中，expr1只能是一个整数表达式或者枚举常量（更大字体），整数表达式可以是int基本类型或Integer包装类型，由于，byte,short,char都可以隐含转换为int，所以，这些类型以及这些类型的包装类型也是可以的。显然，long、float、double类型不符合switch的语法规定，并且不能被隐式转换成int类型，所以，它们不能作用于swtich语句中。
注意：String类型是Java7开始支持的。
第十三题：
|
1
2
3
4
|
public class OuterClass{
private float f=1.0f;
//插入代码到这里
}
|
正确答案:ABCD 你的答案:BD(错误)
class InnerClass{
public static float func(){return f;}
}
abstract class InnerClass{
public abstract float func(){}
}
static class InnerClass{
protected static float func(){return f;}
}
public class InnerClass{
static float func(){return f;}
}
参考：https://www.nowcoder.com/test/question/done?tid=14190307&qid=5120#summary
1.为什么使用内部类?
使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，
对于内部类都没有影响
1.1.使用内部类最大的优点就在于它能够非常好的解决多重继承的问题,使用内部类还能够为我们带来如下特性:
(1)、内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独。
(2)、在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类。
(3)、创建内部类对象的时刻并不依赖于外围类对象的创建。
(4)、内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。
(5)、内部类提供了更好的封装，除了该外围类，其他类都不能访问。
2.内部类分类:
(一).成员内部类:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
public
class
Outer{
private
int
age =
99
;
String name =
"Coco"
;
public
class
Inner{
String name =
"Jayden"
;
public
void
show(){
System.out.println(Outer.
this
.name);
System.out.println(name);
System.out.println(age);
}
}
public
Inner getInnerClass(){
return
new
Inner();
}
public
static
void
main(String[] args){
Outer o =
new
Outer();
Inner in = o.
new
Inner();
in.show();
}
}
|
如 public 、 protected 、 private 等
2.Inner 类中定义的 show() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，
如直接访问 Outer 类中的私有属性age
3.定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，
即：内部类 对象名 = 外部类对象.new 内部类( );
4.编译上面的程序后，会发现产生了两个 .class 文件: Outer.class,Outer$Inner.class{}
5.成员内部类中不能存在任何 static 的变量和方法,可以定义常量:
(1).因为非静态内部类是要依赖于外部类的实例,而静态变量和方法是不依赖于对象的,仅与类相关,
简而言之:在加载静态域时,根本没有外部类,所在在非静态内部类中不能定义静态域或方法,编译不通过;
非静态内部类的作用域是实例级别
(2).常量是在编译器就确定的,放到所谓的常量池了
★★友情提示:
1.外部类是不能直接使用内部类的成员和方法的，可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法;
2.如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，
可以使用 this 关键字,如:Outer.this.name
(二).静态内部类: 是 static 修饰的内部类,
1.静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问
2.如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；
如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员
3.创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名 = new 内部类();
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public
class
Outer{
private
int
age =
99
;
static
String name =
"Coco"
;
public
static
class
Inner{
String name =
"Jayden"
;
public
void
show(){
System.out.println(Outer.name);
System.out.println(name);
}
}
public
static
void
main(String[] args){
Inner i =
new
Inner();
i.show();
}
}
|
(1).局部内部类就像是方法里面的一个局部变量一样，是不能有 public、protected、private 以及 static 修饰符的
(2).只能访问方法中定义的 final 类型的局部变量,因为:
当方法被调用运行完毕之后，局部变量就已消亡了。但内部类对象可能还存在,
直到没有被引用时才会消亡。此时就会出现一种情况，就是内部类要访问一个不存在的局部变量;
==>使用final修饰符不仅会保持对象的引用不会改变,而且编译器还会持续维护这个对象在回调方法中的生命周期.
局部内部类并不是直接调用方法传进来的参数，而是内部类将传进来的参数通过自己的构造器备份到了自己的内部，
自己内部的方法调用的实际是自己的属性而不是外部类方法的参数;
防止被篡改数据,而导致内部类得到的值不一致
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
/*
使用的形参为何要为 final???
在内部类中的属性和外部方法的参数两者从外表上看是同一个东西，但实际上却不是，所以他们两者是可以任意变化的，
也就是说在内部类中我对属性的改变并不会影响到外部的形参，而然这从程序员的角度来看这是不可行的，
毕竟站在程序的角度来看这两个根本就是同一个，如果内部类该变了，而外部方法的形参却没有改变这是难以理解
和不可接受的，所以为了保持参数的一致性，就规定使用 final 来避免形参的不改变
*/
public
class
Outer{
public
void
Show(){
final
int
a =
25
;
int
b =
13
;
class
Inner{
int
c =
2
;
public
void
print(){
System.out.println(
"访问外部类:"
+ a);
System.out.println(
"访问内部类:"
+ c);
}
}
Inner i =
new
Inner();
i.print();
}
public
static
void
main(String[] args){
Outer o =
new
Outer();
o.show();
}
}
|
该类的定义会立即消失，所以匿名内部类是不能够被重复使用;
(3).使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口;
(4).匿名内部类中是不能定义构造函数的,匿名内部类中不能存在任何的静态成员变量和静态方法;
(5).匿名内部类中不能存在任何的静态成员变量和静态方法,匿名内部类不能是抽象的,它必须要实现继承的类或者实现的接口的所有抽象方法
(6).匿名内部类初始化:使用构造代码块！利用构造代码块能够达到为匿名内部类创建一个构造器的效果
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public
class
OuterClass {
public
InnerClass getInnerClass(
final
int
num,String str2){
return
new
InnerClass(){
int
number = num +
3
;
public
int
getNumber(){
return
number;
}
};
/* 注意：分号不能省 */
}
public
static
void
main(String[] args) {
OuterClass out =
new
OuterClass();
InnerClass inner = out.getInnerClass(
2
,
"chenssy"
);
System.out.println(inner.getNumber());
}
}
interface
InnerClass {
int
getNumber();
}
|
下列叙述中，错误的是（ ）正确答案: B 你的答案: A (错误)
File类能够存储文件属性
File类能够读写文件
File类能够建立文件
File类能够获取文件目录信息
File类使用详解
|
1
2
3
4
5
|
public
class
MyRunnable implements Runnable {
public
void
run() {
//some code here
}
}
|
正确答案: C 你的答案: A (错误)
new Runnable(MyRunnable).start()
new Thread(MyRunnable).run()
new Thread(new MyRunnable()).start()
new MyRunnable().start()
正确答案: B D 你的答案: C D (错误)
Collection是java.util下的类，它包含有各种有关集合操作的静态方法
Collection是java.util下的接口，它是各种集合结构的父接口
Collections是java.util下的接口，它是各种集合结构的父接口
Collections是java.util下的类，它包含有各种有关集合操作的静态方法
使用FileOutputStream可以将对象进行传输
使用PrintWriter可以将对象进行传输
使用transient修饰的变量不会被序列化
对象序列化的所属类需要实现Serializable接口
正确答案: A B C D 你的答案: A D (错误)
HashMap和Hashtable都实现了Map接口
HashMap是非synchronized，而Hashtable是synchronized
HashTable使用Enumeration，HashMap使用Iterator
Hashtable直接使用对象的hashCode，HashMap重新计算hash值，而且用与代替求模