JAVA基础部分-选择题
(单选)1.在Java语言中,字符串“Java程序员”在内存中所占用的字节数是:()。
A.10
B.7
C.13
D.14
2. (单选)下列表达式中,可以得到精确结果的是()。
A.double d1 = 3.0 - 2.6;
B.double d4 = 2.5 * 1.5;
C.double d2 = 30/300;
D.double d3 = 1/2 + 0.5;
3.(多选)所谓“水仙花”数是一个整数等于各位数字立方的和,例如:153 = 111+555+333,下面的程序用于输出2~1000内的水仙花数:
for (int n = 2; n <= 1000; n++) {
空白处
if (s == n) {
System.out.println(n);
}
}
下列选项中,空白处可以填入的代码是:()。
A.int s = 0, n1 = n; while (n1 > 0) { int t = n1 % 10; s += t * t * t; n1 /= 10; }
B.int s = 0, n1 = n; while (n1 > 0) { int t = n1 / 10; s+= t * t * t; n1 %= 10; }
C.int s = 0; for(int n1 = n; n1>0; n1 /= 10) { int t = n1%10; s += t * t * t; }
D.int s = 0; for(int n1 = n; n1>0; n1 %= 10) { int t = n1 / 10; s += t * t * t; }
4.下列语句序列执行后,k 的值是 ( )
int x=6, y=10, k=5;
switch( x % y )
{
case 0: k=x*y;
case 6: k=x/y;
case 12: 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.下列程序
class Test{
public static void main(String[] args){
doSomething(1);
doSomething(1,2);
}
//insert code here
}
在程序中插入下列哪一行代码可以编译通过:
A static void doSomething(int[] args){}
B static void doSomething(int… args){}
C static coid doSomething(int…args,int x){}
D static void doSomething(int x,int…args){}
简答题
1.现有一个长度为20的数组,数组内的数字0-9之间的任意数字,统计出数组中每个元素出现的次数?
现有一个字符串"fdasafdasfdasa",现统计出子串"as"出现的次数.
2.请描述冒泡排序算法的基本思想。
3.一个数组中只有0,1两种数字,进行排序,0全部在前,1全部在后
OOP部分
1.(单选)关于下列代码说法正确的是:
public class A {
private int counter = 0;
public static int getInstanceCount() {
return counter;
}
public A() {
counter++;
}
public static void main(String[] args) {
A a1 = new A();
A a2 = new A();
A a3 = new A();
System.out.println(A.getInstanceCount());
}
}
A.该类编译失败
B.输出:1
C.输出:3
D.输出:0
2.试图编译和运行以下代码,将获得什么结果(JAVA)
class Base {
int i = 99;
public void amethod() {
System.out.println("Base.amethod()");
}
Base() {
amethod();
}
}
public class RType extends Base {
int i = -1;
public static void main(String argv[]){
Base b = new RType();
System.out.print(b.i+"\t");
b.amethod();
RType r = (RType)b;
System.out.print(r.i+"\t");
}
public void amethod(){
System.out.print("RType.amethod()"+"\t");
}
}
A RType.amethod -1 RType.amethod -1
B RType.amethod 99 RType.amethod -1
C 99 RType.amethod 99
D 编译时错误(Compile time error)
3、下边程序运行的结果是? ( )
class Base {
Base() { System.out.print("Base"); }
}
public class Alpha extends Base {
public static void main( String[] args ) {
new Alpha();
new Base();
}
}
A.Base
B.BaseBase
C.程序编译失败.
D.程序运行但没有任何输出
4.指出下列程序运行的结果
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';
}
}
A.good and abc
B.good and gbc
C.test ok and abc
D.test ok and gbc
OOP部分-简答题
1.抽象类和接口的区别
2.静态变量和实例变量的区别?
3.String s = new String(“xyz”);创建了几个String Object ?
4.字符串连接时为什么推荐使用StringBuffer而不是直接用String+String的方式,请简述原因?
5.final, finally, finalize的区别。
6.线程
继承Thread类
如果某个类继承了Thread类,那么此时这个类就是一个线程类,如果要创建此类的线程对象 A extends Thread
A a = new A();
a.start()
实现Runnable接口
如果某个类实现了Runnable接口,此时这个类不是线程类,这个类中只有将线程要执行的任务写好了
如果此时用用线程来执行这个任务
A implements Runnable
A a = new A();
//创建一个线程对象指向该任务
Thread th = new Thread(Runnable r,name);
th.start()
生命周期:5种状态
新建,就绪,运行,阻塞,死亡
多线程并发问题:
脏数据:污染了数据
-前提条件:多个线程访问同一个对象
如何避免脏数据的产生:线程同步 - synchronized
可以用来修饰方法,代码块:本质是给对象加锁
如果修饰方法:给调用方法的对象(this)加锁
如果修饰代码块:
sychronized(要加锁的对象){}
一般情况下,加锁的对象都为this
线程间的通信 - 线程间要交流
生产者消费者
Object类下的几个方法来实现了线程间的通信
wait() :一定出现在sychronized的方法中
notify() notifyAll()
线程池:
Excutors.newFixedThreadPool(int nThread) - ExcutorService
execute()
ThreadLocal:将数据绑定到当前线程上,那么在整个线程过程中都可以使用该数据
IO流:
RandomAccessFile:随机访问流(任意访问流)
特殊之处:
1.这个流既可以读文件,也可以写文件
2.可以定位到文件的任意位置,而且可以获取当前的偏移量
RandomAccessFile(File dest,String mode)
read() write() - 按照字节
seek(long pos)
getFilePointer() - long
数据库部分-选择题
1.当在执行过程中,如果QUANTITY的值是空的话,哪个语句将显示一个0?
A.SELECT id_number,100/quantity FROM inventory;
B.SELECT id_number,NVL(100/quantity,0) FROM inventory;
C.SELECT id_number,NULL(100/quantity,0) FROM inventory;
D.SELECT id_number,TO_CHAR(100/quantity,0) FROM inventory;
2.分析下面SQL语句,在什么情况下引起这个语句失败?STUDEN表结构:ID NUMBER(9) FIRST_NAME VARCHAR2(25) LAST_NAME VARCHAR2(25)
SELECT * FROM student WHERE id=
(SELECT id FROM student WHERE UPPER(first_name)='KATE' AND UPPER(last_name)='HENRY');
A.在数据表中没有学生的名字是Kate Henry
B.数据表中学生的名字叫Kate的多于一个
C.数据表中的学生的名字叫Kate Henry的多于一个
D.FIRST_NAME和LAST_NAME的值在数据库中是小写的
3.分析下面的SQL语句,这个语句为什么会出现一个错误?
CREATE TABLE sale_items(id_number NUMBER(9),description VARCHAR(25))
AS SELECT id_number,description FROM inventory WHERE quantity>500;
A.一个子句丢失
B.一个关键字丢失
C.where子句不能应用在创建表上
D.数据类型在新表中不需要被定义
4.在SQL语言中,关于主键描述正确的是()(多选)
A 只能包含一列
B 可以包含两列
C 可以包含一列或者多列
D 以上都不正确
数据库简答题
1.写SQL语句显示员工表中工资超过平均工资的员工。
2.假如订单表orders用来存储订单信息,cid代表客户编号,money代表单次订购额,现要查询每个客户的订购次数和每个客户的订购总金额?
统计单笔消费超过50元的用户总共的消费次数以及消费总金额,总金额>2000
3. 表PERSONNEL 的结构如下:
ID NUMBER(9)
NAME VARCHAR2(25)
MANAGER_ID NUMBER(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.请描述一下spring MVC工作原理。
2.Spring的核心是什么?
答案:
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 = new int[10];
for(int i:ary){
counts[i]++;
}
for(int j: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(int i=0;i<arr.length-1;i++){//外层循环控制排序趟数
for(int j=0;j<arr.length-1-i;j++){//内层循环控制每一趟排序多少次
if(arr[j]>arr[j+1]){
int temp=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};
int index = 0;
for(int i=0;i<ary.length;i++){
if(ary[i]==0){
ary[i] = 1;
ary[index++] = 0;
}
}
for(int i:ary){
System.out.print(i+" ");
}
OOP部分-选择题
1.A
2.B
3.B
7.B
解析:
数组和对象在作为数的参数传递的时候,是引用传递,如果在方法中对其做过修改,则真的会影响原始数据
OOP部分-简答题
1.
2.答案:
在语法定义上的区别:
静态变量前要加static 关键字,而实例变量前则不加。
在程序运行时的区别:
实例变量属于某个对象的属性,必须创建了实例对象,其中的实例变量才会被分配空间,才能使用这个实例变量。
静态变量不属于某个实例对象,而是属于类,所以也称为类变量,只要程序加载了类的字节码,不用创建任何实例对象,
静态变量就会被分配空间,静态变量就可以被使用了。总之,实例变量必须创建对象后才可以通过这个对象来使用,静态变量则可以直接使用类名来引用。
3.答案:
只要是new,都是重新分配堆空间,如果不区分栈和堆,这里创建了1个String Object。如果是从jvm角度来说的话,它是创建了两个对象,String s是在栈里创建了一个变量,new String(“xyz”)是在堆里创建了一个对象并被s引用到。
如果是String s = “xyz”,那就要看常量池里有没有"xyz",如果有直接引用,如果没有则创建再引用
这里"xyz"本身就是pool中的一个对象,而在运行时执行new String()时,将pool中的对象复制一份放到heap中,并且把heap中的这个对象的引用交给s持有。ok,这条语句就创建了2个String对象。
**难度等级:**中
4.
答案:
每次String+String都会生成一个新的String,而使用StringBuffer则不会出现此种情况,可以减少String对象的实例化次数。
5.
(1)final为关键字;可以修饰类,方法,变量
(2)finalize()为方法;由JVM进行调用,用于对对象进行垃圾回收
(3)finally:用于标识代码块,与try{}进行配合,不论try中的代码执行完或没有执行完(这里指有异常),该代码块之中的程序必定会进行;通常用于释放资源
A demoGC = new A();
demoGC = null;
System.gc();
System.out.println("gc was runed ");
public class A {
@Override
protected void finalize() throws Throwable {
System.out.println(“Demo finalized”);
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
通过现有的表生成一个新的物理表
create table 表名 as select 子句 where 字句(不成立的条件)
4.C
数据库简答题
1.SELECT * from staff where salary>(SELECT AVG(salary) from staff)
SELECT dept_id from staff UNION All SELECT id from department
MAX()
MIN(expr)
COUNT(DISTINCT expr,[expr...])
SUM(expr)
UNION 求去重后的并集
UNION All 求全并集
minus 差集
-
统计单笔消费超过50元的用户总共的消费次数以及消费总金额,总金额>2000
select cid,COUNT(*),SUM(money) from orders where money>50 GROUP BY cid HAVING SUM(money)>2000
-
SELECT s1.name,s2.name as mgrName from staff s1 LEFT JOIN staff s2 ON s1.mgr_id=s2.id
4.答案:
五种:
1.主键约束 PRIMARY KEY
2.外键约束 FOREIGN KEY
3.唯一约束 UNIQUE
4.检查约束 CHECK
5.非空约束 NOT NULL
5.答案:
mysql分页查询:
select * from staff LIMIT 0,2
oracle的分页语句:3是起始记录号,6是终止记录号
select
*
from
(
select
e.*,
rownum rn
from emp e
) emp_alias
where emp_alias.rn>=3 and emp_alias.rn<=6
mysql分页语句:0是起始记录的前一个数字,3是每页显示多少条数据
select * from 表名 limit 0,3
-
SELECT s.name,d.name,d.location from staff s,department d where s.dept_id=d.id and comm is not NULL
-
select s.name,d.location from staff s,department d where s.dept_id=d.id and s.name LIKE ‘%a%’
-
SELECT s.name,s.salary from staff s,(select AVG(salary) av,dept_id did from staff group by dept_id) tmp where s.salary>tmp.av and s.dept_id=tmp.did
Servlet部分
1、request对象
2、response对象
3、session对象
4、application对象
5、out 对象
6、pageContext 对象
7、config 对象
8、page 对象
9、exception 对象
四大域对象:
HttpServletRequest:一次请求
HttpSession:一次会话
ServletContext:整个服务器生命周期
PageContext:当前页面
2.答案:
Servlet 生命周期:实例化—>初始化—>服务—>销毁。
init():在Servlet的生命周期中,仅执行一次init()方法。它是在服务器装入Servlet时执行的,负责初始化Servlet对象。可以配置服务器,以在启动服务器或客户机首次访问Servlet时装入Servlet。无论有多少客户机访问Servlet,都不会重复执行init()。
service():它是Servlet的核心,负责响应客户的请求。每当一个客户请求一个HttpServlet对象,该对象的Service()方法就要调用,而且传递给这个方法一个“请求”(ServletRequest)对象和一个“响应”(ServletResponse)对象作为参数。在HttpServlet中已存在Service()方法。默认的服务功能是调用与HTTP请求的方法相应的do功能。
destroy(): 仅执行一次,在服务器端停止且卸载Servlet时执行该方法。当Servlet对象退出生命周期时,负责释放占用的资源。一个Servlet在运行service()方法时可能会产生其他的线程,因此需要确认在调用destroy()方法时,这些线程已经终止或完成。
5.答案:
1、模型(Model) :
模型是应用程序的主体部分。模型表示业务数据
2、视图(View) :
视图是应用程序中用户界面相关的部分,是用户看到并与之交互的界面。
3、控制器(controller) :
控制器工作就是根据用户的输入,控制用户界面数据显示和更新model对象状态。
MVC 式的出现不仅实现了功能模块和显示模块的分离,同时它还提高了应用系统的可维护性、可扩展性、可移植性和组件的可复用性
视图层:jsp、html超文本标记语言
控制层: servlet,controller,action
模型层:mybatis,entity,service
#框架部分
1.答案:
1、客户端发出一个http请求给web服务器,web服务器对http请求进行解析,如果匹配DispatcherServlet的请求映射路径(在web.xml中指定),web容器将请求转交给DispatcherServlet.
2、DipatcherServlet接收到这个请求之后将根据请求的信息(包括URL、Http方法、请求报文头和请求参数Cookie等)以及HandlerMapping的配置找到处理请求的处理器(Handler)。
3-4、DispatcherServlet根据HandlerMapping找到对应的Handler,将处理权交给Handler(Handler将具体的处理进行封装),再由具体的HandlerAdapter对Handler进行具体的调用。
5、Handler对数据处理完成以后将返回一个ModelAndView()对象给DispatcherServlet。
6、Handler返回的ModelAndView()只是一个逻辑视图并不是一个正式的视图,DispatcherSevlet通过ViewResolver将逻辑视图转化为真正的视图View。
7、Dispatcher通过model解析出ModelAndView()中的参数进行解析最终展现出完整的view并返回给客户端。
2.核心是IOC和AOP
IOC:控制反转的意思,在spring中,将对象的创建权交由spring来完成(如果问为什么,答为了更好的解耦),DI是IOC的实现过程,是依赖注入的意思
AOP:面向切面编程,底层采用的是动态代理机制(2种:JDK代理(给有接口的类生成代理),CGlib代理(给无接口的类生成代理)),是指将一些重复性的代码提取出来成切面,
给相应的方法定义切点,在指定切点插入切面中的代码。目的就是为了将重复性的代码和核心业务代码分离。主要的应用:spring的声明式事务,日志记录等等