Java基础笔记

时间 2019-11-19

标签 java 基础笔记栏目 Java 繁體版

原文原文链接

一、简述Java的基本历史javascript

java起源于SUN公司的一个GREEN的项目，其原先目的是：为家用消费电子产品发送一个信息的分布式代码系统，经过发送信息控制电视机、冰箱等css

二、简单写出Java特色，写出5个以上，越多越好html

简单的、面向对象的、分布式的、安全的、稳定的、与平台无关的、可解释的、多线的、动态的语言。java

三、什么是Java?node

JAVA：一种编程语言程序员

一种开发环境web

一种应用环境面试

一种部署环境ajax

四、请写出Java的版本分类，以及每种版本的应用方向算法

三种版本：

JME：是面向内存有限的移动终端. 为消费性产品设计的；

JSE：是SUN公司针对桌面开发和低端商务计算方案开发的版本。为笔记本电脑、PC机设计的；

JEE：是一种利用JAVA 2平台来简化企业解决方案的开发、部署和管理相关的复杂问题的体系结构。为企业级的、服务器端的高端应用而设计的；

五、描述Java技术的主要特性

java虚拟机

垃圾回收

代码安全性

六、描述 Java虚拟机的功能

（1）经过 ClassLoader 寻找和装载 class 文件

（2）解释字节码成为指令并执行，提供 class 文件的运行环境

（3）进行运行期间垃圾回收

（4）提供与硬件交互的平台

七、简述Java代码安全性

（1）编译时的错误检验

（2）类装载检查，把本机上的类和网络资源类相分离，在调入类的时候进行检查，于是能够限制任何“特洛伊木马”的应用

（3）字节码校验

（4）沙箱机制，限定访问权限

八、描述Java垃圾回收机制

Java 编程语言解除了程序员释放内存的责任。它可提供一种系统级线程以跟踪每一次内存的分配状况。在 Java 虚拟机的空闲周期，垃圾收集线程检查并释放那些可被释放的内存。垃圾收集在 Java 技术程序的生命周期中自动进行，它解除了释放内存的要求，这样可以有效避免内存漏洞和内存泄露（内存泄露就是程序运行期间，所占用的内存一直往上涨，很容易形成系统资源耗尽而下降性能或崩溃。

垃圾回收有如下特色：

（1）垃圾回收是一个自动的系统行为，程序员不能控制垃圾回收的功能和行为。

（2）有一些跟垃圾回收相关的方法，好比：System.gc( ) ,调用这些方法，仅仅是在通知垃圾回收程序，至于垃圾回收程序运不运行，何时运行，都是没法控制的。

（3）程序员能够经过设置对象为 null，来标示某个对象再也不被须要了，这只是表示这个对象能够被回收了，并非立刻被回收。

九、简述Java代码的运行过程

（1）编写代码

（2）编译

（3）类装载经过类装载器装载CLASS文件

（4）校验代码由字节码校验

（5）解释由解释器将字节码转换成机器码

（6）运行

十、简述如何搭建Java开发环境

首先下载安装JDK 而后配置环境

（1）配置PATH，操做系统运行环境的路径

（2）配置CLASSPATH JAVA运行应用程序时所须要的类包的路径

（3）配置JAVA_HOME 供须要运行JAVA的程序使用

十一、简述classpath，path，JAVA_HOME的意义和配置方法

path 操做系统运行环境的路径

classpath JAVA运行应用程序时所须要的类包的路径

JAVA_HOME 供须要运行JAVA的程序使用

十二、请描述：一个完整的Java文件的代码分几个部分，每部分都起什么做用，大体的写法

package 当前类所在位置

import 当前类运行时所须要的包或类

