Argol

ServletResponse接口只提供了兩個流可供選擇：ServletOutputStream用于輸出字節，PrintWriter用于輸出字符數據。

PrintWriter
用于把文本數據打印到一個字符流。盡管也可以把字符數據寫至OutputStream，但PrintWriter流專門設計用于處理字符數據。

OutputStream

用于其他的任何內容。

PrintWriter實際上“包裝“ 了ServletOutputStream。也就是說，PrintWriter有ServletOutputStream的一個引用，而且會把調用委托給ServletOutputStream。

     摘要: Keycode對照表：字母和數字鍵的鍵碼值(keyCode)按鍵鍵碼按鍵鍵碼按鍵鍵碼按鍵鍵碼A65J74S83149B66K75T84250C67L76U85351D68M77V86452E69N78W87553F70O79X88654G71P80Y89755H72Q81Z90856I73R82048957　　 數字鍵盤上的鍵的鍵碼值(keyCode)功能鍵鍵碼值(keyCode)按鍵鍵...  閱讀全文

基礎數據類型直接在棧空間分配。

方法的形式參數，直接在棧空間分配，當方法調用完成后從棧空間回收。

引用數據類型，需要用new來創建，既在棧空間分配一個地址空間，又在堆空間分配對象的類變量。

方法的引用參數，在棧空間分配一個地址空間，并指向堆空間的對象區，當方法調用完成后從棧空間回收。

局部變量 new 出來時，在棧空間和堆空間中分配空間，當局部變量生命周期結束后，棧空間立刻被回收，堆空間區域等待GC回收。

方法調用時傳入的 literal 參數，先在棧空間分配，在方法調用完成后從棧空間分配。

字符串常量在 DATA 區域分配。

this 在堆空間分配。

數組既在棧空間分配數組名稱， 又在堆空間分配數組實際的大小。

棧與堆都是Java用來在RAM中存放數據的地方。與C++不同，Java自動管理棧和堆，程序員不能直接地設置棧或堆。 

Java的堆是一個運行時數據區,類的對象從中分配空間。這些對象通過new、newarray、anewarray和multianewarray等指令建立，它們不需要程序代碼來顯式的釋放。堆是由垃圾回收來負責的，堆的優勢是可以動態地分配內存大小，生存期也不必事先告訴編譯器，因為它是在運行時動態分配內存的，Java的垃圾收集器會自動收走這些不再使用的數據。但缺點是，由于要在運行時動態分配內存，存取速度較慢。 

棧的優勢是，存取速度比堆要快，僅次于寄存器，棧數據可以共享。但缺點是，存在棧中的數據大小與生存期必須是確定的，缺乏靈活性。棧中主要存放一些基本類型的變量（,int, short, long, byte, float, double, boolean, char）和對象句柄。 

棧有一個很重要的特殊性，就是存在棧中的數據可以共享。假設我們同時定義： 

int a = 3; 

int b = 3； 

編譯器先處理int a = 3；首先它會在棧中創建一個變量為a的引用，然后查找棧中是否有3這個值，如果沒找到，就將3存放進來，然后將a指向3。接著處理int b = 3；在創建完b的引用變量后，因為在棧中已經有3這個值，便將b直接指向3。這樣，就出現了a與b同時均指向3的情況。 

這時，如果再令a=4；那么編譯器會重新搜索棧中是否有4值，如果沒有，則將4存放進來，并令a指向4；如果已經有了，則直接將a指向這個地址。因此a值的改變不會影響到b的值。 

要注意這種數據的共享與兩個對象的引用同時指向一個對象的這種共享是不同的，因為這種情況a的修改并不會影響到b, 它是由編譯器完成的，它有利于節省空間。而一個對象引用變量修改了這個對象的內部狀態，會影響到另一個對象引用變量。 

String是一個特殊的包裝類數據。可以用： 

String str = new String("abc"); 

String str = "abc";

 兩種的形式來創建，第一種是用new()來新建對象的，它會在存放于堆中。每調用一次就會創建一個新的對象。 

