Java面向对象
1. Java的跨平台原理（字节码文件、虚拟机） 1
2.简述Java的垃圾回收机制 1
3.类和对象的关系 2
4.面向过程和面向对象的区别 2
5. private/默认/protected/public权限修饰符的区别 2
6.方法重载和方法重写（覆盖）的区别 3
7.子类可以从父类继承到哪些内容 3
8. this和super关键字的作用 3
9. static关键字的作用（修饰变量、方法、代码块） 3
10. final和abstract关键字的作用 4
11. final、finally、finalize的区别 4
12.写出java.lang.Object类的六个常用方法 4
13. 继承条件下构造方法的执行过程 5
14. 实现多态的三个条件 5
15. 多态的技能点（向上转型、向下转型） 5
16. 接口和抽象类的异同之处 5
17. String、StringBuffer、StringBuilder区别与联系 6
18. ==和equals的区别和联系 6
19. String类型是基本数据类型吗？基本数据类型有哪些 6
20.String s="Hello";s=s+"world!";执行后，原始String内容是否改变？ 7
21.String s = new String("xyz");创建了几个String Object? 二者之间有什么区别？ 7
22.下面这条语句一共创建了多少个对象：String s="a"+"b"+"c"+"d"; 8
23.&和&&的区别和联系，|和||的区别和联系 8
24.用最有效率的方法算出2乘以8等于多少 8
25.Math.round(11.5)等於多少? Math.round(-11.5)等於多少? 8
26.xml有哪些解析技术?区别是什么?
27.你在项目中用到了xml技术的哪些方面?如何实现的?
28.用jdom解析xml文件时如何解决中文问题?如何解析?
答:看如下代码,用编码方式加以解决
package test;
import java.io.*;
public class DOMTest
{
private String inFile = "c:\people.xml"
private String outFile = "c:\people.xml"
public static void main(String args[])
{
new DOMTest();
}
public DOMTest()
{
try
{
javax.xml.parsers.DocumentBuilder builder =
javax.xml.parsers.DocumentBuilderFactory.newInstance().newDocumentBuilder();
org.w3c.dom.Document doc = builder.newDocument();
org.w3c.dom.Element root = doc.createElement("老师");
org.w3c.dom.Element wang = doc.createElement("王");
org.w3c.dom.Element liu = doc.createElement("刘");
wang.appendChild(doc.createTextNode("我是王老师"));
root.appendChild(wang);
doc.appendChild(root);
javax.xml.transform.Transformer transformer =
javax.xml.transform.TransformerFactory.newInstance().newTransformer();
transformer.setOutputProperty(javax.xml.transform.OutputKeys.ENCODING, "gb2312");
transformer.setOutputProperty(javax.xml.transform.OutputKeys.INDENT, "yes");
transformer.transform(new javax.xml.transform.dom.DOMSource(doc),
new
javax.xml.transform.stream.StreamResult(outFile));
}
catch (Exception e)
{
System.out.println (e.getMessage());
}
}
}
29.编程用JAVA解析XML的方式
答:用SAX方式解析XML，XML文件如下：
<?xml version=1.0 encoding=gb2312?>
<person>
<name>王小明</name>
<college>信息学院</college>
<telephone>6258113</telephone>
<notes>男,1955年生,博士，95年调入海南大学</notes>
</person>
事件回调类SAXHandler.java
import java.io.*;
import java.util.Hashtable;
import org.xml.sax.*;
public class SAXHandler extends HandlerBase
{
private Hashtable table = new Hashtable();
private String currentElement = null;
private String currentValue = null;
public void setTable(Hashtable table)
{
this.table = table;
}
public Hashtable getTable()
{
return table;
}
public void startElement(String tag, AttributeList attrs)
throws SAXException
{
currentElement = tag;
}
public void characters(char[] ch, int start, int length)
throws SAXException
{
currentValue = new String(ch, start, length);
}
public void endElement(String name) throws SAXException
{
if (currentElement.equals(name))
table.put(currentElement, currentValue);
}
}
JSP内容显示源码,SaxXml.jsp:
<HTML>
<HEAD>
<TITLE>剖析XML文件people.xml</TITLE>
</HEAD>
<BODY>
<%@ page errorPage=ErrPage.jsp
contentType=text/html;charset=GB2312 %>
<%@ page import=java.io.* %>
<%@ page import=java.util.Hashtable %>
<%@ page import=org.w3c.dom.* %>
<%@ page import=org.xml.sax.* %>
<%@ page import=javax.xml.parsers.SAXParserFactory %>
<%@ page import=javax.xml.parsers.SAXParser %>
<%@ page import=SAXHandler %>
<%
File file = new File(c:people.xml);
FileReader reader = new FileReader(file);
Parser parser;
SAXParserFactory spf = SAXParserFactory.newInstance();
SAXParser sp = spf.newSAXParser();
SAXHandler handler = new SAXHandler();
sp.parse(new InputSource(reader), handler);
Hashtable hashTable = handler.getTable();
out.println(<TABLE BORDER=2><CAPTION>教师信息表</CAPTION>);
out.println(<TR><TD>姓名</TD> + <TD> +
(String)hashTable.get(new String(name)) + </TD></TR>);
out.println(<TR><TD>学院</TD> + <TD> +
(String)hashTable.get(new String(college))+</TD></TR>);
out.println(<TR><TD>电话</TD> + <TD> +
(String)hashTable.get(new String(telephone)) + </TD></TR>);
out.println(<TR><TD>备注</TD> + <TD> +
(String)hashTable.get(new String(notes)) + </TD></TR>);
out.println(</TABLE>);
%>
</BODY>
</HTML>
30.XML文档定义有几种形式？它们之间有何本质区别？解析XML文档有哪几种方式？
Java面向对象
1. Error和Exception的区别 10
2. Checked异常和Runtime异常的区别 10
3. Java异常处理try-catch-finally的执行过程 10
4. 异常处理中throws和throw的区别 11
5. 编写一段简单的log4j日志处理代码 11
public class Test11 {
private static Logger logger=Logger.getLogger(Test11.class.getName());
public static void main(String[] args) {
try {
Scanner in = new Scanner(System.in);
System.out.print("请输入被除数:");
int num1 = in.nextInt();
logger.debug("输入被除数：" + num1);
System.out.print("请输入除数:");
int num2 = in.nextInt();
logger.debug("输入除数：" + num2);
System.out.println(String.format("%d / %d = %d", num1, num2, num1/ num2));
logger.debug("输出运算结果：" + num1 / num2));
} catch (InputMismatchException e) {
logger.error("被除数和除数必须是整数", e);
} catch (ArithmeticException e) {
logger.error(e.getMessage());
} catch (Exception e) {
logger.error(e.getMessage());
} finally {
System.out.println("欢迎使用本程序！");
}
}
}
6. 基本数据类型和包装类 11
7、Integer与int的区别 12
8. Java集合体系结构（List、Set、Collection、Map的区别和联系） 12
9. Vector和ArrayList、ArrayList和LinkedList的区别和联系 13
10. HashMap和Hashtable的区别和联系 14
11. HashSet的使用和原理（hashCode()和equals()） 14
12. TreeSet的原理和使用（Comparable和comparator） 14
13. 集合和数组的比较（为什么引入集合） 15
14. Collection和Collections的区别 15
15. 使用JDBC进行数据库操作的基本步骤 15
public class Test5 {
private static Logger logger = Logger.getLogger(Test5.class.getName());
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
// 1、加载驱动
try {
Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
} catch (ClassNotFoundException e) {
logger.error(e);
}
try { // 2、建立连接
conn = DriverManager.getConnection(
"jdbc:sqlserver://localhost:1433;DatabaseName=epet","jbit", "bdqn");
// 3、向数据库发送SQL命令并得到结果
stmt = conn.createStatement();
rs = stmt.executeQuery("select * from dog");
//4、处理返回结果
System.out.println(" 狗狗信息列表");
System.out.println("编号 姓名 健康值 亲密度 品种");
while (rs.next()) {
System.out.print(rs.getInt(1)+" ");System.out.print(rs.getString(2)+" ");
System.out.print(rs.getInt("health")+ " ");
System.out.print(rs.getInt("love")+" "); System.out.println(rs.getString("strain"));
}
} catch (SQLException e) {
logger.error(e);
} finally {
// 5、关闭Statement和数据库连接
try { if (null != rs) {rs.close();}
if (null != stmt) { stmt.close();}
if (null != conn) { conn.close();}
} catch (SQLException e) {
logger.error(e);
}
}
}
}
16. Statement和PreparedStatement的区别 16
17.为什么引入事务？事务的基本特性。JDBC和Hibernate中如何使用事务 16
18. 请使用递归算法计算n！ 17
19.请写出冒泡排序代码 17
- 冒泡排序算法
public class TestBubbleSort {
public static void sort(int[] a) {
int temp = 0;
// 外层循环，它决定一共走几趟
for (int i = 0; i <a.length-1; ++i) {
//内层循环，它决定每趟走一次
for (int j = 0; j <a.length-i-1 ; ++j) {
//如果后一个大于前一个
if (a[j + 1] < a[j]) {
//换位
temp = a[j];a[j] = a[j + 1];a[j + 1] = temp;
}
}
}
public static void sort2(int[] a) {
int temp = 0;
for (int i = 0; i <a.length-1; ++i) {
//通过符号位可以减少无谓的比较，如果已经有序了，就退出循环
int flag = 0;
for (int j = 0; j <a.length-1-i ; ++j) {
if (a[j + 1] < a[j]) {
temp = a[j];a[j] = a[j + 1];a[j + 1] = temp;
flag = 1;
}
}
if(flag == 0){ break;}
}
}
}
20.请写出选择排序的代码 18
public class TestSelectSort {
public static void sort(int arr[]) {
int temp = 0;
for (int i = 0; i < arr.length - 1; i++) {
// 认为目前的数就是最小的, 记录最小数的下标
int minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[minIndex] > arr[j]) {
// 修改最小值的下标
minIndex = j;
}
}
// 当退出for就找到这次的最小值
if (i != minIndex) {
temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
}
}
21.请写出插入排序的代码 19
22.开发存储过程，实现操作： 19
查询订单数据，如果发现有超过六个月没有下单的客户，自动向流失预警表中添加一条记录。
|
USE [jb_crm_team0] GO SET ANSI_NULLS OFF GO SET QUOTED_IDENTIFIER OFF GO ALTER PROCEDURE [dbo].[Check_Lost] AS DECLARE @lst_cust_no char(17),@lst_cust_name nvarchar(100), @lst_cust_manager_id bigint,@lst_manager_name nvarchar(50), @lst_status varchar(10) DECLARE Lost_Cust_Cursor CURSOR FOR select cust_no,cust_name,cust_manager_id,cust_manager_name, 1 from cst_customer where cust_no in ( select distinct cst.cust_no from cst_customer cst,v_orders odr where cst.cust_name=odr.odr_customer and DATEDIFF(m,odr.odr_date,getdate())>6 ) OPEN Lost_Cust_Cursor FETCH NEXT FROM Lost_Cust_Cursor into @lst_cust_no,@lst_cust_name,@lst_cust_manager_id,@lst_manager_name,@lst_status WHILE @@FETCH_STATUS = 0 BEGIN insert into cst_lost(lst_cust_no,lst_cust_name,lst_cust_manager_id,lst_cust_manager_name,lst_status) values (@lst_cust_no,@lst_cust_name,@lst_cust_manager_id,@lst_manager_name,@lst_status) FETCH NEXT FROM Lost_Cust_Cursor into @lst_cust_no,@lst_cust_name,@lst_cust_manager_id,@lst_manager_name,@lst_status END CLOSE Lost_Cust_Cursor DEALLOCATE Lost_Cust_Cursor |
Java高级
1.Java反射技术的主要实现类有哪些，其作用分别是什么？ 21
2.Class类的作用？生成Class对象的方法主要有哪些？ 21
3.反射的使用场合和作用、及其优缺点 21
4.进程和线程有什么联系和区别？ 22
5.创建线程的两种方式分别是什么？ 23
6.如何实现线程同步？ 24
7. Java中实现线程通信的三个方法的作用是什么？ 24
8.说明生产者和消费者问题，如何采用多线程实现？ 25
9.讲解ThreadLocal的作用及其使用 25
10.什么是java序列化，如何实现java序列化？ 26
11.介绍OSI七层模型和TCP/IP模型 26
12. TCP协议和UDP协议的比较 27
13.什么是Socket编程；简述基于TCP协议的Socket编程的主要步骤 27
基于TCP协议的Socket编程的主要步骤
14.Java内存结构
15.GC相关
16.JVM问题
17.注解
元注解
@Retention
它是被定义在一个注解类的前面，用来说明该注解的生命周期。它有以下参数：
RetentionPolicy.SOURCE ：指定注解只保留在一个源文件当中。
RetentionPolicy.CLASS ：指定注解只保留在一个 class 文件中。
RetentionPolicy.RUNTIME ：指定注解可以保留在程序运行期间。
@Target
它是被定义在一个注解类的前面，用来说明该注解可以被声明在哪些元素前。它有以下参数：
ElementType.TYPE ：说明该注解只能被声明在一个类前。
ElementType.FIELD ：说明该注解只能被声明在一个类的字段前。
ElementType.METHOD ：说明该注解只能被声明在一个类的方法前。
ElementType.PARAMETER ：说明该注解只能被声明在一个方法参数前。 ElementType.CONSTRUCTOR ：说明该注解只能声明在一个类的构造方法前 。
ElementType.LOCAL_VARIABLE ：说明该注解只能声明在一个局部变量前。
ElementType.ANNOTATION_TYPE ：说明该注解只能声明在一个注解类型前 。
ElementType.PACKAGE ：说明该注解只能声明在一个包名前。
@Inherited
可以被子类继承
@Documented
生成文件档时，包含本注解信息
例子:spring的事务注解@Transactional
@Target({ElementType.METHOD, ElementType.TYPE})//可以作用在类上和方法上
@Retention(RetentionPolicy.RUNTIME)//可以通过反射读取注解
@Inherited//可以被子类继承
@Documented//javadoc生成文件档时，包含本注解信息
public @interface Transactional {
String value() default "";
//使用时没有指定key,值默认赋给value,如：Transactional("abc")
Propagation propagation() default Propagation.REQUIRED;
Isolation isolation() default Isolation.DEFAULT;
int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
boolean readOnly() default false;
Class<? extends Throwable>[] rollbackFor() default {};
String[] rollbackForClassName() default {};
Class<? extends Throwable>[] noRollbackFor() default {};
String[] noRollbackForClassName() default {};
}
注解可以有哪些成员
注解和接口相似，它只能定义 final 静态属性和公共抽象方法。
注解的方法
1. 方法前默认会加上 public abstract
2. 在声明方法时可以定义方法的默认返回值。
例如 :
String color() default "blue";
String[] color() default {"blue", "red",......}
3. 方法的返回值可以有哪些类型
8 种基本类型， String 、 Class 、枚举、注解及这些类型的数组。
使用注解
注解的使用分为三个过程。
定义注解 --> 声明注解 --> 得到注解
a. 定义注解（参照上面的注解定义）
b. 声明注解
1. 在哪些元素上声明注解
如果定义注解时没有指定 @Target 元注解来限制它的使用范围 ， 那么该注
解可以使用在 ElementType 枚举指定的任何一个元素前。否则，只能声明在
@Target 元注解指定的元素前。
一般形式：
@ 注解名 ()
- 对注解的方法的返回值进行赋值
对于注解中定义的每一个没有默认返回值的方法 ， 在声明注解时必须对它
的每一个方法的返回值进行赋值。
一般形式 :
@ 注解名 ( 方法名 = 方法返回值 ， 、 、 、 、 、 、 )
如果方法返回的是一个数组时，那么将方法返回值写在 {} 符号里
@ 注解名 ( 方法名 ={ 返回值 1 ，返回值 2 ， 、 、 、 、 、 、 } ， 、 、 、 、 、 、 、 )
3. 对于只含有 value 方法的注解，在声明注解时可以只写返回值。
c. 得到注解
对于生命周期为运行期间的注解，都可以通过反射获得该元素上的注解实例 。
1 、声明在一个类中的注解
可以通过该类 Class 对象的 getAnnotation 或 getAnnotations 方法获得。
2 、声明在一个字段中的注解
通过 Field 对象的 getAnnotation 或 getAnnotations 方法获得
3 、声明在一个方法中的注解
通过 Method 对象的 getAnnotation 或 getAnnotations 方法获得
动态网页技术
1. JSP的执行过程 29
3.JSP的9个内置对象及其含义，分别写出其常用方法三个 29
4. page/request/session/application的范围区别 29
5. get和post的区别 30
6.Servlet的生命周期 30
2.JSP和Servlet的区别和联系 30
7.session和cookie的区别 31
8.转发和重定向的区别 31
9.MVC模式及其优缺点 32
10.B/S和C/S的含义及其区别 33
11.为什么要使用连接池？数据库连接池的原理。 33
12.EJB与JavaBean的区别？ 34
数据库部分
1、用两种方式根据部门号从高到低，工资从低到高列出每个员工的信息。
2、列出各个部门中工资高于本部门的平均工资的员工数和部门号，并按部门号排序
3、存储过程与触发器必须讲，经常被面试到?
4、数据库三范式是是什么？
5、说出一些数据库优化方面的经验？
6、union和union all有什么不同?
假设我们有一个表Student，包括以下字段与数据：
drop table student;
create table student
(
id int primary key,
name nvarchar2(50) not null,
score number not null
);
insert into student values(1,'Aaron',78);
insert into student values(2,'Bill',76);
insert into student values(3,'Cindy',89);
insert into student values(4,'Damon',90);
insert into student values(5,'Ella',73);
insert into student values(6,'Frado',61);
insert into student values(7,'Gill',99);
insert into student values(8,'Hellen',56);
insert into student values(9,'Ivan',93);
insert into student values(10,'Jay',90);
commit;
Union和Union All的区别。
select *
from student
where id < 4
union
select *
from student
where id > 2 and id < 6
结果将是
1 Aaron 78
2 Bill 76
3 Cindy 89
4 Damon 90
5 Ella 73
如果换成Union All连接两个结果集，则返回结果是：
1 Aaron 78
2 Bill 76
3 Cindy 89
3 Cindy 89
4 Damon 90
5 Ella 73
7、分页语句
8、用一条SQL语句 查询出每门课都大于80分的学生姓名
9、所有部门之间的比赛组合
10、每个月份的发生额都比101科目多的科目
--复制最上面的数据，故意把所有发生额数字改大一点
insert into TestDB values
(null,'103','1988-1-1',150),
(null,'103','1988-2-1',160),
(null,'103','1988-3-1',180),
(null,'103','1988-4-1',120),
(null,'103','1988-5-1',120),
(null,'103','1988-6-1',120),
(null,'103','1988-7-1',120),
(null,'103','1988-8-1',120);
--复制最上面的数据，故意把所有发生额数字改大一点
insert into TestDB values
(null,'104','1988-1-1',130),
(null,'104','1988-2-1',130),
(null,'104','1988-3-1',140),
(null,'104','1988-4-1',150),
(null,'104','1988-5-1',160),
(null,'104','1988-6-1',170),
(null,'104','1988-7-1',180),
(null,'104','1988-8-1',140);
--复制最上面的数据，故意把第二个月份的发生额数字改小一点
insert into TestDB values
(null,'105','1988-1-1',100),
(null,'105','1988-2-1',80),
(null,'105','1988-3-1',120),
(null,'105','1988-4-1',100),
(null,'105','1988-5-1',100),
(null,'105','1988-6-1',100),
(null,'105','1988-7-1',100),
(null,'105','1988-8-1',100);
11、统计每年每月的信息
year month amount
1991 1 1.1
1991 2 1.2
1991 3 1.3
1991 4 1.4
1992 1 2.1
1992 2 2.2
1992 3 2.3
1992 4 2.4
查成这样一个结果
year m1 m2 m3 m4
1991 1.1 1.2 1.3 1.4
1992 2.1 2.2 2.3 2.4
提示：这个与工资条非常类似，与学生的科目成绩也很相似。
准备sql语句：
drop table if exists sales;
create table sales(id int auto_increment primary key,year varchar(10), month varchar(10), amount float(2,1));
insert into sales values
(null,'1991','1',1.1),
(null,'1991','2',1.2),
(null,'1991','3',1.3),
(null,'1991','4',1.4),
(null,'1992','1',2.1),
(null,'1992','2',2.2),
(null,'1992','3',2.3),
(null,'1992','4',2.4);
12、显示文章标题，发帖人、最后回复时间
13、删除除了id号不同,其他都相同的学生冗余信息
14、航空网的几个航班查询题：
15、查出比经理薪水还高的员工信息：
16、求出小于45岁的各个老师所带的大于12岁的学生人数
17、求出发帖最多的人：
18、一个用户表中有一个积分字段，假如数据库中有100多万个用户，若要在每年第一 天凌 晨将积分清零，你将考虑什么，你将想什么办法解决?
19、一个用户具有多个角色，请查询出该表中具有该用户的所有角色的其他用户。
20、xxx公司的sql面试
21、注册Jdbc驱动程序的三种方式
做实在是没有必要，还会影响程序的运行。
Java代码
- static {
- try {
- java.sql.DriverManager.registerDriver(new Driver());
- } catch (SQLException E) {
- throw new RuntimeException("Can't register driver!");
- }
- }
由new com.mysql.jdbc.Driver()可以知道，这里需要创建一个类的实例。创建类的实例就需要在java文件中将该类通过import导入，否则就会报错，即采用这种方式，程序在编译的时候不能脱离驱动类包，为程序切换到其他数据库带来麻烦
jdbc是使用桥的模式进行连接的。DriverManager就是管理数据库驱动的一个类，java.sql.Driver就 是一个提供注册数据库驱动的接口，而com.microsoft.sqlserver.jdbc.SQLServerDriver()是 java.sql.Driver接口的一个具体实现。
第二种与第三种注册的方法看起来更加的直接与好理解。第一种方法是通过Class把类先装载到java的虚拟机中，并没有创建Driver类的实例。
第一种与第二种方法可以脱离jdbc的驱动进行编译，第三种方法不可以的，它一定要有jdbc的驱动才可以通过编译，这样对我们的程序就有很多的不好之处，为程序换数据库会带来麻烦。
所以推荐使用第一种方法来注册驱动。
总结：推荐1，和2两种方式。
原因：3在编译时需要导入对应的lib。1，2不需要。
22、用JDBC如何调用存储过程
代码如下：
package com.huawei.interview.lym;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Types;
public class JdbcTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Connection cn = null;
CallableStatement cstmt = null;
try {
//这里最好不要这么干，因为驱动名写死在程序中了
Class.forName("com.mysql.jdbc.Driver");
//实际项目中，这里应用DataSource数据，如果用框架，
//这个数据源不需要我们编码创建，我们只需Datasource ds = context.lookup()
//cn = ds.getConnection();
cn = DriverManager.getConnection("jdbc:mysql:///test","root","root");
cstmt = cn.prepareCall("{call insert_Student(?,?,?)}");
cstmt.registerOutParameter(3,Types.INTEGER);
cstmt.setString(1, "wangwu");
cstmt.setInt(2, 25);
cstmt.execute();
//get第几个，不同的数据库不一样，建议不写
System.out.println(cstmt.getString(3));
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
/*try{cstmt.close();}catch(Exception e){}
try{cn.close();}catch(Exception e){}*/
try {
if(cstmt != null)
cstmt.close();
if(cn != null)
cn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
23、JDBC中的PreparedStatement相比Statement的好处
24、写一个用jdbc连接并访问oracle数据的程序代码
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class JDBCTest {
public static void main(String[] args) throws Exception {
//1.加载驱动
//Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
//Class.forName("com.mysql.jdbc.Driver");
Class.forName("oracle.jdbc.driver.OracleDriver");
//2.创建数据库连接对象
//Connection conn = DriverManager.getConnection("jdbc:sqlserver://localhost:1433;databaseName=db","sa","sqlpass");
//Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db?useUnicode=true&characterEncoding=UTF-8","root","123456");
Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl","scott","Oracle123");
//3.创建数据库命令执行对象
Statement stmt = conn.createStatement();
// PreparedStatement ps = conn.prepareStatement("select * from t_user");
//4.执行数据库命令
ResultSet rs = stmt.executeQuery("select * from t_user");
// ResultSet rs = ps.executeQuery();
//5.处理执行结果
while (rs.next()) {
int id = rs.getInt("id");
String username = rs.getString("username");
String password = rs.getString("password");
System.out.println(id + " " + username + " " + password);
}
//6.释放数据库资源
if (rs != null) {
rs.close();
}
// if (ps != null) {
// ps.close();
// }
if (stmt != null) {
stmt.close();
}
if (conn != null) {
conn.close();
}
}
}
25、Class.forName的作用?为什么要用?
26、大数据量下的分页解决方法。
27、用 JDBC 查询学生成绩单, 把主要代码写出来（考试概率极大）.
28、这段代码有什么不足之处?
29、说出数据连接池的工作机制是什么?
30、为什么要用 ORM? 和 JDBC 有何不一样?
SSH2开源框架
1.Struts1的工作原理 35
2. Struts2的工作原理 35
3. Struts1与Struts2的区别 36
|
特性 |
Struts1.x |
Struts2 |
|
Action类 |
Struts1.x要求Action类要扩展自一个抽象基类。Struts1.x的一个共有的问题是面向抽象类编程而不是面向接口编程。 |
Struts2的Action类实现了一个Action接口。Struts2也提供ActionSupport基类来实现一般使用的接口。当然，Action接口不是必须的。任何使用execute方法的POJO可以被当作Struts 2的Action对象来使用。 |
|
线程模型 |
Struts1.x Action类是单例类，因为只有一个实例来控制所有的请求。单例类策略造成了一定的限制，并且给开发带来了额外的烦恼。Action资源必须是线程安全或者同步的。 |
Struts2 Action对象为每一个请求都实例化对象，所以没有线程安全的问题。（实践中，servlet容器给每一个请求产生许多丟弃的对象，并且不会导致性能和垃圾回收问题）。 |
|
Servlet 依赖 |
Struts1.x的Action类依赖于servlet API，当Action被调用时，以Request和Response作为参数传给execute方法。 |
Struts2的Action和容器无关。Servlet上下文被表现为简单的Maps，允许Action被独立的测试。 |
|
易测性 |
测试Struts1.x的主要问题是execute方法暴露了Servlet API使得测试依赖于容器。第三方扩展，如Struts TestCase，提供一套Struts1的模拟对象（来进行测试）。 |
Struts2的Action可以通过初始化、设置属性、调用方法来测试。依赖注入的支持也是测试变得更简单。 |
|
捕获输入 |
Struts1.x使用ActionForm对象来捕获输入。象Action一样，所有的ActionForm必须扩展基类。因为其他的JavaBean不能作为ActionForm使用，开发者经常创建多余的类来捕获输入。DynaBeans可以被用来作为替代ActionForm的类来创建。但是，开发者可能是在重新描述(创建)已经存在的JavaBean（仍然会导致有冗余的javabean）。 |
Struts2直接使用Action属性作为输入属性，消除了对第二个输入对象的需求。输入属性可能是有自己(子)属性的rich对象类型。Action属性能够通过web页面上的taglibs访问。Struts2也支持ActionForm模式。rich对象类型，包括业务对象，能够用作输入/输出对象。这种ModelDriven 特性简化了taglib对POJO输入对象的引用。 |
|
表达式语言 |
Struts1.x整合JSTL，所以它使用JSTL的表达式语言。表达式语言有基本的图形对象移动，但是对集合和索引属性的支持很弱。 |
Struts2使用JSTL，但是也支持一个更强大和灵活的表达式语言－－"Object Graph Notation Language" (OGNL)。 |
|
将值绑定到页面 |
Struts1.x使用标准JSP机制来绑定对象到页面上下文。 |
Struts2使用“ValueStack”技术，使taglib能够访问值而不需要把你的页面（view）和对象绑定起来。ValueStack策略允许通过一系列名称相同但类型不同的属性重用页面（view）。 |
|
类型转换 |
Struts1.x的ActionForm属性经常都是String。Struts 1.x使用Commons-Beanutils来进行类型转换。转换每一个类，而不是为每一个实例配置。 |
Struts2使用OGNL进行类型转换。提供基本和常用对象的转换器。 |
|
验证 |
Struts1.x支持在ActionForm的validate方法中手动校验，或者通过Commons Validator的扩展来校验。 |
Struts2支持通过validate方法和XWork校验框架来进行校验。 |
|
Action执行控制 |
Struts1.x支持每一个模块有单独的Request Processors（生命周期），但是模块中的所有Action必须共享相同的生命周期。 |
Struts2支持通过拦截器堆栈（Interceptor Stacks）为每一个Action创建不同的生命周期。堆栈能够根据需要和不同的Action一起使用。 |
4. Struts2中拦截器的主要作用、工作原理，如何自定义拦截器 37
3.2配置和引用拦截器
5. 拦截器和过滤器的异同 38
6. Hibernate相比JDBC的优势所在 38
二者的联系：
7.Hibenate的基本原理（ORM） 39
8.cascade和inverse的区别 40
9. HQL和SQL的区别 40
10. 如何提高Hibernate的性能 40
11. Hibernate中持久化类的三种状态及其特征 40
12. Spring IoC的原理 41
13. Spring AOP的原理 41
14. AOP的基本概念：切面、通知、切入点、连接点、织入 42
15. SSH整合的基本步骤 42
16. 并行操作下数据库事务出现的问题及含义；事务的隔离级别和四大属性 42
17. 手动搭建Web项目，手动搭建SSH环境 43
1、安装Tomcat
安装版：只适用Windows，会自动安装Window服务
解压版：适合于其他操作系统，安装完毕后需要配置环境变量，并可以添加成Window服务
建议安装解压版，了解Tomcat的启动过程
2、配置Tomcat
JAVA_HOME D:javajdk1.6.0_18
CATALINA_HOME: D:java omcat60
3、启动和关闭Tomcat
startup.bat shutdown.bat
4.安装Eclipse
解压即可
5、手动创建Web项目
1、classes
2、lib
3、jsp
4、java
5、web.xml
6、servlet
6、手动部署Web项目
方式1：在WebApps下创建一个文件夹，并把WebRoot下所有内容复制到该目录下
方式2：在server.xml的host标签中配置如下内容<Context path="/jbm"
docBase="D:javaWorkspacesjbmessage_javaWebRoot" reloadable="true"></Context>
7、搭建Hibernate环境并测试
1.添加jar
2.添加hibernate.cfg.xml
3.添加HibernateUtil.java
4.创建实体类和映射文件
5.在hibernate.cfm.xml中添加映射文件路径
6.编写测试类测试hibernate(需要添加slf-logging.jar)
8、搭建Struts2环境并测试
1.添加jar
2.在web.xml中配置总控制器
3.添加struts.xml
4.创建Action和JSP
5.配置struts.xml
6.测试Struts2
9、搭建Spring环境并测试
1.添加jar
2.创建applicationContext.xml
3.测试IoC
18. 缓存算法
19. SpringMVC的执行流程
2.springmvc执行流程详细介绍
20. 谈谈你对Spring的认识
Spring提供了一个bean的容器，可以把系统中使用的各种框架的核心组件管理起来，放在spring的容器中，当需要这些组件的时候，就从容器中取出来，所以我们经常用spring做系统集成，管理系统中使用的各种组件。这样，我们就可以为各个组件定义一些特性，比如IOC,AOP，可以为组件注入一些属性，也可以实现AOP。需要注意的是，如果直接new一个组件，这个时候，不是从容器中取出来的，这样就不能具有事先配置好的特性。比如，我们在项目中，一般在service层配置事务，如果直接new一个service层bean，这个bean不会注入dao，而且这个bean在执行增删改查的时候，不会具有事务。
Spring容器的顶层接口是ApplicationContext, 其实它是包装了BeanFactory的所有功能，我们在web项目中，一般使用的WebXmlApplicationContext这个容器。在编写代码的时候，如果需要拿到这个容器，可以使用ContextLoader.getCurrentWebApplicationContext(),得到这个容器。
Spring中配置bean默认是单例的，即singleton，spring在配置bean的时候，需要注意作用域，有singleton表示单例，有prototype表示多例，表示每次从容器中取一个bean的实例，都是new一个新的实例。一般在项目中配置dao，service的时候，使用单例，在使用struts2的时候，配置action，一般配置prototype，因为struts2的action中一般会定义私有属性进行传值，这是一个共享数据，有线程不安全问题，所以需要每次请求的时候，从容器中获取action都new一个新的。
Spring，我们在项目中，一般使用最多的就是它的IOC,AOP特性，IOC使用了单例和工厂模式，其实spring中的单例，是指在spring的容器中，bean是单例的，但是在JVM范
畴内，它不一定是单例的，比如一个service， 在spring容器中是单例，但是在JVM中，可以手动new一个service，这样在JVM的范围内，这个service不是单例的。
AOP使用到了代理模式，一般使用jdk动态代理，还有cglib代理，jdk动态代理，要求目标类必须具有接口，cglib代理是在运行过程中，动态生成目标类的子类的方式进行代理。我们在项目中，一般在配置事务的时候，使用了AOP，其他的情况，比如记录日志，也可以采用AOP，在控制用户是否登录的时候，对一些操作，要求用户登录才能进行，这时候，也可以采用AOP的方式，拦截action或controller的方法，先判断用户是否登录，如果没有登录，跳转到登录页面。
Jdk动态代理，cglib动态代理，都是使用生成字节码文件，即class的方式实现的。Cglib的效率比jdk要快，一般是2倍。
21. Spring常用注解
22. Spring MVC常用注解
@Controller指定类是一个spring的controller
@RequestMapping指定访问的路径
@RequestMethod指定请求的方式get|post
@RequestParam指定请求正文中的参数
包括：
1.路径?号后面的param=value
2.表单提交的数据
3.ajax方式提交的数据
@PathVariable指定请求路径中的参数,注意这里不是指路径?号后面的param=value
@RequestMapping("/user/edit/{id}")
public String edit(@PathVariable("id") String id){
}
例子:
访问路径:http://host:port/web根路径/user/edit/123.do
这里123就是id参数的值
@RequestBody
指定请求消息正文部分整个作为一个json数据
@ResponseBody
指定相应消息正文部分整个作为一个json数据
@ModelAttribute
指定提交的数据封装到一个实体类参数
例子:
实体类:
public class User{
private String username;
private String password;
}
jsp:
<form action="${ctx}/user/addSave.do" method="post">
<input type="text" name="username"/>
<input type="text" name="password"/>
</form>
Controller:
@RequestMapping("/user/addSave")
public String addSave(@ModelAttribute User u){
//将表单中的username,password数据直接封装到User 对象u中
}
@CookieValue
指定cookie中的参数
@RequestHeader
指定请求消息头中的参数
@ExceptionHandler
Spring注解配置，可以使用
@Component, 可以用在所有的组件上，
在dao层我们使用@Respository区分一下,
在service层使用@Service区分一下,
在控制层，比如struts2的action，springmvc的controller，使用@Controller,在struts2的action上使用@Scope(“prototype”) 配置action是多例的，因为spring的bean配置默认是单例的,
在bean里面注入属性的时候，可以使用@Autowired这个注解, 如果需要注入xml配置文件中的bean，可以使用@Resource(name=””)这个注解, 指定bean的name
还可以使用@Transactional这个注解，加在需要开启事务的方法上，如果加载类上，表示方法都需要开启事务。
23. 谈谈你对Hibernate的认识
24. 使用ibatis 需要注意几个问题
25. 谈谈你对Struts2的认识
Struts2是一个MVC框架，一般用在web项目中，它有一个核心过滤器FilterDispatcher, 我们在使用struts2的时候，通常需要在web.xml中注册这个核心过滤器，在web应用启动的时候，会去加载struts2的配置文件struts.xml，在内部生成一个请求路径url到控制器Action的映射(Map)，保存在ActionMapper中，当前台有请求过来的时候，通过url，查找到对应的Action，调用对应的方法，最终返回一个字符串，指定跳转的页面，这个字符串在struts.xml中使用result来定义，在到达Action之前，会先经过一系列拦截器，调用Action的方法之后，也会经过拦截器，（这个时候经过拦截器的顺序颠倒）,一般我们在项目中，编写Action类是继承ActionSupport, 配置struts.xml，是继承struts-default，使用默认的拦截器栈defaultStack, 它里面定义了18个拦截器，其中有负责数据类型转换，国际化，文件上传下载等等。
使用struts2的时候，传值一般有两种方式，一种是在action中定义一个私有属性，生成getter,setter方法，另外一种，就是，通过ServletActionContext得到request，response，session等对象来进行传值的操作。拿到这些对象之后，也可以不配置result跳转页面，直接编写代码，使用request或者response来进行转发和重定向。
然后在使用ajax的时候，一般我们是直接使用response.getWriter().write(),将json字符串输出前台。
然后struts2的标签，性能比较低，我们在项目中，一般是使用jstl代替它。
Struts2其实有很多安全漏洞，从10年到14年，一共暴过7次安全漏洞，最近一次就是因为，struts2标签使用的ognl表达式出的漏洞。
其实现在springmvc用的比较多，特别是互联网项目，不过现在一些企业系统也用的比较多，spring mvc在使用的时候，需要在web.xml中注册一个servlet,是DispatcherServlet, 在web应用启动的时候，会加载springmvc的配置文件，里面配置了注解扫描的包路径，我们一般是采用注解的方式配置springmvc的Controller,在里面使用@RequestMapping配置路径，在web应用启动的时候，会形成一个请求路径url到控制器Controller的映射(Map), 存放在HandlerMapping中，当前台请求过来的时候，会调用HandlerMapping，查找url对应的控制器，最终调用控制器的方法，返回ModelAndView对象，Model存放数据,View存放视图页面的信息，然后调用ViewResolver对象，解析视图，生成最终的html页面，ViewResolver主要用来集成一些其他的前台框架，比如jstl,freemarker, velocity.
当需要使用文件上传的时候，需要配置multipartResolver
比如，当springmvc 集成jstl, 就是使用InternalResourceViewResolver，返回的View类型是JstlView，
当springmvc 集成freemarker的时候，就是使用FreeMarkerViewResolver,返回的View类型是FreeMarkerView，
当springmvc 集成velocity的时候，就是使用VelocityViewResolver
Springmvc在传值的时候，是通过方法参数进行传值，它提供了很多注解，用来接收不同类型的参数。
比如@CookieValue用来接收cookie中的参数，@RequestParam用来接收表单参数，@PathVariable用来接收路径参数，springmvc有一个好处，支持rest风格的编程，就是在路径/后面添加参数，
还可以直接使用实体类参数，将前台数据封装在实体类中，使用MultipartFile接收文件对象。
也可以在方法中直接添加request,response参数，通过request去获取前台传递的参数。
26. Struts2和springmvc的区别
27. Hibernate和ibatis的区别
