Java笔试面试题汇总.docx
《Java笔试面试题汇总.docx》由会员分享，可在线阅读，更多相关《Java笔试面试题汇总.docx（45页珍藏版）》请在冰豆网上搜索。
Java笔试面试题汇总
Java笔试面试题：
1.类的定义格式:
[修饰符]class类名{
类的主体;
}
2.方法声明的基本格式:
[修饰符]返回值类型方法名（参数类型参数名,...）{
定义变量;
定义方法;
}
3.局部变量与成员变量的区别:
成员变量有默认值,而局部变量没有;
4.Java的判断条件结果必须是一个布尔值；
5.this关键字和super关键字分别代表什么?
以及他们各自的使用场景和作用。
this:
代表当前类的对象引用
super:
代表父类存储空间的标识。
（可以理解为父类的引用，通过这个东西可以访问父类的成员）
应用场景:
A:
调用成员变量
this.成员变量调用本类的成员变量
super.成员变量调用父类的成员变量
B:
调用构造方法
this（...）调用本类的构造方法
super（...）调用父类的构造方法
C:
调用成员方法
this.成员方法调用本类的成员方法
super.成员方法调用父类的成员方法
6.权限修饰符：
本类同一个包下（子类和无关类）不同包下（子类）不同包下（无关类）
privateY
默认YY
protectedYYY
publicYYYY
JAVA的事件委托机制和垃圾回收机制:
java事件委托机制的概念,一个源产生一个事件并将它送到一个或多个监听器那里。
在这种方案中，监听器简单的等待，直到它收到一个事件。
一旦事件被接受，监听器将处理这个事件，然后返回。
垃圾回收机制垃圾收集是将分配给对象但不再使用的内存回收或释放的过程。
如果一个对象没有指向它的引用或者其赋值为null,则次对象适合进行垃圾回收
7.控制跳转语句：
break:
中断
continue:
继续
return:
返回
break:
中断的意思
使用场景：
A:
switch语句中
B:
循环语句中。
（循环语句中加入了if判断的情况）
注意：
离开上面的两个场景，无意义。
如何使用呢?
A:
跳出单层循环
B:
跳出多层循环
要想实现这个效果，就必须知道一个东西。
带标签的语句。
格式：
标签名:
语句
wc:
for（intx=0;x<3;x++）{
nc:
for（inty=0;y<4;y++）{
if（y==2）{
breakwc;
}
System.out.print（"*"）;
}
System.out.println（）;
}
continue:
继续
使用场景：
循环中。
离开此场景无意义。
测试，找到和break的区别：
break:
跳出单层循环
continue:
跳出一次循环，进入下一次的执行
练习题：
for（intx=1;x<=10;x++）{
if（x%3==0）{
//在此处填写代码
}
System.out.println（“Java基础班”）;
}
我想在控制台输出2次:
“Java基础班“
break;
我想在控制台输出7次:
“Java基础班“
continue;
我想在控制台输出13次:
“Java基础班“
System.out.println（“Java基础班”）;
return:
返回
其实它的作用不是结束循环的，而是结束方法的。
8.什么是java序列化，如何实现java序列化？
（写一个实例）
序列化:
可以将一个对象保存到一个文件，所以可以通过流的方式在网络上传输，可以将文件的内容读取，转化为一个对象。
处理对象流的机制，所谓对象流也就是将对象的内容进行流化。
可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。
序列化是为了解决在对对象流进行读写操作时所引发的问题。
序列化的实现：
将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，
implementsSerializable只是为了标注该对象是可被序列化的，然后使用一个输出流
（如：
FileOutputStream）来构造一个ObjectOutputStream（对象流）对象，接着，使用
ObjectOutputStream对象的writeObject（Objectobj）方法就可以将参数为obj的对象写出（即保存其状态），要恢复的话则用输入流。
9.一个".java"源文件中是否可以包括多个类（不是内部类）？
有什么限制？
可以。
如果这个类的修饰符是public，其类名与文件名必须相同
10.方法重写（Override）和方法重载（Overload）的区别?
方法重载能改变返回值类型吗?
Override：
方法重写也称方法覆盖
Overload：
方法重载
方法重写：
在子类中，出现和父类中一模一样的方法声明的现象。
方法重载：
同一个类中，出现的方法名相同，参数列表不同的现象。
方法重载能改变返回值类型，因为它和返回值类型无关。
子类对象调用方法的时候：
先找子类本身，再找父类。
方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
这样，即沿袭了父类的功能，又定义了子类特有的内容。
方法重写的注意事项
A:
父类中私有方法不能被重写
因为父类私有方法子类根本就无法继承
B:
子类重写父类方法时，访问权限不能更低
最好就一致
C:
父类静态方法，子类也必须通过静态方法进行重写
其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解
子类重写父类方法的时候，最好声明一模一样。
11.看程序写结果
字符串数据和其他数据做+，结果是字符串类型。
这里的+不是加法运算，而是字符串连接符。
System.out.prinln（8+8+”88”+8+8）;//168888
12.final:
最终的意思。
常见的是它可以修饰类，方法，变量。
final修饰局部变量的问题
基本类型：
基本类型的值不能发生改变。
引用类型：
引用类型的地址值不能发生改变，但是，该对象的堆内存的值是可以改变的。
final修饰变量的初始化时机
A:
被final修饰的变量只能赋值一次。
B:
在构造方法完毕前。
（非静态的常量）
继承时候类的执行顺序问题,一般都是选择题,问你将会打印出什么?
父类：
13.
packagetest;
publicclassFatherClass{
publicFatherClass（）{
System.out.println（"FatherClassCreate"）;
}
}
子类:
packagetest;
importtest.FatherClass;
publicclassChildClassextendsFatherClass{
publicChildClass（）{
System.out.println（"ChildClassCreate"）;
}
publicstaticvoidmain（String[]args）{
FatherClassfc=newFatherClass（）;
ChildClasscc=newChildClass（）;
}
}
输出结果：
FatherClassCreate
FatherClassCreate
ChildClassCreate
14.内部类的实现方式?
答：
示例代码如下：
publicclassOuterClass{
privateclassInterClass{
publicInterClass（）{
System.out.println（"InterClassCreate"）;
}
}
publicOuterClass（）{
InterClassic=newInterClass（）;
System.out.println（"OuterClassCreate"）;
}
publicstaticvoidmain（String[]args）{
OuterClassoc=newOuterClass（）;
}
}
输出结果:
InterClassCreate
OuterClassCreate
15.如在Collection框架中，实现比较要实现什么样的接口？
Collection框架中实现比较要实现Comparable接口和Comparator接口
16.看程序写结果
classA{
static{
System.out.print（"1"）;
}
publicA（）{
System.out.print（"2"）;
}
}
classBextendsA{
static{
System.out.print（"a"）;
}
publicB（）{
System.out.print（"b"）;
}
}
publicclassC{
publicstaticvoidmain（String[]ars）{
Aa=newB（）;//执行到此处,结果:
1a2b
a=newB（）;//执行到此处,结果:
1a2b2b
}
}
类的static代码段,可以看作是类首次加载（被虚拟机加载）执行的代码,而对
于类的加载,首先要执行其基类的构造,再执行其本身的构造
17.抽象类和接口的区别？
（1）接口可以被多重implements,抽象类只能被单一extends
（2）接口只有定义,抽象类可以有定义和实现
（3）接口的字段定义默认为:
publicstaticfinal,当功能需要累积时用抽象类，不需要累积时用接口
18.什么是类的反射机制?
通过类（Class对象），可以得出当前类的fields、method、construtor、interface、superClass、modified等，同时可以通过类实例化一个实例、设置属性、唤醒方法。
Spring中一切都是反射、struts、hibernate都是通过类的反射进行开发的
19.类的反射机制中的包及核心类
java.lang.Class
java.lang.refrection.Method
java.lang.refrection.Field
java.lang.refrection.Constructor
java.lang.refrection.Modifier
java.lang.refrection.Interface
20.得到Class的三个过程是什么?
对象.getClass（）
类.class或Integer.type（int）Integer.class（java.lang.Integer）
Class.forName（）;
21.如何唤起类中的一个方法？
产生一个Class数组，说明方法的参数
通过Class对象及方法参数得到Method
通过method.invoke（实例,参数值数组）唤醒方法
22.如何将数值型字符转换为数字（Integer，Double）？
Integer.parseInt（“1234”）;
Double.parseDouble（“123.2”）;
23.数据类型转换：
bytea=3;
intb=4;
//intc=a+b;//这个肯定没有问题
//bytec=a+b;//这个是有问题的
//用强制类型转换改进
bytec=（byte）（a+b）;
思考题1：
请问下面这个有没有问题
doubled=12.345;
floatf=d;
答：
是有问题的，需要进行强制类型转换
思考题2：
看看下面两个定义有没有区别呢?
floatf1=（float）12.345;
floatf2=12.345f;
f1其实是通过一个double类型转换过来的。
而f2本身就是一个float类型。
面试题：
byteb1=3,b2=4,b;
b=b1+b2;
b=3+4;
哪句是编译失败的呢？
为什么呢？
b=b1+b2;//编译失败。
因为变量相加，题中首先会转换为int类型数据，最终把结果赋给byte类型的变量b时由于可能会损失精度，因此会报错！
常量相加，首先做加法，然后看结果是否在赋值的数据类型范围内，如果不是，才报错。
具体分析：
//b=b1+b2;//这个是类型提升，所以有问题
b=3+4;//常量，先把结果计算出来，然后看是否在byte的范围内，如果在就不报错。
byteb=130;有没有问题?
如果我想让赋值正确，可以怎么做?
结果是多少呢?
//因为byte的范围是：
-128到127。
//而130不在此范围内，所以报错。
//byteb=130;
//我们可以使用强制类型转换
byteb=（byte）130;
//结果是多少呢?
System.out.println（b）;//-126
分析过程：
我们要想知道结果是什么，就应该知道是如何进行计算的。
而我们又知道计算机中数据的运算都是补码进行的。
而要得到补码，首先要计算出数据的二进制。
A:
获取130这个数据的二进制。
00000000000000000000000010000010
这是130的原码，也是反码，还是补码。
B:
做截取操作，截成byte类型的了。
10000010
这个结果是补码。
C:
已知补码求原码。
符号位数值位
补码：
10000010
反码：
10000001
原码：
11111110
24.运算符
面试题：
shorts=1;s=s+1;//错误，运算的时候s先转换为int类型，然后参与运算,此时需要强制类型转换为short类型
shorts=1;s+=1;//正确
扩展的赋值运算符其实隐含了一个强制类型转换。
s+=1;
不是等价于s=s+1;
而是等价于s=（s的数据类型）（s+1）;
25.位运算符
classOperatorDemo{
publicstaticvoidmain（String[]args）{
//&,|,^,~
inta=3;
intb=4;
System.out.println（3&4）;//0
System.out.println（3|4）;//7
System.out.println（3^4）;//7
System.out.println（~3）;//-4
}
}
分析：
因为是位运算，所以我们必须先把数据换算成二进制。
3的二进制：
11
00000000000000000000000000000011
4的二进制：
100
00000000000000000000000000000100
&位与运算：
有0则0。
00000000000000000000000000000011
&00000000000000000000000000000100
-----------------------------------
00000000000000000000000000000000
结果是：
0
|位或运算：
有1则1。
00000000000000000000000000000011
|00000000000000000000000000000100
-----------------------------------
00000000000000000000000000000111
结果是：
7
^位异或运算：
相同则0，不同则1。
00000000000000000000000000000011
&00000000000000000000000000000100
-----------------------------------
00000000000000000000000000000111
结果是：
7
~按位取反运算符：
0变1，1变0
00000000000000000000000000000011
~11111111111111111111111111111100（补码）
补码：
11111111111111111111111111111100
反码：
11111111111111111111111111111011
原码：
10000000000000000000000000000100
结果是：
-4
面试题：
<<:
左移左边最高位丢弃，右边补齐0
>>:
右移最高位是0，左边补齐0；最高为是1，左边补齐1
>>>:
无符号右移无论最高位是0还是1，左边补齐0
请用最有效率的方式写出计算2乘以8的结果?
2*8
2<<3
classOperatorDemo{
publicstaticvoidmain（String[]args）{
//<<把<<左边的数据乘以2的移动次幂
System.out.println（3<<2）;//3*2^2=3*4=12;
//>>把>>左边的数据除以2的移动次幂
System.out.println（24>>2）;//24/2^2=24/4=6
System.out.println（24>>>2）;//6
System.out.println（-24>>2）;//-6
System.out.println（-24>>>2）;//1073741818
}
}
详细分析：
计算出3的二进制：
11
00000000000000000000000000000011
（00）00000000000000000000000000001100
计算出24的二进制11000
00000000000000000000000000011000
00000000000000000000000000000110（00）
计算出24的二进制：
11000
原码：
10000000000000000000000000011000
反码：
11111111111111111111111111100111
补码：
11111111111111111111111111101000
11111111111111111111111111101000
11111111111111111111111111111010（00）补码
补码：
11111111111111111111111111111010
反码：
11111111111111111111111111111001
原码：
10000000000000000000000000000110
结果：
-6
>>>的移动：
计算出24的二进制：
11000
原码：
10000000000000000000000000011000
反码：
11111111111111111111111111100111
补码：
11111111111111111111111111101000
11111111111111111111111111101000
00111111111111111111111111111010（00）
结果：
1073741818
/*
面试题：
请自己实现两个整数变量的交换
*/
classOperatorDemo{
publicstaticvoidmain（String[]args）{
inta=10;
intb=20;
System.out.println（"a:
"+a+",b:
"+b）;
//方式1：
使用第三方变量（开发中用的）
intc=a;
a=b;
b=c;
System.out.println（"a:
"+a+",b:
"+b）;
System.out.println（"------------"）;
//方式2：
用位异或实现（面试用）
//左边：
a,b,a
//右边：
a^b
a=a^b;
b=a^b;//a^b^b=a
a=a^b;//a^b^a=b
System.out.println（"a:
"+a+",b:
"+b）;
//方式3：
用变量相加的做法
a=a+b;//a=30
b=a-b;//b=10
a=a-b;//a=20
System.out.println（"a:
"+a+",b:
"+b）;
//方式4：
一句话搞定
b=（a+b）-（a=b）;//b=30-20=10,a=20
System.out.println（"a:
"+a+",b:
"+b）;
}
}
/*
练习：
获取两个整数中的最大值
获取三个整数中的最大值
比较两个整数是否相同
*/
publicclassOperatorTest{
publicstaticvoidmain（String[]args）{
//获取两个整数中的最大值
intx=100;
inty=200;
intmax=（x>y?
x:
y）;
System.out.println（"max:
"+max）;
System.out.println（"--------"）;
升级会员 