而第二種是先在棧中創建一個對String類的對象引用變量str，然后查找棧中有沒有存放"abc"，如果沒有，則將"abc"存放進棧，并令str指向”abc”，如果已經有”abc” 則直接令str指向“abc”。 

比較類里面的數值是否相等時，用equals()方法；當測試兩個包裝類的引用是否指向同一個對象時，用==，下面用例子說明上面的理論。 

String str1 = "abc"; 

String str2 = "abc"; 

System.out.println(str1==str2); //true 

可以看出str1和str2是指向同一個對象的。 

String str1 =new String ("abc"); 

String str2 =new String ("abc"); 

System.out.println(str1==str2); // false 

用new的方式是生成不同的對象。每一次生成一個。 

因此用第一種方式創建多個”abc”字符串,在內存中其實只存在一個對象而已. 這種寫法有利與節省內存空間. 同時它可以在一定程度上提高程序的運行速度，因為JVM會自動根據棧中數據的實際情況來決定是否有必要創建新對象。而對于String str = new String("abc")；的代碼，則一概在堆中創建新對象，而不管其字符串值是否相等，是否有必要創建新對象，從而加重了程序的負擔。 

另一方面, 要注意: 我們在使用諸如String str = "abc"；的格式定義類時，總是想當然地認為，創建了String類的對象str。擔心陷阱！對象可能并沒有被創建！而可能只是指向一個先前已經創建的對象。只有通過new()方法才能保證每次都創建一個新的對象。 

由于String類的immutable性質，當String變量需要經常變換其值時，應該考慮使用StringBuffer類，以提高程序效率。

 

在閱讀本文之前，如果你連堆棧是什么多不知道的話，請先閱讀文章后面的基礎知識。 

接觸過編程的人都知道，高級語言都能通過變量名來訪問內存中的數據。那么這些變量在內存中是如何存放的呢？程序又是如何使用這些變量的呢？下面就會對此進行深入的討論。下文中的C語言代碼如沒有特別聲明，默認都使用VC編譯的release版。 

首先，來了解一下 C 語言的變量是如何在內存分部的。C 語言有全局變量(Global)、本地變量(Local)，靜態變量(Static)、寄存器變量(Regeister)。每種變量都有不同的分配方式。先來看下面這段代碼： 

#include <stdio.h> 

int g1=0, g2=0, g3=0; 

int main() 
{ 
static int s1=0, s2=0, s3=0; 
int v1=0, v2=0, v3=0; 

//打印出各個變量的內存地址 

printf("0x%08x\n",&v1); //打印各本地變量的內存地址 
printf("0x%08x\n",&v2); 
printf("0x%08x\n\n",&v3); 
printf("0x%08x\n",&g1); //打印各全局變量的內存地址 
printf("0x%08x\n",&g2); 
printf("0x%08x\n\n",&g3); 
printf("0x%08x\n",&s1); //打印各靜態變量的內存地址 
printf("0x%08x\n",&s2); 
printf("0x%08x\n\n",&s3); 
return 0; 
} 

編譯后的執行結果是： 

0x0012ff78 
0x0012ff7c 
0x0012ff80 

0x004068d0 
0x004068d4 
0x004068d8 

0x004068dc 
0x004068e0 
0x004068e4 

輸出的結果就是變量的內存地址。其中v1,v2,v3是本地變量，g1,g2,g3是全局變量，s1,s2,s3是靜態變量。你可以看到這些變量在內存是連續分布的，但是本地變量和全局變量分配的內存地址差了十萬八千里，而全局變量和靜態變量分配的內存是連續的。這是因為本地變量和全局/靜態變量是分配在不同類型的內存區域中的結果。對于一個進程的內存空間而言，可以在邏輯上分成3個部份：代碼區，靜態數據區和動態數據區。動態數據區一般就是“堆棧”。“棧(stack)”和“堆(heap)”是兩種不同的動態數據區，棧是一種線性結構，堆是一種鏈式結構。進程的每個線程都有私有的“棧”，所以每個線程雖然代碼一樣，但本地變量的數據都是互不干擾。一個堆棧可以通過“基地址”和“棧頂”地址來描述。全局變量和靜態變量分配在靜態數據區，本地變量分配在動態數據區，即堆棧中。程序通過堆棧的基地址和偏移量來訪問本地變量。 

