java必備基礎知識點

時間 2019-11-17

標籤 java 必備基礎知識欄目 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子句。在任一子句中包括的每一列都是索引能夠選擇的對象。

　　對新索引進行試驗以檢查它對運行查詢性能的影響。

　　考慮已在表上建立的索引數量。最好避免在單個表上有不少索引。

　　檢查已在表上建立的索引的定義。最好避免包含共享列的重疊索引。

　　檢查某列中惟一數據值的數量，並將該數量與表中的行數進行比較。比較的結果就是該列的可選擇性，這有助於肯定該列是否適合創建索引，若是適合，肯定索引的類型。

類型

根據數據庫的功能，能夠在數據庫設計器中建立三種索引：惟一索引、主鍵索引和彙集索引。

　　提示：儘管惟一索引有助於定位信息，但爲得到最佳性能結果，建議改用主鍵或惟一約束。