Java基础面试题及答案.docx
《Java基础面试题及答案.docx》由会员分享，可在线阅读，更多相关《Java基础面试题及答案.docx（15页珍藏版）》请在冰豆网上搜索。
Java基础面试题及答案
JAVA基础部分-选择题
（单选）1.在Java语言中，字符串“Java程序员”在内存中所占用的字节数是：
（）。
A.10
B.7
C.13
D.14
2.（单选）下列表达式中，可以得到精确结果的是（）。
A.doubled1=3.0-2.6;
B.doubled4=2.5*1.5;
C.doubled2=30/300;
D.doubled3=1/2+0.5;
3.（多选）所谓“水仙花”数是一个整数等于各位数字立方的和，例如：
153=111+555+333，下面的程序用于输出2~1000内的水仙花数：
for（intn=2;n<=1000;n++）{
空白处
if（s==n）{
System.out.println（n）;
}
}
下列选项中，空白处可以填入的代码是：
（）。
A.ints=0, n1=n; while（n1>0）{intt=n1%10; s+=t*t*t; n1/=10;}
B.ints=0, n1=n; while（n1>0）{intt=n1/10; s+=t*t*t; n1%=10;}
C.ints=0; for（intn1=n;n1>0; n1/=10）{intt=n1%10; s+=t*t*t;}
D.ints=0; for（intn1=n; n1>0; n1%=10）{intt=n1/10; s+=t*t*t;}
4.下列语句序列执行后，k的值是（）
intx=6,y=10,k=5;
switch（x%y）
{
case0:
k=x*y;
case6:
k=x/y;
case12:
k=x-y;
default:
k=x*y-x;
}
A.60
B.5
C.0
D.54
5.设a=8，则表达式a>>>2的值是：
（无符号右移动）（）
A.1
B.2
C.3
D.4
6.下列程序
classTest{
publicstaticvoidmain（String[]args）{
doSomething
（1）;
doSomething（1,2）;
}
//insertcodehere
}
在程序中插入下列哪一行代码可以编译通过：
AstaticvoiddoSomething（int[]args）{}
BstaticvoiddoSomething（int...args）{}
CstaticcoiddoSomething（int...args,intx）{}
DstaticvoiddoSomething（intx,int...args）{}
简答题
1.现有一个长度为20的数组，数组内的数字0-9之间的任意数字，统计出数组中每个元素出现的次数？
现有一个字符串"fdasafdasfdasa",现统计出子串"as"出现的次数.
2.请描述冒泡排序算法的基本思想。
3.一个数组中只有0，1两种数字，进行排序，0全部在前，1全部在后
OOP部分
1.（单选）关于下列代码说法正确的是：
publicclassA{
privateintcounter=0;
publicstaticintgetInstanceCount（）{
returncounter;
}
publicA（）{
counter++;
}
publicstaticvoidmain（String[]args）{
Aa1=newA（）;
Aa2=newA（）;
Aa3=newA（）;
System.out.println（A.getInstanceCount（））;
}
}
A.该类编译失败
B.输出：
1
C.输出：
3
D.输出：
0
2.试图编译和运行以下代码，将获得什么结果（JAVA）
classBase{
inti=99;
publicvoidamethod（）{
System.out.println（"Base.amethod（）"）;
}
Base（）{
amethod（）;
}
}
publicclassRTypeextendsBase{
inti=-1;
publicstaticvoidmain（Stringargv[]）{
Baseb=newRType（）;
System.out.print（b.i+"\t"）;
b.amethod（）;
RTyper=（RType）b;
System.out.print（r.i+"\t"）;
}
publicvoidamethod（）{
System.out.print（"RType.amethod（）"+"\t"）;
}
}
ARType.amethod-1RType.amethod-1
BRType.amethod99RType.amethod-1
C99RType.amethod99
D编译时错误（Compiletimeerror）
3、下边程序运行的结果是？
（）
classBase{
Base（）{System.out.print（"Base"）;}
}
publicclassAlphaextendsBase{
publicstaticvoidmain（String[]args）{
newAlpha（）;
newBase（）;
}
}
A.Base
B.BaseBase
C.程序编译失败.
D.程序运行但没有任何输出
4.指出下列程序运行的结果
publicclassExample{
Stringstr=newString（"good"）;
char[]ch={'a','b','c'};
publicstaticvoidmain（Stringargs[]）{
Exampleex=newExample（）;
ex.change（ex.str,ex.ch）;
System.out.print（ex.str+"and"）;
System.out.print（ex.ch）;
}
publicvoidchange（Stringstr,charch[]）{
str="testok";
ch[0]='g';
}
}
A.goodandabc
B.goodandgbc
C.testokandabc
D.testokandgbc
OOP部分-简答题
1.抽象类和接口的区别
2.静态变量和实例变量的区别？
3.Strings=newString（"xyz"）;创建了几个StringObject？
4．字符串连接时为什么推荐使用StringBuffer而不是直接用String+String的方式，请简述原因？
5.final,finally,finalize的区别。
6.线程
继承Thread类如果某个类继承了Thread类,那么此时这个类就是一个线程类,如果要创建此类的线程对象AextendsThreadAa=newA（）;a.start（）
实现Runnable接口如果某个类实现了Runnable接口,此时这个类不是线程类,这个类中只有将线程要执行的任务写好了
如果此时用用线程来执行这个任务
AimplementsRunnable
Aa=newA（）;
//创建一个线程对象指向该任务
Threadth=newThread（Runnabler,name）;
th.start（）
生命周期:
5种状态
新建,就绪,运行,阻塞,死亡
多线程并发问题:
脏数据:
污染了数据-前提条件:
多个线程访问同一个对象
如何避免脏数据的产生:
线程同步-synchronized
可以用来修饰方法,代码块:
本质是给对象加锁
如果修饰方法:
给调用方法的对象（this）加锁
如果修饰代码块:
sychronized（要加锁的对象）{}一般情况下,加锁的对象都为this
线程间的通信-线程间要交流
生产者消费者
Object类下的几个方法来实现了线程间的通信
wait（）:
一定出现在sychronized的方法中
notify（）notifyAll（）
线程池:
Excutors.newFixedThreadPool（intnThread）-ExcutorService
execute（）
ThreadLocal:
将数据绑定到当前线程上,那么在整个线程过程中都可以使用该数据
IO流:
RandomAccessFile:
随机访问流（任意访问流）
特殊之处:
1.这个流既可以读文件,也可以写文件
2.可以定位到文件的任意位置,而且可以获取当前的偏移量
RandomAccessFile（Filedest,Stringmode）
read（）write（）-按照字节
seek（longpos）
getFilePointer（）-long
数据库部分-选择题
1.当在执行过程中，如果QUANTITY的值是空的话，哪个语句将显示一个0？
A.SELECTid_number,100/quantityFROMinventory;
B.SELECTid_number,NVL（100/quantity,0）FROMinventory;
C.SELECTid_number,NULL（100/quantity,0）FROMinventory;
D.SELECTidnumber,TOCHAR（100/quantity,0）FROMinventory;
2.分析下面SQL语句，在什么情况下引起这个语句失败？
STUDEN表结构：
IDNUMBER（9）FIRSTNAMEVARCHAR2（25）LASTNAMEVARCHAR2（25）
SELECT*FROMstudentWHEREid=
（SELECTidFROMstudentWHEREUPPER（first_name）='KATE'ANDUPPER（last_name）='HENRY'）;
A.在数据表中没有学生的名字是KateHenry
B.数据表中学生的名字叫Kate的多于一个
C.数据表中的学生的名字叫KateHenry的多于一个
D.FIRSTNAME和LASTNAME的值在数据库中是小写的
3.分析下面的SQL语句，这个语句为什么会出现一个错误？
CREATETABLEsale_items（id_numberNUMBER（9）,descriptionVARCHAR（25））
ASSELECTid_number,descriptionFROMinventoryWHEREquantity>500;
A.一个子句丢失
B.一个关键字丢失
C.where子句不能应用在创建表上
D.数据类型在新表中不需要被定义
4.在SQL语言中，关于主键描述正确的是（）（多选）
A只能包含一列
B可以包含两列
C可以包含一列或者多列
D以上都不正确
数据库简答题
1.写SQL语句显示员工表中工资超过平均工资的员工。
2.假如订单表orders用来存储订单信息，cid代表客户编号，money代表单次订购额，现要查询每个客户的订购次数和每个客户的订购总金额？
统计单笔消费超过50元的用户总共的消费次数以及消费总金额,总金额>2000
3.表PERSONNEL的结构如下:
IDNUMBER（9）
NAMEVARCHAR2（25）
MANAGER_IDNUMBER（9）
在这里,部门的管理者也看作是雇员，写出SQL语句查询每个雇员的姓名以及管理者的姓名
4.ORACLE数据库有哪几种约束类型？
5.请分别写出mysql与oracle的分页查询语句（查询第3-第7条数据）
6.写一个查询，来查询出挣到佣金（comm）的雇员姓名ename,部门名称，和部门所处的位置loc。
（有employ表和dept表）
7.写一个查询，查出在名字里面有一个"A"的所有雇员姓名ename和其所在的部门loc的名称。
8．显示所有薪金高于各自部门平均薪金的人？
9.查询平均成绩大于60分的同学的学号和平均成绩；
Servlet部分
1.JSP九大内置对象，Servlet域对象以及各自的作用范围
2.说出Servlet的生命周期？
5.请简述mvc架构。
同时说明在自己熟悉的架构中mvc分别对应什么？
框架部分
1.请描述一下springMVC工作原理。
2.Spring的核心是什么？
JAVA基本部分-选择题
1.D
2.B
解析：
此题考查java的浮点运算的精度问题，浮点数是以二进制得形式存储得，如0.5=2得-1次方
选项A返回结果0.3999999999999999
选项B返回结果3.75
选项C返回结果0.0因为30和300都是整数，只要把任何一个定义成浮点型数据，数据会更精确
选项D返回结果0.5原理同选项C
3.AC
解析：
固定算法，只是用while循环或for循环
4.D
解析：
switch分支结构如果在case的语句体中添加break;语句，那么只要找到对应的case的常量，就执行对应case常量后的语句，如果没有break语句就继续执行后面所有case后的语句如果最后有default也会执行。
5.B
解析：
Java中的位运算符：
\int类型占4个字节，一个字节占8位，所以一个int数字占用32位。
>>表示右移，如果该数为正，则高位补0，若为负数，则高位补1；>>>表示无符号右移，也叫逻辑右移，即若该数为正，则高位补0，而若该数为负数，则右移后高位同样补0。
6.BD
解析：
根据题意，方法名称不变，参数的个数可变，解决方案是用可变参数类型...类型名称比如：
int...args可变参数其本质是一个数组，且必须放在方法参数的最后一个位置，可以接受零个或多个参数，在方法中使用数组方式来访问，比如：
args[0]args[1].....
简答：
1.
int[]ary={1,2,1,4,5,6};
int[]counts=newint[10];
for（inti:
ary）{
counts[i]++;
}
for（intj:
counts）{
System.out.print（j+""）;
}
2.答案：
1．冒泡排序的基本思想冒泡排序是交换排序中一种简单的排序方法。
它的基本思想是对所有相邻记录的关键字值进行比效，如果是逆顺（a[j]>a[j+1]），则将其交换，最终达到有序化。
其处理过程为：
（1）将整个待排序的记录序列划分成有序区和无序区，初始状态有序区为空，无序区包括所有待排序的记录。
（2）对无序区从前向后依次将相邻记录的关键字进行比较，若逆序将其交换，从而使得关键字值小的记录向上"飘浮"（左移），关键字值大的记录好像石块，向下“堕落”（右移）。
每经过一趟冒泡排序，都使无序区中关键字值最大的记录进入有序区，对于由n个记录组成的记录序列，最多经过n-1趟冒泡排序，就可以将这n个记录重新按关键字顺序排列。
2．原始的冒泡排序算法对由n个记录组成的记录序列，最多经过（n-1）趟冒泡排序，就可以使记录序列成为有序序列，第一趟定位第n个记录，此时有序区只有一个记录；第二趟定位第n-1个记录，此时有序区有两个记录；以此类推，算法框架为：
for（i=n；i>1；i--）{定位第i个记录；}
若定位第i个记录，需要从前向后对无序区中的相邻记录进行关键字的比较，它可以用如下所示的语句实现。
下面给出完整的冒泡排序算法：
for（inti=0;iarr[j+1]）{ inttemp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } }
3.答案：
int[]ary={1,0,1,1,0,0,1,1,1,0,0,1,0,1};
intindex=0;
for（inti=0;iif（ary[i]==0）{
ary[i]=1;
ary[index++]=0;
}
}
for（inti:
ary）{
System.out.print（i+""）;
}
OOP部分-选择题
1.A
2.B
3.B
7.B
解析：
数组和对象在作为数的参数传递的时候，是引用传递，如果在方法中对其做过修改，则真的会影响原始数据
OOP部分-简答题
1.
2.答案：
在语法定义上的区别：
静态变量前要加static关键字，而实例变量前则不加。
在程序运行时的区别：
实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。
静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。
总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。
3.答案：
只要是new，都是重新分配堆空间，如果不区分栈和堆，这里创建了1个StringObject。
如果是从jvm角度来说的话，它是创建了两个对象，Strings是在栈里创建了一个变量，newString（"xyz"）是在堆里创建了一个对象并被s引用到。
如果是Strings="xyz"，那就要看常量池里有没有"xyz"，如果有直接引用，如果没有则创建再引用这里"xyz"本身就是pool中的一个对象，而在运行时执行newString（）时，将pool中的对象复制一份放到heap中，并且把heap中的这个对象的引用交给s持有。
ok，这条语句就创建了2个String对象。
难度等级：
中
4.
答案：
每次String+String都会生成一个新的String，而使用StringBuffer则不会出现此种情况，可以减少String对象的实例化次数。
5.
（1）final为关键字；可以修饰类，方法，变量
（2）finalize（）为方法；由JVM进行调用，用于对对象进行垃圾回收
（3）finally：
用于标识代码块，与try{}进行配合，不论try中的代码执行完或没有执行完（这里指有异常），该代码块之中的程序必定会进行；通常用于释放资源AdemoGC=newA（）;
demoGC=null;
System.gc（）;
System.out.println（"gcwasruned"）;
publicclassA{@Override
protectedvoidfinalize（）throwsThrowable{
System.out.println（"Demofinalized"）;System.out.println（Thread.currentThread（）.getName（））;super.finalize（）;
}
}
数据库部分-选择题
1.C
2.B
解析：
nvl（expr1,expr2）将null转换为非null值如果expr1位null，则取值expr2，expr2是实际值expr1和expr2可以是任何数据类型，但两个参数的数据类型必须是一致的
3.D
通过现有的表生成一个新的物理表
createtable表名asselect子句where字句（不成立的条件）
4.C
数据库简答题
1.SELECT*fromstaffwheresalary>（SELECTAVG（salary）fromstaff）
SELECTdept_idfromstaffUNIONAllSELECTidfromdepartment
MAX（）
MIN（expr）
COUNT（DISTINCTexpr,[expr...]）
SUM（expr）
UNION求去重后的并集
UNIONAll求全并集
minus差集
2.统计单笔消费超过50元的用户总共的消费次数以及消费总金额,总金额>2000
selectcid,COUNT（*）,SUM（money）fromorderswheremoney>50GROUPBYcidHAVINGSUM（money）>2000
3.SELECTs1.name,s2.nameasmgrNamefromstaffs1LEFTJOINstaffs2ONs1.mgr_id=s2.id
4.答案：
五种：
1.主键约束PRIMARYKEY
2.外键约束FOREIGNKEY
3.唯一约束UNIQUE
4.检查约束CHECK
5.非空约束NOTNULL
5.答案：
mysql分页查询:
select*fromstaffLIMIT0,2
oracle的分页语句：
3是起始记录号，6是终止记录号select*from（selecte.*,rownumrnfromempe）emp_aliaswhereemp_alias.rn>=3andemp_alias.rn<=6 mysql分页语句：
0是起始记录的前一个数字，3是每页显示多少条数据 select* from表名limit0,3
6.SELECTs.name,d.name,d.locationfromstaffs,departmentdwheres.dept_id=d.idandcommisnotNULL
7.selects.name,d.locationfromstaffs,departmentdwheres.dept_id=d.idands.nameLIKE'%a%'
8.SELECTs.name,s.salaryfromstaffs,（selectAVG（salary）av,deptiddidfromstaffgroupbydeptid）tmpwheres.salary>tmp.avands.dept_id=tmp.did
Servlet部分
1.
1、request对象
升级会员 