├———————┤低端內存區域 
│ …… │ 
├———————┤ 
│ 動態數據區 │ 
├———————┤ 
│ …… │ 
├———————┤ 
│ 代碼區 │ 
├———————┤ 
│ 靜態數據區 │ 
├———————┤ 
│ …… │ 
├———————┤高端內存區域 

堆棧是一個先進后出的數據結構，棧頂地址總是小于等于棧的基地址。我們可以先了解一下函數調用的過程，以便對堆棧在程序中的作用有更深入的了解。不同的語言有不同的函數調用規定，這些因素有參數的壓入規則和堆棧的平衡。windows API的調用規則和ANSI C的函數調用規則是不一樣的，前者由被調函數調整堆棧，后者由調用者調整堆棧。兩者通過“__stdcall”和“__cdecl”前綴區分。先看下面這段代碼： 

#include <stdio.h> 

void __stdcall func(int param1,int param2,int param3) 
{ 
int var1=param1; 
int var2=param2; 
int var3=param3; 
printf("0x%08x\n",¶m1); //打印出各個變量的內存地址 
printf("0x%08x\n",¶m2); 
printf("0x%08x\n\n",¶m3); 
printf("0x%08x\n",&var1); 
printf("0x%08x\n",&var2); 
printf("0x%08x\n\n",&var3); 
return; 
} 

int main() 
{ 
func(1,2,3); 
return 0; 
} 

編譯后的執行結果是： 

0x0012ff78 
0x0012ff7c 
0x0012ff80 

0x0012ff68 
0x0012ff6c 
0x0012ff70 

├———————┤<—函數執行時的棧頂（ESP）、低端內存區域 
│ …… │ 
├———————┤ 
│ var 1 │ 
├———————┤ 
│ var 2 │ 
├———————┤ 
│ var 3 │ 
├———————┤ 
│ RET │ 
├———————┤<—“__cdecl”函數返回后的棧頂（ESP） 
│ parameter 1 │ 
├———————┤ 
│ parameter 2 │ 
├———————┤ 
│ parameter 3 │ 
├———————┤<—“__stdcall”函數返回后的棧頂（ESP） 
│ …… │ 
├———————┤<—棧底（基地址 EBP）、高端內存區域 

上圖就是函數調用過程中堆棧的樣子了。首先，三個參數以從又到左的次序壓入堆棧，先壓“param3”，再壓“param2”，最后壓入“param1”；然后壓入函數的返回地址(RET)，接著跳轉到函數地址接著執行（這里要補充一點，介紹UNIX下的緩沖溢出原理的文章中都提到在壓入RET后，繼續壓入當前EBP，然后用當前ESP代替EBP。然而，有一篇介紹windows下函數調用的文章中說，在windows下的函數調用也有這一步驟，但根據我的實際調試，并未發現這一步，這還可以從param3和var1之間只有4字節的間隙這點看出來）；第三步，將棧頂(ESP)減去一個數，為本地變量分配內存空間，上例中是減去12字節(ESP=ESP-3*4，每個int變量占用4個字節)；接著就初始化本地變量的內存空間。由于“__stdcall”調用由被調函數調整堆棧，所以在函數返回前要恢復堆棧，先回收本地變量占用的內存(ESP=ESP+3*4)，然后取出返回地址，填入EIP寄存器，回收先前壓入參數占用的內存(ESP=ESP+3*4)，繼續執行調用者的代碼。參見下列匯編代碼： 

;--------------func 函數的匯編代碼------------------- 

