Java面试题（02）
第一部分：选择题（每题2分）
1）Java内部使用的编码格式是（C）
A）UTF-8
B）ASCII
C）UNICODE
D）ISO8859-1
2）public class Threads2 implements Runnable{
@Override
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");
}
}
运行的结果是什么，请选择2个（C、D）
A）java.lang.RuntimeException: Problem
B）Run java.lang.RuntimeException: Problem
C）End of method java.lang.RuntimeException: Problem
D）End of method Run java.lang.RuntimeException: Problem
E）Run java.lang.RuntimeException: Problem End of method
3）public class SimpleCale {
public int value;
public void calculate(){
value+=7;
}
}
public class MultiCale extends SimpleCale{
public void calculate(){
value-=3;
}
public void calculate(int multiplier){
calculate();
super.calculate();
value=multiplier;
}
public static void main(String[] args) {
MultiCale calculator=new MultiCale();
calculator.calculate(2);
System.out.println("Value is==>"+calculator.value);
}
}
运行结果是（A）
A）Value is:8
B）Compilation fails
C）Value is:12
D）Value is:-12
E）The code runs with no output.
F）An exception is thrown at runtime.
4）对于JSP的通用规则，描述正确的是：（E）
A）JSP标记不区分大小写。
B） 指令和脚本元素的语法不是基于XML的，但有替代的基于XML的语法。
C） 在标记中出现的属性值可以不用引号括起来，比如：<%@ page language="Java" %>和<%@ page language=java %>是等同的。
D）在标记中使用字符/(正斜杠)作为转义字符。
E） 如果URL不是以"/"开始的，就被解释为相对于当前的JSP路径。
5）在MVC设计模式中，JavaBean的作用是（C）
A）Controller
B）Model
C）业务数据的封装
D）View
6）在一个Filter中，处理filter业务的是（C）方法。A. dealFilter (ServletRequest request,ServletResponse response,FilterChain chain)
B. dealFilter (ServletRequest request,ServletResponse response)
C. doFilter (ServletRequest request,ServletResponse response,FilterChain chain)
D. doFilter (ServletRequest request,ServletResponse response)
7）对下面Spring声明式事物的配置含义说明错误的是（C）
<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>
8）Hibernate API中的接口可以分为以下几类：（A、B、C、D）
A）提供访问数据库的操作的接口，包括session、Transaction、Query接口；
B）用于配置Hibernate的接口，Configuration；
C）间接接口，使应用程序接受Hibernate内部发生的事件，并作出相关的回应，包括：Interceptor、Lifecycle、Validatable；
D）用于扩展Hibernate功能的接口，如UserType、CompositeUserType、IdentifierGenerator接口。
9）事务的原子性是指（A）。
A)事务中包括的所有操作要么都做，要么都不做
B)事务一旦提交，对数据库的改变是永久的
C)一个事务内部的操作及使用的数据对并发的其他事务是隔离的
D)事务必须是使数据库从一个一致性状态改变到另一个一致性状态
10）外连接的条件可以放在以下的哪一个子句中（B）
A）FROM
B）WHERE
C）SELECT
D）HAVING
第二部分：简答题（每题10分）
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、列举你所知道的排序方法，请写出快速排序的伪代码。
答：排序的方法有：插入排序，选择排序，冒泡排序，堆排序，快速排序，归并排序，计数排序，基数排序，桶排序
快速排序的伪代码：
public void QuickSort(SeqList R,int low,int high){
//对R[low...high]进行快速排序
int pivotpos;//划分后的基准记录的位置
if(low<high){
//仅当区间长度大于1时才需排序
pivotpos = Partition(R,low,high);//对R[low...high]进行划分
QuickSort(R,low,pivotpos-1);
QuickSort(R,pivotpos+1,high);
}
}
3、谈谈final，finally，finalize的区别？
答：
1.final：如果一个类被final修饰，意味着该类不能派生出新的子类，不能作为父类被继承。因此一个类不能被声明为abstract，又被声明为final。将变量或方法声明为final。可以保证他们在使用的时候不被改变。其初始化可以在两个地方：一是其定义的地方，也就是在final变量在定义的时候就对其赋值；二是在构造函数中。这两个地方只能选其中的一个，要么在定义的时候给值，要么在构造函数中给值。被声明为final的方法也只能使用，不能重写。
2.finally：在异常处理的时候，提供finally块来执行任何的清除操作。如果抛出一个异常，那么相匹配的catch字句就会执行，然后控制就会进入finally块，前提是有finally块。
3.finalize：finalize是方法名，java技术允许使用finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是在垃圾收集器确认一个对象没有被引用时对这个对象调用的。它是在Object类中定义的，因此，所有的类都继承了它。子类覆盖finalize()方法已整理系统资源或者执行其他清理工作。finalize()方法是在垃圾收集器删除对象之前对这个对象调用的。
4、Struts的validate框架是如何验证的？（Struts1）与Struts2 任选其一）
Struts2提供了一个Validateable接口，这个接口中只存在validate()方法，实现这个接口的类可直接被Struts2调用，ActionSupport类就实现了Vadidateable接口，但他的validate()方法是一个空方法，需要我们来重写。
validate()方法会在execute()方法执行前执行，仅当数据校验正确，才执行execute()方法， 如错误则将错误添加到fieldErrors域中，如果定义的Action中存在多个逻辑处理方法，且不同的处理逻辑需要不同的校验规则，这种情况下validate()会对所有处理逻辑使用相同的校验规则，为了实现不同的校验逻辑，需要通过validateX()方法，其中X表示处理逻辑的方法名。
5、叙述Spring AOP事物的含义。
事务：一个或者一组sql语句来完成一个功能！
事务具有的四个特性： ACID特性！
01.原子性：一个事物都是一个不可分割的单位！所有的操作 要么都执行，要么都不执行！
02.一致性：事务必须是数据库从一个一致性的状态到达另一个一致性的状态！
03.隔离性：一个事务的执行不会被其他的事务干扰！事务之间相互独立！
04.持久性：事务一旦被提交！这个操作对数据库来说是永久性的！
Spring的事务管理：
事务本事是数据库中的概念！ 按理说应该在数据访问层（dao）！
绝大多数的情况下，我们是把事务 提升到 业务逻辑层！
01.使用spring的事务代理工厂 来 管理事务！
02.使用spring的注解 来 管理事务！ 常用
03.使用AspectJ的AOP配置 来 管理事务！ 常用
需要掌握的两个属性名：
isolation：事务的隔离级别！
01.default：采用数据库默认的事务隔离级别
001.mysql ---》repeatable-read
002.oracle---》read_committed
02. repeatable-read:可重复读取！解决了脏读，不可重复读，没解决幻读！
03. read_committed：读已提交！ 解决了脏读，没解决不可重复读，幻读！
04. read_uncommitted：读未提交！什么都没有解决！
05. serializable：串行化！级别最高！效率最低！不存在并发的问题！
propagation: 事务的传播行为：一共7中方式！
01.required：是spring默认的事务传播行为！
指定的方法必须在事务中执行！如果没有事务，则会自动创建一个事务！
02.supports:有事务就在事务环境下执行，没有事务就直接执行！
03.mandatory:
指定的方法必须在事务中执行！如果没有事务，则抛出异常！
04.requires_new:总是新创建一个事务！
如果当前方法存在事务，则把当前的事务挂起，直到新创建的事务执行完毕后执行！
05.not_supported:指定的方法不能在事务中执行！如果当前方法存在事务，则把当前的事务挂起！
06.never:指定的方法不能在事务中执行！如果当前方法存在事务，则抛出异常！
07.nested:指定的方法必须在事务内执行！
如果执行的方法没有事务，则会创建一个事务！
如果执行的方法没有事务，则会嵌套执行！
timeout_default:定义了事务默认的超时时间！
Spring事务管理的接口：PlatformTransactionManager
常用的两个实现类：
01.使用jdbc和MyBatis时 使用DataSourceTrancationManager
02.使用hibernate时 使用HibernateTrancationManager
Spring事务回滚的方式：
默认的回滚方式--》发生运行时异常回滚！发送受查异常时提交！
受查异常肯定需要我们手动的设置回滚方式！
运行时异常严重！一旦发生，JVM中止执行！
实现自定义异常类！RuntimeException --> Exception ---> Throwable
第三部分：编程题（每题15分）
1、写出使用jdbc连接数据库进行查询的Java代码（数据库不限制）
JDBC连接数据库
创建一个以JDBC连接数据库的程序，包含7个步骤：
1、加载JDBC驱动程序：
在连接数据库之前，首先要加载想要连接的数据库的驱动到JVM（Java虚拟机），
这通过java.lang.Class类的静态方法forName(String className)实现。
例如：
try{
//加载MySql的驱动类
Class.forName("com.mysql.jdbc.Driver") ;
}catch(ClassNotFoundException e){
System.out.println("找不到驱动程序类 ，加载驱动失败！");
e.printStackTrace() ;
}
成功加载后，会将Driver类的实例注册到DriverManager类中。
2、提供JDBC连接的URL
连接URL定义了连接数据库时的协议、子协议、数据源标识。
书写形式：协议：子协议：数据源标识
协议：在JDBC中总是以jdbc开始
子协议：是桥连接的驱动程序或是数据库管理系统名称。
数据源标识：标记找到数据库来源的地址与连接端口。
例如：（MySql的连接URL）
jdbc:mysql:
//localhost:3306/test?useUnicode=true&characterEncoding=gbk ;
useUnicode=true：表示使用Unicode字符集。如果characterEncoding设置为
gb2312或GBK，本参数必须设置为true 。characterEncoding=gbk：字符编码方式。
3、创建数据库的连接
要连接数据库，需要向java.sql.DriverManager请求并获得Connection对象，
该对象就代表一个数据库的连接。
使用DriverManager的getConnectin(String url , String username ,
String password )方法传入指定的欲连接的数据库的路径、数据库的用户名和
密码来获得。
例如：
//连接MySql数据库，用户名和密码都是root
String url = "jdbc:mysql://localhost:3306/test" ;
String username = "root" ;
String password = "root" ;
try{
Connection con =
DriverManager.getConnection(url , username , password ) ;
}catch(SQLException se){
System.out.println("数据库连接失败！");
se.printStackTrace() ;
}
4、创建一个Statement
要执行SQL语句，必须获得java.sql.Statement实例，Statement实例分为以下3
种类型：
1、执行静态SQL语句。通常通过Statement实例实现。
2、执行动态SQL语句。通常通过PreparedStatement实例实现。
3、执行数据库存储过程。通常通过CallableStatement实例实现。
具体的实现方式：
Statement stmt = con.createStatement() ;
PreparedStatement pstmt = con.prepareStatement(sql) ;
CallableStatement cstmt =
con.prepareCall("{CALL demoSp(? , ?)}") ;
5、执行SQL语句
Statement接口提供了三种执行SQL语句的方法：executeQuery 、executeUpdate
和execute
1、ResultSet executeQuery(String sqlString)：执行查询数据库的SQL语句
，返回一个结果集（ResultSet）对象。
2、int executeUpdate(String sqlString)：用于执行INSERT、UPDATE或
DELETE语句以及SQL DDL语句，如：CREATE TABLE和DROP TABLE等
3、execute(sqlString):用于执行返回多个结果集、多个更新计数或二者组合的
语句。
具体实现的代码：
ResultSet rs = stmt.executeQuery("SELECT FROM ...") ;
int rows = stmt.executeUpdate("INSERT INTO ...") ;
boolean flag = stmt.execute(String sql) ;
6、处理结果
两种情况：
1、执行更新返回的是本次操作影响到的记录数。
2、执行查询返回的结果是一个ResultSet对象。
ResultSet包含符合SQL语句中条件的所有行，并且它通过一套get方法提供了对这些
行中数据的访问。
使用结果集（ResultSet）对象的访问方法获取数据：
while(rs.next()){
String name = rs.getString("name") ;
String pass = rs.getString(1) ; // 此方法比较高效
}
（列是从左到右编号的，并且从列1开始）
7、关闭JDBC对象
操作完成以后要把所有使用的JDBC对象全都关闭，以释放JDBC资源，关闭顺序和声
明顺序相反：
1、关闭记录集
2、关闭声明
3、关闭连接对象
if(rs != null){ // 关闭记录集
try{
rs.close() ;
}catch(SQLException e){
e.printStackTrace() ;
}
}
if(stmt != null){ // 关闭声明
try{
stmt.close() ;
}catch(SQLException e){
e.printStackTrace() ;
}
}
if(conn != null){ // 关闭连接对象
try{
conn.close() ;
}catch(SQLException e){
e.printStackTrace() ;
}
}
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;