public class 类名 {

属性定义;

方法定义:

构造方法定义;

public static void main(String args []) 例外{ 程序入口

语句;

}

//注释

1三、 Java代码的注释有几种？分别举例说明

（1） // 单行注解

（2） /* */ 块注释

（3） /* *

* 文档注释

1四、什么是Java代码的语句，什么是Java代码的块，举例说明

语句是一行以分号终止的代码,例：int a;

块是以{ }为边界的一些语句的集合例：public void tt( ){}

1五、什么是标示符？

标识符：是赋予变量、类、方法的名称。

//标识符是标识变量、类或方法的有效字符序列

1六、标示符定义的规则？

（1）首字母只能以字母、下划线、$开头,其后能够跟字母‘下划线、$和数字配置CLASSPATH

（2）表示符不能是关键字

（3）标识符区分大小写

1七、什么是关键字？

关键字就是编程语言与机器语言的编码约定

1八、 true、false、null、sizeof、goto、const那些是Java关键字

true 、false 、null 为JAVA的关键字

1九、 Java的基本数据类型有几种？分别是？

short int long boolean float double char byte

/*布尔类型（boolean）

字符型（char）

数值类型

定点类型字节型（byte）

短整型（short）

整型（int）

长整型（long）

浮点类型单精度（float）

双精度（double）

20、请写出每种基本类型的默认值？取值范围？分别给出一个定义的例子

默认值取值范围示例

字节型： 0 -2^7----2^7-1 byte b=10;

字符型： ' \u0000' 0----2^16-1 char c=’c’ ;

short : 0 -2^15----2^15-1 short s=10;

int : 0 -2^31----2^31-1 int i=10;

long : 0 -2^63----2^63-1 long o=10L;

float : 0.0f -2^31----2^31-1 float f=10.0F

double : 0.0d -2^63----2^63-1 double d=10.0;

boolean: false true\false boolean flag=true;

2一、在基本类型中，若是不明确指定，整数型的默认是什么类型？带小数的默认是什么类型？

整数类型默认为 int

带小数的默认为 double

boolean的默认值 false

2二、如何定义float类型和long型

float f = 1.2f

long l = 1.2L

2三、什么是变量？

变量是用来引用一块内存区域或一个值，用标识符来表示，能够经过操做变量来操做变量所对应的内存区域或值块的值。

2四、变量的定义规则？

（1）以字母、$、下划线开头，其后能够跟字母、下划线、$和数字；

（2）首字母小写，中间单词用大写字母隔开；

（3）名称具备必定含义；

//4.能够先声明再赋值也能够声明的同时进行赋值

//5.没有赋值的变量是不能够使用的

2五、请写出Java编码约定中对下列部分的要求：类、属性、方法、包、文件名、变量、常量、控制结构、语句行、注释

类：一个类文件中类名要和文件名相同，类名必定要以大写字母开头，单词之间用大写字母分隔

属性：属性名首字母小写，中间用大写字母隔开。

方法：方法名首字母小写，中间用大写字母隔开。

包：引用包必须写在类文件的开头,有且只能有一个包，所有用小写字母。

控制结构：当语句是控制结构的一部分时，即便是单个语句，也应使用大括号将语句封闭。

语句行：每行只写一个语句，并使用四个缩进的空格，使代码更易读，注意用分号结束。

注释：用注释来讲明那些不明显代码的段落。

常量：常量名通常用大写字母，单词之间用下划线分隔，一旦赋值不容许修改。

2六、什么是Javadoc?

按照必定格式生成程序的文档的工具。

2七、什么是引用类型？

用户定义类型, 它可引用类和数组。

除去基本数据类型的其余类型都是引用数据类型。

2八、什么是按值传递？什么是按引用传递？

按值传递：就是将该值的副本传过去（基本数据类型+String类型的传递，就是按值传递）

按引用传递：就是将值的内存地址传过去（除基本数据类型+String之外类型的传递，就是引用传递）

2九、如何建立一个新对象？如何使用对象中的属性和方法？

使用new 关键字来建立一个新的对象；

经过对象的实例用“.”(点)来调用对象中的属性和方法；

静态的方法和属性，也能够直接用类名“.”（点）来调用；

30、简述new关键字所作的工做

new 建立一个对象，并为对象分配一块内存。

3一、简述”=” 和”= =”的功能和区别

"=" 赋值,

"= ="当比较基本数据类型的时候，判断先后两个值是否相等；

当比较引用数据类型的时候，判断= =先后两个值的内存地址是否相等；

区别：

= ：为赋值表达式

= = ：为逻辑表达式

3二、什么是实例变量？什么是局部变量？什么是类变量？什么是final变量？

实例变量：类中定义的变量，即类成员变量，若是没有初始化，会有默认值；

局部变量：在方法中定义的变量，必须初始化；

类变量：用static修饰的属性；

final变量：用final 修饰的变量，

3三、简述上述各类变量的定义规则和使用规则？

实例变量：不须要static关键字来声明，须要类的实例（对象）调用（用“.”）；

类变量：用static修饰，能够用类名调用，也能够用类的实例调用；

局部变量：在方法内任意定义变量即为局部变量；

final变量：一旦赋值，不能够再修改的变量；

final属性只容许赋值一次，且只能经过构造方法赋值，定义后也就是一个常量；

final修饰的变量，只容许赋值一次

3四、 a++和++a的区别？

a++ ：先使用，后加1

++a ：先加1，后使用

3五、请描述instanceof、?:、&、&&各自的功能

instanceof ：用来判断某个实例变量是否属于某种类的类型。

? : 三目运算符：

表达式1?表达式2:表达式3

若是表达式1为true，执行表达式2，不然执行表达式3

&：位运算：按位与 |

&&：逻辑运算：逻辑与

3六、请描述>>、<<、>>>的功能

10>>4 ：算术或符号右移位运算符

<< ：算术或符号左移位运算符

>>> ：逻辑或无符号右移位运算符

3七、请描述什么是强制类型转换？什么是自动类型转换？什么是向上造型？并分别举例说明

强制类型转换：在一个类型前面加( )，来强制转换

long l = 9L;

int i = (int)l;

自动类型转换：

int i = 5;

String str = ""+i;

向上造型：把范围小的造型为范围大的类型：

int i = 2;

long l = i;

3八、请写出完整的if条件控制语句的结构

if(布尔表达式){

语句

}else{

语句

}

3九、请写出完整的switch语句的结构

switch(字符){

case 字符: 语句

break;

case 字符: 语句

break;

default:语句

}

40、请写出完整的for语句的结构

for(初始语句;条件语句;步长){

}

4一、请写出完整的while语句的结构

while(boolean语句){

}

4二、请写出完整的do while语句的结构

do{

}while(boolean语句);

4三、请描述break 和 continue的功能和用法

break：终止（跳出）最近的循环

continue：跳出本次循环，执行下一次循环

4四、定义一个一维的int数组，先建立它，并初始化它，给它赋值，而后输出其中的一个值

public class Arr{

public static void main(String args[]){

int a[] = new int[5];

a={1,2,3,4,5};//错误 , 只能在初始化时这样作

a[0]=1;

a[1]=2;

System.out.println(a[0]);

}

4五、定义一个一维的A类型数组，直接定义并赋值，而后输出其中的一个值

public class A{

     public static int i;

     public static void main(String args[]){

        A aa = new A( );

        A bb = new A( );

    A a[] = {aa,bb};

        a[0].i=2;

     System.out.println(a[0]);

     }

}

4六、把上面的数组改为2维的数组

public class A{

     public static int i;

      public static void main(String args[]){

         A a[ ][ ] = new A[5][5];

         a[0][0].i=2;

         System.out.println(a[0][0]);

      }

    }

4七、举例说明数组拷贝方法的使用：arraycopy方法

public class A{

        public static void main(String args[]){

     int a[] = new int[5];

     int b[] = new int[5];

         System.arraycopy(a[5],0,b[5],0,a.length)

     System.out.println(b[0][0]);

      }

}

4八、什么是构造和析构方法？功能是？

构造方法：每一个类至少有一个构造方法，类初始化时调用的方法

1．方法名和类名相同

2．无返回值类型

格式：访问权限类名(参数列表) {}；

1．本身定义构造后，就没有默认的构造方法

2．无构造方法时，默认为空参的构造方法(无参数,方法体为空)

析构方法：finalize

类销毁时，自动调用方法

当对象在内存中被删除时,自动调用该方法

在此方法中能够写回收对象内部的动态空间的代码

4九、简述Java的访问修饰符类型？分别有什么功能？

public 公开的，任何一个类都有能够访问

protected 同包同类,只可被它的子类访问

default 只能被同一个包中类访问

private 私有的，只能在本类中被访问

50、分别说明：在类上、在属性上、在方法上能使用哪些访问修饰符

在类上：public default final

在方法上：访问权限：public protected private default

方法修饰符：static

final

返回类型：void

在属性上：public protected private default

static

final

5一、简述什么是包？包的功能

包：对所定义的多个JAVA类进行分组，将多个功能相关的类定义到一个包(文件)中。

功能：1.易于查找和使用适当的类

2.包不止包含类和接口,还能够包含其它包,造成层次的包空间

3.有助于避免命名冲突

5二、请写出5个以上的JDK中的包，以及他们的基本功能

java.awt：包含构成抽象窗口工具集的多个类，用来构建和管理应用程序的图形用户界面

java.lang：提供java编成语言的程序设计的基础类

java.io：　包含提供多种输出输入功能的类，

java.net：　包含执行与网络有关的类，如URL，SCOKET，SEVERSOCKET，

java.applet：包含java小应用程序的类

java.util：　包含一些实用性的类

5三、什么是包装类？Java中都有哪些包装类

在JDK中针对各类基本类型分别定义相应的引用类型 --------------称为封装类

Boolean Byte Short Integer Long Float Double Character

5四、 OOP（面向对象）语言的三大特征是？

封装性，继承性，多态性

5五、分别表述类的三大特性及其余们的功能

封装：隐藏类的实现细节、迫使用户去使用一个接口去访问数据、使代码更好维护

继承：子类能够直接继承使用父类的方法，程序员只须要作的是定义额外特征或规定将适用的变化

多态性：同一个行为具备多个不一样表现形式或形态的能力

5六、如何实现继承？继承的规则？

public class A extends B{

}

（1）单继承性

（2）构造方法不能继承

（3） super引用父类，调用父类的属性，方法

（4）当子类中出现与父类的方法名，返回类型，参数列表相同的方法时要覆盖此方法

5七、简述this和super的功能和用法

this ：

（1）能访问除构造方法之外全部的属性、方法，经过this.　来调用方法和属性

（2）不能够在静态方法中使用，

（3）在调用其它构造方法时，必须放在该构造方法的第一行

（4）在构造方法中使用this(参数列表)，至关于调用本类的其它构造方法，它必须做为构造方法的第一句

super ：访问父类

（1） super. 点取父类中被子类隐藏的方法和属性，

（2）经过 super(参数列表) 来调用父类的属性和方法，在调用父类的构造方法时必须放在子类构造方法里的第一行；

5八、如何肯定在多态的调用中，到底是调用的那个方法？

new的是哪个类就是调用的哪一个类的方法。

5九、请描述方法定义的完整的语法结构

权限修饰符修饰符返回类型方法名(参数) 例外{

方法体;

}

60、什么是重载？

在一个类中出现方法名相同，但参数列表不一样时，这种状况就是重载。

6一、简述重载的规则

（1）方法名称必须相同；

（2）参数列表必须不一样（个数不一样，或类型不一样，或参数排列顺序不一样）；

（3）与返回类型无关；

6二、什么是方法的覆盖？什么状况下出现？

方法覆盖：

子类能够修改从父类继承过来的行为,也就是说子类能够建立一个与父类方法有不一样功能的方法，但具备相同的：名称、返回类型名和参数列表。

在父子类的状况下出现时。

6三、方法覆盖的规则？

（1）方法名要和父类中被覆盖的方法名相同,返回类型相同，参数列表相同。

（2）访问权限要大于等于被覆盖方法的权限。

（3）例外列表要小于等于被覆盖方法的例外列表。

6四、 static修饰符的功能是？能够用在什么地方？怎么访问？

static 修饰符功能:

（1）共用一块内存区域，也就是用static修饰的变量或成员方法对全部类的实例都是相同的

（2）静态成员方法和静态变量的优势在于他们能在没有建立类的任何一个实例的状况下被引用。

（3）能够用在方法或属性上

访问方式：

（1）直接使用类名调用

（2） new 一个实例，用实例调用

6五、 static的基本规则

（1）类中的静态方法只能够调用静态的属性和方法，不容许调用非静态的属性和方法。

（2）静态变量为类变量，能够用类名直接调用静态的属性和方法。

（3）静态方法中不容许出现this和super

（4）构造方法不容许声明static

（5）非静态变量为实例变量，经过实例调用

（6）静态方法不能被非静态方法覆盖

6六、 final修饰符的功能是？能够用在什么地方？

功能：final标记全部通用的功能,不能随意更改

能够用在类、属性和方法上

6七、 final的基本规则

（1） final修饰的类不能被继承

（2） final修饰的成员变量只容许赋值一次，且只能经过构造方法里赋值。

（3） final修饰的局部变量即为常量，只能赋值一次。

（4） final修饰的方法不容许被子类覆盖。

6八、什么是抽象方法，什么是抽象类

用abstract修饰的方法，只有方法的声明，而没有方法的实现，就叫抽象方法。

用abstract修饰的类，就叫抽象类。

6九、抽象类的规则

（1）抽象类内部能够没有抽象方法

（2）必须用abstract修饰

（3）不可以直接使用抽象类，必须经过子类继承而且实现

（4）抽象方法不容许被private修饰

70、什么状况下使用抽象类

（1）当一个类的一个或多个方法是抽象方法时；

（2）当类是一个抽象类的子类，而且不能为任何抽象方法提供任何实现细节或方法体时；

（3）当一个类实现一个接口，而且不能为任何抽象方法提供实现细节或方法体时；

7一、 equals方法和”= =”的功能和区别

功能：判断对象是否相等

区别：

equals方法比较的是对象的值

= =:比较的是对象值的内存地址，对基本数据类型来讲= =比较的是数值

7二、 toString方法的功能和基本写法

返回一个String类型

public String toString(){

return “”;

}

7三、 String的方法的功能和基本使用方法，请描述5个以上

substring(参数1,参数2); 功能:取字符串中参数1到参数2的的全部字符; "String".subString(0,1);

replace(参数1,参数2); 功能:用参数1中的值替换字符串中全部参数2的值 "String".replace(ing,tt);

equals( ); 功能:判断两个字符串是否相等 "String".equals("tt");

trim( ); 　功能:去掉字符串两边的空格 "String".trim();

indexof( ); 功能:查找字符串中参数所在位置,并返回字符串第一个出该参数的下标

"String".indexOf("ing");

split( ); 功能:根据参数分割该字符串 "String".split("-");

7四、为何使用StringBuffer类？有什么功能和优势？

–只建立一个对象

–StringBuffer 对象的内容是能够被修改的

–除了字符的长度以外，还有容量的概念

–经过动态改变容量的大小，加速字符管理

7五、举例说明如何使用StringBuffer

StringBuffer sb = new StringBuffer();

sb.append("aaa");

7六、如何使用Java读写系统属性？

读：

Properties props = System.getProperties();

Enumeration prop_names = props.propertyNames();

while (prop_names.hasMoreElements()) {

String prop_name = (String) prop_names.nextElement();

String property = props.getProperty(prop_name);

System.out.println("Property '" + prop_name + "' is '"+ property + "'");

}

写：

System.setProperties(props);

7七、简述properties文件的结构和基本用法

结构：扩展名为properties的文件，内容为key、value的映射，例如“a=2”

用法：

public class Test {

public static void main(String args[]) {

try {

String name = "test.properties";

InputStream in = new BufferedInputStream(new FileInputStream(name));

Properties p = new Properties();

p.load(in);

System.out.println("a的值==" + p.getProperty("a"));

} catch (Exception err) {

err.printStackTrace();

}

}

}

7八、什么是接口？接口的定义规则？

接口是抽象方法和常量值的定义的集合。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

public interface Tt {

public void outPut( );

public int tt( );

}

7九、接口的做用？为何使用接口？

多重继承

封装、隔离

功能,实现的分离

多态

便于后期维护

接口是可插入性的保证。

80、什么是多重接口

就是一个类实现多个接口

8一、描述接口的基本思想？

封装　隔离

接口及相关机制的最基本做用在于：经过接口能够实现不相关类的相同行为，

而不需考虑这些类之间的层次关系。

根据接口能够了解对象的交互界面，而不需了解对象所属的类。

面向对象程序设计讲究“提升内聚，下降耦合”。

8二、如何在代码中使用接口？

public class MyCast implements Tt{

public void outPut( ){}

public int tt( ){

return 0;

}

8三、举例说明如何把接口看成类型使用

public interface Animal(){

public void tt( );

}

public class Dog implements Animal{

public void tt ( ){}

}

Animal ani = new Dog();

8四、如何选择接口和抽象类？为何？

优先选用接口，尽可能少用抽象类

在下列状况下选择抽象类：须要定义子类的行为，又要为子类提供共性的功能。

8五、什么是异常，异常的分类？

程序中致使程序中断的一些状况叫作异常，通常程序员能够处理。

异常分为运行时异常和非运行时异常（通常异常）

运行时异常是指因设计或实现方式不当致使的问题。也能够说，是程序员的缘由致使的，原本能够避免发生的状况。例如：BufferOverflowException, ClassCastException，IndexOutOfBoundsException，ArithmeticException。出现这些异常的代码不须要try块包围。

非运行时异常是指除运行时异常之外全部的异常，出现这些异常的代码必须用try块包围。例如：FileNotFoundException,EOFException,

8六、简述处理异常的两种方式？

抛出（throws）和catch语句处理

8七、简述try块的功能和规则

try块内部通常写一些编程人员认为可能会出现异常的代码,使程序运行时不会由于出现异常而中断。

8八、简述catch块的功能和规则

功能：能够截获所声明的异常，并在语句块内对其进行处理

规则：catch(Exeption e){

e.printStackTrace( );

}

8九、简述finally块的功能和规则

finally块通常写一些不管是否发生异常都必须执行一次的代码

例如关闭与数据库的链接等

90、简述throw和throws的功能和使用方法

throw 指编程人员主动抛出一个异常

throw new NullPointerExeption( );

throws指程序遇到异常状况自动的被动抛出一个异常

public void test( ) throws Exeption{}

9一、异常的分类？

错误（Error）： JVM 系统内部错误、资源耗尽等严重状况，程序员不可控制

例外（Exception）：其它因编程错误或偶然的外在因素致使的通常性问题，程序能够控制

9二、什么是预约义异常

java程序中预先定义好的异常叫作预约义异常

9三、简述自定义异常的规则

写一个类继承Exception

用户自定义异常一般属Exception范畴，依据惯例，应以Exception结尾，应该由人工建立并抛出。

9四、什么是断言？

用来证实和测试程序的假设。

9五、如何使用断言？举例说明

一种是assert<<布尔表达式>>；另外一种是assert<<布尔表达式>>：<<细节描述>>。

assert a= =10 : "这里a等于10";

集合框架

一、什么是集合？什么是元素？

能够包含其余对象的简单对象就叫集合

集合框架中所包含的对象就叫作元素

二、描述出Java集合框架中集合的接口关系

Collection----Set和List

Set----HashSet和SortedSet

List----ArrayList和LinkedList

Map----HashMap、SortedMap和TreeMap

三、代码示例：Collection接口的使用，包括如何定义、初始化、赋值、取值、修改值除值

Collection col = new ArrayList();

String oldValue = "abcd";

String newValue = "1234";

//增长

col.add(oldValue);

Iterator it = col.iterator();

while(it.hasNext()){

//取值

String str = (String)it.next();

if(str.equals(oldValue)){

//删除

col.remove(oldValue);

//修改

col.add(newValue);

}

四、代码示例：List接口的使用，包括如何定义、初始化、赋值、取值、修改值、删值

List col = new ArrayList();

String oldValue = "abcd";

String newValue = "1234";

col.add(oldValue);

Iterator it = col.iterator();

while(it.hasNext()){

String str = (String)it.next();

if(str.equals(oldValue)){

col.remove(oldValue);

col.add(newValue);

}

}

五、代码示例：Set接口的使用，包括如何定义、初始化、赋值、取值、修改值、删值

Set col = new HashSet();

String oldValue = "abcd";

String newValue = "1234";

col.add(oldValue);

Iterator it = col.iterator();

while(it.hasNext( )){

String str = (String)it.next();

if(str.equals(oldValue)){

col.remove(oldValue);

col.add(newValue);

}

}

六、代码示例：Map接口的使用，包括如何定义、初始化、赋值、取值、修改值、删

Map map = new HashMap();

String oldValue = "abcd";

String newValue = "1234";

//增长

map.put("1",oldValue);

Set set = map.keySet( );

Iterator it = set.iterator( );

while(it.hasNext( )){

String key = (String)it.next( ); 

//取值

String value = map.get(key);

}

//修改

map.put("1",newValue);

//删除

map.remove("1");

}

七、描述List接口、Set接口和Map接口的特色

List接口中的对象按必定顺序排列，容许重复

Set接口中的对象没有顺序，可是不容许重复

Map接口中的对象是key、value的映射关系，key不容许重复

八、如何给集合排序？

实现comparable接口

IO

一、什么是流？可画图说明

流是要传输的数据在源和目的地之间运行的轨迹。

二、描述I/O流的基本接口和类的结构

三、代码示例：使用URL流，读取网页代码

import java.io.*;
import java.net.URL;
import java.net.URLConnection;
public class ReadURL {
     public static void main(String[] args) throws Exception {
         URL url = new URL("http://bbs.tarena.com.cn"); //创建封装统一资源定位符的类
         URLConnection uc = url.openConnection(); //打开链接
         InputStreamReader isr = new InputStreamReader(uc.getInputStream());
         BufferedReader br = new BufferedReader(isr);

//传输数据
         while(true){
             String temp = br.readLine();
             if(temp==null){
                break;
             }
             System.out.println(temp);
         }
         br.close();
    }
}

四、什么是Unicode？

是一种字符的编码方式，占16位字节，Java 技术使用 Unicode 来表示字符串和字符。

五、代码示例：如何使用Reader和Writer来进行输入输出

//Writer写入操做

FileOutputStream fos=new FileOutputStream("a.txt");

OutputStreamWriter osw=new OutputStreamWriter(fos);

BufferedWriter bw=new BufferedWriter(osw);

bw.write("欢迎来到java快车");

bw.close();

//Reader读取操做

FileInputStream fis=new FileInputStream("a.txt");

InputStreamReader isr=new InputStreamReader(fis);

BufferedReader br=new BufferedReader(isr);

String str=br.readLine();

System.out.println(str);

六、什么叫保持？什么是可序列化？如何实现可序列化？

将一个对象存放在某种类型的永久存储器上（好比硬盘，光盘，软盘等），称为保持。

标识一个类能够被持久化，叫序列化，也叫串行化或持久化。表示这个类中的数据能够按流式输出。

实现可序列化的方法：实现java.io.Serializable接口。

七、代码示例：如何读写对象流

//读

try {

String str = "123";

FileOutputStream f = new FileOutputStream("test.txt");

ObjectOutputStream s = new ObjectOutputStream(f);

s.writeObject(str);

f.close( );

}catch(Exception e) {

e.printStackTrace( );

}

//写

try {

FileInputStream f = new FileInputStream("test.txt");

ObjectInputStream s = new ObjectInputStream(f);

str =(String)s.readObject( );

f.close( );

}catch(Exception e){

e.printStackTrace( );

}

八、简述File类的基本功能

处理文件和获取文件信息；文件或文件夹的管理。

归纳一句话就是：除了读写文件内容其余的均可以作。

九、代码示例：如何使用随机文件读写类来读写文件内容

RW表示文件时可读写的

读：

try{

RandomAccessFile f = new RandomAccessFile("test.txt", "rw");

long len = 0L;

long allLen = f.length();

int i = 0;

while (len < allLen) {

String s = f.readLine();

if (i > 0) {

col.add(s);

}

i++;

//游标

len = f.getFilePointer();

}

}catch(Exception err){

err.printStackTrace();

}

写：

try{

RandomAccessFile f = new RandomAccessFile("test.txt", "rw");

StringBuffer buffer = new StringBuffer("\n");

Iterator it = col.iterator();

while (it.hasNext()) {

buffer.append(it.next() + "\n");

}

f.writeUTF(buffer.toString());

}catch(Exception err){

err.printStackTrace();

}

十、代码示例：如何使用流的基本接口来读写文件内容

try{

DataInputStream in =

new DataInputStream(

new BufferedInputStream(

new FileInputStream("Test.java")

)

);

String currentLine=null;

while ((currentLine = in.readLine()) != null){

System.out.println(currentLine);

}

}catch (IOException e){

System.err.println("Error: " + e);

}

多线程

一、什么是线程？

轻量级的进程

二、线程的三个部分是？

处理机

代码

数据

三、为何使用多线程

使UI响应更快

利用多处理器系统

简化建模

四、代码示例：Java中实现多线程的两种方式，包括如何定义多线程，如何使用多线程

实现Runnable接口

class Thread1 implements Runnable{

public void run( ){

//run里通常写一个while(true)循环

System.out.println("Runnable");

}

public class Test{

public static void main(String[] a){

Thread1 r = new Thread1();

Thread t1 = new Thread(r);

Thread t2 = new Thread(r);

t1.start();

t2.start();

}

继承Thread

class Thread2 extends Thread{

public void run(){

System.out.println("extends");

}

public class Test{

public static void main(String[] a){

Thread t = new Thread2();

t.start();

}

五、如何实现线程的调度？如何暂停一个线程的运行

调度用wait和notify，

----

sleep()

六、什么是线程的优先级

判断哪一个线程先执行的级别

七、简述sleep方法和wait方法的功能和区别

sleep是让线程休眠一段时间

wait是让线程挂起

八、什么是守候线程

隐藏在后台持续运行的线程

九、什么是临界资源

指多个线程共享的资源

十、什么是互斥锁，Java中如何实现

用来保证在任一时刻只能有一个线程来访问临界资源的那个标记

在Java中使用

用在对象前面限制一段代码的执行

用在方法声明中，表示整个方法为同步方法。

十一、什么是死锁？如何避免？

若是程序中有多个线程竞争多个资源，就可能会产生死锁。当一个线程等待由另外一个线程持有的锁，然后者正在等待已被第一个线程持有的锁时，就会发生死锁。

要避免死锁，应该确保在获取多个锁时，在全部的线程中都以相同的顺序获取锁。尽可能少用临界资源。

十二、简述wait和notify,notifyAll的使用

被锁定的对象能够调用wait( )方法，这将致使当前线程被阻塞并放弃该对象的互斥锁，即解除了wait( )方法的当前对象的锁定状态，其余的线程就有机会访问该对象。

notify使等待队列上的一个线程离开阻塞状态

notifyAll使等待队列上的全部线程离开阻塞状态

Socket编程

1三、什么是url？基本的格式是？

统一资源定位器

Http://www.163.com:port

1四、简述IP,Port,TCP的基本功能

IP表明网络位置

Port表明端口号

TCP可保证不一样厂家生产的计算机能在共同网络环境下运行，解决异构网通讯问题，是目前网络通讯的基本协议

1五、简述Java网络模型的基本功能

描述服务端和客户端的链接过程

1六、简述Java网络编程究竟作些什么？如何作？

1.创建链接

2.准备输出的数据，流式输出

3.流式输入，编程业务须要的格式

4.关闭链接

服务器分配一个端口号。若是客户请求一个链接，服务器使用accept( )方法打开socket链接。

客户在host的port端口创建链接。

服务器和客户使用InputStream和OutputStream进行通讯。

1七、代码示例：基于Socket编程

try {

ServerSocket s = new ServerSocket(8888);

while (true) {

Socket s1 = s.accept();

OutputStream os = s1.getOutputStream();

DataOutputStream dos = new DataOutputStream(os);

dos.writeUTF("Hello," +s1.getInetAddress() + "port#" + s1.getPort() + "\nbye!");

dos.close();

s1.close();

}

}catch (IOException e) {

System.out.println("程序运行出错:" + e);

}

1八、 TCP和UDP区别

TCP（传输控制协议）和UDP（用户数据报协议）是传输层协议

TCP是面向链接的可靠数据传输协议，能保证传输内容的完整和准确；数据传输的辅助开销大，效率低

UDP: 是无链接的，不可靠地传输协议，不能保证传输内容的完整和准确，对信息的适时要求比较高

设计模式

一、什么是设计模式？

就是通过实践验证的用来解决特定环境下特定问题的解决方案。

二、设计模式用来干什么？

寻找合适的对象

决定对象的粒度

指定对象的接口

描述对象的实现

运用复用机制

重复使用通过实践验证的正确的，用来解决某一类问题的解决方案来达到减小工做量、提升正确率等目的

三、什么是对象粒度

对象中方法的大小就是粒度

四、基本的Java编程设计应遵循的规则？

面向接口编程，优先使用对象组合

五、设计模式的应用范围

所能解决的特定的一类问题中

六、简述什么是单例模式，以及解决的问题，应用的环境，解决的方案，应用时应注意什么？

解决的问题：在任什么时候间内只有一个类实例存在的模式。

应用环境：须要有一个从中进行全局访问和维护某种类型数据的区域的环境下使用单例模式。

解决方案：保证一个类只有一个类实例存在。

本质：控制实例的数量。

注意：要合理的使用单例，避免单例成为瓶颈。

七、代码示例：单例模式的两种实现方法，并说明优缺点

public class Test{

private static Test test = new Test();

public Test(){

}

public static Test getInstance(){

return test;

}

public class Test{

private static Test test = null;

private Test(){

}

public static Test getInstance(){

if(test==null){

test = new Test();

}

return test;

}

第一种方式：装载类的时候就建立类的实例，用空间换时间。

第二种方式：延迟装载，不需每次都建立一个类实例，而只是在第一次使用时建立，有效的利用资源，用时间换资源。

八、简述什么是工厂模式，以及他解决的问题，应用的环境，解决的方案，模式的本质

利用工厂来解决接口选择的问题的模式。

应用环境：当一个类没法预料要建立哪一种类的对象或是一个类须要由子类来指定，建立的对象时，就须要用到工厂模式。

解决方案：定义一个建立对象的类，在类的方法中决定具体实例化哪个类。

本质：就是根据不一样的状况来选择不一样的实现类，重在选择。

九、代码示例：工厂模式的实现方法

单独是使用工厂：

public class Factory{

public static Sample creator(int which){

if (which==1){

return new SampleA();

}else if (which==2)

return new SampleB();

}

工厂+单例：

public class MyFactory{

public static MyFactory f = null;

public MyFactory(){

}

public static MyFactory getInstance(){

if(f==null){

f=new MyFactory();

}

public DBDAO getDAO(){

return new DBDAOImpl();

}

十、简述什么是值对象模式，以及他解决的问题，应用的环境，解决的方案，模式的本质

用来把一组数据封装成一个对象的模式

解决问题：在远程方法的调用次数增长的时候，相关的应用程序性能将会有很大的降低

解决方案：使用值对象的时候，能够经过仅仅一次方法调用来取得整个对象，而不是使用屡次方法调用以获得对象中每一个域的数值

本质：封装数据。

十一、代码示例：值对象模式的实现方法

步骤：

public class UserModel{

private String userId;

private String userName;

public void setUserId(String id){

this.userId = id;

}

public String getUserId(){

return userId;

}

public void setUserName(String name){

this.userName = name;

}

public String getUserName(){

return userName;

}

十二、简述什么是DAO模式，以及他解决的问题，应用的环境，解决的方案，模式的本质

数据访问对象

解决问题：根据数据源不一样，数据访问也不一样。根据存储的类型（关系数据库、面向对象数据库、纯文件等）和供应商实现不一样，持久性存储（如数据库）的访问差异也很大。如何对存储层之外的模块屏蔽这些复杂性，以提供统一的调用存储实现。程序的分布式问题

解决方案：将数据访问逻辑抽象为特殊的资源，也就是说将系统资源的接口从其底层访问机制中隔离出来；经过将数据访问的调用打包，数据访问对象能够促进对于不一样数据库类型和模式的数据访问。

本质：分层，是系统组件和数据源中间的适配器。（一层屏蔽一种变化）

1三、代码示例：DAO模式的实现方法

1四、什么是框架？框架的优势？

框架是可以完成必定功能的半成品

　１.优势：完成必定的功能、提供一个精良的应用程序架构

　　２.框架都是以接口的形式出现

　３.应该了解框架完成的功能、框架的API接口、框架的功能是怎么实现的

1五、什么是开放-封闭法则(OCP)

可扩展可是不能够更改已有的模块

对扩展是开放的，对修改是封闭

1六、什么是替换法则(LSP)

使用指向基类（超类）的引用的函数，必须可以在不知道具体派生类（子类）对象类型的状况下使用。

1七、如何综合使用咱们学过的设计模式来构建合理的应用程序结构

是采用接口进行隔离，而后同时暴露值对象和工厂类，若是是须要数据存储的功能，又会经过DAO 模式去与数据存储层交互。

1八、构建经常使用的合理的Java应用包结构

Ui(表现层)

business--factory,ebi,ebo

dao--factory,dao,impl

awt、swing

一、什么是GUI中的容器？什么是GUI中的组件？

容器：能包含其余container和其余component的component。

组件：在设计上能实现必定功能的封装体；

二、简述AWT中的Frame、Panel和组件的关系

组件放在Panel上，而多个Panel能够叠加到Frame上，Frame通常只有一个，各个Panel能够互相在Frame上切换

三、简述如何使用一个组件

初始化，加到容器中，注冊事件，实现相应的事件

Panel pan ＝ new Panel();

TextField td = new TextField();

td.setText("this is in a TextField.");

pan.add(td);

四、描述一个GUI界面的基本构成？

Frame，Panel，組件

Popmenu

五、如何控制外观，如颜色、字体等？

可以使用setColor()，setFont()方法

例如：

Frame f = new Frame();

Font font = new Font("TimesRoman", Font.PLAIN, 14);

f.setColor(Color.red);

f.setFont(f);

六、什么是布局管理器？

用来管理GUI界面中组件的分布情況，负责决定布局方针以及其容器的每个子组件的大小

七、描述每种布局管理器的基本特色

FlowLayout 从左到右分布，排满推到下一行

BorderLayout 上下左右中分布

CardLayout 卡片式分布

GridLayout 网格式分布

XYLayout 坐标分布

八、什么是JFC(Java基础类)？

是关于GUI组件和服务完整集合，

主要包括5个API：

AWT，JavaD,Accessibility,Drag&Drop,Swing

提供了帮助开发人员设计复杂应用程序的一整套应用程序开发包；

九、 Swing和AWT的区别？

Swing提供了更完整的组件，引入了许多新的特性和能力。Swing API是围绕着实现AWT 各个部分的API 构筑的。

AWT 采用了与特定平台相关的实现，而绝大多数Swing 组件却不是这样作的，所以Swing 的外观和感受是可客户化和可插的。

十、什么是双缓冲？

在后台进行界面的更新，而后在前台进行界面交换

功能：双缓冲能够改善一个被频繁改变的组件的外观

十一、描述GUI的事件机制

事件源：是一个事件的产生者，或产生事件的组件对象

事件监听器：调用事件处理方法的对象

事件处理器：就是一个接收事件、解释事件并处理用户交互的方法。

十二、描述Swing应用程序的基本结构？

组件定义

初始化界面

各类事件处理方法

各类适配类

1三、描述表现层的基本功能？

展现数据

人机交互

收集参数、调用逻辑层api

1四、描述在开发Swing应用程序中，通常都要写那些代码？都写到什么地方？

通常要在类的初始化的时候给组件赋值，写在jinit的方法里面

通常要在按扭的事件处理中写收集参数，组织参数，调用业务接口的方法

1五、对于GUI组件而言，最主要的方法是哪些？

初始化

如何给组件初始化

如何从组件中取值

设计组件的属性

1六、如何学习GUI组件的用法？

主要学会组件的定义、取值、赋值的方法

类比学习

JavaScript

一、什么是Javascript

JavaScript是一种基于对象(Object)和事件驱动(Event Driven)并具备安全性能的脚本语言。

二、 Java和Javascript的区别

一、基于对象和面向对象

Java是一种真正的面向对象的语言，即便是开发简单的程序，必须设计对象。

JavaScript是种脚本语言，它能够用来制做与网络无关的，与用户交互做用的复杂软件。它是一种基于对象（Object Based）和事件驱动（Event Driver）的编程语言。于是它自己提供了很是丰富的内部对象供设计人员使用。

二、解释和编译

两种语言在其浏览器中所执行的方式不同。Java的源代码在传递到客户端执行以前，必须通过编译，于是客户端上必须具备相应平台上的仿真器或解释器，它能够经过编译器或解释器实现独立于某个特定的平台编译代码的束缚。

JavaScript是一种解释性编程语言，其源代码在发往客户端执行以前不需通过编译，而是将文本格式的字符代码发送给客户编由浏览器解释执行。

三、强变量和弱变量

两种语言所采起的变量是不同的。

Java采用强类型变量检查，即全部变量在编译以前必须做声明。

JavaScript中变量声明，采用其弱类型。即变量在使用前不需做声明，而是解释器在运行时检查其数据类型，

四、代码格式不同

Java是一种与HTML无关的格式，必须经过像HTML中引用外媒体那么进行装载，其代码以字节代码的形式保存在独立的文档中。

JavaScript的代码是一种文本字符格式，能够直接嵌入HTML文档中，而且可动态装载。编写HTML文档就像编辑文本文件同样方便。

五、嵌入方式不同

在HTML文档中，两种编程语言的标识不一样，JavaScript使用<Script>...</Script>来标识，而Java使用<applet>...</applet>来标识。

六、静态联编和动态联编

Java采用静态联编，即Java的对象引用必须在编译时的进行，以使编译器可以实现强类型检查。

JavaScript采用动态联编，即JavaScript的对象引用在运行时进行检查，如不经编译则就没法实现对象引用的检查。

三、 Javascript的运行环境

具有javascript运行器的

四、如何在web页面加入Javascript，请写出两种方式并示例

alert(11);

</script>

或者

五、写出Javascript基本的数据类型

整型

实型

布尔

字符型

空值

特殊字符

六、 Javascript中如何定义变量，有何规则

必须是一个有效的变量，即变量以字母开头，中间能够出现数字如test一、text2等。除下划线（－）做为连字符外，变量名称不能有空格、（＋）、（－）、（，）或其它符号。

不能使用javascript中的关键字

七、代码示例：Javascript中的if控制语句的结构

if(i>4){

alert(11);

}

八、代码示例：Javascript中的for、while循环语句的结构

for(var i=0;i<10;i++){

alert(11);

}

while(i<10){

alert(22);

}

九、简述break和continue的用法和功能

使用break语句使得循环从For或while中跳出，continue使得跳过循环内剩余的语句而进入下一次循环。

十、 Javascript中如何定义类，如何定义属性，如何定义方法，请代码示例

function QuaryArgItem(){

this.keys = new Array();

this.values = new Array();

}

QuaryArgItem.prototype.push = function(key, value)

{

key = (key == null) ? "" : "" + key;

value = (value == null) ? "" : "" + value;

this.keys.push(key.toUpperCase());

this.values.push(value);

}

QuaryArgItem是类名

push至关于方法名

使用的时候：

a = new QuaryArgItem();

a.push();

十一、 Javascript的function如何定义，有何规则

Function 方法名（参数,变元）{

方法体;

Return 表达式;

}

十二、如何触发Javascript的function

function test(){

alert(11);

}

1三、说出下列String对象的方法的功能和用法：toLowerCase、indexOf、subString、toUpperCase

toLowerCase将指定字符串转化为小写

indexOf判断是否包含某一字符或字符串

substring从字符串中取一段并返回

toUpperCase将指定字符串转化为大写

1四、 Javascript的日期对象是？如何初始化日期对象？

提供一个有关日期和时间的对象Date

date = new Date();

1五、说出下列Javascript系统方法的功能和用法：eval、unEscape、escape、parseFloat

eval：返回字符串表达式中的值

unEscape：返回字符串ASCI码

escape：返回字符的编码

parseFloat：返回实数

1六、 Javascript中如何定义数组？如何初始化？如何取值和赋值

var arrayName = new Array();

Function arrayName(size){

This.length=Size;

for(var x=; x<=size;x++){

this[x]=0;

}

Reture this;

}

1七、简要描述Javascript中下列内部对象的功能：Navigator、Window、Location、History、Document

Navagator：提供有关浏览器的信息

Window：Window对象处于对象层次的最顶层，它提供了处理Navagator窗口的方法和属性

Location：提供了与当前打开的URL一块儿工做的方法和属性，是一个静态的对象

History：提供了与历史清单有关的信息

Document：包含与文档元素一块儿工做的对象，它将这些元素封装起来供编程人员使用

1八、如何利用Document来从页面上取值和赋值

取值：var a = document.all("text1").value;

赋值：document.all("text1").value = '123';

1九、简要描述Javascript对象层次结构

window--document--组件

20、说出下列常见事件何时被触发：onFocus、onBlur、onSelect、onChange、onClick

onBlur:当失去输入焦点后产生该事件

onFocus:当输入得到焦点后，产生该文件

onchange:当文字值改变时，产生该事件

onselect:当文字加亮后，产生该事件

onClick：当组件被点击时产生的事件

2一、代码示例：使用Frame做一个基本的三分页面

<HTML>

<HEAD>

</HEAD>

</Frameset>

</HTML>

2二、框架如何载入页面

2三、如何从框架中的一个页面访问另外一个页面中的组件

var value = parent.right.document.all("text1");

CSS

一、如何把样式表加入到html页面中

在文档<HEAD>中用<Style type="text/css"></style>定义；

使用<LINK>元素连接到外部的样式表单。<LINK REL="stylesheet" href="style1.css">；

二、如何连接元素和样式，请写出4种方法，并代码示例

一、直接链接

二、class链接

三、id链接

四、元素的style=""

Xml

一、 XML有几种解析方法，有什么区别？

有XML DOM解析、SAX解析、StAX解析

XML DOM：（XML Document Object Model）处理大型文件时其性能降低的很是厉害。这个问题是由DOM的树结构所形成的，这种结构占用的内存较多，并且DOM必须在解析文件以前把整个文档装入内存,适合对XML的随机访问；

SAX：（Simple API for XML）不一样于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不须要一次所有装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户经过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问；

StAX：（Streaming API for XML）与其余方法的区别就在于应用程序可以把 XML 做为一个事件流来处理，不管从性能仍是可用性上都优于其余方法；

DOM解析代码以下：

import java.io.*;

import java.util.*;

import javax.xml.parsers.*;

import javax.xml.transform.*;

import javax.xml.transform.dom.*;

import javax.xml.transform.stream.*;

import org.w3c.dom.*;

public class Fuxi{

public Fuxi(){}

public void runXml(){

File f = new File("f:/test/xmltest/student.xml");

try{

//首先建立一个documentbuilderfoctory的工厂

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

//利用工厂来建立documengbuilder

DocumentBuilder db = dbf.newDocumentBuilder();

//利用db的parse方法来解析xml文件

Document doc = db.parse(f);

//将读出来的文件格式化

doc.normalize();

//定义一个nodelist数组来存放xml文件中的节点（标签）

NodeList students = doc.getElementsByTagName("student");

//从xml文件中读取数据

for(int i=0;i<students.getLength();i++){

//定义一个元素

Element student = (Element)students.item(i);

System.out.println("stu_id :"+student.getElementsByTagName("stu_id").item(0).getFirstChild().getNodeValue());

System.out.println("name :"+student.getElementsByTagName("name").item(0).getFirstChild().getNodeValue());

System.out.println("age :"+student.getElementsByTagName("age").item(0).getFirstChild().getNodeValue());

}

//向文件中写数据

String stu_id = "001";

String name = "xingxing";

String age = "22";

Text msg;

//建立元素

Element studentNew = doc.createElement("student");

//建立子元素

Element stuid = doc.createElement("stu_id");

//设置元素的值

msg = doc.createTextNode(stu_id);

//将值添加给元素

stuid.appendChild(msg);

//将元素添加到节点数组中

studentNew.appendChild(stuid);

Element name1 = doc.createElement("name");

msg = doc.createTextNode(name);

name1.appendChild(msg);

studentNew.appendChild(name1);

Element age1 = doc.createElement("age");

msg = doc.createTextNode(age);

age1.appendChild(msg);

studentNew.appendChild(age1);

//将元素studentnew添加到document树中

doc.getDocumentElement().appendChild(studentNew);

//进行写操做

TransformerFactory tff = TransformerFactory.newInstance();

Transformer tfor = tff.newTransformer();

DOMSource dos = new DOMSource(doc);

StreamResult result = new StreamResult(f);

tfor.transform(dos,result);

}catch(Exception e){

System.out.println(e.toString());

}

public static void main(String[] args){

Fuxi ff = new Fuxi();

ff.runXml();

}

JEE

一、简述JEE

JEE　： JAVA　 PLATFORM　 ENTERPRISE　 EDITION

JEE是一个规范集；

JEE是一个框架集；

JEE是一个技术集或API集；

适用于建立服务器端的大型的软件服务系统

二、 C/S B/S 模式

C/S client/server即客户机/服务器模式，客户端也参与程序的运行与计算（富客户端、胖客户端）

B/S border/server即浏览器/服务器模式，又称为瘦客户端，客户端不参与程序的运行与计算

三、企业级应用（大规模的应用）的特色

1.生命周期长、稳定、可靠

2.组件每每分布在异构的环境中，可以跨平台

3.维护性、扩展性、重用性

4.有事务、安全、线程

四、什么是业务逻辑？

依照业务逻辑划分模块，

所谓断定业务　就是具备如下特征：

1.业务流程

2.业务判断

3.功能组合

五、平台（角色）的划分

1.平台供应商。提供知足API集实现的厂商（BEA weblogic IBM webshphere）

2.组件供应商

3.组件装配人员

4.部署人员

5.系统管理人员

6.工具供应商提供开发组件所使用的工具（Jbuilder、eclipse）

六、 java技术分布（设计架构模块内部设计）

1.表现层 Servlet、 Jsp、 JavaBean、 Taglib

2.逻辑层 EJB(SessionBean)

3.数据层（　JDBC 　EJB（EntityBean））

4.服务 JTA（JAVA事务架构） JTS（JAVA事务服务） JAAS（JAVA受权与验证服务）

5.分布式通信 RMI（IIOP）+JNDI 、JAXP（JAVA 的 XML 架构）

JAVAMAIL（邮件服务）、JMS（消息服务）、IDLC、JCA（JAVA链接器框架（成））

七、 JEE的体系结构：是一种组件的体系结构

1.组件：可以完成必定功能的封状体（独立的功能的集合）

不能单独运行，必须运行在容器上

分为两类：web组件、ejb组件

2.容器：提供组件的运行环境，并对组件进行管理（一段程序）

管理组件的生命周期

不能单独运行，必须运行在服务器上

程序（组件）经过上下文来调用容器（context）

组件经过web.xml向容器描述本身，使容器可以认识组件

容器经过回调方法来调用组件

分为两类：web容器、ejb容器

3.服务器：提供容器的运行环境，提供大量的JEE基础服务

web服务器（只提供web服务）

jee服务器（提供web、jee服务）

八、什么是回调方法

由容器自动调用的方法，就叫回调方法。

九、ＲＭＩ远程方法的调用机制

例如：Ａ主机有Ｂ（）方法，Ｃ主机有Ｄ（）方法，Ａ　想调用Ｃ主机的Ｄ方法

十、学习方法

1.规范（熟记） 2.熟悉API 3.多练 4.多想

Servlet

一、描述war包、jar包、ear包的结构

war- web文档压缩包

---WEB-INF

----web.xml web应用部署文件

----lib 本web应用须要的jar包（可选）

----classes 本web应用须要的类文件（可选）

jar- java文件压缩包

---META-INF

----*.MF java包的启动和描述文件

ear- 企业资源包/企业应用包

--META-INF

---Application.xml 配置文件

--*.war

--*.jar

二、什么是servlet？servlet主要作什么？

Servlet是运行在服务器端的小应用程序，是接收网络服务的请求和产生响应的一种方式。

servlet的功能：接受http请求，产生动态http响应。

三、 servlet 与cgi相比的优势？servlet的缺点

优势：

性能（线程比进程更快）

可伸缩

Java强健且面向对象

Java平台独立

缺点：

处理代码（业务逻辑）与HTML（表现逻辑）混合在一块儿

四、经常使用的servlet包的名称是？

javax.servlet

javax.servlet.http

五、描述servlet接口的层次结构？

Servlet

--GenericServlet

--HttpServlet

--本身的servlet

ServletRequest

--HttpServletRequest

ServletResponse

--HttpServletResponse

六、对比get方法和post方法？

（1）安全性问题，经过Get方式提交数据，数据在URL中能够看到；POST方式，数据在URL中不可见。

（2）GET方式提交的数据最多只能有1024字节，而POST则没有此限制。

（3）GET方式不能够传输中文，POST方式能够传输中文。

（4）POST 是被设计用来向上放东西的，而GET是被设计用来从服务器取东西的，GET也可以向服务器传送较少的数据，而Get之因此也能传送数据,只是用来设计告诉服务器,你到底须要什么样的数据。POST的信息做为HTTP 请求的内容，而GET是在HTTP 头部传输的。

七、归类描述HttpServletRequest接口都完成那些功能

读取HTTP头标
读取cookie
读取路径信息
标识HTTP会话。

八、归类描述HttpServletResponse接口都完成那些功能

设置HTTP头标
设置cookie
设定响应的content类型
输出返回数据

九、描述service方法所完成的基本功能？默认是在那里实现的？

基本功能：service方法是在servlet生命周期中的服务期，根据HTTP请求方法（GET、POST等），将请求分发到doGet、doPost等方法

实现：默认在HttpServlet类中实现

十、如何开发本身的Servlet？描述应该作的步骤和每步须要完成的工做

1.引jar包

1)构建开发环境：新建工程，把tomcat下lib文件夹下的servlet-api.jar引入到Eclipse的工程中

2.开发servlet类

1)首先继承HttpServlet

2)重写 doGet( ) doPost( )

3.部署

安装web服务器，例如Tomcat

在Tomcat的webapps目录下新建一个文件夹做为web应用的根

在根下新建一个名为WEB-INF的文件夹，里面创建一个web.xml的文件、一个classes的文件夹、一个lib文件夹

按照servlet的DTD配置web.xml文件

把编译好的servlet的class文件复制到classes目录下

lib文件存放程序所须要的jar包

4.启动服务器

十一、为什么servlet须要部署描述？

servlet须要配置web.xml文件来使容器认识servlet程序（web组件）

十二、 Servlet基本的描述应该是？请写出来

<servlet-name>Hello</servlet-name>

<servlet-class>com.javakc.web.action.MyServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>Hello</servlet-name>

<url-pattern>/greeting</url-pattern>

</servlet-mapping>

1三、如何在html中使用servlet

FORM标记

ACTION– 指定form信息的目的地（相关的URL）

METHOD – 指定HTTP方法（GET或POST）

语法：

{HTML form tags and other HTML content}

</FORM>

1四、如何接受request中的参数

String userName = request.getParameter("userName")方法

1五、如何接受request中header的值

request.getHeader(name);

request.getIntHeader(name);

request.getDateHeader(name);

request.getHeaderNames();

1六、如何输出html

PrintWriter pw = response.getWriter();

pw.write("<html>");

pw.write("Hello");

pw.write("</html>");

1七、如何设置输出的contentType

response.setContentType("text/html")

1八、描述servlet的生命周期？

生命周期是指servlet实例在web容器中从：首次建立调用init方法开始初始化期，通过service方法运行期，一直到destory方法销毁期结束。

servlet实例的生命周期由web容器来管理。

1九、描述init,service,destroy方法的功能和特色

init方法：是在servlet实例建立时调用的方法，用于建立或打开任何与servlet相的资源和初始

化servlet的状态，Servlet规范保证调用init方法前不会处理任何请求

service方法：是servlet真正处理客户端传过来的请求的方法，由web容器调用，

根据HTTP请求方法（GET、POST等），将请求分发到doGet、doPost等方法

destory方法：是在servlet实例被销毁时由web容器调用。Servlet规范确保在destroy方法调用之

前全部请求的处理均完成，须要覆盖destroy方法的状况：释听任何在init方法中

打开的与servlet相关的资源存储servlet的状态

20、什么是回调方法？有什么特色？

由容器来调用程序的方法

由容器来决定何时来调

2一、如何设置初始化servlet的参数？

在<servlet>中添加以下配置

<init-param>

<param-name>greetingText</param-name>

<param-value>Hello</param-value>

</init-param>

2二、如何获取servlet初始化的参数

public void init() {

greetingText = getInitParameter("greetingText");

System.out.println(">> greetingText = '" + greetingText + "'");

}

2三、 ServletConfig接口默认实在那里实现的

GenericServlet类实现ServletConfig接口

2四、什么是ServletContext？有什么做用？

Servlet上下文

ServletContext对象是Web应用的运行时表示，约等于整个web应用；可经过其实现Web应用中的资源共享

2五、如何访问ServletContext接口？是在那里实现的？

在Servlet的实现类中经过this.getServletContext()方法访问。

GenericServlet类实现了ServletContext接口。

2六、 ServletContext接口的功能包括？分别用代码示例

只读初始化参数： getInitParameter(name:String) : String

getInitParameterNames() : Enumeration

读写访问应用级属性：getAttribute(name:String) : Object

setAttribute(name:String, value:Object)

getAttributeNames() : Enumeration

只读访问文件资源： getResource(path) : URL

getResourceAsStream(path) : InputStream

写web应用日志文件：log(message:String)

log(message:String, Throwable:excp)

2七、如何设置ServletContext的参数？

<context-param>

<param-name>catalogFileName</param-name>

<param-value>/WEB-INF/catalog.txt</param-value>

</context-param>

2八、如何获取ServletContext设置的参数值？

ServletContext context = this.getServletContext();

String catalogFileName = context.getInitParameter(“catalogFileName”);

2九、描述Web应用的生命周期？

Web容器启动时，初始化每一个Web应用

Web容器关闭时，销毁每一个Web应用

能够建立"监听器"对象触发这些事件；

30、如何用代码实现监控Web应用的生命周期？

public class Test implements ServletContextListener{

public void contextDestroyed(ServletContextEvent arg0) {

System.out.println("web 容器销毁了+++++");

}

public void contextInitialized(ServletContextEvent arg0) {

System.out.println("web 容器启动了+++++");

}

web.xml文件中的配置：

<listener-class>

com.csy.Test

</listener-class>

</listener>

3一、 web应用中以下错误码示什么意思：400，401，404，500

400 Bad Request//错误请求

401 Unauthorized//未被承认

404 Not Found//没有建立

500 Internal Server Error//服务器内部错误

3二、描述Web应用中用声明方式来进行错误处理的两种方法

使用error-page元素声明一个给定HTTP状态码的处理器

<error-page>

<error-code>404</error-code>

<location>/error/404.html</location>

</error-page>

能够声明任意数量的错误页面，但一个给定的状态码只能对应一个页面

使用exception-type元素声明给定Java异常的处理器

<error-page>

<exception-type>

java.lang.ArithmeticException

</exception-type>

<location>/error/ExceptionPage</location>

</error-page>

能够声明任意数量的错误页面，但一个给定的异常类型只对应一个页面

不能使用父类捕获多种异常

3三、描述记录异常日志的方法，都位于那些接口？

GenericServlet：

log(message:String)

log(message:String, Throwable:excp)

ServletContext：

log(message:String)

log(message:String, excp:Throwable)

3四、什么是会话？

Web容器可为每一个用户保存一个"会话对象"，用来存储特定用户的会话信息。

3五、如何得到会话？

HttpSession session = request.getSesseion( );

3六、会话Api的基本功能？

getID() :String

isNew() :boolean

getAttribute(name):Object

setAttribute(name,value)

removeAttribute(name)

3七、如何销毁会话？

一、可以使用部署描述符控制全部会话的生命周期

<session-config>

<session-timeout>10</session-timeout>

</session-config>

二、可以使用控制特定会话对象的生命周期HttpSession接口

invalidate()

getCreationTime() :long

getLastAccessedTime() :long

getMaxInactiveInterval() :int

setMaxInactiveInterval(int)

3八、描述会话保持状态的基本原理

client server

request

response (sessionid)

request (cookies)

当客户端第一次请求时，服务器建立一个session与request绑定，用响应对象response来返回sessionid 放到客户端的cookies中存储下来，下次在发送请求时，直接根据sessionid来检索服务器的会话（每次请求都会将全部的cookies带到服务器端）

3九、请描述session和cookie的异同之处

40、如何读写cookie，代码示例

写： Cookie c = new Cookie("yourname", name);

response.addCookie(c);

读：Cookie[] cookies = request.getCookies();

for ( int i=0; i < cookies.length; i++ ) {

String key =cookies[i].getName();

String value = cookies[i].getValue();

System.out.println("cook"+i+":key="+key+",value="+value);

}

4一、什么是URL重写，如何实现，代码示例

Cookie不能使用时，可以使用URL重写 request.encodeURL();

客户在每一个URL的后面追加额外的数据

服务器将此标识符与其存储的有关会话数据相关联

http://host/path/file;jsessionid=123

4二、描述web应用的4种认证技术

BASIC – Web浏览器接收用户名和口令，将其以明码方式发送给Web服务器

DIGEST – Web浏览器接收用户名和口令，使用加密算法将此数据发送给Web服务器

FORM – Web应用提供发送给Web浏览器的HTML form

CLIENT-CERT – Web容器使用SSL验证用户，服务端和客户端的链路保护

4三、什么是受权，什么是验证？

受权是根据用户角色划分web资源的过程，其标识web应用中的安全域分配权限

web容器使用厂商指定的机制验证用户的角色匹配权限

4四、什么是HTTPS

HTTPS (Secure Hypertext Transfer Protocol) 是使用SSL协议的HTTP

4五、什么是审计？

也就是访问跟踪，是为web应用的每次访问保留记录的过程

4六、如何实现声明性受权

一、标识web资源集

二、标识角色

三、将web资源集影射到角色

四、标识每一个角色中的用户

在 web.xml里配

4七、描述servlet并发问题？

多个同类线程运行，能够共享同一个Servlet实例，共享的数据和资源未合理同步，可能会引发数据的冲突

4八、描述Web应用中的六种属性范围

局部变量（页面范围）

实例变量

类变量

请求属性（请求范围）

会话属性（会话范围）

上下文属性（应用范围）

4九、指出上述六种哪些是线程安全的

局部变量和请求属性

50、什么是STM？如何实现？

SingleThreadModel接口

能够实现SingleThreadModel接口保证某一时刻只有一个请求执行service方法

5一、如何实现并发管理？

尽量使用局部和请求属性

使用synchronized语法控制并发

尽量减小同步块和同步方法的使用

使用正确设置了线程安全的资源类

Jsp

一、什么是Jsp?

Java Server Page 结合java和html在服务端动态生成web页面的技术

二、描述Jsp页面的运行过程？

第一步：

请求进入Web容器，将JSP页面翻译成Servlet代码

第二步：

编译Servlet代码，并将编译过的类文件装入Web容器（JVM）环境

第三步：

Web容器为JSP页面建立一个Servlet类实例，并执行jspInit方法

第四步：

Web容器为该JSP页面调用Servlet实例的_jspService方法；将结果发送给用户

三、描述Jsp页面的五类脚本元素的功能、写法、并示例

注释 <%-- --%>

<HTML>

<%-- scripting element --%>

</HTML>

指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段

<%@ page session=”false” %>

声明标记 <%! %> 声明标记容许JSP页面开发人员包含类级声明

<%! public static final String DEFAULT_NAME = “World”; %>

脚本标记 <% %> 脚本标记容许JSP页面开发人员在_jspService方法中包含任意的Java代码

<% int i = 0; %>

表达式标记 <%= %> 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>

四、描述Jsp页面中的注释种类和写法

HTML注释

JSP页面注释

<%-- JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。--%>

Java注释

/* Java注释显示在servlet代码中，不显示在响应中

五、描述Jsp页面的指令标记的功能、写法、并示例

指令标记影响JSP页面的翻译阶段

<%@ page session=”false” %>

<%@ include file=”incl/copyright.html” %>

<%@ taglib %>

六、描述Jsp页面的声明标记的功能、写法、并示例

声明标记容许JSP页面开发人员包含类级声明

写法：

<%! JavaClassDeclaration %>

例：

<%! public static final String DEFAULT_NAME = “World”; %>

<%! public String getName(HttpServletRequest request) {

return request.getParameter(“name”);

}

<%! int counter = 0; %>

七、描述Jsp页面翻译成Servlet的规则

jsp中的注释标记被翻译成Servlet类中的注释

jsp中的指令标记被翻译成Servlet类中的import语句等

jsp中的声明标记被翻译成Servlet类中的属性

jsp中的脚本标记被转移到Servlet类中service方法中的代码

jsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码

八、描述Jsp页面的九个预约义变量的功能、用法、并示例

request 与请求相关的HttpServletRequest对象

response 与送回浏览器的响应相关的HttpServletResponse对象

out 与响应的输出流相关的JspWriter对象

session 与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参

与一个HTTP会话时有意义

application 用于Web应用的ServletContext对象

config 与该JSP页面的servlet相关的ServletConfig对象

pageContext 该对象封装了一个JSP页面请求的环境

page 该变量与Java编程语言中的this变量等价

exception 由其它JSP页面抛出的Throwable对象，该变量只在"JSP错误页面"中可用

九、 page指令的功能，写法、并示例，并描述它的以下属性的功能和用法：import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding

import import 定义了一组servlet类定义必须导入的类和包，值是一个由

逗号分隔的彻底类名或包的列表。

session session 定义JSP页面是否参与HTTP会话，值能够为true（缺省）

或false。

buffer buffer 定义用于输出流（JspWriter对象）的缓冲区大小，值能够为

none或Nkb，缺省为8KB或更大。

errorPage 用来指定由另外一个jsp页面来处理全部该页面抛出的异常

isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或

false（缺省）。

ContentType 定义输出流的MIME类型，缺省为text/html。

pageEncoding 定义输出流的字符编码，缺省为ISO-8859-1

十、描述MVC各部分的功能？MVC的优势？MVC的缺点？

MVC各部分的功能：

Model（模型表示企业数据和业务逻辑）

封装应用状态

响应状态查询

暴露应用的功能

Controller（控制器接受用户的输入并调用模型和视图去完成用户的需求）

验证HTTP请求的数据

将用户数据与模型的更新相映射

选择用于响应的视图

View（视图是用户看到并与之交互的界面）

产生HTML响应

请求模型的更新

提供HTML form用于用户请求

MVC的优势：

低耦合性：视图层和业务层分离

高重用性和可适用性

较低的生命周期成本

快速的部署

可维护性

有利于软件工程化管理

提升软件的健壮性

MVC的缺点：

工做量大，增长工做的复杂性，MVC不适合小型甚至中等规模的应用程序

十一、什么是Model 1结构，以及结构中各部分的功能

结构：jsp+javabean

Model1中使用jsp来处理web应用中的视图控制部分

Javabean收集参数

十二、什么是JavaBean?

用户能够使用JavaBean将功能、处理、值、数据库访问和其余任何能够用java代码创造的对象进行打包，而且其余的开发者能够经过内部的JSP页面、Servlet、其余JavaBean、applet程序或者应用来使用这些对象。

1三、 JavaBean的规则？

使用get和set方法定义属性

一个无参构造方法

无public实例变量( 全部属性私有化)

1四、什么是jsp标准动做？包含那些？分别都是什么功能？如何使用？

JSP页面中使用相似于XML的标记表示运行时的动做

jsp:useBean

jsp:setProperty

jsp:getProperty

jsp:param

jsp:include

jsp:forward

1五、用代码示例以下标准动做的使用：useBean、getProperty、setProperty

<jsp:useBean

id="myForms"

class="com.base.mystruts.forms.MyActionForm" scope="session" />

<jsp:setProperty name="myForms" property="name" />

<jsp:getProperty name="myForms" property="id" />

1六、描述说明Bean的四种scope

page

request

session

application

1七、描述说明页面上的字段和Bean中属性的对应规则

id 指javabean的变量名

class指javabean类的全路径

scope指javabean的应用范围

name指所用到的javabean的变量名

property指javabean中的属性

1八、描述useBean动做的处理过程

使用id声明变量

试图在指定的范围内查找对象

若是没找到

建立一个类的实例

执行useBean标记体初始化对象

若是找到

将对象转换为类指定的类型

1九、描述forward动做的功能

使用脚本代码处理请求时，可用jsp:forward 动做产生一个不一样的视图，

使用同一个request：

20、什么是Model 2结构，以及结构中各部分的功能

jsp+model+servlet

Model 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器

Servlet控制器：

验证HTML form数据

调用模型中的业务服务

存储请求（或会话）范围内的域对象

选择下一个用户的视图

JSP页面视图：

使用用户界面（在HTML中）

访问域对象

2一、如何得到分发器？分发器的功能？

上下文对象中的分发器：

ServletContext context = this.getServletContext();

RequestDispatcher servlet = context.getNamedDispatcher("MyServlet");

servlet.forward(request, response);

请求对象中的分发器：

RequestDispatcher view = request.getRequestDispatcher("tools/nails.jsp");

view.forward(request, response);

能够将请求转发到另外一个jsp页面，并保持请求的传递性

2二、 Jsp中页面跳转的两种方式？

使用分发器跳转页面

RequestDispatcher dispatcher = request.getRequestDispatcher(“url”);

dispatcher.forword(request);

特色：保持请求的传递（上一次请求中的数据，在下一个请求中仍然能够获得）；

转发的页面只能是同一个Web应用程序的其余Web组件

使用重定向跳转页面

response.sendRedirect(“url”);

特色：产生全新的请求，（上一次请求中的数据，在下一个请求中不能获得）；

从新定向的页面能够是任意的URL

2三、描述Jsp中引入另外页面的两种方法，并比较两种方法的特色？

<%@ include file=””%> 在编译期间把另外一个页面彻底嵌入这个页面,能够说是一个页面

在这里能够共享变量

<jsp:include page=””> 动态的再运行期间把另外一个页面加入这个页面,能够说是两个

页面，不能够共享变量

2四、什么是自定义标记

自定义标记库是一个Web组件，

包括：

一个标记库描述符文件（*.tld）

全部相关的标记处理器类(*.jar)

2五、描述使用自定义标记的步骤，以及每步详细的工做

使用自定义标记前，要拿到.tld和.jar两类文件

一、把.jar文件放到WEB-INF的lib里面。

二、把.tld文件放到WEB-INF根目录下。

三、在web.xml中配置。

<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>

<taglib-location>/WEB-INF/c.tld</taglib-location>

</taglib>

四、在页面中引用。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="s"%>

uri必须与web.xml中的uri对应

prefix是前缀，用来区分是哪个taglib

使用标记
格式：<prefix:tag名称属性>

<s:forEach >

在tomcat下配置数据源

一、服务器与数据库的链接

配置server.xml文件

1.oracle

<Resource name="jdbc/company" scope="Shareable" auth="Container" type="javax.sql.DataSource"

factory="org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory"

url="jdbc:oracle:thin:@127.0.0.1:1521:orcl"

driverClassName="oracle.jdbc.driver.OracleDriver"

username="aa"

password="aa"

maxActive="50"

maxIdle="10"

maxWait="-1"

2.sqlserver

<Resource name="jdbc/webpage" scope="Shareable" auth="Container" type="javax.sql.DataSource"

factory="org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory"

url="jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;

DatabaseName=webpagetest"

driverClassName="net.sourceforge.jtds.jdbc.Driver"

username="aa"

password="aa"

maxActive="50"

maxIdle="10"

maxWait="-1"

二、配置本身的web应用的xml文件

<Context path="/eb03web" docBase="F:/workweb/eb03web"

privileged="true" antiResourceLocking="false" antiJARLocking="false">

</Context>

三、配置web.xml文件

与服务器创建链接

<resource-ref>

<res-ref-name>jdbc/company</res-ref-name>

<res-type>javax.sql.DataSource</res-type>

<res-auth>Container</res-auth>

</resource-ref>

四、在应用程序中不直接与数据库链接，经过DataSource链接池创建链接

//1.在程序单独用时设置系统的属性，在tomcat下能够不用配置，

System.setProperty(Context.PROVIDER_URL,"");

System.setProperty(Context.INITIAL_CONTEXT_FACTORY,"");

//2.建立一个上下文对象

InitialContext context = new InitialContext();

//3.经过上下文对象在链接池中查找DataSource

DataSource ds = (DataSource)context.lookUp("java:comp/env/jdbc/company");

//4.经过数据源创建链接

ds.getConnection();

Struts2

一、 struts2简介

struts2是一种基于MVC（Model View Controller ）的web应用框架。

struts2包括三个部分：struts和xwork，对其余框架或技术的支持

struts处理web相关的部分，xwork处理web无关的部分。

二、描述基本的struts应用的组成部分以及每部分的功能，并指出哪些是须要开发人员作的

1） struts ActionContext Clear Up ：负责清空ActionContext，确保不会出现因为内存引发的并发问题。

2） other Filters ：其余的过滤器

3） Filter Dispatcher ：struts2的总调度类，经过http请求到ActionMapper询问请求的Action是否执行

4） ActionMapper ：决定这个action须要被执行

5） ActionProxy：找ConfigurationManager要Action的配置，而后产生Action Invocation对象

6） ConfigurationManager：响应ActionProxy的请求找到xwok.xml

7） struts.xml ：经过配置让 Action 调用器调用Action

8） Action Invocation：调用对应的Action

9） Interceptor ：拦截在Action和result执行先后完成一些功能（好比将request中的数据映射到值栈中）

10） Action ：处理客户端请求，调用逻辑层API，经过Result选择下一界面

11） Result：常量字符串

12）页面：经过Taglib的标签获得值栈中的数据并显示

13） Taglib：获得封装对象中的数据

须要开发的有：Action，页面（配置上Taglib的前缀，用OGNL获得数据），struts.xml，若是要解决中文问题还要配置 struts.properties文件

三、描述struts开发的步骤，以及每步具体的工做

见教材第二章

四、描述从页面点击一个按钮开始，完整的Struts应用运行过程

1）用户点击页面的提交按钮，即客户端发送http请求到web容器。

2） web容器经过web.xml找到web容器的Filter；经过url-pattern 找到filter-name，再经过filter-name找到filter-class，即找到FilterDispatcher。

3） Action代理调用ConfigurationManager读取xwork.xml文件，根据提交的xx.action,找到对用的action的全路径，经过Action调用器调用Action类。

4）在调用Action类以前，首先被配置的拦截器拦截到，进行相关的处理，如将request中的数据映射到值栈中。

5）回调Action中的execute方法，执行后返回Result。

6）获得Reslut后，在xwork.xml中匹配下一个页面。

7）执行Result调用下一个页面。

五、图示描述struts的架构

六、为何推荐使用ActionSupport

由于ActionSupport不只实现了Action接口，并且实现了其余的接口，例如：validate()方法-数据检验，getLocal()获取本地信息等功能

七、 Struts中数据检测的方式有几种，详细写出分别怎么作

一、在validate()方法中进行数据检验

二、在execute()方法中进行数据检验，但必定要有返回值为INPUT

八、 Struts中如何使用本地信息

一、和Action类同级新建一个与Action同名的.properties文件，并用key，value定义好组件对应的信息（国际化信息）

二、在Action类中使用：this.getText("key")

九、详细写出struts的Action中三种数据的对应方式，并比较优缺点

一、域模型：灵活，封装数据， public 或 private+get/set

二、字段驱动：把字段直接封装在Action中，适用于字段少的程序

三、模型驱动：Action类实现ModelDriver接口，并实现getModel方法，页面上直接用返回对象的字段就能够，但一个Action只能对应一个Model

十、什么是Result

result是一个字符串常量，他表示Action执行完成的状态，struts.xml根据返回的result选择下一个界面

十一、写出通用Result中dispatch,redirect和chain的特色

一、dispatch：保持同一请求，保持数据的传递

二、redirect：重定向，一个全新的请求，丢失数据

三、chain；保持数据的传递，但不是同一请求（一个全新的请求）

十二、 Interceptor的功能和运行特色

能在Action和Result执行先后完成一些功能；也能够把Action的共性功能分离出来，以便之后发生变化便于修改，不用动不少的类

1三、配置Interceptor要注意什么，什么是Interceptor栈

注意：之后自定义的Intercepter要追加到defaultStack后——即本身定义一个栈把默认栈和自定义的Intercepter追加上

多个Interceptor构成Interceptor栈

1四、什么是OGNL

OGNL是Object-Graph Navigation Language的缩写，它是一种功能强大的表达式语言（Expression Language，简称为EL），经过它简单一致的表达式语法，能够存取对象的任意属性，调用对象的方法，遍历整个对象的结构图，实现字段类型转化等功能。它使用相同的表达式去存取对象的属性。

1五、代码示例：在struts中向session中取值和赋值

Action向session中取值：

ServletActionContext.getRequest().getSession().getAttribute("nowPage");

赋值：

ServletActionContext.getRequest().getSession().setAttribute("nowPage",nowPage);

页面向session中取值： <ss:property value="#session['pageNum']"/>

1六、代码示例：在struts中定义集合，并取值和赋值

<ss:set name=“col” value=“{1,2,3}”/>

<ss:property value=“#col[1]”/>

1七、简述值栈的原理

一、值栈与request绑定，并且是线程安全的

二、值栈至关于一个小型的数据库

三、struts全部的Action属性值存取都经过值栈

1八、如何在struts中取得HttpSession的数据

（1）取得HttpRequest对象：

HttpServletRequest request = ServletActionContext. getRequest();//这个方法返回了与当前线程的ActionContext相关联的request

（2）取得HttpSession对象：

HttpSession session = ServletActionContext. getRequest().getSession();

1九、描述如何使用验证框架的步骤和每步应作的工做

使用验证框架的方法特别简单：

（1）写validatiors.xml文件，注册要用到的验证器

（2）写类名-validation.xml文件，并放到相应的地方

（3）开启Action的验证功能，在xwork.xml文件中指定拦截器“validation”或者“validationWorkflowStack”，示例：

<interceptor-ref name="validationWorkflowStack"/>

注意：无论验证是否经过，咱们的Action都会执行，但若是验证没有经过，它不会调用Action的execute()方法

20、 set标签是用来作什么的，描述set标签支持的做用域

功能：对值栈中的表达式进行求值，并将结果赋给特定做用域中的某个变量

下面来看个例子：

每次都要重复#session[‘user’]不只是麻烦，并且容易出错，较好的方式是：定义一个临时变量来代替它。

<ss:set name=“test” value=“#session[‘user’]”>

<ss:property value=“#test.username”/>

<ss:property value=“#test.age”/>

<ss:property value=“#test.address”/>

做用域的说明： Set标签支持5种做用域：default(也是默认的，ActionContext)，page,request,session,application。一般咱们不须要管，除非你要把一个标签或者servlet集成到struts中。

2一、代码示例：property、set、Iterator、bean、param、if、else标签的用法

<ss:property value="#session['user'].username"/>

<ss:property value=“#session[‘user’].username”/>

<ss:property value=“#session[‘user’].age”/>

<ss:property value=“#session[‘user’].address”/>

<ss:set name="test" value="#session['user']">

<ss:iterator id="kc" value="ewm.col">

</ss:iterator>

<ss:bean id="kc" name="com.opensymphony.struts.util.Counter">

<ss:param name="last" value="100"/>

</ss:bean>

<ss:if test="#s.even">

<ww:property />偶数行

</ss:if>

<ss:else>

<ss:property />奇数行

</ss:else>

ORM对象关系型数据库映射

(Object Relation Mapping)

1、映射的特色

1.一个对象能够对应多个表

2.一个表能够对应多个对象

3.对象和表的关系不用彻底对应

4.对象的属性的名称和表字段的名称能够不一样

5.类型能够不一样，但数据类型之间能够转换

6.对象中必须有主键，数据库的表对主键无所谓

7.数据库中有主外键关系时，对象中能够有，也能够没有

二、有一个映射的描述文件————>xml

三、怎样实现描述文件————>一段程序

对象映射（mapping）数据库

user

id=11

name="张三"———— > (1) —————> tbl_user(id,name,age,tel,address)

age=25 <————(2) <————

(1)从对象映射到数据库

1.JDBC

2.根据描述文件来动态拼接sql

3.执行，添加到数据库中

(2)从数据库中映射到对象

1.JDBC

2.拼接查询sql

3.ResultSet

4.Model

hibernate

开发流程：

一、是什么？

hibernate是一种基于orm 的轻量级的框架

二、有什么？

1. session 保持链接状态（依赖事务和链接池）

2. Transaction事务

3. Connection Provider 链接池

三、能干什么？

1.orm

2.提供操做数据库的接口，简化数据持久化的编程任务

四、怎么作？

1.搭建hibernate的运行环境，将hibernate的包和hibernate所须要的包拷贝到lib 文件夹下

2.O（vo）

3.R （关系型数据库中的表）

4.配置文件

4.1 cfg.xml 放在classes根目录下，默认名字为hibernate.cfg.xml

a.与数据库的链接

b.可选配置

c.映射资源的注册

4.2 hbm.xml文件名字与类名相同而且与类放在一块儿

a. 对象与数据库表之间的映射

b. 对象的属性与数据库表的字段之间的映射

c.组件之间的映射

d.对象与对象之间的关系映射

五、客户端

1.获得SessionFactory

2.经过SessionFactory 工厂来建立Session实例

3.打开事务

4.操做数据库

5.事务提交

6.关闭链接

运行流程：

五、总体流程

1.经过configuration来读cfg.xml文件

2.获得SessionFactory 工厂（根据数据库的链接来建立sessionfactory）

3.经过SessionFactory 工厂来建立Session实例

4.打开事务

5.经过session的api操做数据库

6.事务提交

7.关闭链接

六、 save

1.to--->po

2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件

3.根据hbm.xml文件和model来动态的拼sql

4.客户端提交或者刷新内存

5.执行sql，值放到数据库

七、 update、delete

1.根据model 的id在内存hibernate的缓存中查找该对象

若是内存中没有就到数据库中查找来保证对象的存在

2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件

3.根据model和hbm.xml 文件来动态拼sql

4.客户端提交或者刷新内存

5.执行sql

八、 Query

load

1.根据model的类型来找到hbm.xml文件

2.判断id对应的对象在缓存中是否存在，若是存在，就直接使用，若是不存在就进行下一步。

3.用id作为查询条件来动态拼sql

4.执行sql 查询（先在内存中查找，若是没有找到（会抛出例外），就去数据库中查找）

5.返回一个model类型的对象

get

1.根据model的类型来找到hbm.xml文件

2.用id作为查询条件来动态拼sql

3.执行sql 直接在数据库中查找，若是没有查到就会返回null

query

1.分析hql语句，获得model的类型

2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件

3.根据model和hbm.xml文件来动态拼sql

4.执行sql查询数据库

5.返回一个resultset

6.循环resultset的值，放到model中在放到集合（List）中

谈谈hibernate缓存机制

缓存其实很直观的理解为放到内存或者硬盘上的一块区域，缓存就是一个缓冲的做用，有不少时候，咱们的数据须要常常访问，若是放到数据库中，不是不可，只是效率上低，若是有了中间产物来代替数据库，就省不少事情了。打个比方，去买酱油，不必定必定要去酱油的生产工厂去买。代码中须要数据的时候，能够先到缓存中查找，若是存在，就直接拿数据，不存在就去数据库中取，也省了不少事。

hibernate使用的是二级缓存，有两个级别，分别是Session，SessionFactroy级别，一级缓存是Session级别的缓存，Hiberante来管理的，这个咱们通常不用管，二级缓存是SessionFactory级别的，能够进行配置和更改，加载卸载，就是咱们平时用的hibernate配置文件中的配置SessionFactory的属性。

对一级缓存中的session事务进行数据的预存取，数据在各个session的上下文中存在（单例），当session关闭时，就是session.close( )，整个全部session范围内的数据所有清空；二级缓存默认的状况下是不开启的，数据库汇总的全部数据都先copy到二级缓存中，这里要注意的是，一级缓存是每一个线程下建立的session缓存区域，能够是多个，二级缓存只有一个区域，画个图比较容易理解。

| | | |

---------------------------------------------------------------------------------------------------

sessionFactroy级别的二级缓存

-------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------------------------

-----------------------------------------------------------------------------------------------------------------

Spring

一、是什么？

Spring是基于JEE的轻量级的应用框架

二、有什么？

每一个包的功能：

Spring MVC：spring 自己提供的web 框架

WEB：集成其余的web 应用的框架，或者说是对其余web应用框架的支持。如struts，struts

JEE ：集成一系列的jee的技术（对JEE技术的支持）

DAO：封装了JDBC；（对JDBC的支持）

ORM：提供了对ＯＲＭ工具的集成（支持）

AOP ：面向切面编成

CORE：spring的核心包，提供bean的工厂和IOC容器

三、能干什么？

把一系列的jee的技术有效的组合在一块儿造成以良好的系统

四、怎么用？

一、搭建web工程，引入spring的jar包

二、在web.xml中添加以下配置

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath*:applicationContext*.xml</param-value>

</context-param>

<filter-name>struts2</filter-name>

<filter-class>

org.apache.struts2.dispatcher.FilterDispatcher

</filter-class>

</filter>

<filter-mapping>

<filter-name>struts2</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

<listener-class>

org.springframework.web.context.ContextLoaderListener

</listener-class>

</listener>

三、部署

五、容器和bean

Ioc容器是Bean实例的容器，相似于一个实例池，Ioc容器对Bean进行实例化、配置及管理（控制Bean的生命周期及相互的关系）。

Ioc容器与jee的容器类比:

Jee:提供组件的运行环境和管理组件的生命周期（不能单独存在）

Ioc容器:提供bean的运行环境和管理bean的生命周期（能够单独存在）

Bean是受Spring Ioc容器管理(控制)的对象，这些对象除了表明类实例自己，还能够包含各类资源，好比文件、图片、集合、数组、数字、字符串等一切外部资源。

六、 IOC控制反转

Spring的ioc中最重要的两个类是ApplicationContext和BeanFactory

在使用Ioc容器以前，应用程序老是经过工厂，主动索取须要的资源（bean），好比表现层经过调用逻辑层的工厂获得逻辑层接口的实例，这样作层与层之间就会耦合。

当使用Ioc容器以后，应用程序由主动索取变成被动等待，由Ioc容器控制应用程序须要的资源对象，应用程序只须要作相应的配置声明，说明须要什么bean资源，Ioc容器就能够给应用程序注入相应的资源了。

程序的控制权由应用程序转到了Ioc容器，应用程序由“主动控制”转换成了被Ioc容器控制，控制权发生了转移，因此是控制反转；应用程序依赖Ioc容器的注入才能够运行，因此称为依赖注入。控制反转、依赖注入，方向不一样，但描述的倒是同一件事情。

好处：

使程序模块化，真正实现松散耦合

使程序可装配

使代码可重用

代码开发：

容器：

BeanFactory是Spring IoC容器的实际表明者，经过BeanFactory的对象能够对Ioc容器中的bean进行管理。

BeanFactory的建立过程是：先读取BeanFactory的配置文件（FileSystemResource或ClassPathResource），再建立BeanFactory的实例（XmlBeanFactory）。

容器实例化bean的三种方法：

构造器实例化

静态工厂实例化

<bean id="exampleBean"

class="examples.ExampleBean2"

factory-method="createInstance"/>

实例工厂实例化

bean id="myFactoryBean" class="...">

...

</bean>

<bean id="exampleBean"

factory-bean="myFactoryBean"

factory-method="createInstance"/>

BeanFactory有containsBean、getBean、isSingleton、getType、getAliases等方法。

ApplicationContext是BeanFactory的子接口，它加强了BeanFactory的功能，好比：提供国际化的消息访问、资源访问（读文件）、bean相关的事件控制、在web环境中能够实例化。

BeanFactory是延迟加载，ApplicationContext是建立Ioc容器就对bean进行初始化。

七、 DI依赖注入

1. 应用程序依赖spring注入所须要的对象

IOC和DI是对同一种事情的不一样描述

2.setter注入：在配置文件中将接口的实现配置为bean在应用程序中注入bean

例如：

在配置文件中

</bean>

在应用程序中

Public DBDAO dao ;

Public void setDao(DBDAO dao){

This.dao = dao;

}

3．构造器注入

<constructor-arg>

4.lookup方法注入

5．ref 表示参照其它的bean

在参照的过程当中必定要注意死循环

6.自动装配-----------〉no

自动装配根据名字来匹配相应的bean 尽可能不要去自动装配

7. bean的做用域：

singleton 单例

prototype 非单例

使用spring的webApplicationContext,则能够使用request,session和globalSession

8.DI的优势：

1.程序被动等待，强化面向接口编成

2.切断了对象或组件之间的联系，使程序的结构更加松散，运行和维护更加简单

八、 Aop面向切面编程

Aop中最重要的三个概念是切入点、切面，通知。

1.AOP面向切面编程

切面：表明咱们所关注的一系列的共同的功能点（模块之间的共同的功能点）

面向切面编程提供了另一种角度来思考程序的结构，弥补了面向对象编程的不足。

2.AOP的好处：

灵活的实现功能

使各个模块之间不耦合

3.AOP 的概念

1.切面：咱们所关注的功能点

2.链接点：事件的触发点（方法的执行）

3.通知：链接点触发时执行的动做（方法）

4.切入点：一系列的链接点的集合（链接点的模块化）

5.引入：扩展的功能

6.目标对象：包含链接点的对象

7.aop代理：实现机制

8.织入：把advice和目标对象链接起来

4.AOP的事件机制

1.经过切面找出一系列共同的功能点

2.找到目标对象(在标准的spring 中接口的实现类为target)

3.找到切入点

4.肯定链接点

5.通知spring AOP，查询xml文件，经过代理找到advice。

6.由aop代理来实现动态织入

5. AspectJ

5.1.在xml中配置比较烦琐

全部的入口必须从一个代理（ProxyFactoryBean）开始

<aop:config>

<aop:aspect ref="myAdvice">

<aop:pointcut id="kc"

expression="execution(* com.javakc.aop.MyTarget.t*())"/>

<aop:before pointcut-ref="kc" method="abc"/>

</aop:aspect>

</aop:config>

5.3.使用注解的方法相对简单

@AspectJ的基本语法

1.@Aspect声明一个切面，将一系列的共同的功能定义成一个切面

直接在类上定义@Aspect

2.@Pointcut声明切入点

2.一、用一个专门的类来定义pointcut，类中的方法名就是该pointcut的名字

2.二、能够使用匿名的pointcut

2.三、执行切点的几种方法

2.3.1 execute（public * 包结构.*.*.（..））能够指定到具体的方法

2.3.2 within 指定到包，不能指定到类

within（"com.javakc.spring..*"）

2.3.3 this 指定到实现接口的全部的实现类

2.3.4 target 指定具体的实现类

5.4.advice的五种类型的示例

　　　客户端必须从接口走才能获得监控，实现想要追加的功能　　　　　　

5.4.1.@AfterReturning(pointcut="" returning="retVal")

追加的方法的参数名字必定要与retrning的名字相同

在注解@AfterReturning中必须加上pointcut和returning两个参数

pointcut指所要监控的目标对象的方法

获得目标对象的方法的返回值，来做为参数，进行下一步的处理,参数没有顺序，按参数的名字进行匹配

完成追加的功能

1 定义一个pointcut，经过方法名来做为pointcut的名称来引用

(1).@AfterReturning("com.javakc.spring.schemaaop.TestPointcut.t4()")

(2).

2.直接引用匿名的pointcut

(1).@AfterReturning("execution(

* com.javakc.spring.schemaaop.Api.test4())")

(2).@AfterReturning(pointcut=

"com.javakc.spring.schemaaop.TestPointcut.t4() &&

args(str)", returning="retVal")

@AfterReturning (pointcut="com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)",returning="retVal")

public void testAfterReturning(String str,Object retVal){

System.out.println("afterReturning1=>"+retVal+"=>"+str);

}

5.4.2.@Aronud

注解@Around环绕追加功能；

在执行目标对象的方法的前、后追加功能；

必须有参数；第一个参数的类型必须为ProceedingJoinPoint；

经过ProceedingJoinPoint的实例的proceed来调用所监控的

目标对象的方法

1 定义一个pointcut，经过方法名来做为pointcut的名称来引用

(1).@Around("com.javakc.spring.schemaaop.TestPointcut.t1()")

(2).@Around("com.javakc.spring.schemaaop.TestPointcut.t2()

&& args(str)")

2.直接引用匿名的pointcut

(1).@Around("execution(

* com.javakc.spring.schemaaop.Api.test1())")

(2).@Around("execution(

* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)")

// @Around("com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)")

@Around("execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)")

public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{

System.out.println("around1==========before1pointcut==>"+str)

Object obj = prj.proceed();

System.out.println("around1==========after1pointcut==>"+str);

}

5.4.3.@Before

注解@Before在执行目标对象的方法前追加相应的功能

1 定义一个pointcut，经过方法名来做为pointcut的名称来引用

(1).@Before("com.javakc.spring.schemaaop.TestPointcut.t1()")

(2).@Before("com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)")

注意args后的名称与参数名相同

2.直接引用匿名的pointcut

(1).@Before("execution(* com.javakc.spring.schemaaop.Api.test1())")

(2).@Before("execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)")

注意args后的名称与参数名相同

// @Before("com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)")

@Before("execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)")

public void testBeforeParam(String str){

System.out.println("before1=param=>"+str);

}

5.4.4.@After

注解@After在执行目标对象的方法后追加相应的功能

1 定义一个pointcut，经过方法名来做为pointcut的名称来引用

(1).@After("com.javakc.spring.schemaaop.TestPointcut.t1()")

2.直接引用匿名的pointcut

(1).@After("execution(* com.javakc.spring.schemaaop.Api.test1())")

@After("com.javakc.spring.schemaaop.TestPointcut.t1()")

public void testAfter(){

System.out.println("after1== >pointcut");

}

5.4.5.@AfterThorwing

九、描述一下spring中BeanFactory和ApplicationContext的差异

BeanFactory是一个Interface,这是Spring的核心。它仅仅只是提供的一些基本功能。ApplicaionContext 也是一个interface,这是从BeanFactory继承过来的因此它具有了BeanFactory的全部功能。但它也从其它的类或interface获得了一些特性。好比提供国际化的消息访问，资源访问，事件传播。

但其主要区别在于BeanFactory是延迟加载,若是Bean的某一个属性没有注入，BeanFactory加载后，直至第一次使用getBean方法调用此Bean时才会抛出异常；而ApplicationContext则在初始化自身时检验，这样有利于检查所依赖属性是否注入；因此一般状况下咱们选择使用ApplicationContext.

代码示例：

BeanFactory beanFactory = new XmlBeanFactory(new FileSystemResource("beans.xml"));

ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");

十、谈谈spring对DAO的支持

Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不一样的数据访问技术。

简化 DAO 组件的开发。 Spring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。

IoC 容器的使用，提供了 DAO 组件与业务逻辑组件之间的解耦。全部的 DAO 组件，都由容器负责注入到业务逻辑组件中，其业务组件无须关心 DAO 组件的实现。

面向接口编程及 DAO 模式的使用，提升了系统组件之间的解耦，下降了系统重构的成本。

方便的事务管理: Spring的声明式事务管理力度是方法级。

异常包装:Spring可以包装JDBC异常，把它们从CheckedException变为RuntimeException; 开发者可选择在恰当的层处理数据中不可恢复的异常，从而避免烦琐的 catch/throw 及异常声明。

十一、谈谈spring对hibernate的支持

在全部的 ORM 框架中， Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操做及 DAO 支持等。另外， Spring 还提供了统一的异常体系及声明式事务管理等。

一旦 Hibernate 处于 Spring 的管理下， Hibernate 所须要的基础资源，都由 Spring 提供注入。 Hibernate 建立 SessionFactory 必需的 DataSource ，执行持久化必需的 Session 及持久层访问必需的事务控制等，这些本来必须经过代码控制的逻辑，都将由Spring 接管:DataSource, SessionFactory, TransactionManager等，都将做为 Spring 容器中的 bean。将这些bean 放在配置文件中管理。

一、通用的资源管理: Spring 的 ApplicationContext 能管理 SessionFactory，使得配置值很容易被管理和修改，无须使用Hibernate 的配置文件。详细配置以下：

<bean id="myDataSource"

class="org.apache.commons.dbcp.BasicDataSource">

<value>oracle.jdbc.driver.OracleDriver</value>

</property>

<value>jdbc:oracle:thin:@localhost:1521:orcl</value>

</property>

<value>javakc2</value>

</property>

<value>javakc2</value>

</property>

</bean>

<bean id="mySessionFactory"

class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

<list>

<value>com/javakc/spring/h3/UserModel.hbm.xml</value>

</list>

</property>

<value>

hibernate.dialect=org.hibernate.dialect.OracleDialect

</value>

</property>

</bean>

</bean>

若是须要使用容器管理的数据源，则无须提供数据驱动等信息，只须要提供数据源的JNDI 便可。对上文的SessionFactory只需将dataSource的配置替换成 JNDI 数据源，并将原有的 myDataSource Bean 替换成以下所示:

<bean id="myDataSource"

class="org.springframework.jndi.JndiObjectFactoryBean">

</property>

</bean>

二、有效的 Session 管理: Dao类继承HibernateDaoSurport后，Spring 提供了 HibernateTemplate，用于持久层访问，该模板类无须显示打开 Session及关闭 Session。它只要得到 SessionFactory 的引用，将能够智能打开 Session，并在持久化访问结束后关闭 Session ，程序开发只需完成持久层逻辑，通用的操做则由HibernateTemplate 完成。

三、统一的事务管理。不管是编程式事务，仍是声明式事务， Spring 都提供一致的编程模型，无须烦琐的开始事务、显式提交及回滚。

建议使用声明式事务管理，Spring 的声明式事务以 Spring 的 AOP 为基础。可将事务管理逻辑与代码分离。代码中无须实现任何事务逻辑，程序开发者能够更专一于业务逻辑的实现。声明式事务不与任何事务策略藕合，采用声明式事务能够方便地在全局事务和局部事务之间切换。

Spring声明性事务有两种配置方法，一种是xml配置：

</bean>

<tx:advice id="txAdvice" transaction-manager="txManager">

<tx:attributes>

<tx:method name="*" propagation="REQUIRED" />

</tx:attributes>

</tx:advice>

<aop:config proxy-target-class="true">

<aop:pointcut id="test" expression="execution(* com.javakc.spring.h3.JdbcTest.*(..))" />

<aop:advisor advice-ref="txAdvice" pointcut-ref="test"/>

</aop:config>

另外一种是经过注解，在须要添加事务的类上注明 @Transactional

Spring2.0以前事务的写法

<bean id="txProxyTemplate"

class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"

abstract="true">

<props>

<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>

<prop key="*">PROPAGATION_REQUIRED</prop>

</props>

</property>

</bean>

十二、谈谈Spring对事务的支持

一、声明式事务管理：

1.流程：由客户端访问----aop监控----调用advice来追加事务

2.作法：

2.1 在配置文件的头中引入xmlns：tx 和schema的文件

2.2 <aop:aspectj-autoproxy/>

2.3 注入数据源

</bean>

2.4 由spring实现的事务管理，但须要注入数据源

</bean>

2.5 事务监控全部的方法（事务增强）

<tx:advice id="txAdvice" transaction-manager="txManager">

<tx:attributes>

<tx:method name="create*" propagation=”REQUIREDNEW”/>

</tx:attributes>

</tx:advice>

2.6 定义切入点

<aop:config>

<aop:pointcut id="my"

expression="execution(* com.javakc.spring.schemaaop.api.*.*(..))"/>

<aop:advisor advice-ref="txAdvice" pointcut-ref="my"/>

</aop:config>

二、使用注解实现事务管理：

1.注解@Transcational

（能够在类上，也能够在方法上）

2.在配置文件中一样须要注入dataSource和spring的事务管理

3.使用注解的方法来追加事务注解驱动

<tx:annotation-driven transaction-manager="txManager"/>

如何在Spring中使用Hibernate的事务：

</bean>

如何在Spring中使用JTA的事务：

1三、

事务

一、 ACID

（1）原子性（A）：一系列的操做具备不可分割性，要么成功，要么失败

（2）一致性：操做的先后知足一样的规则，保持平衡。

（3）隔离性：在事务运行的过程当中。事务内的数据对外的可见性和可操做性（必需由数据库的支持）

（4）稳定性：保证数据在事务的操做的过程当中不会遭到破坏，并且是永久性存储的

二、事务模型

（1）经典事务模型又叫平面事务模型（JDBC）事务不容许嵌套

（2）嵌套事务模型

三、事务的两种方式

（1）声明式

在配置文件中设置如下6项

（１）.required

若是客户端没有事务　在bean中新起一个事务

若是客户端有事务bean 中就加进去

(2)、 requiresNew

无论客户端有没有事务服务器段都新起一个事务

若是客户端有事务就将事务挂起

(3)、supports

若是客户端没有事务服务端也没有事务

若是客户端有事务服务端就加一个事务

(4)、mandatcry

若是客户端没有事务服务端就会报错

若是客户端有事务服务端就加事务

(5)、notSupported

无论客户端有没有事务服务端都没有事务

若是客户端有事务服务端就挂起

(6)、never

无论客户端有没有事务服务端都没有事务

若是客户端有事务就报错

（2）编程式事务

Javax.transaction.UserTranscation

JTA 事务能够精确到事务的开始和结束

四、事务的隔离性

Read-uncommited

读取未提交的数据（基本上没有锁）脏读，存在不当读取的问题。

Read-commited

读取已提交的数据（行级锁）

没法读取已经写入，但没有被提交的数据。

Repeatable_read

读取的数据不容许修改或删除

不可重复读（行级锁+不容许修改/删除）

Serializable

幻影读（表级锁）

struts

开发流程

一、建立表单

二、从表单中得到输入

三、处理输入（业务逻辑）

四、根据动态输入改变输入流

要完成上述四步，咱们须要建立

一、一个ActionForm

二、一个action

三、一个配置文件struts-config.xml

四、建立页面

建立ActionForm

一、写一个类继承ActionForm

二、私有的属性

三、相应的get、set方法

四、重写tostring、equals、hashcode三个方法

建立action

一、写一个类继承Action

二、实现一个公有的方法（回调方法）

public ActionForward execute(ActionMapping mapping,

ActionForm form,

HttpServletRequest request,

HttpServletResponse response)

{

//1.收集参数

MyActionForm myForm = (MyActionForm)form;

//2.组织参数

//3.调用逻辑层

boolean flag = true;

//4.根据返回值来跳转到相应的页面

ActionForward af = new ActionForward();

if(flag){

af = mapping.findForward("1");

}else{

af = mapping.findForward("2");

}

return af;

}

配置struts-config.xml文件

1.<form-beans>

<form-bean name="myActionForm" type="全路径.MyActionForm"/>

<form-bean />

</form-beans>

2.<action-mappings>

<action path="/sll"

name="myActionForm"

type="全路径.MyAction"

scope="session"

input="错误返回的页面">

</action>

</action-mappings>

步骤:

1.建立一个空的web应用

2.将struts的包放到lib文件夹下

3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下

4.配置struts-config.xml文件和web.xml文件

5.在页面引入tag文件uri

STRUTS运行机制

一、界面点击产生请求

二、容器接到请求

三、匹配web.xml文件中的*.do来调用ActionServlet

四、ActionServlet的处理

4.1 读struts-congfig.xml文件造成ActionMapping

4.2 经过path 来匹配Action类，经过Action的name属性来匹配ActionForm类

4.3 经过反射机制来给Form添数据

4.4 由ActionServlet转调Action的execute方法

4.5 获得execute方法的返回值，跳转页面

4.5.1 RequestDispatcher

4.5.2 response.sendRedirect("list.jsp");

进入execute方法

1 收集参数

2 组织参数

3 调用，逻辑层

4 返回值

4.1 选择下一个页面（ActionForward）

4.2 把值传给下一个页面

比较struts和struts2的不一样

	Struts	Struts2
组成	五个部分：ActionServlet，ActionMapping，AtcionForward，ActionForm，Action	十个部分：AcionContext，FilterDispatcher，ActionMapper，ActionProxy，Configuration Manager，Action Invocation，Intercepter，Action，Result，Taglib
Action类	Action扩展一个抽象基类 Struts1的一个共有的问题是面向抽象类编程，而不是面向接口编程。	Struts 2的Action类实现了一个Action接口，连同其余接口一块儿来实现可选择和自定义的服务。Struts 2提供一个名叫ActionSupport的基类来实现通常使用的接口。
Servlet依赖	Struts 1的Action类依赖于servlet API觉得HttpServletRequest和HttpServletResponse做为参数传递给execute方法。	Struts 2的Action和容器无关。Servlet上下文表现为简单的Maps，容许Action被独立的测试。Struts 2的Action也能够独立访问请求和响应
url	.do	.action
分发控制	AtcionServlet	FilterDispatcher
收集参数	利用JavaBean技术，将数据封装到ActionForm的子类中；一个Action对应一个ActionForm的子类	使用拦截器将数据封装到值栈中。使用域模型，一个Action对应多个值栈中的Model
读取配置文件	ActionMapping	Configuration Manager
拦截器	无拦截器	执行Action先后有拦截器
返回页面	将字符串封装到AtcionForward，进行跳转页面	Action中直接返回字符串，经过Result跳转页面
页面跳转方式	两种：dispatch，redirect	多种：dispatch，redirect，chain
标签	struts1的标签和JSTL的表达式语言一块儿使用${}	Struts2的标签和OGNL的表达式语言一块儿使用
值栈	无值栈，Action经过在request范围内设置属性，向jsp页面传递数据	有值栈，Action和jsp页面经过值栈传递数据，jsp页面经过OGNL取得值栈中的数据
验证	在action中写validate方法验证	在action中写validate方法验证，也能够使用验证框架验证
配置文件	struts-config.xml	struts.xml
中文问题	不能解决（须要使用filter）	能够解决中文问题

UML

一、是什么？

一种标准的图形化的建模语言

二、能干什么？

三、有什么？

1.视图

1.一、用例视图

1.二、逻辑视图

1.三、并发视图

1.四、组件视图

1.五、展开视图（部署视图）

2.图

2.一、用例图：指用户、系统、用例之间的关系

2.二、类图：表示系统中的类和类之间的关系

2.三、对象图：表示类的实例图

2.四、状态图：用来描述对象的状态和引发状态变化的事件

2.五、时序图：按着时间的顺序描述对象之间的交互关系

2.六、协做图：按照空间的顺序描述对象之间的协做（调用）的关系

2.七、组件图：描述组件及其组件之间的关系

2.八、展开图：描述系统中软、硬件的物理架构（软件在硬件上的分布）

2.九、活动图：描述活动的流程（流程图）

3.模型元素：

类之间的五种关系：

关联：类A与类B之间存在特定的对应关系。

依赖：类A访问类B提供的服务。

汇集：类A为总体类，类B为局部类，类A的对象由类B的对象组合而成。

泛化：类A继承类B。

实现：类A实现B接口。

汇集是关联的一种特殊形式。

4.通用机制

5.扩展机制

用例视图--------------------------用例图------------------------------需求分析

逻辑视图（静态）-------------------类图----------------------------详细设计

-------------------------活动图--------------------------需求分析

并发视图（动态）-------------------对象图-------------------------详细设计

-------------------状态图-------------------------详细设计

-------------------时序图-------------------------详细设计

-------------------协做图-------------------------详细设计

组件视图 -----------------------------组件图--------------------------概要设计

展开视图---------------------------- --展开图--------------------------概要设计（雏形）

------------------------详细设计

---------------------------测试

用例：

用例：表明系统的一个完整的功能
系统：在这里并非指一个完整的系统，是一部分功能的集合
角色：指与系统交互的人或事

思惟方式：

角度：站在系统的角度来看角色（用户）、再站在用户的角度来看系统
度：对于任何事情都要把握度
分层：

消息：

1、简单消息：

同步消息（调用）：在调用过程当中必定要等待返回
异步消息（调用）：在调用过程当中不须要等待返回，能够处理其余的事情

2、状态图的要素

状态
转移
转移的条件

3、活动图的要素

活动
条件
变迁（转移）

4、泳道：活动图的一种，是按照必定的规则来划分

如：按部门、阶段等；

在项目设计阶段，画uml图经常使用的工具备rose，together，MyEclipse的uml插件

其余开发工具和技术

Ant

Ant是基于java的批处理（打包、部署）工具

1、配置ant的运行环境

1.将ant的bin目录添加到path中

2.配置JAVA_HOME

3.配置ANT_HOME

2、配制build.xml文件，该文件放在应用程序的根目录下

编译java文件

执行java文件

copy

删除

打jar包

根据注解生成配置文件

Xdoclet

经过注释生成一系列文件的工具（txt、xml、java、html等）

xdoclet本质是摸板技术+字符串的替换

1.在java文件中写符合要求的注释（将hbm.xml文件的内容搬到java文件中去写）

1.1 在类的上面写与表的对应

1.2 将每个属性的注释都写到get方法的上面

2.在ant中引入相应的task来驱动xdoclet

log4j日志管理

一、是什么？

在开发期间用来测试、对整个日志信息进行管理的工具

二、功能

1.控制输出的目的地

2. 控制输出的格式

3. 控制输出的级别

三、日志的级别

1. debug 调试

2. info 给用户的提示信息

3. warn 给用户的警告信息

4.error 给程序员用来调试

Debug----〉info----〉warn--------〉error

四、配置

1.配置级别

2.输入源（控制台和文件）

3.能够进行分包控制

Log4f.logger.包结构 = 级别

五、使用

Logger log=Logger.getLogger(Test.class);

public void t3(){

log.debug("this is debug");

log.info("this is info");

log.warn("this is warn ");

log.error("this is error");

}

Junit

1.是什么？

单元测试的框架

2.怎么作？

写一个类继承TestCase

测试的方法通常都以test开头而且没有参数

在测试方法前执行的方法public void setUp( )

在测试方法后执行的方法public void tearDown( )

error和故障的区别

error ：代码有问题

故障：逻辑有问题与祈望的值不相符合

生命周期

测试---〉SetUp（）---〉testXX（）---〉tearDown（）---〉结束；

TestCase套件

public class MyTest{

Public static Test suite(){

TestSuite suite = new TestSuite();

suite.addTestCase(Test1.class);

suite.addTestCase(Test2.class);

}

Ajax

一、是什么？

AJAX即“Asynchronous JavaScript and XML”（异步JavaScript和XML)。是一种建立交互式网页应用的网页开发技术。

无刷新页面。

二、有什么？

AJAX是多种技术的综合，包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。

三、能干什么？

使用XHTML+CSS标准化呈现；
使用DOM进行动态显示及交互；
使用 XML 和 XSLT 进行数据交换及相关操做；
使用 XMLHttpRequest 进行异步数据查询、检索；
使用JavaScript绑定和处理有所得数据；

传统的web应用容许用户填写表单(form)，当提交表单时就向web服务器发送一个请求。服务器接收并处理传来的表单，然後返回一个新的网页。这个作法浪费了许多带宽，由于在前後两个页面中的大部分HTML代码每每是相同的。因为每次应用的交互都须要向服务器发送请求，应用的响应时间就依赖于服务器的响应时间。这致使了用户界面的响应比本地应用慢得多。
    与此不一样，AJAX应用能够仅向服务器发送并取回必需的数据，它使用SOAP或其它一些基于XML的web service接口，并在客户端采用JavaScript处理来自服务器的响应。由于在服务器和浏览器之间交换的数据大量减小，结果咱们就能看到响应更快的应用。同时不少的处理工做能够在发出请求的客户端机器上完成，因此Web服务器的处理时间也减小了。
    使用Ajax的最大优势，就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动做，并避免了在网络上发送那些没有改变过的信息。
    对应用Ajax最主要的批评就是：
    1 它破坏了浏览器后退按钮的正常行为，就是用户点击后退按钮后不能看到以前的数据；
    2 一些手持设备（如手机、PDA等）如今还不能很好的支持Ajax；
    3 用JavaScript做的Ajax引擎，JavaScript的兼容性和DeBug都是让人头痛的事；
    4 Ajax的无刷新重载，因为页面的变化没有刷新重载那么明显，因此容易给用户带来困扰――用户不太清楚如今的数据是新的仍是已经更新过的；现有的解决有：在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;

四、怎么作？

var req;

function add(){

//1:建立用于传输的对象

req=new ActiveXObject("Microsoft.XMLHTTP");

// 声明返回后，处理数据的方法

req.onreadystatechange=manage;

//2:准备传输的内容

var str="test1111";

//3:发出请求

req.open("GET" ,"/others/ajax/test/t2.jsp?str="+str);

req.send(null);

}

//4:接受返回并处理

function manage(){

if(req.readyState==4){

alert("r=="+req.responseText);

}

</script>

readyState的取值以下：

　　0 (未初始化)

　　1 (正在装载)

　　2 (装载完毕)

　　3 (交互中)

　　4 (完成)

五、原理

Ajax的原理简单来讲经过XmlHttpRequest对象来向服务器发异步请求，从服务器得到数据，能够是xml格式，也能够是一个字符串，而后用javascript来操做DOM而更新页面。

Dwr

一、是什么？

DWR（Direct Web Remoting）是一个开源的类库，能够帮助开发人员开发包含AJAX技术的页面。它能够容许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法同样。

二、有什么？

它包含两个主要的部分：容许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据；另一方面提供了一个JavaScript库能够帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。

三、能干什么？

动态地把java类生成为JavaScript，感受调用就像发生在浏览器端，实际上代码调用发生在服务器端，Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种很是像RMI或者SOAP的常规RPC机制。

四、怎么作？

① 编写配置文件

web.xml

<servlet-name>dwr-invoker</servlet-name>

<servlet-class>

org.directwebremoting.servlet.DwrServlet

</servlet-class>

<init-param>

<param-name>debug</param-name>

<param-value>true</param-value>

</init-param>

</servlet>

<servlet-mapping>

<servlet-name>dwr-invoker</servlet-name>

<url-pattern>/dwr/*</url-pattern>

</servlet-mapping>

dwr.xml

<allow>

</create>

</allow>

②编写service

public class Service {

public String sayHello(String yourName) {

//能够是访问数据库的复杂代码

return "Hello World " + yourName;

}

③测试DWR

将代码放入应用服务器（好比Tomcat），启动。

而后在地址栏输入http://localhost:8080/你的工程/dwr

④编写jsp页面

1）要引用3个dwr的js，其中engine.js必需要，若是须要用到dwr提供的一些方便的工具要引用util.js

2）而后还要引用dwr自动生成的js，dwr/interface/service.js，注意js名字要和dwr.xml配置的同样

3） js里的service.sayHello和java类的那个有一点区别，多了一个参数，用来获得返回的数据

SQL与Oracle

1、 SQL分类：
DDL—数据定义语言(CREATE，ALTER，DROP，DECLARE) 用于创建，修改，删除数据库中的各类对象-----表、视图

DQL—数据查询语言（SELECT）用于检索数据库

基本结构是由SELECT子句，FROM子句，WHERE子句组成的查询块：

SELECT <字段名表>

FROM <表或视图名>

WHERE <查询条件>

GROUP BY <分组字段>

HAVING<分组后的筛选条件>

ORDER BY字段名表>

DML—数据操纵语言(DELETE，UPDATE，INSERT)用于改变数据库数据

主要有三种形式：

插入：INSERT

更新：UPDATE

删除：DELETE

DCL—数据(事务)控制语言(GRANT，REVOKE，COMMIT，ROLLBACK) 用于维护数据的一致性

包含五条语句：

提交COMMIT;

回滚ROLLBACK;

标记SAVEPOINT

受权GRANT

撤回REVOKE：。

2、基本语法

一、建立数据库
create database database-name

二、删除数据库
drop database dbname

四、建立新表
create table tabname(
          col1 type1 [not null] [primary key],
          col2 type2 [not null],
          ..
)

根据已有的表建立新表：
A：create table tab_new like tab_old (使用旧表建立新表)(在orcale中不能用)
B：create table tab_new as select col1,col2… from tab_old where 1=2

五、删除新表

drop table tabname
六、增长一个列
Alter table tabname add column col type
注：列增长后将不能删除。DB2中列加上后数据类型也不能改变，惟一能改变的

是增长varchar类型的长度。
七、添加主键

Alter table tabname add primary key(col)

Alter table tabname add primary key(col1,col2)

七、建立索引

create [unique] index idxname on tabname(col….)
删除索引

drop index idxname
注：索引是不可更改的，想更改必须删除从新建。

八、建立视图

create view viewname as select statement

删除视图：

drop view viewname

九、几个简单的基本的sql语句

选择：select * from table1 where 范围

插入：insert into table1(field1,field2) values(value1,value2)

Insert into table1 values(‘001’,’sll’)

删除：delete from table1 where 范围
更新：update table1 set field1=value1 where 范围
查找：select * from table1 where field1 like ’%value1%’

表示模糊查询（匹配字符串）
排序：select * from table1 order by field1,field2 [desc]
总数：select count（*） as totalcount from table1
求和：select sum(field1) as sumvalue from table1
平均：select avg(field1) as avgvalue from table1
最大：select max(field1) as maxvalue from table1
最小：select min(field1) as minvalue from table1

十、使用外链接
  A、left join：
  左外链接（左链接）：结果集几包括链接表的匹配行，也包括左链接表的全部行。
  sql: select a.a, a.b, a.c, b.c, b.d, b.f from a LEFT JOIN b ON a.a

=b.c
B：right join:
右外链接(右链接)：结果集既包括链接表的匹配链接行，也包括右链接表的全部行。
C：full join：
全外链接：不只包括符号链接表的匹配行，还包括两个链接表中的全部记录。

D：等值链接

E：无条件链接，取两个表的笛卡尔积

十一、 in 的使用方法

select * from table1 where a [not] in (‘值1’,’值2’,’值4’,’值6’)

十二、两张关联表，删除主表中已经在副表中没有的信息
delete from table1 where not exists ( select * from table2

Where table1.field1=table2.field1 )

1三、日程安排提早五分钟提醒
sql: select * from 日程安排 where datediff('minute',f开始

时间,getdate())>5
1五、一条sql 语句搞定数据库分页

asc 按升序排列

desc 按降序排列
方法一（两层查询）：

select uuid, userid, username
from (select rownum r, uuid, userid, username from tbl_sysuser)
where r >= 2
and r < 4
方法二（三层查询）：

SELECT *
  FROM (SELECT A.*, ROWNUM RN
          FROM (SELECT * FROM tbl_sysuser where 1=1 ) A
         WHERE ROWNUM < 4)
WHERE RN >= 2

1六、前10条记录

select uuid, userid, username
from (select rownum r, uuid, userid, username from tbl_sysuser)
where r >= 1
and r < 11

或

select * from tbl_sysuser where rownum <= 10

1七、说明：选择从10到15的记录
select uuid, userid, username
from (select rownum r, uuid, userid, username from tbl_sysuser)
where r >= 10
and r <= 15

一些示例、

员工工资表

Tbl_s

id	sallary	pid
100	8300	100
200	9000	200
101	9500	100
201	9100	200
202	8355	100
102	8600	200

查询员工的工资大于所属部门的部门经理的工资的员工信息

参考答案：

select * from tbl_s t where pid in (select pid from tbl_s where id = pid) and sallary > (select sallary from tbl_s where id=t.pid)

查询亲属的数量大于1的员工的姓名

select t1.name (select count(*) from tbl_r t2 where t1.id=t2.id) 亲属数量 from

tbl_emp t1 Where (select count(*) from tbl_r t2 where t1.id=t2.id)>1

1 使用SQL语句创建员工信息数据表：员工编号（PK）、员工姓名、员工性别、联系电话、备注。员工亲属信息表：员工编码（PK）、亲属编码（PK）、亲属姓名、联系电话、备注。

2使用SQL语句在员工信息表备注前增长住址字段
Alter table tbl_employee add address varchar2(50);

3.建立两个表

Create table tbl_employee (

Uuid varchar2(20) not null primary key,

Name varchar2(20),

Sex varchar2(2),

Tel varchar2(20),

Descripton varchar2(100)

)

Create table tbl_relation(

Empid varchar2(20) not null,

Uuid varchar2(20) not null,

Name varchar2(20),

Tel varchar2(20)

Description varchar2(100),

Primary key (empid,uuid) 双主键

)

4.使用SQL向员工信息表中插入一条数据：（001，张三，男，010-62570007，北京市海淀区）

　Insert into tbl_employee values(‘001’，’张三’，’男’，’010-62570007’，’北京市海淀区’)

5. 使用SQL变动001员工地址为：北京市朝阳区。
update tbl_employee set address=’chaoyanqu’ where id=’001’

6. 因为两张表之间没有创建外键引用，致使亲属信息表中存在垃圾数据，这部分数据的特色是员工编码在员工信息表中不存在，请用SQL语句将这部分数据查询出来

Select * from tbl_relation where empid not in(select uuid from tbl_employee)

7. 为防止再次出现垃圾数据状况，使用SQL语句在亲属表和员工表之间创建外键约束

ALTER TABLE "JAVAKCOA"."TBL_REL"

ADD (CONSTRAINT "SF" FOREIGN KEY("empid")

REFERENCES "JAVAKCOA"."tbl_emp"("uuid"))

8. 用SQL查询出亲属数量大于1的员工编码、员工姓名，员工亲属数量
select t1.uuid,t1.name (select count(*) from tbl_relation t2 where t2.empid=t1.uuid) ‘亲属数量’ from tbl_employee t1 where (select count(*) from tbl_relation t2 where t2.empid=t1.uuid)>1

9. 有部分员工的亲属信息录入重复，例如父亲信息录入两次，这类信息的特征是亲属名称相同，可是亲属编码不一样，请用SQL语句将这类状况的员工编码、重复的亲属编码，亲属姓名查询出来

Select t1.empid,t1.uuid,t1.name from tbl_relation t1 where (select count(*) from tbl_relation t2 where t2.empid = t1.uuid and t2.name = t1.name )>1

1）有两个表：

TableX有两个字段Code和Name，其中Code为主键，已有记录以下：

Code	Name
Zhang	张三
Zhao	赵四
Li	李五

TableY有三个字段Code、Class、Score，其中Code＋Class为主键，已有记录以下：

Code	Class	Score
Zhang	C1	80
Zhang	C2	90
Li	C1	85

请写SQL：

a）取出学生个数

b）取出各个学生的Code及Score合计

c）取出没有考试成绩的学生Code及Name

d）在两个表做等值联接的状况下，取出Name、Class、Score，请写出SQL语句及输出结果；

e）在以TableX为主，两个表做外联接的状况下，取出Name、Class、Score，请写出SQL语句及输出结果；

f）在以TableY为主，两个表做外联接的状况下，取出Name、Class、Score，请写出SQL语句及输出结果；

A,Select count(*) from tableX

B.select x.code,sum(score) from tableX x ,tableY y where x.code = y.code

select code,sum(score) '总成绩' from tbl_y group by code

C.select * from tableX where code not in(select code from tableY)

select code,name from tbl_x where code not in(select code from tbl_y)

D. select tbl_x.code,tbl_x.name,tbl_y.score from tbl_x,tbl_y where tbl_x.code =tbl_y.code

用别名：select x.code,x.name,y.score from tbl_x as x,tbl_y as y where x.code =y.code

E. select * from tbl_employee t1 left outer join tbl_emprelation t2 on t1.id=t2.empid

面试中遇到的技术问题：

一、 get()和load()的区别？

二、 Set和ArrayList的区别?

三、为何.NET用SQLSEVREL数据库的多，而ORACLE用的少？

四、平时都数据库作哪些操做，好比优化方面？

五、客户端用什么工具操做数据库？

六、当你和你的上级为解决一个问题发生不一样观点的时候你是服务呢仍是坚持呢

七、用的什么版本控制软件，发生过冲突没有，怎么处理这种状况？怎么避免这种状况呢？

八、谈谈你最近开发的项目，你作了哪一个模块，用到什么技术，有什么技术上的困题？

九、

面试中遇到的非技术问题：

一、你工做中碰到本身解决不了的问题怎么办？

二、若是项目经理给你的任务你在尽最大努力的状况下也不能完成怎么办？

三、为何离职？

四、谈谈你的性格？

五、你的性格是外向仍是内向？工做之余平时都做些什么？

谈一谈Jsp中页面跳转的两种方式

参考文章：

数据库索引

索引

数据库索引比如是一本书前面的目录，能加快数据库的查询速度。

　　例如这样一个查询：select * from table1 where id=44。若是没有索引，必须遍历整个表，直到ID等于44的这一行被找到为止；有了索引以后(必须是在ID这一列上创建的索引)，直接在索引里面找44（也就是在ID这一列找），就能够得知这一行的位置，也就是找到了这一行。可见，索引是用来定位的。

　　索引分为聚簇索引和非聚簇索引两种，聚簇索引是按照数据存放的物理位置为顺序的，而非聚簇索引就不同了；聚簇索引能提升多行检索的速度，而非聚簇索引对于单行的检索很快。

索引的优缺点

概述

　　创建索引的目的是加快对表中记录的查找或排序。

　　为表设置索引要付出代价的：一是增长了数据库的存储空间，二是在插入和修改数据时要花费较多的时间(由于索引也要随之变更)。

详述

　　建立索引能够大大提升系统的性能。第一，经过建立惟一性索引，能够保证数据库表中每一行数据的惟一性。第二，能够大大加快数据的检索速度，这也是建立索引的最主要的缘由。第三，能够加速表和表之间的链接，特别是在实现数据的参考完整性方面特别有意义。第四，在使用分组和排序子句进行数据检索时，一样能够显著减小查询中分组和排序的时间。第五，经过使用索引，能够在查询的过程当中，使用优化隐藏器，提升系统的性能。

　　也许会有人要问：增长索引有如此多的优势，为何不对表中的每个列建立一个索引呢？由于，增长索引也有许多不利的方面。第一，建立索引和维护索引要耗费时间，这种时间随着数据量的增长而增长。第二，索引须要占物理空间，除了数据表占数据空间以外，每个索引还要占必定的物理空间，若是要创建聚簇索引，那么须要的空间就会更大。第三，当对表中的数据进行增长、删除和修改的时候，索引也要动态的维护，这样就下降了数据的维护速度。

　　索引是创建在数据库表中的某些列的上面。在建立索引的时候，应该考虑在哪些列上能够建立索引，在哪些列上不能建立索引。通常来讲，应该在这些列上建立索引：在常常须要搜索的列上，能够加快搜索的速度；在做为主键的列上，强制该列的惟一性和组织表中数据的排列结构；在常常用在链接的列上，这些列主要是一些外键，能够加快链接的速度；在常常须要根据范围进行搜索的列上建立索引，由于索引已经排序，其指定的范围是连续的；在常常须要排序的列上建立索引，由于索引已经排序，这样查询能够利用索引的排序，加快排序查询时间；在常用在WHERE子句中的列上面建立索引，加快条件的判断速度。

　　一样，对于有些列不该该建立索引。通常来讲，不该该建立索引的的这些列具备下列特色：第一，对于那些在查询中不多使用或者参考的列不该该建立索引。这是由于，既然这些列不多使用到，所以有索引或者无索引，并不能提升查询速度。相反，因为增长了索引，反而下降了系统的维护速度和增大了空间需求。第二，对于那些只有不多数据值的列也不该该增长索引。这是由于，因为这些列的取值不多，例如人事表的性别列，在查询的结果中，结果集的数据行占了表中数据行的很大比例，即须要在表中搜索的数据行的比例很大。增长索引，并不能明显加快检索速度。第三，对于那些定义为text, image和bit数据类型的列不该该增长索引。这是由于，这些列的数据量要么至关大，要么取值不多。第四，当修改性能远远大于检索性能时，不该该建立索引。这是由于，修改性能和检索性能是互相矛盾的。当增长索引时，会提升检索性能，可是会下降修改性能。当减小索引时，会提升修改性能，下降检索性能。所以，当修改性能远远大于检索性能时，不该该建立索引。

索引列

能够基于数据库表中的单列或多列建立索引。多列索引能够区分其中一列可能有相同值的行。

　　若是常常同时搜索两列或多列或按两列或多列排序时，索引也颇有帮助。例如，若是常常在同一查询中为姓和名两列设置判据，那么在这两列上建立多列索引将颇有意义。

　　肯定索引的有效性：

　　检查查询的WHERE和JOIN子句。在任一子句中包括的每一列都是索引能够选择的对象。

　　对新索引进行试验以检查它对运行查询性能的影响。

　　考虑已在表上建立的索引数量。最好避免在单个表上有不少索引。

　　检查已在表上建立的索引的定义。最好避免包含共享列的重叠索引。

　　检查某列中惟一数据值的数量，并将该数量与表中的行数进行比较。比较的结果就是该列的可选择性，这有助于肯定该列是否适合创建索引，若是适合，肯定索引的类型。

类型

根据数据库的功能，能够在数据库设计器中建立三种索引：惟一索引、主键索引和汇集索引。

　　提示：尽管惟一索引有助于定位信息，但为得到最佳性能结果，建议改用主键或惟一约束。

　　惟一索引惟一索引是不容许其中任何两行具备相同索引值的索引。

　　当现有数据中存在重复的键值时，大多数数据库不容许将新建立的惟一索引与表一块儿保存。数据库还可能防止添加将在表中建立重复键值的新数据。例如，若是在employee表中职员的姓(lname)上建立了惟一索引，则任何两个员工都不能同姓。

　　主键索引

　　数据库表常常有一列或列组合，其值惟一标识表中的每一行。该列称为表的主键。

　　在数据库关系图中为表定义主键将自动建立主键索引，主键索引是惟一索引的特定类型。该索引要求主键中的每一个值都惟一。当在查询中使用主键索引时，它还容许对数据的快速访问。

　　汇集索引

　　在汇集索引中，表中行的物理顺序与键值的逻辑（索引）顺序相同。一个表只能包含一个汇集索引。

　　若是某索引不是汇集索引，则表中行的物理顺序与键值的逻辑顺序不匹配。与非汇集索引相比，汇集索引一般提供更快的数据访问速度。

转：http://www.cnblogs.com/whyhappy/p/5279802.html