:00401000 83EC0C sub esp, 0000000C //創建本地變量的內存空間 
:00401003 8B442410 mov eax, dword ptr [esp+10] 
:00401007 8B4C2414 mov ecx, dword ptr [esp+14] 
:0040100B 8B542418 mov edx, dword ptr [esp+18] 
:0040100F 89442400 mov dword ptr [esp], eax 
:00401013 8D442410 lea eax, dword ptr [esp+10] 
:00401017 894C2404 mov dword ptr [esp+04], ecx 

……………………（省略若干代碼） 

:00401075 83C43C add esp, 0000003C ;恢復堆棧，回收本地變量的內存空間 
:00401078 C3 ret 000C ;函數返回，恢復參數占用的內存空間 
;如果是“__cdecl”的話，這里是“ret”，堆棧將由調用者恢復 

;-------------------函數結束------------------------- 

;--------------主程序調用func函數的代碼-------------- 

:00401080 6A03 push 00000003 //壓入參數param3 
:00401082 6A02 push 00000002 //壓入參數param2 
:00401084 6A01 push 00000001 //壓入參數param1 
:00401086 E875FFFFFF call 00401000 //調用func函數 
;如果是“__cdecl”的話，將在這里恢復堆棧，“add esp, 0000000C” 

聰明的讀者看到這里，差不多就明白緩沖溢出的原理了。先來看下面的代碼： 

#include <stdio.h> 
#include <string.h> 

void __stdcall func() 
{ 
char lpBuff[8]="\0"; 
strcat(lpBuff,"AAAAAAAAAAA"); 
return; 
} 

int main() 
{ 
func(); 
return 0; 
} 

編譯后執行一下回怎么樣？哈，“"0x00414141"指令引用的"0x00000000"內存。該內存不能為"read"。”，“非法操作”嘍！"41"就是"A"的16進制的ASCII碼了，那明顯就是strcat這句出的問題了。"lpBuff"的大小只有8字節，算進結尾的\0，那strcat最多只能寫入7個"A"，但程序實際寫入了11個"A"外加1個\0。再來看看上面那幅圖，多出來的4個字節正好覆蓋了RET的所在的內存空間，導致函數返回到一個錯誤的內存地址，執行了錯誤的指令。如果能精心構造這個字符串，使它分成三部分，前一部份僅僅是填充的無意義數據以達到溢出的目的，接著是一個覆蓋RET的數據，緊接著是一段shellcode，那只要著個RET地址能指向這段shellcode的第一個指令，那函數返回時就能執行shellcode了。但是軟件的不同版本和不同的運行環境都可能影響這段shellcode在內存中的位置，那么要構造這個RET是十分困難的。一般都在RET和shellcode之間填充大量的NOP指令，使得exploit有更強的通用性。 

├———————┤<—低端內存區域 
│ …… │ 
├———————┤<—由exploit填入數據的開始 
│ │ 
│ buffer │<—填入無用的數據 
│ │ 
├———————┤ 
│ RET │<—指向shellcode，或NOP指令的范圍 
├———————┤ 
│ NOP │ 
│ …… │<—填入的NOP指令，是RET可指向的范圍 
│ NOP │ 
├———————┤ 
│ │ 
│ shellcode │ 
│ │ 
├———————┤<—由exploit填入數據的結束 
│ …… │ 
├———————┤<—高端內存區域 

windows下的動態數據除了可存放在棧中，還可以存放在堆中。了解C++的朋友都知道，C++可以使用new關鍵字來動態分配內存。來看下面的C++代碼： 

#include <stdio.h> 
#include <iostream.h> 
#include <windows.h> 

void func() 
{ 
char *buffer=new char[128]; 
char bufflocal[128]; 
static char buffstatic[128]; 
printf("0x%08x\n",buffer); //打印堆中變量的內存地址 
printf("0x%08x\n",bufflocal); //打印本地變量的內存地址 
printf("0x%08x\n",buffstatic); //打印靜態變量的內存地址 
} 

void main() 
{ 
func(); 
return; 
} 

程序執行結果為： 

0x004107d0 
0x0012ff04 
0x004068c0 

