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;
//插入代码到这里
}
|
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();
}
}
|
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
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();
}
}
|
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类能够获取文件目录信息
1
2
3
4
5
|
public
class
MyRunnable implements Runnable {
public
void
run() {
//some code here
}
}
|
new Runnable(MyRunnable).start()
new Thread(MyRunnable).run()
new Thread(new MyRunnable()).start()
new MyRunnable().start()
Collection是java.util下的类,它包含有各种有关集合操作的静态方法
Collection是java.util下的接口,它是各种集合结构的父接口
Collections是java.util下的接口,它是各种集合结构的父接口
Collections是java.util下的类,它包含有各种有关集合操作的静态方法
使用FileOutputStream可以将对象进行传输
使用PrintWriter可以将对象进行传输
使用transient修饰的变量不会被序列化
对象序列化的所属类需要实现Serializable接口
HashMap和Hashtable都实现了Map接口
HashMap是非synchronized,而Hashtable是synchronized
HashTable使用Enumeration,HashMap使用Iterator
Hashtable直接使用对象的hashCode,HashMap重新计算hash值,而且用与代替求模