JAVA程序员面试宝典之”葵花宝典”
CoreJava 部分：
1.什么是面向对象？面向对象有哪些特征？
以事物为驱动的编程思想。
我理解的面向对象是必须有一个具体的事物，
这个事物可以是一个具体的人，一个具体的物，
这个事物有自己的特征（属性），有自己的行为（方法）,
那么对这个事物特征的描述，和对行为的操作称为面向对象的。
继承：
实体和实体之间的一种关系。
例如：父子类之间 对于父类而言，他的一些东西（属性和方法）是可以共享的，
对于子类而言，它可以共享到父类的一些东西（属性和方法），那么
我们把父类与子类的这种关系称为继承。
封装：
实体的有些东西是自身特有的，不需要共享。
例如：小明的爸爸有自己不想公开的东西，那么对于小明的爸爸而言，
这些东西应该设置为私有的 。这就体现出java 的封装。
多态：行为和引用。
一个类中 （行为）。
例如: 打 ，打人，打车，打麻将 ，也叫方法重载
父子类之间 （引用）
儿子可以引用父亲的行为,也叫方法的重写。
2.说一下什么是javaBean 规范：
1.要有包--类必须写在包中
2.属性都是私有--private
3.要有无参构造方法
4.写有效的setXXX getXXX 方法
5.实现序列化接口
3.简述一下java 基本数据类型及所占位数, java 基本数据类型：4 类8 种
逻辑型：boolean false/true 1byte 8bit
字符型：char 2byte 16bit 运算时按照int 类型运算
整数型：
byte(1byte 8bit) 运算时按照int 类型运算
short(2byte 16bit) 运算时按照int 类型运算
int(4byte 32bit)
long(8byte 64bit) 后缀为L/l
注：整数类型的默认类型是int 类型 也就是说整数类型的字面量都是int 类型
浮点数型：
float(4byte 32bit) 后缀为F/f
double(8byte 64bit) 后缀为D/d
注：浮点类型的默认类型是double 类型
除了基本数据类型，其他类型都是引用类型。
引用类型首字母大写的类型：String，Integer 等
Java 中的字面量：true ，false ，null，18，1.8
Java 中的特殊关键字：goto const
Int a1=5+4;//正确 编译期优化
byte b1=a1+5;//错误 a1 是变量 遵循类型运算规则
short s1=2 short s2=0
s2=s1+s2;//错误 a1 是变量 遵循类型运算规则
s2+=s1;//正确 +=是复合运算类型 直接在s2 值的基础追加一个s1 的值
4. 说出9 个的启动时异常:
RunTimeException
|---NullPointerException
|——ArrayIndexOutOfBoundsException
|——ArithmeticException
|——ClassCastException
|——NumberFormatException
|——SystemException
|——ArrayStoreException
|——EmptyStackException
|——BufferOverflowException
注：异常Exception 分为两大类：
编译时异常：编译期间要检查的
运行时异常：编译期间不检查的
5.说出5 个常用的java-api 包
java.lang
java.util
java.sql
java.text
java.io
6.说出String 类中常用的5 个方法
charAt() 返回指定索引处的char 值
concat() 将指定字符串连接到此字符串的结尾
length()返回此字符串的长度
split()根据给定正则表达式的匹配拆分此字符串
trim()返回字符串的副本，忽略前导空白和尾部空白.
7. HashMap 和HashTable 的区别：
1.HashMap 允许空键值对，HashTable 不允许
2.HashMap 不是线程安全的，HashTable 是
3.HashMap 直接实现Map 接口，HashTable 直接继承Dictionary 类
8. ArrayList ，Vector ，LinkedList 存储性能和特性
它们都实现List 接口
ArrayList 和Vector 都是基于数组实现的
LinkedList 基于双向循环链表（查找效率低，添加删除容易）
ArrayList 不是线程安全的而Vector 是线程安全的，所以速度上ArrayList 高于Vector
7.Collection 和 Collections 的区别。
Collection 是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections 是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜
索、排序、线程安全化等操作。
9.List、Map、Set 三个接口，存取元素时，各有什么特点？
List 以特定次序来持有元素，可有重复元素。
Set 无法拥有重复元素, 内部排序。
Map 保存key-value 值，value 可多值。
10. final, finally, finalize 的区别
final 用于声明属性，方法和类，分 别表示属性不可变，方法不可覆盖，类不可继承。
finally 是异常处理语句结构的一部分，表 示总是执行。
finalize 是Object 类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方
法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。
11. Overload 和Override 的区别。Overload 的方法是否可以改变返回值的类型?
方法的重写Overriding 和重载Overloading 是Java 多态性的不同表现。
重写Overriding 是父类与子类之间多态性的一种表现,方法名，参数列表，
返回值类型都得与父类的方法一致.
重载Overloading 是一个类中多态性的一种表现。重载的方法是可以改变返回值的类型。
12.用一句话总结一下冒泡排序。
依次比较相邻的两个数，将小数放在前面，大数放在后面.
13.写出选择，冒泡，插入排序的代码
选择排序：
for (int i=0;i<ary.length-1;i++){
for (int j=i+1;j<ary.length;j++){
if (ary[i]>ary[j]){
int t = ary[i];
ary[i]=ary[j];
ary[j]=t;
}
}
}
冒泡排序：
for (int i=0;i<ary.length-1;i++){
for (int j=0;j<ary.length-i-1;j++){
if (ary[j]>ary[j+1]){
int t = ary[j];
ary[j]=ary[j+1];
ary[j+1]=t;
}
}
}
14.写出二分查找的代码：
注：二分法从数组查询元素，必须保证数组内部元素是有顺序的。
意思就是先对数组进行排序。
public class BinarySearch {
static int idx=1;
public static void find(int leftIndex,int rightIndex,int val,int[] arr){
int midIndex=(rightIndex+leftIndex)/2;
int midVal=arr[midIndex];//找到中间的数
if(rightIndex>=leftIndex){
//如果要找的数比midVal大
if(midVal>val){
idx++;
//在arr左边数中找
find (leftIndex,midIndex-1,val,arr);
}else if(midVal<val){
//在arr 的右边去查找
idx++;
find (midIndex+1,rightIndex,val,arr);
}else if(midVal==val){
System.out.println("找到下标"+midIndex+"共查找了"+idx+"次");
}
}else{
System.out.println("没有该数!");
}
}
public static void main(String[] args) {
int[] arr=new int[]{100,300,500,800,1000,2000,3000};
find (0,arr.length-1,1000,arr);
}
}
15.实现线程安全的两种方式
1）synchronized 方法：通过在方法声明中加入synchronized 关键字来声明
synchronized 方法。
2 ）synchronized 块：通过synchronized 关键字来声明synchronized 块。
16.实现多线程的两种方式
1)继承Thread 类
2)实现Runnable 接口
优先选择实现Runnable 接口 因为比较灵活。
17. 简述如下几个概念。
程序：指令+数据的byte 序列。PC 上面的可运行文件
进程：正在运行的程序，是程序动态的执行过程。
线程：在进程的内部，程序并发执行的过程。
并发: 进程是并发运行的, 操作系统(OS)将时间划分为很多时间片段, 尽可能
均匀分配给正在运行的程序, 微观上进程走走停停, 宏观上都在运行
这种都运行的现象叫: 并发。
18 ．说一下 “==”和equals()方法在字串变量操作中的不同?
”==”比较的是两个字符串对象的地址，equals()是比较的两个字符串的具体值。
19. sleep()和wait()有什么区别？
sleep 是线程类（Thread ）的方法，导致此线程暂停，然后执行给定时间，让出
cpu 给其他线程，但不会释放对象锁，时间到了自动恢复.
wait 是Object 类的方法，对此对象调用wait 方法导致本线程放弃对象锁，进入
等待此对象的等待锁定池，只有针对此对象发出notify 方法（或notifyAll）后本线程
才进入对象锁定池 准备获得对象锁进入运行状态。
20.&与&& 的区别?
&位运算符,非短路逻辑运算符，它会把所有条件执行完毕之后，才会返回结果
&&逻辑运算符（and ）：短路运算符，遇到不符合条件，立即终止程序的执行
21. error 和exception 区别
error:表示恢复不是不可能的一种严重的问题, 比如：内存溢出，不指望程序处理
exception 程序运行时的异常，如果程序设计合理从不会出现的情况
22.请说出你所知道的线程同步的方法。
join():合并当前线程，相当于方法调用
yield():让出cpu
wait():使一个线程处于等待状态，并且释放所持有的对象的lock；
sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法
要捕捉InterruptedException 异常；
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM 确定唤醒哪个线程，而且不是按
优先级；
notityAll():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。
suspended() –挂起，该方法已过时: 在临时停止或中断线程的执行时，线程就处于挂起状态。
resume()—恢复，该方法已过时 : 在挂起的线程被恢复执行时，可以说它已被恢复。
stop()--暴力结束当前正在执行的线程，该方法已过时
23.线程的生命周期：
24.IO 字节流：
FileInputStream 和FileOutputStream 对文件基本的输入输出操作
BufferedInputStream 和BufferedOutputStream 加缓冲区的操作
DataInputStream 和DataOutputStream 对基本操作的扩展,
可以一次读一种基本数据类型的数据.
字符流:
InputStreamReader 和OutputStreamWriter 基本字符流 可以处理字符编码
BuffereReader 和PrintWriter 可以一次读取一行数据
25.什么是反射？
在运行过程中:
1.对于任意一个类,可以知道这个类的属性和方法.
2.对于任意一个对象,可以调用这个对象的任意方法.
对于这种动态获取的信息, 以及动态调用对象方法的功能称为反射机制.
java 反射机制提供的功能:
1.运行时判断任意对象的所属类;
2.运行时构造任意类的对象;
3.运行时判断和调用对象的成员变量和方法;
4.生成动态代理.
26.什么是回调函数？
某个程序S(Student.main) 调用服务程序A(Arrays)中的某个方法(sort), 服务程
序 A 的 sort方法在某个时候反过来调用 S 的某个方法(compareTo),这种情况
下,compareTo 叫做S 的回调方法。
例如：public class Student implements Comparable{
private int id;
private String name;
private int age;
private int score;
//构造器
//getter / setter 方法
// 回调方法
public int compareTo(Object obj){
return
this.id - ((Student)obj).id;
}
}
Student s1 = new Student(1,"a",18,89);
Student s2 = new Student(2,"x",22,94);
Student s3 = new Student(3,"w",19,78);
Student [] arrs = {s1,s2,s3};
Arrays.sort(arrs);
27 ．遍历文件夹下所有.java 的文件?
public void listFiles(String path){
File dir = new File(path);
Files files [] = dir.listFiles(new FileFilter(){
public boolean accept(File f){
return f.getName().endWith(".java");
}
});
for(File file : files){
System.out.println(file.getName());
}
}
28.描述一下JVM 加载class 文件的原理机制?
JVM 中类的装载是由ClassLoader 和它的子类来实现的
Java ClassLoader 是一个重要的Java 运行时系统组件。
它负责在运行时查找和装入类文件的类。
Oracle 部分：
1.薪水排序后薪水排名在第3--5 的员工
1)select * from(select ename,sal,rownum rn from
(select ename,sal from emp_44 where sal is not null order by sal desc) where rownum<6)where
rn>2;
2)select * from(select ename,sal,rownum rn from
(select ename,sal from emp_44 where sal is not null order by sal desc))where rn between 3 and
5;
2. 删除一张表中所有数据的方式？
1.truncate table 命令将快速删除数据表中的所有记录
2.delete 产生 rollback ，如果删除在数据量的表速度会很慢，同时会占用很多的
rollback,segments.truncate 是DLL 操作，不产生rollback，速度会快一些。
3. 用一条sql 语句取出所有姓名有重复的学员姓名和重复的记录数.
select name, count(*) from student group by name
having count(*) > 1 order by count(*) desc;
4. 去除oracle 数据库 表中重复数据应有如下两种方法：
方法一：创建新表删除旧表法
1）create table student1 as select distinct id, name, score from student;
2 ）drop table student;
3 ）rename student1 to student;
方法二：使用rowid(地址)伪列
删除伪列地址除了最大地址值以外的记录
delete from temp where rowid not in (select max(rowid) from temp group by id);
删除伪列地址除了最大地址值以外的记录
delete from temp where rowid not in (select min(rowid) from temp group by id);
5. 按工资进行排名，排名从1 开始，工资相同排名相同（如果两人并列第一则没有第二名，
从第三名继续排）
方法一：
select empno,ename,sal, (select count(*)+1 from iv_emp where sal>e.sal) rank
from iv_emp e
order by rank asc;
方法二：select e.empno,e.ename,e.salary,rank() over(order by
salary desc) mingci from emp_ding e;
6. 按工资进行排名，排名从1 开始，工资相同排名相同。
select e.empno,e.ename,e.salary,dense_rank() over(order by
salary desc) mingci from emp_ding e;
7. 查询每个部门工资最高的前2 名员工
方法一:
select *
from(select empno,ename,salary,deptno,(select count(*)+1 from emp_ding where
salary>e.salary and deptno = e.deptno ) rank
from emp_ding e) ee
where ee.rank<=2
order by deptno,rank asc;
方法二：
select * from ( select e.empno,e.deptno,e.ename,e.salary, dense_rank()
over (partition by deptno order by salary desc) mingci from emp_ding e ) x where
x.mingci<=2;
PL/SQL 部分：
解释如下概念
1.触发器(trigger)：是存储在数据库中的块，这些块一旦被构造后，就可以多次执行，
当触发它的事件发生时调用该触发器。触发事件是指对表中数据的操作，如插入(inserting)、
删除(deleting)和修改(updating) 。需要注意的是：触发器没有参数，没有返回值，不能够显
示调用。
create or replace trigger user_log –user_log 该触发器的名字
before delete or update or insert
on t_user
for each row
begin
if deleting then
insert into t_user_log values
(myseq.nextval,'用户'||:old.username||'被删除了'); --:old 特殊的变量表示操作的原数据
elsif inserting then
insert into t_user_log values
(myseq.nextval,'用户'||:new.username||'被添加了');--new,特殊的变量表示操做的新数据
elsif updating then
insert into t_user_log values
(myseq.nextval,'用户'||:old.username||'被修改了'||:new.username);
else
null;
end if;
end;
2.存储过程(procedure)：是将常用的或很复杂的工作，预先用SQL 语句写好并用一个指定的名称存储起来, 那么以后要叫数据库提供与已定义好的存储过程的功能相同的服务时, 只需调用execute,即可自动运行。我的理解就是一堆sql 的集合，可以建立非常复杂的查询，
编译运行运行一次后，以后再运行速度比单独执行SQL 快很多.
1、具有删除功能的存储过程
create or replace procedure
delete_stu(v_stuid number)
is
begin
delete from t_student where
sid=v_stuid;
end;
调用存储过程：
exec delete_stu(1001);
3.游标(cursor) ：游标(cursor)，是一种控制结构，可以帮助我们处理多条记录。游标不是一
种数据类型。
对于游标的使用：
1、声明游标 cursor cursor_name is select....
2、打开游标 open cursor_name
3、从游标中抓取数据 fetch cursor_name into v_row_data
4 、关闭游标 close cursor_name
静态游标的使用：
declare
v_data t_student%rowtype;
cursor mycursor
is
select * from t_student;
begin
open mycursor;
fetch mycursor into v_data;
dbms_output.put_line(v_data.stuname);
close mycursor;
end;
动态游标的使用：
declare
type cur_type is ref cursor;
v_data t_student%rowtype;
v_mycursor cur_type;
begin
open v_mycursor
for
select * from t_student;
fetch v_mycursor into v_data;
while v_mycursor%found loop
dbms_output.put_line(v_data.stuname);
fetch v_mycursor into v_data;
end loop;
close v_mycursor;
end;
4.索引（index ）：相当于书签，能够提高数据的访问效率
主键列自动创建索引
其他列必须手动创建索引。
5.视图(view):虚拟的存在于数据库中。
用到视图的时候，系统会自动搜索数据库中的表，数据都是从表中取到的，
并不是从视图中直接拿到的。
6.函数(function):必须有返回值，一般用于查询。
create or replace function emp_income
(v_empno emp_lc.empno%type)
return number
is
v_income number(10,2);
begin
select sal*12+nvl(comm,0)*12
into v_income
from emp_lc where empno=v_empno;
return v_income;
end;
7.序列(sequence):oracle 数据库没有提供主键自动增长，为了方便操作，
oracle 数据库提供了序列，它的作用就是能够间接的实现主键自增长。
JDBC&XML 部分：
1.说说jdbc 连接数据库的步骤
1.注册驱动Class.forName(“”);
2.获得连接Connection conn=DriverManager.getConnection(“”);
3.创建声明
4.执行sql 语句,获得结果集，进行结果集的处理
5.关闭结果集
6.关闭声明
7.关闭连接，释放资源
2. statement 和preparedstatement 的区别
1.statement 是preparedstatemnet 的父类
2.statement 是直接发送sql 语句到数据库，事先没有进行预编译,这样会导致
恶意注入sql 语句的问题出现.prepatedstatement 会将sql 进行预编译，当sql 语句要重
复执行时，数据库会调用以前编译好的sql，所以preparedstatement 在性能方面会更好
3.preparedstatement 在执行sql 时，对传入的参数进行强制类型转换，以保证数据格式与底层数据库格式一致。
4.PreparedStatement 相对于Statemnet 要安全一些，可以有效防止sql 注入.
5.PreparedStatement 能够执行批处理，而Statement 不行.
另： CallableStatement 是用来调用存储过程的
3.数据库数据如何提高查询速度？
1. jdbc setFetchSize （）；
2. 数据库：索引
3. 把大表可以拆分成多个小表
4. dba 对表进行分区
4. 解析一个XML 文档有哪些方式？
解析有：dom 和sax 两种
dom：把整个XML 文档放入内存，适合XML 随机访问, 占用内存资源大
sax ：事件驱动型的XML 解析方式，顺序读取，不用一次装载整个文件，
遇到标签会触发一个事件，适和对XML 的顺序访问，占用内存资源稍小
5.XML 文档定义有几种形式？
a: 两种形式dtd schema
b: 本质区别:schema 本身是xml 的，可以被XML 解析器解析(这
也是从DTD 上发展schema 的根本目的)，
c:有DOM,SAX,STAX 等
6.Java 连接数据库有几种模式(方式) ？
1.直接连接JDBC （瘦连接）
2.通过客户端（胖连接）
3.使用桥连接ODBC(桥接)
7.分页？
1. 缓存分页（假分页）
特点: 第一次取全部数据时比较慢.(可能非常慢) 以后每次都从缓存中取数据, 比较快.
只访问数据库一次. 内存压力大.如果需求是一般只查看前几页,浪费内存资源.
2. 数据库分页（查询分页）
特点:每次只向数据库查询并返回一页的数据频繁的数据库访问.
每次查询的时间都差不多.没有缓存压力.
两者比较：
基于缓存的方式,适合小表,全部查看
基于查询的方式,适合大表,只查询部分数据
HTML/CSS/JavaScript 部分：
一个完整的网页由结构、表现、行为组成。
结构指HTML、XHTML、XML 等
表现指CSS 样式
行为指脚本(JS)
JavaScript 是Netscape(网景)推出客户端运行的解释性脚本语言。
注：Javascript 是弱类型语言，变量的声明只能用var
Html 基本结构：<html> <head><title></title></head><body></body></html>
设置隐藏文本框：<input type="hidden" name="id">
设置只读文本框：<input type="text" readonly="readonly" name="username">
== 等于 比较的是值
=== 绝对等于 不仅比较值 还要比较类型
Undefined:未定义
1.声明但没有赋值
2.没有声明的变量
获得对象：document.getElementById(“id”);
获得对象的值：document.getElementById(“id”).value
创建数组：
1）var 变量名称 = new Array()
2 ）var 变量名称 = new Array(长度)
3 ）var 变量名称 = new Array(值,....)
4 ）var 变量名称 = [值,...]
属性
length --> 返回数组成员的数目
方法
push() --> 向数组的未尾添加一个或多个成员,返回为新数组的长度
unshift() --> 向数组的开头添加一个或多个成员,返回为新数组的长度
shift() -> 删除数组的第一个成员，并且返回该成员。
pop() --> 删除数组的最后一个成员，并且返回该成员。
splice() --> 插入/删除数组成员，并且用新成员取代原有成员。
slice(start[,end]) --> 返回数组的一部分
join() --> 使用分隔符将数据成员连接在一起
Ajax&JQuery 部分：
1、什么是ajax ？asynchronous javascript and xml:
异步的javascript 和xml 。
为了解决传统的 web应用当中“请求-处理-等待-响应”的弊端而创建的技术，其实质
是：使用javascript 调用浏览器内置的一个对象（XmlHttpRequest)异步向服务器发送请
求，服务器返回xml 或者text 给XmlHttpRequest ，然后，javascript 使用服务器返回的数
据更新页面。在整个过程当中，页面没有任何的刷新。
2.使用ajax 发送异步请求：
首先获得浏览器内置对象
function getXhr(){
var xhr=null;
/* (typeof XMLHttpRequest) !='undefined' */
if(window.XMLHttpRequest){
xhr=new XMLHttpRequest();
}else{
xhr=new ActiveXObject('Microsoft.XMLHttp');
}
return xhr;}
/* Ajax 发送get 请求*/
function sendAjaxGet(){
var username=document.getElementById("t1").value;
var password=document.getElementById("t2").value;
var s1=document.getElementById("s1");
var xhr=getXHR();
var uri="test.do?username="+username+"&password="+password;
xhr.open("get",encodeURI(uri),true);
xhr.onreadystatechange=function(){
if(xhr.readyState==4){
if(xhr.status==200){
var txt=xhr.responseText;
s1.innerHTML=txt;
}else{
s1.innerHTML="系统异常，稍后再试!";
}
}else{
s1.innerHTML="正在验证....";
}
}
xhr.send(null);
}
/*ajax 发送post 请求 */
function sendAjaxPost(){
var username=document.getElementById("t1").value;
var password=document.getElementById("t2").value;
var s1=document.getElementById("s1");
var xhr=getXHR();
var uri="test.do";
xhr.open("post",encodeURI(uri),true);
xhr.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
xhr.onreadystatechange=function(){
if(xhr.readyState==4){
if(xhr.status==200){
var txt=xhr.responseText;
s1.innerHTML=txt;
}else{
s1.innerHTML="系统异常，稍后再试!";
}
}else{
s1.innerHTML="正在验证....";
}
}
xhr.send("username="+username+"&password="+password);
}
什么是JQuery?
Jquery 是一个js 框架，对底层js 代码进行封装，方便用户操作。
并且jquery 提供了对ajax 的支持，使用jquery 也可以发送异步请求，
不需要屏蔽浏览器差异，代码书写简单。
Jquery 对ajax 的支持：
1)、序列化元素：
serialize():将jquery 对象包含的表单或者表单控件转换成查询字符串
serializeArray():转换为一个数组，
每个数组元素形如{name:fieldName,value:fieldVal} 的对象。
2)、三个方法
（1）load(url),将服务器响应插入当前
jQuery 对象匹配的dom 元素之内。一般用于从服务器获取静态的数据
( 比如.html 文件),支持返回javascript 。
/* jquery 的load 请求*/
$(function(){
$('#i4').click(function(){
$("#d1").load("list.do");
});
});
（2 ）$.get(url,[data],[callback],[type])
url:服务器端要访问的组件的地址
data: 向服务器传递的参数，参数的格式必须是：{"name":"zs","age",22}
callback: 回调函数，其格式 function(data,statusText){}
data:服务器返回给客户端的数据
statusText:服务器返回的状态
type:服务器返回的数据的类型
包括如下几种：
xml:返回xml 文档对象
html:返回的是一个html
script:返回的是一个js 脚本
json:返回的是一个json 字符串，jQuery
会将该字符串自动转换成js 对象。
text:返回的是一个文本
$.post()格式同上。
/* jquery 发送get 或者post*/
$(function(){
$("#i5").click(function(){
$.get(
"test.do",
{"username":$('#t1').val(),"password":$('#t2').val()},
function(data,statusText){
if(statusText=="success"){
alert(statusText);
alert(data.id+","+data.username+","+data.password);
}else{
alert("系统异常，稍后再试.");
}
},
"json"
);
});
});
（3 ）$.ajax(options):
options 是一个形如{key1:value1,key2,value2...} 的js 对象，
用于指定发送请求的选项。
选项参数如下：
url(string):请求地址
type(string):GET/POST
data(object/string):发送到服务器的数据格式是 {"":"","",""}
dataType(string) :预期服务器返回的数据类型，一般有：
xml ，html， script， json ， text:
success(function):请求成功后调用的回调函数，有两个参数：
function(data,textStatus),其中，
data 是服务器返回的数据，可以是html,text,jsonObj,xmlDoc
textStatus 描述状态的字符串。
error(function):请求失败时调用的函数，有三个参数
function(XmlHttpRequest,textStatus,errorThrown){}
如果textStatus 取不到错误消息，就用errorThrown 。
/*jquery 发送ajax 请求 */
$(function(){
$('#i6').click(function(){
$.ajax({
url:"test.do",
type:"get",
data:{"username":$('#t1').val(),"password":$('#t2').val()},
dataType:"json",
success:function(data,statusText){
alert(data.id+","+data.username+","+data.password);
},
error:function(xhr,statusText,errorThorwn){
alert(statusText);
}
});
});
});
Servlet&Jsp 部分：
1. MVC 的各个部分都有那些技术来实现?如何实现?
M-Model 模型
模型的职责是负责业务逻辑。包含两部分：业务数据和业务处理逻辑。
例如：实体类、DAO、Service 等都属于模型层
V-View 试图
试图的职责是负责显示界面和用户交互 （收集用户信息）。
属于视图的类是不包含业务逻辑和控制逻辑的JSP(如果 JSP 页面中有<% %>就不能算是视图层的类，或者JSP 中更有转发和重定向的控制逻辑也是不可以的)。
C-Controller 控制器
控制器是模型层M 和视图层V 之间的桥梁，用于控制流程。
比如我们之前项目中写的Action 或Servlet
2.servlet 的生命周期
web 容器加载 servlet，生命周期开始。
通过调用 servlet 的 init()方法进行 servlet 的初始化。
通过调用 service()方法实现，根据请求的不同调用不同的 doGet()或者doPost()方法。
结束服务，web 容器调用 servlet 的 destroy()方法。
3. jsp与servlet的区别及联系
JSP 是Servlet 技术的扩展，本质上是Servlet 的简易方式，更强调应用的外表表达。
JSP编译后是"类servlet"。Servlet 和JSP 最主要的不同点在于，Servlet 的应用逻辑是在
Java文件中，并且完全从表示层中的HTML 里分离开来。而JSP 的情况是Java 和HTML 可以组合成一个扩展名为.jsp 的文件。
JSP 侧重于视图，Servlet 主要用于控制逻辑。
4. 数据库连接池的工作机制：
J2EE 服务器启动的时候，会创建一定数量的池连接，并维持不少于此数量的池连接。
程序需要时，池驱动程序会返回一个未使用的池连接并将其标记为忙。
如果当前没有空闲连接，池驱动会新建一批，数量由配置参数决定。
当调用池连接完成后，池驱动将此连接标记为空闲，其他调用就可以使用这个连接。
5 .jsp 有哪些内置对象?作用分别是什么?
答：JSP 共有以下9 种基本内置组件（可与ASP 的6 种内部组件相对应）：
page jsp 网页本身
pageContext 网页的属性是在这里管理
request 客户端请求，此请求会包含来自GET/POST 请求的参数
session 与请求有关的会话期，只要浏览器不关闭，保存在session 里面的值都存在.
application servlet 正在执行的内容
config servlet 的构架部件
response 网页传回用户端的回应
out 用来传送回应的输出
exception 针对错误网页，未捕捉的例外
6.forward(转发) 和redirect(重定向)的区别
答：forward 是服务器请求资源，服务器直接访问目标地址的URL，把那个URL 的响应内容
读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来
的，所以它的地址栏中还是原来的地址。
redirect 就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，一般来说
浏览器会用刚才请求的所有参数重新请求。
7.Jsp 的四种会话范围
page 是代表与一个页面相关的对象和属性。作用域在当前页.
request 是代表与Web客户机发出的一个请求相关的对象和属性。
session 只要访问的浏览器不关闭，作用域就一直存在。
application 只要访问的服务器不关闭，作用域就一直存在。
8. 什么是B/S 结构,C/S 结构？
C/S 是Client/Server 的缩写。服务器通常采用高性能的PC、工作站或小型机，并采用大 型数据库系统，如Oracle、Sybase 、Informix 或 SQL Server 。客户端需要安装专用的客户端软件。
B/S 是 Brower/Server的缩写，客户机上只要安装一个浏览器(Browser)，如 Netscape Navigator 或Internet Explorer，服务器安装Oracle、Sybase 、Informix 或 SQL Server 等数据库。 在这种结构下，用户界面完全通过 WWW 浏览器实现，一部分事务逻辑在前端实现，但是主要事务逻辑在服务器端实现。浏览器通过Web Server同数据库进行数据交互。
9. 编码格式转换问题：
String str=new String(" 中国".getBytes("ISO-8859-1"),"GBK").trim();
10.URL 和URI 的区别？
URL：统一资源定位符, 指的是Internet 文件在网上的地址, 用在客户程序和服务器上，定位客户端连接服务器所需要的信息，它不仅定位了这个信息资源，而且定义了如何找到这个资源.
URI：统一资源标识符，Web 上可用的每种资源 ：HTML 文档、图像、视频片段、程序等„是由一个通过通用资源标志符(Universal Resource Identifier, 简称"URI")进行定位,不局限于客户端服务器.
URI 一般由三部分组成:
1.访问资源的命名机制。
2.存放资源的主机名。
3.资源自身的名称，由路径表示。
URL 是URI 的一个子集。
三大框架部分：
Struts2 部分:
2．介绍一下Struts的工作原理？
1.读取配置,加载struts 控制器.
2.用户请求 用户提交表单或调用URL 向WEB 应用程序服务器提交一个请求，请求的数据,用HTTP 协议上传给WEB 服务器。
3.通过struts 控制器进行处理，
4.经过一系列的拦截器处理
5.进行业务逻辑的处理
6.响应用户JSP 将结果展现给用户。
为什么要用：
1. JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。但用
这些技术构建的系统非常的繁乱。
2. 基于Struts开发的应用:
不用再考虑公共问题
专心在业务实现上
结构统一，易于学习、维护
新手也可写出好程序
3. struts 框架提供了哪些辅助功能
1 自动收集数据（成员变量）
2 支持类型转换
3 国际化
4 异常处理
5 标签
4. struts1 和struts2 的区别
1 struts1 控制器servlet struts2 控制器filter
2 struts 收集数据时 ActionForm Struts2 成员变量
3 struts1 execute(Resquest,Response)
struts2 execute()
4 struts1 与ServletAPI 耦合性强
struts2 与ServletAPI 耦合性低
5 struts1 没有拦截器 struts2 有拦截器(可以使代码各司其职)
6 struts1 只能使用jstl 标签，而struts2 提供了OGNL 表达式
Hibernate部分：
1. hibernate工作原理
1.读取并解析配置文件
2.读取并解析映射信息，创建SessionFactory
3.打开Sesssion
4.创建事务Transation
5.持久化操作
6.提交事务
7.关闭Session
8.关闭SesstionFactory
为什么要用：
1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。
2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作
3. hibernate 的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持
各种关系数据库，从一对一到多对多的各种复杂关系。
4.Hibernate 是面向对象进行操作的
2. Hibernate 对象状态有哪几种，并简单介绍一下。
1.临时状态：内存对象，并没有保存在数据库
2.持久化状态 已经保存在数据库并纳入了session 缓存中
3.游离状态 已经保存在数据库中，但没有纳入session 缓存中
3.什么是Hibernate延迟加载?
延迟加载机制是为了避免一些无谓的性能开销而提出来的，所谓延迟加载就是当在真正需要
数据的时候，才真正执行数据加载操作。在Hibernate 中提供了对实体对象的延迟加载以及
对集合的延迟加载，另外在Hibernate3 中还提供了对属性的延迟加载。
4．Hibernate中类之间的关联关系有几种?(如：一对多、多对多的关系)
many-to-one、one-to-many、many-to-many、 one-to-one
5. 说下Hibernate的缓存机制
一、hibernate一级缓存
（1）hibernate支持两个级别的缓存，默认只支持一级缓存；
（2）每个Session内部自带一个一级缓存；
（3）某个Session被关闭时，其对应的一级缓存自动清除；
二、hibernate二级缓存
(1) 二级缓存独立于session，默认不开启；
6. Hibernate的查询方式
本地SQL 查询、Criteria、Hql
Spring 部分：
1.spring 的优点？
1.降低了组件之间的耦合性 ，实现了软件各层之间的解耦
2.可以使用容易提供的众多服务，如事务管理，消息服务等
3.容器提供单例模式支持
4.容器提供了AOP 技术，利用它很容易实现如权限拦截，运行期监控等功能
5.容器提供了众多的辅助类，能加快应用的开发
6.spring 对于主流的应用框架提供了集成支持，如hibernate，JPA，Struts 等
7.spring 属于低侵入式设计，代码的污染极低
8.独立于各种应用服务器
9.spring 的DI 机制降低了业务对象替换的复杂性
10.Spring 的高度开放性，并不强制应用完全依赖于Spring，开发者可以自由选择spring
的部分或全部
2.什么是DI 机制？
依赖注入（Dependecy Injection）和控制反转（Inversion of Control）是同一个概念，
具体的讲：当某个角色需要另外一个角色协助的时候，在传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在spring 中创建被调用者的工作不再由调用者来完成，因此称为控制反转。创建被调用者的工作由spring 来完成，然后注入调用者
因此也称为依赖注入。
spring 以动态灵活的方式来管理对象, 注入的两种方式，设置注入和构造注入。
设置注入的优点：直观，自然
构造注入的优点：可以在构造器中决定依赖关系的顺序。
3.什么是AOP？
面向切面编程（AOP）完善spring 的依赖注入（DI），面向切面编程在spring 中主要表
现为两个方面
1.面向切面编程提供声明式事务管理
2.spring 支持用户自定义的切面
面向切面编程（aop）是对面向对象编程（oop）的补充，
面向对象编程将程序分解成各个层次的对象，面向切面编程将程序运行过程分解成各个
切面。
AOP 从程序运行角度考虑程序的结构，提取业务处理过程的切面，oop 是静态的抽象，aop
是动态的抽象，
是对应用执行过程中的步骤进行抽象，，从而获得步骤之间的逻辑划分。
aop 框架具有的两个特征：
1.各个步骤之间的良好隔离性
2.源代码无关性
4. 为什么要用spring?
Spring是一个轻量级的IOC和AOP框架。
IOC （控制反转）意味着将你设计好的类交给系统去控制，而不是在你的类内部控制。这
称为控制反转
AOP （面向切面），它将那些影响多个类的行为封装到可重用的模块中，面向对象是把问
题从同类事物中抽象出来，面向切面是把问题从不同类问题中抽象出来。
- J2EE 共有23 中设计模式，说出其中几种常用的：
- 工厂模式（Factory）单例模式（Singleton ）
- 适配器模式（Adapter ）代理模式（Proxy）
- 模板方法模式（Template Method ）
2. 应用服务器有哪些：
- weblogic ，jboss ，tomcat
设计模式部分
设计模式指的是解决问题的思路和方法。
使用设计模式可以解决一定的问题，实现代码重复利用，便于程序维护和扩展。
23 种设计模式可分为以下三大类:
1. 创建型模式--与对象创建相关的设计模式
a) *单例模式
特点：实现一个类只能创建一个对象实例.
一般应用于工厂类的设计。
1）饱汉式
特点：在getInstance 方法调用时，创建单例对象
public class 老婆 {
//3.静态变量，唯一性
private static 老婆 instance = null ;
//1.将构造方法隐藏
private 老婆(){}
//2.提供一个静态方法，用于获取老婆对象
public static synchronized 老婆 getInstance(){
if (instance == null ){instance = new 老婆();}
return instance;}
public synchronized void 做饭(){
System.out .println("做饭");}}
2 ）饿汉式
特点：在类加载时创建单例对象
public class 老婆 {
//3.静态变量，唯一性
private static 老婆 instance = new 老婆();
//1.将构造方法隐藏
private 老婆(){}
//2.提供一个静态方法，用于获取老婆对象
public static 老婆 getInstance(){
return instance;}
public void 做饭(){
System.out .println("做饭");}}
注意：避免使用时的线程并发问题。利用synchronized 解决。
b) 工厂方法模式
c) 抽象工厂模式
2. 结构型模式--与对象的结构设计相关
a).适配器模式
特点：在子系统交互时，如果提供的类型和使用类型不匹配，可以采用此方
法转换。封装类型转换的过程。
----Struts2 中大量采用了该模式---------
对request,session,application 对象转换成Map 结构的操作
对原有的HttpServletRequestWrapper 封装成StrutsRequestWrapper 类型
public class StrutsRequestWrapper
extends HttpServletRequestWrapper{
public StrutsRequestWrapper(
HttpServletRequestWrapper request){
super(request);
}
public Object getAttribute(String key){
//return super.getAttribute
//找不到去值栈获取
}
}
HttpServletRequest request = new StrutsRequestWrapper(request);
JSP ${name}-->request.getAttribute("name")
3. 行为型模式--与对象交互，职责分配相关的模式
a).模版模式
特点：定义一个模版类，该模版类实现了一个处理的骨架算法，不同的实现部分放到子类具体实现.
Spring 的Template 工具类采用了该模式设计
8098
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