可以發現用new關鍵字分配的內存即不在棧中，也不在靜態數據區。VC編譯器是通過windows下的“堆(heap)”來實現new關鍵字的內存動態分配。在講“堆”之前，先來了解一下和“堆”有關的幾個API函數： 

HeapAlloc 在堆中申請內存空間 
HeapCreate 創建一個新的堆對象 
HeapDestroy 銷毀一個堆對象 
HeapFree 釋放申請的內存 
HeapWalk 枚舉堆對象的所有內存塊 
GetProcessHeap 取得進程的默認堆對象 
GetProcessHeaps 取得進程所有的堆對象 
LocalAlloc 
GlobalAlloc 

當進程初始化時，系統會自動為進程創建一個默認堆，這個堆默認所占內存的大小為1M。堆對象由系統進行管理，它在內存中以鏈式結構存在。通過下面的代碼可以通過堆動態申請內存空間： 

HANDLE hHeap=GetProcessHeap(); 
char *buff=HeapAlloc(hHeap,0,8); 

其中hHeap是堆對象的句柄，buff是指向申請的內存空間的地址。那這個hHeap究竟是什么呢？它的值有什么意義嗎？看看下面這段代碼吧： 

#pragma comment(linker,"/entry:main") //定義程序的入口 
#include <windows.h> 

_CRTIMP int (__cdecl *printf)(const char *, ...); //定義STL函數printf 
/*--------------------------------------------------------------------------- 
寫到這里，我們順便來復習一下前面所講的知識： 
(*注)printf函數是C語言的標準函數庫中函數，VC的標準函數庫由msvcrt.dll模塊實現。 
由函數定義可見，printf的參數個數是可變的，函數內部無法預先知道調用者壓入的參數個數，函數只能通過分析第一個參數字符串的格式來獲得壓入參數的信息，由于這里參數的個數是動態的，所以必須由調用者來平衡堆棧，這里便使用了__cdecl調用規則。BTW，Windows系統的API函數基本上是__stdcall調用形式，只有一個API例外，那就是wsprintf，它使用__cdecl調用規則，同printf函數一樣，這是由于它的參數個數是可變的緣故。 
---------------------------------------------------------------------------*/ 
void main() 
{ 
HANDLE hHeap=GetProcessHeap(); 
char *buff=HeapAlloc(hHeap,0,0x10); 
char *buff2=HeapAlloc(hHeap,0,0x10); 
HMODULE hMsvcrt=LoadLibrary("msvcrt.dll"); 
printf=(void *)GetProcAddress(hMsvcrt,"printf"); 
printf("0x%08x\n",hHeap); 
printf("0x%08x\n",buff); 
printf("0x%08x\n\n",buff2); 
} 

執行結果為： 

0x00130000 
0x00133100 
0x00133118 

hHeap的值怎么和那個buff的值那么接近呢？其實hHeap這個句柄就是指向HEAP首部的地址。在進程的用戶區存著一個叫PEB(進程環境塊)的結構，這個結構中存放著一些有關進程的重要信息，其中在PEB首地址偏移0x18處存放的ProcessHeap就是進程默認堆的地址，而偏移0x90處存放了指向進程所有堆的地址列表的指針。windows有很多API都使用進程的默認堆來存放動態數據，如windows 2000下的所有ANSI版本的函數都是在默認堆中申請內存來轉換ANSI字符串到Unicode字符串的。對一個堆的訪問是順序進行的，同一時刻只能有一個線程訪問堆中的數據，當多個線程同時有訪問要求時，只能排隊等待，這樣便造成程序執行效率下降。 

最后來說說內存中的數據對齊。所位數據對齊，是指數據所在的內存地址必須是該數據長度的整數倍，DWORD數據的內存起始地址能被4除盡，WORD數據的內存起始地址能被2除盡，x86 CPU能直接訪問對齊的數據，當他試圖訪問一個未對齊的數據時，會在內部進行一系列的調整，這些調整對于程序來說是透明的，但是會降低運行速度，所以編譯器在編譯程序時會盡量保證數據對齊。同樣一段代碼，我們來看看用VC、Dev-C++和lcc三個不同編譯器編譯出來的程序的執行結果： 

