第二次面试题
第一部分：选择题
1、java内部使用的编码格式是：C、Unicode
在JVM内部，统一使用Unicode表示。
2、
public class Threads2 implements Runnable{
public void run() {
System.out.println("run.");
throw new RuntimeException("Problem");
}
public static void main(String[] args){
Thread t = new Thread(new Threads2());
t.start();
System.out.println("End of method.");
}
}
运行结果是（D、E）
D、End of method.run.java.lang.RuntimeException: Problem
E、run.java.lang.RuntimeException: Problem End of method
3、
public class SimpleCalc {
public int value;
public void calculate(){
value += 7;
}
}
public class MultiCalc extends SimpleCalc {
public void calculate(){
value -= 3;
}
public void calculate(int multiplier){
calculate();
super.calculate();
value *= multiplier;
}
public static void main(String[] args){
MultiCalc calculator = new MultiCalc();
calculator.calculate(2);
System.out.println("Value is: "+calculator.value);
}
}
运行的结果是（A）
A、Value is：8
4、E
5、C、业务数据的封装
MVC 是model view controller的缩写
jsp对应 view层：主要用于页面的显示
servlet对应 controller层：中间层负责数据的访问（调用service接口）和页面的跳转（跳转到想要显示的jsp页面）
javabean对应 model层：是对数据的封装，处理数据
6、C
7、对下面Spring声明式事务的配置含义的说明错误的是（）
|
1 2 3 4 5 6 7 8 9 10 11 |
<bean id="txProxyTemplate" abstract="true" class= "org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> <property name="transactionManager" ref="myTransactionManager" /> <property name="transactionAttributes"> <props> <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop> <prop key="*">PROPAGATION_REQUIRED</prop> </props> </property> </bean> |
A 定义了声明式事务的配置模板
B 对get方法采用只读事务
C 缺少sessionFactory属性的注入
D 配置需要事务管理的bean的代理时，通过parent引用这个配置模板，代码如下：
<bean id="petBiz" parent="txProxyTemplate">
<property name="target" ref="petTarget"/>
</bean>
答案是：C
这里已经注入了工厂
|
1 |
<property name="transactionManager"ref="myTransactionManager"/> |
8、Hibernate API中的接口可以分为以下几类：
A.提供访问数据库的操作的接口，包括session、Transaction、Query接口；
B.用于配置Hibernate的接口，Configuration；
C.间接接口，使应用程序接受Hibernate内部发生的事件，并作出相关的回应，包括：Interceptor、Lifecycle、Validatable；
D.用于扩展Hibernate功能的接口，如UserType、CompositeUserType、IdentifierGenerator接口。
答案：ABCD
9、事物的原子性是指：
A．事务中包括的所有操作要么都做，要么都不做
B．事务一旦提交，对数据库的改变是永久的
C．一个事务内部的操作及使用的数据对并发的其他事务是隔离的
D．事务必须是使数据库从一个一致性状态改变到另一个一致性状态
答案：A
事务的原子性是指事务的所有操纵在数据库中要么全部正确反映出来，要么全部不反映。选项B) 指的是持久性。选项C) 指的是隔离性。选项D) 指的是一致性。
10、外连接的条件可以放在以下的那一个子句中
A.FROM
B.WEHRE
C.SELECT
D.HAVING
答案：B
第二部分：简答题
1、List、Map、Set三个接口，存取元素时，各有什么特点？
答案：
List与Set都是单列元素的集合，它们有一个功共同的父接口Collection。
Set里面不允许有重复的元素，
存元素：add方法有一个boolean的返回值，当集合中没有某个元素，此时add方法可成功加入该元素时，则返回true；当集合含有与某个元素equals相等的元素时，此时add方法无法加入该元素，返回结果为false。
取元素：没法说取第几个，只能以Iterator接口取得所有的元素，再逐一遍历各个元素。
List表示有先后顺序的集合，
存元素：多次调用add(Object)方法时，每次加入的对象按先来后到的顺序排序，也可以插队，即调用add(int index,Object)方法，就可以指定当前对象在集合中的存放位置。
取元素：方法1：Iterator接口取得所有，逐一遍历各个元素
方法2：调用get(index i)来明确说明取第几个。
Map是双列的集合，存放用put方法:put(obj key,obj value)，每次存储时，要存储一对key/value，不能存储重复的key，这个重复的规则也是按equals比较相等。
取元素：用get(Object key)方法根据key获得相应的value。
也可以获得所有的key的集合，还可以获得所有的value的集合，
还可以获得key和value组合成的Map.Entry对象的集合。
List以特定次序来持有元素，可有重复元素。Set无法拥有重复元素,内部排序。Map保存key-value值，value可多值。
2、列举你所知道的排序方法，请写出快速排序的伪代码。
答案：
排序的方法有：插入排序（直接插入排序、希尔排序），交换排序（冒泡排序、快速排序），选择排序（直接选择排序、堆排序），归并排序，分配排序（箱排序、基数排序）
快速排序的伪代码：
//使用快速排序方法对a[ 0 :n- 1 ]排序
从a[ 0 :n- 1 ]中选择一个元素作为m i d d l e，该元素为支点
把余下的元素分割为两段left 和r i g h t，使得l e f t中的元素都小于等于支点，而right 中的元素都大于等于支点
递归地使用快速排序方法对left 进行排序
递归地使用快速排序方法对right 进行排序
所得结果为l e f t + m i d d l e + r i g h t
伪代码：
quicksort(A, lo, hi)
if lo < hi
p = partition(A, lo, hi)
quicksort(A, lo, p - 1)
quicksort(A, p + 1, hi)
partition(A, lo, hi)
pivot = A[hi]
i = lo //place for swapping
for j = lo to hi - 1
if A[j] <= pivot
swap A[i] with A[j]
i = i + 1
swap A[i] with A[hi]
return i
3、谈谈final，finally，finalize的区别？
答案：
(1) final：修饰符（关键字），如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载
(2) finally：在异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally块（如果有的话）。
(3) finalize：方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。
一、性质不同
（1）final为关键字；
（2）finalize()为方法；
（3）finally为为区块标志，用于try语句中；
二、作用
（1）final为用于标识常量的关键字，final标识的关键字存储在常量池中（在这里final常量的具体用法将在下面进行介绍）；
（2）finalize()方法在Object中进行了定义，用于在对象“消失”时，由JVM进行调用用于对对象进行垃圾回收，类似于C++中的析构函数；用户自定义时，用于释放对象占用的资源（比如进行I/0操作）；
（3）finally{}用于标识代码块，与try{}进行配合，不论try中的代码执行完或没有执行完（这里指有异常），该代码块之中的程序必定会进行。
4、Struts的validate框架是如何验证的？(Struts1与Struts2任选其一)
答案：
方法一：Action类继承ActionSupport类，其中ActionSupport实现了Validateable接口，并定义了validation方法，只要在用户自定义的Action类中重写该方法就可以实现该功能。
其中错误信息可以通过addFieldError方法将错误信息保存起来。
方法二：在Action类的文件的路径下，添加一个校验文件ActionName-validation.xml，并配置校验器。
5、叙述Spring AOP事务的含义。
答案：
spring有两种事务配置方式，一种是配置的事务管理器，另一种的是代码控制的事务。
配置的事务管理器的方式是我们经常用到的经常会用到在配置文件中。代码控制的事务分为jdbc模板的和事务管理器的，jdbc默认自动提交，事务管理器的和咱们通常的一样会有commit rollback等操作。
第三部分：编程题
1、写出使用jdbc连接数据库进行查询的java代码。(数据库不限)
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
public class DBCon {
//数据库驱动对象
public static final String DRIVER="oracle.jdbc.driver.OracleDriver";
//数据库连接地址(数据库名)
public static final String URL="jdbc:oracle:thin:@localhost:1521:orcl";
//登陆名
public static final String USER="FM";
//登陆密码
public static final String PWD="FM";
//创建数据库连接对象
private Connection con=null;
//创建数据库预编译对象
private PreparedStatement ps=null;
//创建结果集
private ResultSet rs=null;
//创建数据源对象
public static DataSource source=null;
/**
* 获取数据库连接
*/
public Connection getCon(){
try {
Class.forName(DRIVER);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
try {
con=DriverManager.getConnection(URL,USER,PWD);
} catch (SQLException e) {
e.printStackTrace();
}
return con;
}
/**
* 关闭所有资源
*/
public void closeAll(){
if(rs!=null)
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
if(ps!=null)
try {
ps.close();
} catch (SQLException e) {
e.printStackTrace();
}
if(con!=null)
try {
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* @param sql数据库查询语句
* @param pras参数列表（可传，可不传，不传为NULL，以数组形式存在）
* @return 返回结果集
*/
public ResultSet query(String sql,String... pras){
con=getCon();
try {
ps=con.prepareStatement(sql);
if(pras!=null)
for(int i=0;i<pras.length;i++){
ps.setString(i+1, pras[i]);
}
rs=ps.executeQuery();
} catch (SQLException e) {
e.printStackTrace();
}
return rs;
}
}
2、写出实现下述功能的SQL语句
有两个表PRODUCT(产品信息表)和表PRODUCT_SS(产品进销表)。
PRODUCT表有下列字段：
|
字段 |
字段说明 |
字段类型 |
字段长度 |
说明 |
|
PRO_ID |
产品编号 |
字符型 |
10 |
主键 |
|
PRO_NAME |
产品名称 |
字符型 |
50 |
|
|
PRO_COUNT |
产品总量 |
数字型 |
10 |
PRODUCT_SALE表有下列字段：
|
字段 |
字段说明 |
字段类型 |
字段长度 |
说明 |
|
ID |
序号，自增 |
主键 |
||
|
PRO_ID |
产品编号 |
字符型 |
10 |
外键 |
|
SALE_COUNT |
销售数量 |
数字型 |
6 |
|
|
SS_DATE |
发生日期 |
日期型 |
1)写出建表的SQL语句
答案：
CREATE TABLE PRODUCT(
PRO_ID VARCHAR(10) PRIMARY KEY COMMENT '产品编号',
PRO_NAME VARCHAR(50) COMMENT '产品名称',
PRO_COUNT INT(10) COMMENT '产品总量'
)COMMENT='产品信息表';
CREATE TABLE PRODUCT_SALE(
ID INT(10) PRIMARY KEY AUTO_INCREMENT COMMENT '序号',
PRO_ID VARCHAR(10) COMMENT '产品编号',
SALE_COUNT INT(6) COMMENT '销售数量',
SS_DATE DATE COMMENT '发生日期'
)COMMENT='产品进销表';
ALTER TABLE PRODUCT_SALE
ADD CONSTRAINT
FOREIGN KEY(PRO_ID) REFERENCES PRODUCT(PRO_ID)
2)显示产品编号以”12”开头的产品信息。
答案：
SELECT * FROM product WHERE pro_id LIKE '12%';
3)插入PRODUCT_SALE表中产品编号为”67890”的产品销售数量为2000。(注 意事务)
答案：
BEGIN;
INSERT INTO product_sale (pro_id,sale_count)
VALUES(67890,2000);
COMMIT;
4)显示所有产品的库存，要求显示产品名称和库存数量(用一条SQL语句).
答案：
SELECT pro_name,pro_count
FROM product;
5)显示所有产品的库存，要求显示产品名称、库存数量、库存状态。(用一条 SQL语句).
当库存数 >=10000时，库存状态显示库存积压；
当库存数 <=1000时，库存状态显示库存不足；
其他情况，库存状态显示库存正常。
答案：
SELECT pro_name AS 产品名称, pro_count AS 库存数量,
(
CASE
WHEN pro_count >= 10000 THEN '库存积压'
WHEN pro_count > 1000 AND pro_count < 10000 THEN '库存正常'
WHEN pro_count <= 1000 THEN '库存不足'
END
)
AS 库存状态
FROM product;