#include <stdio.h> 

int main() 
{ 
int a; 
char b; 
int c; 
printf("0x%08x\n",&a); 
printf("0x%08x\n",&b); 
printf("0x%08x\n",&c); 
return 0; 
} 

這是用VC編譯后的執行結果： 
0x0012ff7c 
0x0012ff7b 
0x0012ff80 
變量在內存中的順序：b(1字節)-a(4字節)-c(4字節)。 

這是用Dev-C++編譯后的執行結果： 
0x0022ff7c 
0x0022ff7b 
0x0022ff74 
變量在內存中的順序：c(4字節)-中間相隔3字節-b(占1字節)-a(4字節)。 

這是用lcc編譯后的執行結果： 
0x0012ff6c 
0x0012ff6b 
0x0012ff64 
變量在內存中的順序：同上。 

三個編譯器都做到了數據對齊，但是后兩個編譯器顯然沒VC“聰明”，讓一個char占了4字節，浪費內存哦。 

基礎知識： 
堆棧是一種簡單的數據結構，是一種只允許在其一端進行插入或刪除的線性表。允許插入或刪除操作的一端稱為棧頂，另一端稱為棧底，對堆棧的插入和刪除操作被稱為入棧和出棧。有一組CPU指令可以實現對進程的內存實現堆棧訪問。其中，POP指令實現出棧操作，PUSH指令實現入棧操作。CPU的ESP寄存器存放當前線程的棧頂指針，EBP寄存器中保存當前線程的棧底指針。CPU的EIP寄存器存放下一個CPU指令存放的內存地址，當CPU執行完當前的指令后，從EIP寄存器中讀取下一條指令的內存地址，然后繼續執行。 

堆和棧的區別
一、預備知識—程序的內存分配
一個由c/C++編譯的程序占用的內存分為以下幾個部分
1、棧區（stack）— 由編譯器自動分配釋放 ，存放函數的參數值，局部變量的值等。其操作方式類似于數據結構中的棧。
2、堆區（heap） — 一般由程序員分配釋放， 若程序員不釋放，程序結束時可能由OS回收 。注意它與數據結構中的堆是兩回事，分配方式倒是類似于鏈表，呵呵。
3、全局區（靜態區）（static）—，全局變量和靜態變量的存儲是放在一塊的，初始化的全局變量和靜態變量在一塊區域， 未初始化的全局變量和未初始化的靜態變量在相鄰的另一塊區域。 - 程序結束后有系統釋放 
4、文字常量區—常量字符串就是放在這里的。 程序結束后由系統釋放
5、程序代碼區—存放函數體的二進制代碼。
二、例子程序 
這是一個前輩寫的，非常詳細 
//main.cpp 
int a = 0; 全局初始化區 
char *p1; 全局未初始化區 
main() 
{ 
int b; 棧 
char s[] = "abc"; 棧 
char *p2; 棧 
char *p3 = "123456"; 123456"0在常量區，p3在棧上。 
static int c =0； 全局（靜態）初始化區 
p1 = (char *)malloc(10); 
p2 = (char *)malloc(20); 
分配得來得10和20字節的區域就在堆區。 
strcpy(p1, "123456"); 123456"0放在常量區，編譯器可能會將它與p3所指向的"123456"優化成一個地方。 
} 

二、堆和棧的理論知識 
2.1申請方式 
stack: 
由系統自動分配。 例如，聲明在函數中一個局部變量 int b; 系統自動在棧中為b開辟空間 
heap: 
需要程序員自己申請，并指明大小，在c中malloc函數 
如p1 = (char *)malloc(10); 
在C++中用new運算符 
如p2 = (char *)malloc(10); 
但是注意p1、p2本身是在棧中的。 

2.2 
申請后系統的響應 
棧：只要棧的剩余空間大于所申請空間，系統將為程序提供內存，否則將報異常提示棧溢出。 
堆：首先應該知道操作系統有一個記錄空閑內存地址的鏈表，當系統收到程序的申請時，會遍歷該鏈表，尋找第一個空間大于所申請空間的堆結點，然后將該結點從空閑結點鏈表中刪除，并將該結點的空間分配給程序，另外，對于大多數系統，會在這塊內存空間中的首地址處記錄本次分配的大小，這樣，代碼中的delete語句才能正確的釋放本內存空間。另外，由于找到的堆結點的大小不一定正好等于申請的大小，系統會自動的將多余的那部分重新放入空閑鏈表中。 

2.3申請大小的限制 
棧：在Windows下,棧是向低地址擴展的數據結構，是一塊連續的內存的區域。這句話的意思是棧頂的地址和棧的最大容量是系統預先規定好的，在WINDOWS下，棧的大小是2M（也有的說是1M，總之是一個編譯時就確定的常數），如果申請的空間超過棧的剩余空間時，將提示overflow。因此，能從棧獲得的空間較小。 
堆：堆是向高地址擴展的數據結構，是不連續的內存區域。這是由于系統是用鏈表來存儲的空閑內存地址的，自然是不連續的，而鏈表的遍歷方向是由低地址向高地址。堆的大小受限于計算機系統中有效的虛擬內存。由此可見，堆獲得的空間比較靈活，也比較大。 

2.4申請效率的比較： 
棧由系統自動分配，速度較快。但程序員是無法控制的。 
堆是由new分配的內存，一般速度比較慢，而且容易產生內存碎片,不過用起來最方便. 
另外，在WINDOWS下，最好的方式是用VirtualAlloc分配內存，他不是在堆，也不是在棧是直接在進程的地址空間中保留一快內存，雖然用起來最不方便。但是速度快，也最靈活。 

2.5堆和棧中的存儲內容 
棧： 在函數調用時，第一個進棧的是主函數中后的下一條指令（函數調用語句的下一條可執行語句）的地址，然后是函數的各個參數，在大多數的C編譯器中，參數是由右往左入棧的，然后是函數中的局部變量。注意靜態變量是不入棧的。 
當本次函數調用結束后，局部變量先出棧，然后是參數，最后棧頂指針指向最開始存的地址，也就是主函數中的下一條指令，程序由該點繼續運行。 
堆：一般是在堆的頭部用一個字節存放堆的大小。堆中的具體內容有程序員安排。 

2.6存取效率的比較 

char s1[] = "aaaaaaaaaaaaaaa"; 
char *s2 = "bbbbbbbbbbbbbbbbb"; 
aaaaaaaaaaa是在運行時刻賦值的； 
而bbbbbbbbbbb是在編譯時就確定的； 
但是，在以后的存取中，在棧上的數組比指針所指向的字符串(例如堆)快。 
比如： 
#include 
void main() 
{ 
char a = 1; 
char c[] = "1234567890"; 
char *p ="1234567890"; 
a = c[1]; 
a = p[1]; 
return; 
} 
對應的匯編代碼 
10: a = c[1]; 
00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh] 
0040106A 88 4D FC mov byte ptr [ebp-4],cl 
11: a = p[1]; 
0040106D 8B 55 EC mov edx,dword ptr [ebp-14h] 
00401070 8A 42 01 mov al,byte ptr [edx+1] 
00401073 88 45 FC mov byte ptr [ebp-4],al 
第一種在讀取時直接就把字符串中的元素讀到寄存器cl中，而第二種則要先把指針值讀到edx中，在根據edx讀取字符，顯然慢了。 

2.7小結： 
堆和棧的區別可以用如下的比喻來看出： 
使用棧就象我們去飯館里吃飯，只管點菜（發出申請）、付錢、和吃（使用），吃飽了就走，不必理會切菜、洗菜等準備工作和洗碗、刷鍋等掃尾工作，他的好處是快捷，但是自由度小。 
使用堆就象是自己動手做喜歡吃的菜肴，比較麻煩，但是比較符合自己的口味，而且自由度大。 

注冊算法：打開MYECLIPSE運行下面代碼，運行結果就是注冊碼

JSP是一種腳本語言，包裝了Java Servlet系統的界面，簡化了Java和Servlet的使用難度，同時通過擴展JSP標簽(TAG)提供了網頁動態執行的能力。盡管如此，JSP仍沒有超出Java和Servlet的范圍，不僅JSP頁面上可以直接寫Java代碼，而且JSP是先被譯成Servlet之后才實際運行的。JSP在服務器上執行，并將執行結果輸出到客戶端瀏覽器，我們可以說基本上與瀏覽器無關。它是與JavaScript不同的，JavaScript是在客戶端的腳本語言，在客戶端執行，與服務器無關。 

那么JSP是什么？就是Servlet. 

JSP與Servlet之間的主要差異在于，JSP提供了一套簡單的標簽，和HTML融合的比較好，可以使不了解Servlet的人可以做出動態網頁來。對于Java語言不熟悉的人(比如像我),會覺得JSP開發比較方便。JSP修改后可以立即看到結果，不需要手工編譯，JSP引擎會來做這些工作；而Servelt缺需要編譯，重新啟動Servlet引擎等一系列動作。但是在JSP中，HTML與程序代碼混雜在一起，而Servlet卻不是這樣。也許大家比較混亂了，那么Servlet又是什么？下面我們對JSP的運行來做一個簡單的介紹，告訴大家怎樣來執行一個JSP文件： 

當Web服務器(或Servlet引擎,應用服務器)支持JSP引擎時，JSP引擎會照著JSP的語法，將JSP文件轉換成Servlet代碼源文件，接著Servlet會被編譯成Java可執行字節碼(bytecode)，并以一般的Servlet方式載入執行。

JSP語法簡單，可以方便的嵌入HTML之中，很容易加入動態的部分，方便的輸出HTML。在Servlet中輸出HTML缺需要調用特定的方法，對于引號之類的字符也要做特殊的處理，加在復雜的HTML頁面中作為動態部分，比起JSP來說是比較困難的。 

除去了轉換和編譯階段，JSP和Servlet之間的區別實在是不大。 

JSP引擎通常架構在Servlet引擎之上，本身就是一個Servlet，把JSP文件轉譯成Servlet源代碼，再調用Java編譯器，編譯成Servlet。這也是JSP在第一次調用時速度比較慢的原因，在第一次編譯之后，JSP與Servlet速度相同.下面我們來看看為什么他們在第一次編譯后再編譯的速度相同： 

在整個運行過程中，JSP引擎會檢查編譯好的JSP(以Servlet形式存在)是否比原始的JSP文件還新，如果是，JSP引擎不會編譯;如果不是，表示JSP文件比較新，就會重新執行轉譯與編譯的過程。 

為了有個深刻的了解，我們看一下JSP的運行和開發環境: 
      瀏覽器：常見的瀏覽器有IE和Netscape兩種。 
      數據庫：常用的數據庫有Oracle,SQL Server,Informix,DB2,Sybase,Access,MySQL等。 
      操作系統：常見的有Windows,Linux,以及各種Unix系統。 
      Web服務器：常見的有IIS,Apache,Netscape Enterprise Server等。 

JSP引擎：一般JSP引擎都以Servlet引擎為基礎，并以Servlet的形式出現。同時，在各種免費和商業引擎的實現中，Servlet引擎和Jsp引擎通常也是一起出現，我們成為Servlet/JSP引擎，或從某種成為JSP引擎。 

引擎是可以提供JSP和Servlet運行支持并對其生存周期進行管理的系統級實體。 

在JSP頁面第一次被請求時，JSP引擎會將JSP原始文件轉換成Servlet源代碼，然后調用Java編譯器，編譯成Servlet,并在Servlet引擎中執行。當再次有請求的時候，JSP引擎會見差異編譯好的JSP是否比原來的JSP原始文件要新，如果是,運行Servlet；如果不是，表示文件已經更新的了，就會從新執行轉換和編譯的過程。