- PrintStream myout = new PrintStream(new FileOutputStream(new File("D:/log.log")));
- System.setOut(myout);
- System.setErr(myout);
posted @
2011-11-18 00:15 Java_liyadong 閱讀(251) |
評論 (0) |
編輯 收藏
摘要: 類與對象 【學習目標】本章主要介紹類類型的定義、構造函數與析構函數的定義與作用、友元函數與友元類的聲明與作用、派生類的定義與作用、虛函數和多態性的概念、靜態數據成員的聲明與定義、模板類的定義與實例化等內容。通過本章的學習，要求同學們：掌握類的概念，類類型的定義格式，類與結構的關系，類與操作符重載，類的成員屬性，類的封裝性，類的繼承性，構造函數和析構函數的作用，this指針的含義，類對象的...
閱讀全文
posted @
2011-10-09 22:03 Java_liyadong 閱讀(324) |
評論 (0) |
編輯 收藏
摘要: 1 類和結構類和結構可以看作是創建對象的模板。每個對象都包括數據，并提供處理和訪問數據的方法。類定義了每個對象（實例）包含什么樣的數據與功能1.1封裝“封裝”有時被稱為面向對象的編程的第一個支柱或原則。根據封裝的原則，類或結構可以指定其每個成員對于該類或結構外部的代碼的可訪問性。可將無意在類或程序集外部使用的方法和變量隱藏起來，以減小編碼錯誤或遭惡意利用的可能性。1.2&n...
閱讀全文
posted @
2011-10-09 21:58 Java_liyadong 閱讀(363) |
評論 (0) |
編輯 收藏1.變更的概念
變量就是系統為程序分配的一塊內存單元，用來存儲各種類型的數據。根據所存儲的數據類型的不同，有各種不同類型的變量。變量名代表這塊內存中的數據 。
2.java的變量類型
3.變量字節大小及有效取值范圍
byte占用一個字節，數字大小為-27—27-1
short占用兩個字節，數字大小為-215—215-1
int占用四個字節，數字大小為-231—231-1
long占用八個字節，數字大小為-263—263-1
float占用四個字節，數字大小為1.4E-45~3.4E+38 , -1.4E-45~-3.4E+38 。用二進制的指數形式表示一個浮點數的格式，如：101*22 , 101*2-3
double占用八個字節，數字大小為4.9E-324~1.7E+308, -4.9E-324~-1.7E+308 。
char占兩個字節，數字大小為0—216-1，是unicode編碼。字符的本來面目，我們為什么可以直接將一個數字賦給字符變量。
Boolean占一個字節，其取值只有兩個，true和false。
4.基本數據類型之間的轉換
自動類型轉換（也叫隱式類型轉換）
實現這種轉換要滿足兩個條件，第一是兩種類型彼此兼容，第二是目標類型的取值范圍大于源類型。如，當byte型向int型轉換時，由于int型取值范圍大于byte型，就會發生自動轉換。所有的數字類型，包括整型和浮點型彼此都可以進行這樣的轉換。如：
byte b=3;
int x=b;
強制類型轉換（也叫顯式類型轉換）
當兩種類型彼此不兼容，或目標類型取值范圍小于源類型時，自動轉換無法進行，這時就需要進行強制類型轉換。強制類型轉換的通用格式如下：
目標類型 變量＝（目標類型）值，如：
byte a;
int b;
a=(byte)b;
表達式的數據類型自動提升
所有的byte型、short型和char的值將被提升到int型。
如果一個操作數是long型，計算結果就是long型；
如果一個操作數是float型，計算結果就是float型；
如果一個操作數是double型，計算結果就是double型。
5.變量的作用域
變量要先定義，后使用，但也不是在變量定義后的語句一直都能使用前面定義的變量。我們可以用大括號將多個語句包起來形成一個復合語句，變量只能在定義它的復合語句中使用。
public class TestScope
{
public static void main(String[] args)
{
int x = 12;
{
int q = 96; // x和q都可用
int x = 3;//錯誤的定義，Java中不允許有這種嵌套定義
System.out.println("x is "+x);
System.out.println("q is "+q);
}
q = x;
System.out.println("x is "+x);
}
｝
6.局部變量的初始化
在一個函數或函數里而把代碼塊中定義的變量稱為局部變量，局部變量在函數或代碼塊被執行時創建，在函數或代碼塊結束時被銷毀。局部變量在進行取值操作前必須被初始化或進行過賦值操作，否則會出現編譯錯誤！
posted @
2011-10-09 21:38 Java_liyadong 閱讀(4119) |
評論 (0) |
編輯 收藏Java 的循環語句有for，while 和 do-while 。這些語句創造了我們通常所稱的循環（loops）。你可能知道，一個循環重復執行同一套指令直到一個結束條件出現。你將看到，Java 有
Java 的循環語句有for，while 和 do-while 。這些語句創造了我們通常所稱的循環（loops）。你可能知道，一個循環重復執行同一套指令直到一個結束條件出現。你將看到，Java 有適合任何編程所需要的循環結構。
5.2.1 while 語句
while 語句是Java 最基本的循環語句。當它的控制表達式是真時，while 語句重復執行一個語句或語句塊。它的通用格式如下：
while(condition) {
// body of loop
}
條件condition 可以是任何布爾表達式。只要條件表達式為真，循環體就被執行。當條件condition 為假時，程序控制就傳遞到循環后面緊跟的語句行。如果只有單個語句需要重復，大括號是不必要的。
下面的while 循環從10開始進行減計數，打印出10行“tick”。
// Demonstrate the while loop.
class While {
public static void main(String args[]) {
int n = 10;
while(n > 0) {
System.out.println("tick " + n);
n--;
}
}
}
當你運行這個程序，它將“tick”10次：
tick 10
tick 9
tick 8
tick 7
tick 6
tick 5
tick 4
tick 3
tick 2
tick 1
因為while 語句在循環一開始就計算條件表達式，若開始時條件為假，則循環體一次也不會執行。例如，下面的程序中，對println( ) 的調用從未被執行過：
int a = 10, b = 20;
while(a > b)
System.out.println("This will not be displayed");
while 循環（或Java 的其他任何循環）的循環體可以為空。這是因為一個空語句（null statement) （僅由一個分號組成的語句）在Java 的語法上是合法的。例如，下面的程序：
// The target of a loop can be empty.
class NoBody {
public static void main(String args[]) {
int i, j;
i = 100;
j = 200;
// find midpoint between i and j
while(++i < --j) ; // no body in this loop
System.out.println("Midpoint is " + i);
}
}
該程序找出變量i和變量j的中間點。它產生的輸出如下：
Midpoint is 150
該程序中的while 循環是這樣執行的。值i自增，而值j自減，然后比較這兩個值。如果新的值i仍比新的值j小，則進行循環。如果i等于或大于j，則循環停止。在退出循環前，i 將保存原始i和j的中間值（當然，這個程序只有在開始時i比j小的情況下才執行）。正如你看到的，這里不需要循環體。所有的行為都出現在條件表達式自身內部。在專業化的Java 代碼中，一些可以由控制表達式本身處理的短循環通常都沒有循環體。
5.2.2 do-while 循環
如你剛才所見，如果while 循環一開始條件表達式就是假的，那么循環體就根本不被執行。然而，有時需要在開始時條件表達式即使是假的情況下，while 循環至少也要執行一次。換句話說，有時你需要在一次循環結束后再測試中止表達式，而不是在循環開始時。幸運的是，Java 就提供了這樣的循環：do-while 循環。do-while 循環總是執行它的循環體至少一次，因為它的條件表達式在循環的結尾。它的通用格式如下：
do {
// body of loop
} while (condition);
do-while 循環總是先執行循環體，然后再計算條件表達式。如果表達式為真，則循環繼續。否則，循環結束。對所有的Java 循環都一樣，條件condition 必須是一個布爾表達式。下面是一個重寫的“tick”程序，用來演示do-while 循環。它的輸出與先前程序的輸出相同。
// Demonstrate the do-while loop.
class DoWhile {
public static void main(String args[]) {
int n = 10;
do {
System.out.println("tick " + n);
n--;
} while(n > 0);
}
}
該程序中的循環雖然在技術上是正確的，但可以像如下這樣編寫更為高效：
do {
System.out.println("tick " + n);
} while(--n > 0);
在本例中，表達式“-- n > 0 ”將n值的遞減與測試n是否為0組合在一個表達式中。它的執行過程是這樣的。首先，執行-- n 語句，將變量n遞減，然后返回n的新值。這個值再與0比較，如果比0大，則循環繼續。否則結束。
do-while 循環在你編制菜單選擇時尤為有用，因為通常都想讓菜單循環體至少執行一次。下面的程序是一個實現Java 選擇和重復語句的很簡單的幫助系統：
// Using a do-while to process a menu selection
class Menu {
public static void main(String args[])
throws java.io.IOException {
char choice;
do {
System.out.println("Help on:");
System.out.println(" 1. if");
System.out.println(" 2. switch");
System.out.println(" 3. while");
System.out.println(" 4. do-while");
System.out.println(" 5. for ");
System.out.println("Choose one:");
choice = (char) System.in.read();
} while( choice < '1' || choice > '5');
System.out.println(" ");
switch(choice) {
case '1':
System.out.println("The if: ");
System.out.println("if(condition) statement;");
System.out.println("else statement;");
break;
case '2':
System.out.println("The switch: ");
System.out.println("switch(expression) {");
System.out.println(" case constant:");
System.out.println(" statement sequence");
System.out.println(" break;");
System.out.println(" // ...");
System.out.println("}");
break;
case '3':
System.out.println("The while: ");
System.out.println("while(condition) statement;");
break;
case '4':
System.out.println("The do-while: ");
System.out.println("do {");
System.out.println(" statement;");
System.out.println("} while (condition);");
break;
case '5':
System.out.println("The for: ");
System.out.print("for(init; condition; iteration)");
System.out.println(" statement;");
break;
}
}
}
下面是這個程序執行的一個樣本輸出：
Help on:
1. if
2. switch
3. while
4. do-while
5. for
Choose one:
4
The do-while:
do {
statement;
} while (condition);
在程序中，do-while 循環用來驗證用戶是否輸入了有效的選擇。如果沒有，則要求用戶重新輸入。因為菜單至少要顯示一次，do-while 循環是完成此任務的合適語句。
關于此例的其他幾點：注意從鍵盤輸入字符通過調用System.in.read( ) 來讀入。這是一個Java 的控制臺輸入函數。盡管Java 的終端 I/O （輸入/輸出)方法將在第12章中詳細討論，在這里使用System.in.read ( ) 來讀入用戶的選擇。它從標準的輸入讀取字符（返回整數，因此將返回值choice 定義為字符型）。默認地，標準輸入是按行進入緩沖區的，因此在你輸入的任何字符被送到你的程序以前，必須按回車鍵。
Java 的終端輸入功能相當有限且不好使用。進一步說，大多數現實的Java 程序和applets （小應用程序）都具有圖形界面并且是基于窗口的。因此，這本書使用終端的輸入并不多。然而，它在本例中是有用的。另外一點:因為使用System.in.read ( ) ，程序必須指定throws java.io.IOException 子句。這行代碼對于處理輸入錯誤是必要的。這是Java 的異常處理的一部分，將在第10章討論。
5.2.3 for 循環
在第2章曾使用過一個for循環的簡單格式。你將看到，for循環是一個功能強大且形式靈活的結構。下面是for 循環的通用格式：
for(initialization; condition; iteration) {
// body
}
如只有一條語句需要重復，大括號就沒有必要。
for循環的執行過程如下。第一步，當循環啟動時，先執行其初始化部分。通常，這是設置循環控制變量值的一個表達式，作為控制循環的計數器。重要的是你要理解初始化表達式僅被執行一次。下一步，計算條件condition 的值。條件condition 必須是布爾表達式。它通常將循環控制變量與目標值相比較。如果這個表達式為真，則執行循環體；如果為假，則循環終止。再下一步執行循環體的反復部分。這部分通常是增加或減少循環控制變量的一個表達式。接下來重復循環，首先計算條件表達式的值，然后執行循環體，接著執行反復表達式。這個過程不斷重復直到控制表達式變為假。
下面是使用for 循環的“tick”程序：
// Demonstrate the for loop.
class ForTick {
public static void main(String args[]) {
int n;
for(n=10; n>0; n--)
System.out.println("tick " + n);
}
}
在for 循環中聲明循環控制變量
控制for循環的變量經常只是用于該循環，而不用在程序的其他地方。在這種情況下，可以在循環的初始化部分中聲明變量。例如，下面重寫了前面的程序，使變量 n 在for循環中被聲明為整型：
// Declare a loop control variable inside the for.
class ForTick {
public static void main(String args[]) {
// here, n is declared inside of the for loop
for(int n=10; n>0; n--)
System.out.printl
本篇文章來源于 黑基網-中國最大的網絡安全站點 原文鏈接：file:///C:/Documents%20and%20Settings/Administrator/桌面/網頁學習資料/java%20循環語句-知識-黑基網.htm
posted @
2011-10-09 21:37 Java_liyadong 閱讀(1057) |
評論 (0) |
編輯 收藏分支語句根據一定的條件，動態決定程序的流程方向，從程序的多個分支中選擇一個或幾個來執行。分支語句共有兩種：if語句和switeh語句。
1．if語句
if語句的基本語法是：
if{邏輯表達式}
語句1；
[else
語句2：
]
if語句中的else子句是可選的。if關鍵字之后的邏輯表達式必須得到一個邏輯值，不能像其他語言那樣以數值來代替。因為Java不提供數值與邏輯值之間的轉換。例如， C語言中的語句形式：
iF(x)
{…}
應該寫作：
int X=3;
if(x!=O)
{…}
if語句的含義是：當邏輯表達式結果為true時，執行語句1，然后繼續執行if后面的語句。當邏輯表達式為false時，如果有else子句，則執行語句2，否則跳過該if語句，繼續執行后面的語句。語句1和語句2既可以是單語句，也可以是語句塊。
posted @
2011-10-09 21:34 Java_liyadong 閱讀(416) |
評論 (0) |
編輯 收藏
同大多數的編程語言一樣，Java語言也包含了許多的運算符。如果大家學習過C或者C++，會發現下面介紹的各種Java的運算符都與之類似。
3.1.1 賦值運算符 =
這是任何編程語言的最基本的運算符，它用來給變量指定一個值。對于基本類型來說，賦值都便于理解，將新的值賦給變量并保存在變量中供使用。但對于對象類型來說，這里就有一點區別，特別需要提醒大家注意。
對象類型并不是把實際的值（這里是實例）賦給了對象類型的變量，而是賦給的一個參考指針。這樣，源對象類型的變量和新的這個變量實際上是指向的同一個實例，如果使用其中一個讓實例改變，那么相應的另一個所指向的實例也會改變。這里我們可以借用C里面的指針的概念來方便理解，但實際上Java是不具有指針的概念和定義的。
我們通過下面的例子可以進一步來理解這個概念。
import java.awt.Dimension;
class ReferenceTest {
Dimension a = new Dimension ( 5,10 );
System.out.println (“a.height = ” + a.height ) ;
Dimension b = a ;
b.height = 30 ;
System.out,println (“a.height = ” + a.height + “after change to b ”);
}
}
復制代碼
運行結果：
c:\java Project\Reference>;java ReferenceTest
a.height = 10
a. height = 30 afer change to b
另外，賦值運算符還可以和其他的運算符，聯合組成新的賦值符。如*=、/=、+=、-=等等，這于C或者C++類似。
3.1.2 比較運算符
比較運算符是用來對相同數據類型的變量進行大小或者是否相等、相同的比較，返回的是Boolean類型的值。因此也就大概分為兩類。
n >;、>;=、<、<=
這是比較變量的大小關系，與我們學過的任何編程語言相同，就不再介紹了。
n = = 、! =
這是比較變量是否相等或相同。這對于平常的比較基本類型的變量容易理解，只是我們要強調一下對對象類型的比較。與我們前面介紹的賦值運算符類似的是，它也是進行的對其參考指針的比較，而并不是比較兩個內容上的差別。我們可以借助下面的例子來理解。
import java.awt.Button
class CompareRefernce {
public static void main ( String [ ] args ) {
Button a = new Button ( “Exit”);
Button b = new Button ( “Exit”);
Button c = a;
System.out.println ( “Is refernce a = = b ? ” + ( a = = b) ) ;
System.out.println ( “Is refernce a = = c ? ” + ( a = = c) ) ;
}
}
復制代碼
運行結果：
Is refernce a = = b ? false
Is refernce a = = c ? true
3.1.3 instanceof運算符
這個是Java語言特殊的一個運算符，它是用來測試其對象是否屬于某類或其超類。但是這里需要提醒大家的是，如果你使用instanceof來比較不是一個繼承關系樹上的類，Java能夠編譯通過，但運行的時候會報錯。另外，你可以對null對象使用這個運算符，只是無論對于什么類測試的結果都是false。
3.1.4 算術運算符
加+、減-、乘*、除/和取模%運算，這與其他的編程語言類似，不再詳述。
3.1.5 自增++、自減--運算符
Java的自增和自減運算符，與C語言類似，同樣需要注意的是其放置的位置不同，可能的結果也不同。如果放置在變量的前面，表示先自增（減）再參與下步運算，而如果放置在后面則表示先參與運算再自增（減）。如下的例子說明了自增運算符的使用：
class IncDec{
public static void main ( String [ ] args ) {
int a = 1;
int b = 1;
int c;
int d;
c = ++b;
d = a++;
c++;
System.out.println ( “a = ” + a );
System.out.println ( “b = ” + b );
System.out.println ( “c = ” + c );
System.out.println ( “d = ” + d );
}
}
復制代碼
運行結果：
a = 2
b = 2
c = 3
d = 1
3.1.6 字符串連接運算符 +
Java語言與C語言類似，也使用+作為連接字符串的運算符，這實際是對String類重載了+運算符。
3.1.7 位運算符
包括位移運算和位邏輯運算，這也與C語言相似。
->; 位移運算
>;>;右移、<<左移、>;>;>;無符號右移。
->; 位邏輯運算
&與、|或、^異或、~非運算，這于其他的編程語言類似，不再詳述。
3.1.8 邏輯運算符
與&&、或||，這于其他的編程語言類似，不再詳述。只是需要提醒大家不要把它們和位邏輯運算符混淆，這也是初學者最容易犯的錯誤。
3.1.9 條件運算符 ？：
這與C語言完全相同，具體不再解釋。
3.1.10 類型轉換
我們在編寫程序的時候經常需要對變量的類型進行轉換，Java語言與其他的編程語言類似，也提供兩種類型轉換方式，即顯式轉換和隱式轉換。轉換的對象可分為兩類，一是基本類型，二是對象類型。
這里需要掌握這樣一個要點。對于基本類型來說，凡是大轉小（以類型的寬度考慮）需要使用顯式轉換，也就是需要在變量前面強制給出需要轉換成的類型。而對小轉大來說，系統會自行進行隱式轉換。
對于對象類型來說，也與之類似。凡是超類轉子類則需要使用顯式強制轉換，而子類轉超類系統可自行進行隱式轉換。另外還需要注意的一點是，對于不在一個繼承關系樹上的類要進行強制轉換，Java編譯可通過，但實際運行會出錯。
3.2 equals()方法
equals（）方法實際與= =運算符作用相同，也是用來比較相同類型的兩個變量是否相同或相等。只是有點區別的是，對于String類來說，它重載equals（）方法，使用它不是比較兩個參考指針的區別，而是實際對所指向的具體內容進行比較，這也滿足了平時我們對比較字符串的實際需求。當然，對其他類來說，你也可以重載equals（）方法，使其滿足你的實際需要，來比較兩個對象類型的變量。
3.3 優先級
與其他編程語言類似的，Java語言的運算符同樣涉及到優先級別的問題，書上130頁從高到低給出了所有運算符的優先級。建議大家，如果對某些運算符之間的優先級不是很清楚的時候，可以使用（）來改變它們的優先級關系。
3.4 方法的參數傳遞
最后，簡單討論一下方法的傳遞的問題。Java語言的參數傳遞類型主要可以分為兩種，值傳遞和引用傳遞。借助C語言的概念，我們知道，第一種就是把參數值直接復制成方法體的參數，這樣對方法體中的參數的改變不會影響到調用它的參數。而對于第二種，參數的引用（或者說是個指針）被傳遞給了方法體的參數，該引用用來訪問調用中指定的實際參數。這樣，對方法體參數的改變將會影響到調用方法體的參數。
由于沒有指針的概念，Java的參數傳遞相對比較簡單。對于一般的基本類型來說，都采用的是值傳遞；而對于對象類型則是使用的引用傳遞
posted @
2011-10-09 21:32 Java_liyadong 閱讀(227) |
評論 (0) |
編輯 收藏
Java語法總結 - 基本數據類型
Java不是純的面向對象的語言，不純的地方就是這些基本數據類型不是對象。當然初期Java的運行速度很慢，基本數據類型能在一定程度上改善性能。如果你想編寫純的面向對象的程序，用包裝器類是取代基本數據類型就可以了。
1、基本類型的存儲空間。byte--8位，short--16位，int--32位，long--64位，float--32位，double--64位。這六種數字類型都是有符號的。固定的存儲空間正是Java可移植性、跨平臺的原因之一！
2、基本類型的存在導致了Java OOP的不純粹性。因為基本類型不是對象，一切皆對象是個小小的謊言。這是出于執行效率的權衡。
3、使用公式-2的（位數-1）次冪到2的（位數-1）次冪-1確定整數類型的范圍（byte、short、int、long）。
4、char是16位Unicode字符或者說是16位無符號整數，范圍從0到65535。即便如此，可以強制轉換非法的數據，如：char c1 = (char) 10000; char c2 = (char) -200;。可以從二進制存儲的角度理解這點。
5、整數有八進制（以0開頭的整數）、十進制、十六進制（以0x或0X開頭的整數）表示。
6、char可以用單引號表示單個字符，如：'良'。也可以用unicode值'"ucafe'（四位十六進制數）。
7、布爾型boolean。布爾型只能是true或者false，并且測試它為真還是假。它不能進行任何其他的運算，或者轉化為其他類型。
正例：boolean b1 = 1 > 2; 反例：int seen = button.isVisible();
實踐：簡潔是美德，請不要這樣寫：if ( is == true && done == false ) ，只有新手才那么寫。
對于任何程序員 if ( whether && !done ) 都不難理解吧。所以去掉所有的==fasle 和 ==true。
8、默認的浮點類型是雙精度（double），要想要一個float必須在浮點數后面加F或者f。如：float pi = 3.14;是錯誤的。
9、默認的整數類型是int型，要想使用長整型可在后面加“l”或“L”，如：1000L。（小寫l容易被誤認為1，不推薦用）
10、float可以精確到7位有效數字，第8位的數字是第9位數字四舍五入上取得的；double可以精確到16位有效數字，第17位的數字是第18位數字四舍五入上取得的。蓋茨到底有多少錢？要用double表示，用float是裝不下的……
11、如果要求精確的答案，請不要使用float和double，因為它們是為了在廣域數值范圍上提供較為精確的快速近似運算而精心設計的。然而，它們沒有提供完全精確的結果。尤其是對貨幣計算尤為不適合，因為要讓一個float或double精確地表達0.1（或者10的任何）
12、BigInteger支持任意精度的整數。BigDecimal支持任意精度的定點數。
13、初始化無論怎么強調都不過分！Java為所有的成員變量提供了默認初始化：byte、short、 int、long--0 float--0.0f double--0.0 boolean--false char--'"u0000'，特別地對象類型的引用全被初始化為null。（注意！除了數組之外的局部變量是得不到這種優待的，需要你自己初始化。另外，默認初始化的值是你想要的嗎？所以最好明確地對變量進行初始化，一般是在構造函數中。）
14、基本類型之間的轉化。Java的類型檢查很嚴格，從低精度轉換到高精度是無須顯式轉換的，double d = 123;。但是反過來，進行窄化轉換，由高精度向低精度，或者一種類型到另一種類型，則必須使用強制類型轉化。Java提供了安全轉化機制，但是結果是否是期望的，你自己保證吧。
double d = 12.5;
float f = (int) d; //結果不是13，而是12！
浮點型轉化為整型時，不進行四舍五入，直接截斷小數點后面的數。
15、提升。各種基本數據類型進行混合運算，結果會是表達能力最強的那種。如：int和long運算，結果是long，整型和浮點型運算結果是浮點型。特殊的一點是：只要類型比int小（如char、byte、short），那么在運算之前，這些值會自動地轉換成int。例子：
byte b1 = 12;
byte b2 = b1 + 1; //在編譯時出錯了！因為b1+1已經是int型了！切記！
16、浮點類型的科學表示法。在數學中e代表自然對數（Math.E給出了double值），而在Java中e代表10的冪次。浮點型的數可以這樣表示float f = 1e-27f; 代表1乘以10的負27次冪。
posted @
2011-10-09 21:31 Java_liyadong 閱讀(225) |
評論 (0) |
編輯 收藏public class TestMethod {
public static void main(String[] args) {
m();
m2(2);
m3('3', 4);
m4(4, 6);
int i = m4(4, 6);
System.out.println(i);
}
public static void m() {
//return;
System.out.println("ok");
System.out.println("hello");
}
public static void m2(int i) {
if(i > 3)
return;
System.out.println(i);
}
public static void m3(int i, int j) {
System.out.println(i + j);
}
public static int m4(int i, int j) {
return i > j ? i : j;
}
}
posted @
2011-10-09 21:28 Java_liyadong 閱讀(213) |
評論 (0) |
編輯 收藏Java中的main()方法詳解
在Java中，main()方法是Java應用程序的入口方法，也就是說，程序在運行的時候，第一個執行的方法就是main()方法，這個方法和其他的方法有很大的不同，比如方法的名字必須是main，方法必須是public static void 類型的，方法必須接收一個字符串數組的參數等等。
在看Java中的main()方法之前，先看一個最簡單的Java應用程序HelloWorld，我將通過這個例子說明Java類中main()方法的奧秘，程序的代碼如下：
/**
* Java中的main()方法詳解
*/
public class HelloWorld {
public static void main(String args[]) {
System.out.println("Hello World!");
}
}
一、先說類：
HelloWorld 類中有main()方法，說明這是個java應用程序，通過JVM直接啟動運行的程序。
既然是類，java允許類不加public關鍵字約束，當然類的定義只能限制為public或者無限制關鍵字（默認的）。
二、再說main()方法
這個main()方法的聲明為：public static void main(String args[])。必須這么定義，這是Java的規范。
為什么要這么定義，和JVM的運行有關系。
當一個類中有main()方法，執行命令“java 類名”則會啟動虛擬機執行該類中的main方法。
由于JVM在運行這個Java應用程序的時候，首先會調用main方法，調用時不實例化這個類的對象，而是通過類名直接調用因此需要是限制為public static。
對于java中的main方法，jvm有限制，不能有返回值，因此返回值類型為void。
main方法中還有一個輸入參數，類型為String[]，這個也是java的規范，main()方法中必須有一個入參，類細必須String[]，至于字符串數組的名字，這個是可以自己設定的，根據習慣，這個字符串數組的名字一般和sun java規范范例中mian參數名保持一致，取名為args。
因此，main()方法定義必須是：“public static void main(String 字符串數組參數名[])”。
三、main()方法中可以throw Exception
因此main()方法中可以拋出異常，main()方法上也可以聲明拋出異常。
比如，下面這個寫法是正確的：
public class TestMain {
public static void main(String[] args) throws Exception {
System.out.println("哈哈哈哈哈");
throw new Exception("");
}
}
運行結果：
哈哈哈哈哈
Exception in thread "main" java.lang.Exception:
at maintest.TestMain.main(TestMain.java:11)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:585)
at com.intellij.rt.execution.application.AppMain.main(AppMain.java:90)
Process finished with exit code 1
四、main()方法中字符串參數數組作用
main()方法中字符串參數數組作用是接收命令行輸入參數的，命令行的參數之間用空格隔開。
下面給出一個例子，看看如何初始化和使用這個數組的。
/**
* 打印main方法中的輸入參數
*/ public class TestMain {
public static void main(String args[]){
System.out.println(
"打印main方法中的輸入參數！");
for(
int i=0;i<args.length;i++){
System.out.println(args[i]);
}
}
}
執行方法和運行結果
D:\Study\basetest\src>javac TestMain.java
D:\Study\basetest\src>java TestMain 1 2 3
打印main方法中的輸入參數！
1
2
3
五、給出HelloWorld的另外一個版本
/**
* 變態版的HelloWorld.呵呵
*/
public class HelloWorld2 {
static {
System.out.println("Hello Wordld!");
}
public static void main(String args[]){
System.exit(0);
}
}
這個main()方法執行的內容就一句"System.exit(0);" ，目的是讓程序正常結束。那“HelloWorld！”是從哪里打印的，秘密就是在static打印的，因為static代碼塊的內容會在main調用前調用。
總結:
main方法作為一個特殊的規范，與普通的方法有很大區別，限制很多，理解其原理需要學習JVM相關知識。是Java中學習中大障礙。這是我對main原理和使用的總結，歡迎各位在此討論。
posted @
2011-10-09 21:27 Java_liyadong 閱讀(207) |
評論 (0) |
編輯 收藏- Java語言使用國際字符集（Unicode）。Unicode字符集定義了一套國際標準字符集。通常的ASCII碼是8位的，而Unicode字符集中的每個字符占16位，即2個字節，整個字符集共包括65336個字符，兼容ASCII，排在Unicode字符集最前面的256個字符就是ASCII碼。Unicode除了可以表示256個ASCII碼外，還可以表示漢字、拉丁語、希臘字母、朝鮮語等。
Java語言規定標識符是以字母、下劃線"_"或美元符號"$"開始，隨后可跟數字、字母、下劃線或美元符號的字符序列。
Java標識符大小寫敏感，沒有長度限制，可以為標識符取任意長度的名字，但關鍵字不能作為標識符。
n為增強程序可讀性，Java作如下的約定：
n類、接口：通常使用名詞，且每個單詞的首字母要大寫
n方法：通常使用動詞，首字母小寫，其后用大寫字母分隔每個單詞
n常量：全部大寫，單詞之間用下劃線分隔
n
變量：通常使用名詞，首字母小寫，其后大寫字母分隔每個單詞，避免使用$符號。 nJava中的關鍵字：
nabstract boolean break byte case catch char class continue default do double else extends final finally float for if implements import instanceof int interface long native new null package private protected public return short static super switch synchronized this throw throws transient try void volatile while
n
ntrue和false不是關鍵字，類似地，對象值null也沒有列入關鍵字。但是不能把它們派作其它用途。
n還有些關鍵字，如cast、future、goto、generic、inner、operator、outer、rest、var等都是Java保留的沒有意義的關鍵字。
總結：
- 1. 只能以字母,下劃線(_)或美元符($)開頭,數字不能作為開頭
- 2. 不能包含美元符($)以外的特殊符號
- 3. 不能包含空格
- 4. 可以是中文字符或日文字符
posted @
2011-10-09 21:25 Java_liyadong 閱讀(3290) |
評論 (0) |
編輯 收藏
摘要: java內存分配棧、堆、常量池雖同屬Java內存分配時操作的區域，但其適用范圍和功用卻大不相同。本文將深入Java核心，詳細講解Java內存分配方面的知識。Java內存分配與管理是Java的核心技術之一，之前我們曾介紹過Java的內存管理與內存泄露以及Java垃圾回收方面的知識，今天我們再次深入Java核心，詳細介紹一下Java在內存分配方面的知識。一般Java在內存分配時會涉及到以下區域： ...
閱讀全文
posted @
2011-10-09 21:23 Java_liyadong 閱讀(145) |
評論 (0) |
編輯 收藏這是我在網上找到的資料，本來我以為我知道他們的區別，認為主要是當前的請求變量是否繼續有效，但看了這個，了解了請求的作用范圍，才完全明白其中的原因，希望對大家有用。
不要僅僅為了把變量傳到下一個頁面而使用session作用域，那會無故增大變量的作用域，轉發也許可以幫助你解決這個問題。
重定向：以前的request中存放的變量全部失效，并進入一個新的request作用域。
轉發：以前的request中存放的變量不會失效，就像把兩個頁面拼到了一起。
正文開始：
先是看上去不同，他們的調用分別如下：
request.getRequestDispatcher("apage.jsp").forward(request, response);//轉發到apage.jsp
response.sendRedirect("apage.jsp");//重定向到apage.jsp
在jsp頁面中你也會看到通過下面的方式實現轉發：
<jsp:forward page="apage.jsp" />
提到轉發和重定向就不得不提到request作用域。很多初學者都知道當我們提交一個表單時，就創建了一個新的請求。實際上，當我們點擊一個鏈接時，也創建了一個新的請求。那么一個請求的作用域到底有多大呢？例如：
在頁面a.jsp中有一個鏈接<a href="b.jsp?id=1">這是指向b的一個鏈接，而且還帶了一個參數</a>。當我們點擊這個連接的時候，就產生了一個請求，為了明確起見，我們把它叫做requestA->B。現在，在b.jsp頁面中我們就可以從這個請求中獲取信息了。在b.jsp中你可以寫入out.println(request.getParameter("id"))進行測試。下面更復雜一點，我們在b.jsp頁面中增加下面的語句：
request.setAttribute("name","funcreal");
out.println(request.getAttriblute("name"));//成功顯示了name變量的值。
現在在b.jsp中再增加一個鏈接：<a href="c.jsp?age=23">這是指向c的一個鏈接，而且還帶了一個參數</a>,當我們點擊這個連接的時候，將產生一個新的請求，這時requestA-B也就安息了，新的請求叫做requestB-C。同樣的道理，在c.jsp中，我們可以訪問到的變量只有age，因為id，name這兩個變量都屬于requestA-B，此時他已經不存在了。下面是源代碼：
a.jsp
<%@ page c %>
<html>
<body bgcolor="#ffffff">
<a href="b.jsp?id=1">指向b.jsp，而且還帶了一個參數id=1。requestA-B現在誕生了</a>
</body>
</html>
b.jsp
<%@ page c %>
<html>
<body bgcolor="#ffffff">
<%
out.println("id=" + request.getParameter("id"));
request.setAttribute("name","Func Real");
out.println("name=" + request.getAttribute("name"));
%>
<a href="c.jsp?age=23">requestA-B已經結束了。指向c.jsp，而且還帶了一個參數age=23</a>
</body>
</html>
c.jsp
<%@ page c %>
<html>
<body bgcolor="#ffffff">
<%
out.println("id=" + request.getParameter("id"));
out.println("name=" + request.getAttribute("name"));
out.println("age=" + request.getParameter("age"));
%>
</body>
</html>
那么轉發又是怎么回事呢？現在增加一個頁面叫做d.jsp，并且在c.jsp中</body>前面增加一句<jsp:forward page="d.jsp"/>
d.jsp
<%@ page c %>
<html>
<body bgcolor="#ffffff">
requestB-C的魔爪已經伸到了d.jsp頁面
<%
out.println("age=" + request.getParameter("age"));
%>
</body>
</html>
運行程序，你會發現c頁面中的內容沒有顯示出來，因為forward是自動執行的，地址欄中雖然是c.jsp但實際上，但瀏覽器中顯示的已經是d.jsp的內容了，而且看到了從b.jsp傳過來的參數。你可以簡單得這樣理解：轉發，就是延長了requestB-C的作用域，<jsp:forward page="d.jsp"/>，這一句話實際上是把c.jsp和d.jsp粘到了一起，他們就像是在一個頁面中。
如果你用過struts，那么你就知道為什么在Action中，最后一句幾乎總是mapping.findForward("xxx");了。因為我們在這個Action中設置的請求作用域的變量都將會在下一個頁面（也許是另一個Action）中用到，所以要用轉發。
總結：
用重定向和轉發不是一個習慣問題。而是什么情況下必須用什么的問題。
不要僅僅為了把變量傳到下一個頁面而使用session作用域，那會無故增大變量的作用域，轉發也許可以幫助你解決這個問題。
重定向：以前的request中存放的變量全部失效，并進入一個新的request作用域。
轉發：以前的request中存放的變量不會失效，就像把兩個頁面拼到了一起。
forward是服務器請求資源，服務器直接訪問目標地址的URL，把那個URL的響應內容讀取過來，然后把這些內容再發給瀏覽器，瀏覽器根本不知道服務器發送的內容是從哪兒來的，所以它的地址欄中還是原來的地址。
redirect就是服務端根據邏輯,發送一個狀態碼,告訴瀏覽器重新去請求那個地址， web應用程序會要求客戶端瀏覽器重新發出請求地址，客戶端會重新連接至所指定的地址，因此瀏覽器的地址會出現重新導向的信息，重新導向后的請求由瀏覽器發出。
forward與include共享Request范圍內的對象,而redirect則不行，
forward與include基本上都是轉發到context內部的資源，而redirect可以重定向到外部的資源
posted @
2011-10-09 17:41 Java_liyadong 閱讀(1302) |
評論 (0) |
編輯 收藏jsp靜態包含和動態包含的區別：
- 動態INCLUDE 用jsp:include 動作實現。
- <jsp:include page="included.jsp"
- flush="true" />它總是會檢查所含文件中的變化，適合用于包含動態頁面，并
- 且可以帶參數
- 靜態INCLUDE 用include 偽碼實現,定不會檢查所含文件的變化，適用于包
- 含靜態頁面：<%@ include file="included.htm" %>
可是經本人驗證這種說話是不完全正確的，至少動態<jsp:inlude>指令是可以包含動態頁面的。
個人認為區別是：
1<jsp:inlude>在同一個頁面中可以包含盡可能多的條數，不管這個頁面中有什么內容，只要頁面本身合法就行，而<%@ include>偽指令如果被包含頁面有定義變量和方法的話只能包含一條。
（這個是和第二條的編譯方式相一致的）
2動態包含在請求到來時編譯包含頁面和被包含頁面，如果都是jsp頁面，那么將生成倆個頁面對應的class文件和java文件。而靜態包含只會生成包含頁面的java文件和類文件。
3所謂動態包含是指在請求包含頁面的時候遇到動態包含指令將請求轉到被包含頁面，這時去編譯被包含頁面。靜態包含是在請求包含頁面時去編譯包含頁面，編譯時遇到靜態頁面包含偽碼將被包含頁面的內容復制到被包含頁面中進行編譯。
4<jsp:inlude >指令時相對包含頁面的被包含文件路徑，但靜態包含是相對被包含文件路徑的。（這一點孫鑫老師在《java web 深入詳解》中講的很清楚）
5引用被包含頁面的范圍屬性時動態包含的指令是與位置相關的，即在<jsp:include>指令之前引用被包含頁面中設置的屬性值是無效的。但是靜態包含是不區分包含指令的位置的，可以在包含指令之前引用被包含頁面設置的屬性，是有效的。
倆者是有相同點的：
1 都可以進行交互，request范圍對象中的屬性包含頁和被包含頁之間可以交互使用。
2被包含頁面中引用包含頁面設置的屬性時倆者都和設置包含頁面中范圍屬性的值有關，即在包含被包含頁面之前設置的范圍屬性才有效。
代碼如下： 包含頁面： index.jsp
<%@ page language="java" import="java.util.*" pageEncoding="utf-8" buffer="23kb"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>this is 'index.jsp' </title>
</head>
<body>
這是包含頁面<br/>
<%--靜態包含前引用被包含頁面設置的屬性 --%>
${name }靜態包含前引用被包含頁面設置的屬性<br/>
<%--包含頁面設置屬性 --%>
<%request.setAttribute("pws","456") ;%>
<%--<%@include file="MyJsp.jsp"%>此處因為MyJsp.jsp中定義了變量，固不可以重復包含 --%>
<%-- --%><%@include file="MyJsp.jsp" %>
${name }包含靜態頁面之后引用屬性<br/>
<%--此處沒有you.jsp中沒有定義變量，所以可以重復包含 --%>
${wangzhanming }<br/>
<%@include file="you.jsp" %>
<%@include file="you.jsp" %>
${wangzhanming }<br/>
<jsp:include page="MyJsp.jsp" ></jsp:include>
<jsp:include page="MyJsp.jsp" ></jsp:include>
<%request.setAttribute("pws","lyx") ;%>
<%--此處可以重復包含--%>
<jsp:include page="MyJsp.jsp" ></jsp:include>
<%@include file="you.jsp" %>
${name }<br/>
</body>
</html>
設置變量的包含頁面： MyJsp.jsp
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<%--定義變量 --%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>this is 'MyJsp.jsp' </title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<!--
<link rel="stylesheet" type="text/css" href="styles.css">
-->
</head>
<body>
這是定義變量的包含頁面<br/>
<%--被包含頁面中設置范圍屬性 --%>
<%request.setAttribute("name","wzm"); %>
${name } <br>
<%--被包含頁面中引用包含頁面的屬性 --%>
${pws }<br/>
</body>
</html>
不包含變量設置的被包含頁面： you.jsp
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<html>
<head>
<title>this is 'you.jsp' </title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<!--
<link rel="stylesheet" type="text/css" href="styles.css">
-->
</head>
<body>
這是不定義變量的被包含頁面 <br>
<%request.setAttribute("wangzhanming","haoren"); %>
${wangzhanming }<br/>
${pws }<br/>
</body>
</html>
posted @
2011-10-09 17:36 Java_liyadong 閱讀(11133) |
評論 (1) |
編輯 收藏一.指令元素
1.page指令
import
session
contentType
buffer
isTreadSafe
info
errorPage
isErrorPage
2.include指令
3.taglib指令
二.腳本元素
1.聲明元素
2.表達式元素
3.腳本元素
4.注釋元素
三.標準動作元素
1.<jsp:param>
2.<jsp:include>
3.<jsp:forward>
4.<jsp:plugin>
5.<jsp:useBean>
6.<jsp:setProperty>
7.<jsp:getProperty>
四.內置對象
1.request
2.response
3.out
4.session
5.pageContext
6.application
7.config
8.page
9.exception
五.JavaBeans的使用
1.JavaBeans在JSP中的基本使用格式
2.scope范圍的具體設定
3.session事件的運用
4.Bean的保存與讀取
六.JSP中的文件操作
七.JSP運行原理剖析
-------------------------------------------------
在早期，開發網絡數據庫應用程序主要采用CGI（Common Gateway Interface）技術。編寫CGI程序可以使用不同的程序語言，如Perl、Visual Basic、Delphi或C/C++等。雖然CGI技術已經發展成熟而且功能強大，但由于其編程困難、效率低下、修改復雜等缺陷，所以有被新技術取代的技術。
在這樣的背景下，新的技術紛紛面世，如ASP（Active Server Page）、PHP（Personal Home Page）、JSP（Java Server Page）等。其中，JSP被許多人認為是未來最有發展前途的動態網站技術。
JSP頁面一般由HTML標簽和JSP元素構成，其中的JSP元素則又是由“指令元素”、“腳本元素” 、“標準動作元素” 、“內置對象”四個部分組成。下面，就讓我們一起來探究JSP的奧秘吧……
一. 指令元素
可以把JSP理解為用來通知JSP引擎的消息。JSP不直接生成可見的輸出，用JSP指令設置JSP引擎處理JSP頁面的機制。
一般JSP指令用標簽<%@…%>表示，JSP指令包括page、include和taglib。page指令是針對當前頁面的指令，而include指令用來指定如何包含另外一個文件，taglib指令用來定義和訪問自定義標記庫。這三種指令通常都有默認值，這樣開發人員就不必顯式的使用每一個指令予以確認。
1. page指令
page指令的設置語法格式是：<%@ page attribute1=”value1” attribute2=”value2”…%>
下面介紹指令中包括的幾個常用屬性，并作簡要說明。
l import
import指令是所有page指令中，唯一可以多次設置的指令，而且累加每個設置。它用來指定jsp網頁中所需要使用到的一些類。例如：
<%@ page import=”java.io.*,java.util.Date”%>
l session
定義當前頁面是否參與http會話。當設置為”true”時，可以獲得隱含名為session的對象，為”false”時，則不能。默認設置為”true”。
l contentType
設置jsp網頁輸出時數據時，所使用的字符壓縮方式，以及所使用的字符集，當編寫中文網頁時，設置如下：
<%@page contentType=”text/html;charset=Gb2312”%>
此屬性的默認值為”text/html;charset=ISO-8859-1”。
l buffer
設置jsp網頁的緩沖區大小，默認為”8k”，如果設置為”none”，則表示不使用緩沖，所有的響應輸出都將被PrintWriter直接寫到ServletResponse中。
l isTreadSafe
定義當前頁面是否支持線程安全。如果為”true”，則該頁面可能同時收到jsp引擎發出的多個請求，反之，jsp引擎會對收到的請求進行排隊，當前頁面在同一時刻只能處理一個請求。默認為”true”。
l info
設置頁面的文本信息，可以通過Servlet.getServletInfo()的方法獲得該字符串。
l errorPage
定義指向另一個jsp頁面的URL。當頁面出現一個沒有被捕獲的異常時，錯誤信息將以throw語句拋出，而被設置為錯誤信息網頁的jsp頁面，將利用exception隱含對象，取得錯誤信息。
默認沒有錯誤處理頁面。
l isErrorPage
設置此jsp網頁是否為錯誤處理頁面。默認值為”false”。當設置為”true”時，jsp頁面將可存取隱含的exception對象，并通過該對象取得從發生錯誤之網頁所傳出的錯誤信息。取得錯誤信息的語法如下：
<% =exception.getMessage()%>
² 一個頁面錯誤處理的例子
產生錯誤的頁面文件為MakeError.jsp，處理錯誤的頁面文件為ErrorPage.jsp，它們的源程序如下：
MakeError.jsp
<%@ page errorPage="ErrorPage.jsp"%>
<html>
<head>
<title>產生錯誤頁面</title>
</head>
<body>
<%
int i=8,j=0;
out.println(ij);
%>
</body>
</html>
ErrorPage.jsp
<%@ page isErrorPage="true"%>
<html>
<head>
<title>錯誤處理頁面</title>
</head>
<body>
<font color=red>
錯誤原因：<%=exception.getMessage()%>
</font>
</body>
</html>
運行程序MakeError.jsp的結果如下：
2. include指令
使用include指令可以把其他的文本文件加入到當前的jsp頁面，格式如下：
<%@ include file=”header.inc”%>
如此，則在當前頁面中加入header.inc源代碼然后再編譯整個文件。
可以使用include指令把一個頁面分成不同的部分，最后合成一個完整的文件，使用jsp的include指令有助于實現jsp頁面的模塊化。
3. taglib指令
（略）
二. 腳本元素
JSP規格提供了四種類型的腳本元素，包括：
l 聲明
l 表達式
l 腳本
l 注釋
下面分別對它們進行詳細敘述。
1. 聲明元素
聲明用于定義jsp頁面中的變量與函數，這些經過定義的變量和函數，將成為Servlet類的屬性與方法（關于Servlet請參看后文）。聲明并不會產生任何的數據輸出，聲明時可同時設置初始值，提供給其他的聲明、表達式或腳本使用。
聲明的語法格式為：
<%!
//聲明語句
%>
舉例：
<%!
//此處定義的變量將成為此jsp頁面的全局變量
int i = 0;
static int j=100;
String s = “注意”;
%>
<%!
//此處定義的函數將成為此jsp頁面的公共函數
Public int square(int i)
{
return(i*i);
}
%>
² jspInit函數與jspDestroy函數
若要在jsp頁面開始執行時進行某些數據的初始化，可以利用jspInit函數完成。此函數將在jsp頁面被執行時調用，且當jsp頁面重新整理時，并不會被再度執行。當關閉服務器時，jspDestroy函數將被執行，可以利用該函數進行數據的善后處理工作。下面舉個簡單的例子說明，文件InitDes.jsp代碼如下：
<%@ page contentType="text/html; charset=GB2312"%>
<%!
public void jspInit()
{
System.out.println("jspInit is called!");
}
public void jspDestroy()
{
System.out.println("jspDestroy is called!");
}
%>
<HTML>
<HEAD><TITLE>jspInit函數與jspDestroy函數的使用</TITLE></HEAD>
<BODY>
<CENTER>
<FONT SIZE = 5 COLOR = blue>jspInit函數與jspDestroy函數的使用</FONT>
</CENTER>
<HR><BR>
</BODY>
</HTML>
首次執行此頁面時，Resin服務器輸出如下：
Resin 1.2.2 -- Tue Jan 16 09:53:18 PST 2001
http listening to *:8080
srun listening to 127.0.0.1:6802
jspInit is called!
刷新此頁面數次后，Resin服務器輸出仍然如上。
此時，如果關閉服務器，則輸出如下：
Resin 1.2.2 -- Tue Jan 16 09:53:18 PST 2001
http listening to *:8080
srun listening to 127.0.0.1:6802
jspInit is called!
closing server
jspDestroy is called!
由此，我們得到啟發，在數據庫的開發過程中，可以利用jspInit函數來進行數據庫的連接工作，用jspDestroy函數來進行數據庫的關畢工作。下面以一個分頁顯示數據庫內容的程序為例子，讓讀者進一步體會jspInit與jspDestroy的功用與好處。
在Pages.jsp這個分頁程序中，我們把數據庫連接的動作寫在jspInit函數中，這樣，每一次重新整理頁面時，就可以避免重新執行數據庫的連接動作。如下：
<%@ page contentType="text/html; charset=GB2312"
import="java.sql.*"%>
<%!
int PageSize = 2; //設置每張網頁顯示兩筆記錄
int ShowPage = 1; //設置欲顯示的頁數
int RowCount = 0; //ResultSet的記錄筆數
int PageCount = 0; //ResultSet分頁后的總頁數
Connection con = null;
Statement stmt = null;
ResultSet rs = null;
public void jspInit() //執行數據庫與相關數據的初始化
{
try
{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
//載入驅動程序類別
con = DriverManager.getConnection("jdbc:odbc:test");
//建立數據庫鏈接
stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
//建立Statement對象, 并設置記錄指標類型為可前后移動
rs = stmt.executeQuery("SELECT * FROM products");
//建立ResultSet(結果集)對象，并執行SQL語句
rs.last(); //將指標移至最后一筆記錄
RowCount = rs.getRow(); //取得ResultSet中記錄的筆數
PageCount = ((RowCount % PageSize) == 0 ?
(RowCountPageSize) : (RowCountPageSize)+1);
//計算顯示的頁數
}
catch(Exception ex)
{
System.out.println(ex.toString());
}
}
public void jspDestroy() //執行關閉各種對象的操作
{
try
{
rs.close(); //關閉ResultSet對象
stmt.close(); //關閉Statement對象
con.close(); //關閉數據庫鏈接對象
}
catch(Exception ex)
{
System.out.println(ex.toString());
}
}
%>
<HTML>
<HEAD>
<TITLE>記錄的分頁顯示</TITLE>
</HEAD>
<BODY>
<CENTER>
<FONT SIZE = 5 COLOR = blue>記錄的分頁顯示</FONT>
</CENTER>
<HR>
<P></P>
<CENTER>
<%
String ToPage = request.getParameter("ToPage");
//判斷是否可正確取得ToPage參數,
//可取得則表示JSP網頁應顯示特定分頁記錄的語句
if(ToPage != null)
{
ShowPage = Integer.parseInt(ToPage); //取得指定顯示的分頁頁數
//下面的if語句將判斷用戶輸入的頁數是否正確
if(ShowPage > PageCount)
{ //判斷指定頁數是否大于總頁數, 是則設置顯示最后一頁
ShowPage = PageCount;
}
else if(ShowPage <= 0)
{ //若指定頁數小于0, 則設置顯示第一頁的記錄
ShowPage = 1;
}
}
rs.absolute((ShowPage - 1) * PageSize + 1);
//計算欲顯示頁的第一筆記錄位置
%>
<H3>目前在第<FONT SIZE = 4 COLOR = red>
<%= ShowPage %></FONT>頁, 共有
<FONT SIZE = 4 COLOR = red>
<%= PageCount %></FONT>頁</H3>
<P></P>
<%
//利用For循環配合PageSize屬性輸出一頁中的記錄
for(int i = 1; i <= PageSize; i++)
{
%>
<TABLE border=1 bordercolor=RoyalBlue bgcolor=LightBlue>
<TR><TD bgcolor=LightYellow width= 100>
<B>商品名</B></TD>
<TD width= 100><B><%= rs.getString("product_name") %>
</B></TD>
<TD bgcolor=LightYellow width= 100>
<B>價格</B></TD>
<TD width= 100><B><%= rs.getInt("price") %>
</B></TD>
<TD bgcolor=LightYellow width= 100>
<B>描述</B></TD>
<TD width= 100><B><%= rs.getString("description") %>
</B></TD>
</TR>
</TABLE><BR>
<%
//下面的if判斷語句用于防止輸出最后一頁記錄時,
//將記錄指標移至最后一筆記錄之后
if(!rs.next()) //判斷是否到達最后一筆記錄
break; //跳出for循環
}
%>
<TABLE>
<TR valign=baseline align=center>
<%
//判斷目前所在分頁是否為第一頁,
//不是則顯示到第一頁與上一頁的超鏈接
if(ShowPage != 1)
{
//下面建立的各超鏈接將鏈接至自己,
//并將欲顯示的分頁以ToPage參數傳遞給自己
%>
<TD Width=150>
<A Href=Pages.jsp?ToPage=<%= 1 %>>到第一頁</A>
</TD>
<TD Width=150>
<A Href=Pages.jsp?ToPage=<%= ShowPage - 1 %>>到上一頁</A>
</TD>
<%
}
//判斷目前所在分頁是否為最后一頁,
//不是則顯示到最后一頁與下一頁的超鏈接
if(ShowPage != PageCount)
{
//下面建立的各超鏈接將鏈接至自己,
//并將欲顯示的分頁以ToPage參數傳遞自己
%>
<TD Width=150>
<A Href=Pages.jsp?ToPage=<%= ShowPage + 1%>>到下一頁</A>
</TD>
<TD Width=150>
<A Href=Pages.jsp?ToPage=<%= PageCount %>>到最后一頁</A>
</TD>
<%
}
%>
<TD Width=150>
<FORM action=Pages.jsp method=POST>
到
<!--
供用戶輸入欲查看頁數的文字方塊, 預設值為目前所在的分頁,
當用戶在此文字方塊中完成數據輸入后按下 Enter 即可將數據送出,
相當于按下Submit按鈕, 因此此表單中將省略Submit按鈕
-->
<INPUT type="text" name=ToPage style="HEIGHT: 25px; WIDTH: 40px"
value=<%= ShowPage%> > 頁
</FORM></TD></TR>
</TABLE>
</CENTER>
</BODY>
</HTML>
執行后，結果如下圖：
2. 表達式元素
表達式是一個簡化了的out.println語句。
表達式的語法格式為：
<%=//要輸出的數據%>
舉例：
<%=square(5)%>
3. 腳本元素
腳本是java程序的一段代碼，只要符合java語法的語句都可以寫在這里，它是在請求時期執行的，它可以使用jsp頁面所定義的變量、方法、表達式或JavaBeans。
腳本的語法格式為：
<%
//java代碼
%>
舉例：
<%
if(age<18)
{
out.println(“你是未成年人！！！！”);
}
else
{
out.println(“你已經成年了！！！！”);
}
%>
4. 注釋元素
用來對程序進行說明注釋。注釋大體有下列三種格式：
<!—客戶端注釋à
<!--<%=客戶端動態注釋%>-->
<%--服務器端注釋--%>
三. 標準動作元素
標準動作元素用于執行一些常用的JSP頁面動作，例如：將頁面轉向、使用JavaBean、設置JavaBean的屬性等。在JSP中，標準動作元素共有以下幾種：
l <jsp:param>
l <jsp:include>
l <jsp:forward>
l <jsp:plugin>
l <jsp:useBean>
l <jsp:setProperty>
l <jsp:getProperty>
其中<jsp:useBean>、<jsp:setProperty>、<jsp:getProperty>這三個是專門用來操作JavaBeans的。
下面分別介紹它們。
1. <jsp:param>
<jsp:param>動作用于傳遞參數，必須配合<jsp:include>、<jsp:forward>、<jsp:plugin>動作一起使用。
語法格式：
<jsp:param name = “name1” value = “value1”/>
2. <jsp:include>
<jsp:include>動作用于動態加載HTML頁面或者JSP頁面。
語法格式：
<jsp:include page = “網頁路徑”>
<jsp:param name = “name1” value = “value1”/>
<jsp:param name = “name2” value = “value2”/>
<jsp:include/>
在jsp頁面中，可以利用下面的語法取得返回的參數：
request.getParameter(“name1”);
若不傳遞參數時，則語法格式如下：
<jsp:include page = “網頁路徑”/>
舉例：
a.jsp頁面代碼如下：
<jsp:include page = "b.jsp">
<jsp:param name = "name1" value = "value1"/>
<jsp:param name = "name2" value = "value2"/>
</jsp:include>
b.jsp頁面代碼如下：
名字1、；<%=request.getParameter("name1")%>
<hr color=red>
名字2、；<%=request.getParameter("name2")%>
執行結果如下：
“include標準動作”和“include指令”的差別在于：“include標準動作”包含的頁面在運行時被加入，而“include指令”在編譯時就被加入了。
3. <jsp:forward>
<jsp:forward>動作用于將瀏覽器顯示的頁面導向到另一個HTML頁面或者jsp頁面。
語法格式：
<jsp:forward page = “網頁路徑”/>
當然，<jsp:forward>動作中也可以加入<jsp:param>參數，其設置和獲得參數的方法與<jsp:include>類似。
4. <jsp:plugin>
<jsp:plugin>動作用于加載applet，用途與HTML語法中的<Applet>及<Object>標記相同。該動作是在客戶端執行的，這里就不作介紹了。
5. <jsp:useBean>
（見后文的“JavaBeans”的使用）
6. <jsp:setProperty>
（見后文的“JavaBeans”的使用）
7. <jsp:getProperty>
（見后文的“JavaBeans”的使用）
四. 內置對象
在jsp頁面中有一些已經完成定義的對象，稱之為內置對象。這些對象可以不經過定義就直接使用，因為它們是由jsp頁面自己定義的。
jsp程序常用的內建對象有如下幾個：request、response、out、session、pageContext、application、config、page、exception。你可以在jsp頁面中直接使用它們，用以加強jsp程序的功能。
下面分別介紹它們。
1. request
與request相聯系的是HttpServletRequest類。通過getParameter方法可以獲得相應的參數值。
2. response
與response相聯系的是HttpServletResponse類。表示Web頁面針對請求的應答。
3. out
與out相聯系的是PrintWrite類。可以使用此對象將內容輸出到頁面中。
4. session
與session相聯系的是HttpSession類。用來傳遞客戶的會話內容。
5. pageContext
與pageContext相聯系的是pageContext類。用它能方便的訪問本頁面中設置的共享數據。
6. application
與application相聯系的是ServletContext類。用它能夠實現應用程序級別的數據共享。
7. config
與config相聯系的是ServletConfig類。用來在jsp頁面范圍內處理jsp配置。
8. page
代表jsp頁面編譯成的Servlet實例，一般不用。
9. exception
與exception相聯系的是Throwable類。用來捕獲jsp執行時拋出的異常。
五. JavaBeans的使用
JavaBeans是運行于java虛擬機上的100％的純java組件，它的概念描述很類似于Microsoft的COM組件概念。
JavaBeans傳統的應用在于可視化領域，如AWT下的應用。其實，基于AWT的任何java程序已經是一個Bean，完全可以把它當作一個組件來使用。
現在，JavaBeans更多的應用在不可視化領域，它在服務器端應用方面表現出了越來越強的生命力。不可視化的JavaBeans在JSP程序中用來封裝事務邏輯，可以很好的實現業務邏輯和前臺程序的分離，使得系統具有更好的健壯性和靈活性。
JavaBeans描述了JDK1.1以前的java所沒有的東西，因此，運行JavaBeans最小的需求是JDK1.1或者以上的版本。
1. JavaBeans在JSP中的基本使用格式
l 在JSP中調用JavaBeans的格式
//加載Bean
<jsp:useBean id = “名稱” scope = “有效范圍” class = “Bean類位置”/>
//設定Bean屬性（兩種方法）
//方法一：“標簽設定”
<jsp:setProperty name = “名稱” property = “屬性” value = “值”/>
//方法二：“方法設定(用于java程序中)”
Bean對象名稱.set屬性(值)
//獲取Bean屬性（兩種方法）
//方法一：“標簽獲取”
<jsp:getProperty name = “名稱” property = “屬性”/>
//方法二：“方法獲取(用于java程序中)”
Bean對象名稱.get屬性()
l JavaBean編寫的格式
//定義Bean類所屬于的包
package 包名
//定義為公開等級的類，并且類名稱與源代碼文件名相同
public class類名
{
//Bean類的屬性，其等級定義為private
private 數據類型 屬性名
//用來初始化的構造函數
//Bean的構造函數無輸入參數
public 類名
{ }
//以setXXX函數，作為設定Bean類屬性的接口
public void set屬性名稱(數據類型 參數)
{
this.屬性 = 參數
}
//以getXXX函數，作為取得Bean類屬性的接口
public void get屬性名稱()
{
return this.屬性
}
}
² 一個簡單的使用JavaBeans的例子
Bean文件LoginData.java的源代碼如下：
package j2ee.jsp;
//定義Bean所屬的包
public class LoginData
{
//Bean屬性
private String Name = "";
private String Pwd = "";
public LoginData() //構造函數
{
}
//以下為設定Bean屬性的方法
public void setLoginName(String name)
{ this.Name = name; }
public void setPassword(String pwd)
{ this.Pwd = pwd; }
//以下為取得Bean屬性的方法
public String getLoginName()
{ return this.Name; }
public String getPassword()
{ return this.Pwd; }
}
調用Bean的jsp文件UseBean.jsp源程序如下：
<%@ page contentType="text/html; charset=GB2312" %>
<HTML>
<HEAD>
<TITLE>使用Beans</TITLE>
</HEAD>
<BODY>
<CENTER>
<FONT SIZE = 5 COLOR = blue>使用Beans</FONT>
</CENTER>
<HR>
<P></P>
<H2>
<jsp:useBean id="login" scope="application"
class="j2ee.jsp.LoginData"/>
<jsp:setProperty name="login"
property="loginName" value="最后的決定"/>
<%
login.setPassword("123456"); //調用Bean對象的方法, 設定屬性
%>
<Font color = red>LoginName</Font>屬性值為
<Font color = blue>
<jsp:getProperty name="login" property="loginName"/>
</Font><BR>
<Font color = red>Password</Font>屬性值為
<Font color = blue>
<%--以調用Bean對象方法的方式取得屬性--%>
<%= login.getPassword() %></Font>
</BODY>
</HTML>
運行結果如下：
在前面的使用中，有兩點值得注意：
（1） Bean中各個方法名的“命名規則及大小寫”與調用Bean時的“方法名規則及大小寫”之間的對應關系需要注意。
（2） Beans的存放目錄將隨選用服務器的不同而不同。以resin服務器而言，Beans默認定義存放在application-programme\WEB-INF\classes子目錄中。
2. scope范圍的具體設定
JavaBeans可以定義四種生命周期?D?Dpage、request、session與application，將分別運用pageContext、request、session、application四種對象的setAttribute方法，將JavaBeans對象保存在該對象中。下面分別說明：
l Page的有效范圍僅僅涵蓋使用JavaBeans的頁面，一旦你離開此頁面，JavaBeans對象的實體也將隨之消失。
l Request的有效范圍僅及于使用JavaBeans的請求而已，一旦你結束該頁面的請求，JavaBeans對象的實體也將隨之消失。
l Session的有效范圍涵蓋了整個用戶會話時期。在用戶會話期間，JavaBeans對象的實體均不會消失。當用戶會話結束時，JavaBeans對象的實體才會消失。
l Application的有效范圍則涵蓋了整個應用程序時期。在應用程序期間，JavaBeans對象的實體均不會消失。只有當應用程序結束時，JavaBeans對象的實體才會消失。
下面，舉一個簡單的例子，對Request與Session兩種生命周期做具體的演示。
Bean文件counter.java的源代碼如下：
package j2ee.jsp;
public class counter
{
private int count = 0;
public void setCount(int c)
{
this.count = c;
}
public int getCount()
{
this.count++;
return this.count;
}
}
Request實例
兩個jsp文件b1.jsp與b2.jsp代碼分別如下：
b1.jsp
<jsp:useBean id="counter" scope="request" class="j2ee.jsp.counter"/>
<%
counter.setCount(100);
%>
<jsp:forward page="b2.jsp"/>
b2.jsp
<jsp:useBean id="counter" scope="request" class="j2ee.jsp.counter"/>
<%
out.println(counter.getCount());
%>
運行結果如下：
Session實例
兩個jsp文件c1.jsp與c2.jsp代碼分別如下：
c1.jsp
<jsp:useBean id="counter" scope="session" class="j2ee.jsp.counter"/>
<%
out.println(counter.getCount());
%>
<a href="c2.jsp" target="_blank">c2.jsp</a>
c2.jsp
<jsp:useBean id="counter" scope="session" class="j2ee.jsp.counter"/>
<%
out.println(counter.getCount());
%>
運行結果如下：
3. session事件的運用
在jsp頁面中，將Bean對象保存至session對象時，可以定義Bean響應HttpSessionBindingEvent事件。當Bean對象加入session、Bean從session中刪除以及session對象終止時，將會觸發此事件。因此，我們可以利用這兩個事件，執行數據起始、善后的工作。
由此，我們可以想到，把jsp頁面中最耗費服務器資源的數據庫連接工作放入HttpSessionBindingEvent事件中。當一個會話開始時，建立一個“數據庫連機”，隨后的整個會話過程中，所有與數據庫相關的操作均使用這一個“連機”，這樣，就避免了每執行一次數據庫操作就產生一個數據庫連機的巨大消耗。當此會話結束時，再關閉釋放這個“數據庫連機”。
如果要Bean對象響應HttpSessionBindingEvent事件，則該Bean對象必須實現HttpSessionBindingListener接口，并且定義響應會話開始的valueBound方法以及響應會話結束的valueUnbound方法。
現在，我們來實做一個例子，首先，建立一個“用來建立會話級別數據庫聯機”的Bean文件DBCon.java，它的源代碼如下所示：
/*
* 文件名：DBCon.java
*
* 類名：DBCon
*
* 所屬包：j2ee.jsp
*
* 導入包：java.sql.*;javax.servlet.http.*;
*
* 作者：楊??
*
* 創建時間：2003.12.9
*
* 用途描述：在此JavaBean中建立會話級別的數據庫聯機，供會話過程中的各個jsp頁面使用
*
* 版本號：1.0
*
*/
package j2ee.jsp;
import javax.servlet.http.*;
import java.sql.*;
//定義DBCon類別實做HttpSessionBindingListener介面
public class DBCon implements HttpSessionBindingListener
{
//與數據庫連結有關的Bean屬性
private Connection con = null;
/**
* 方法名：BulidConnection
* 級別：private
* @param (無)
* @return (無)
* @throws (無)
* 作用：建立一個數據庫聯機
*/
private void BulidConnection()
{
try
{
System.out.println("BulidConnection()方法被調用");
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
//載入驅動程式類別
con = DriverManager.getConnection("jdbc:odbc:test");
//建立數據庫連線
}
catch(Exception ex)
{
System.out.println(ex.toString());
}
}
/**
* 方法名：close
* 級別：private
* @param (無)
* @return (無)
* @throws (無)
* 作用：關閉數據庫聯機
*/
private void close()
{
try
{
con.close(); //關閉Connection對象
con = null;
}
catch(SQLException sex)
{
System.out.println(sex.toString());
}
}
/**
* 方法名：getConnection
* 級別：public
* @param (無)
* @return Connection 數據庫聯機
* @throws (無)
* 作用：返回一個數據庫聯機
*/
public Connection getConnection()
{
//若con為null時, 重新建立數據庫連結
if(con == null)
BulidConnection();
return this.con;
}
/**
* 方法名：valueBound
* 級別：public
* @param HttpSessionBindingEvent 事件
* @return (無)
* @throws (無)
* 作用：建立一個數據庫聯機，并輸出相關信息
*/
public void valueBound(HttpSessionBindingEvent event)
{
BulidConnection();
System.out.println("會話級別的數據庫連接已經建立！！！");
}
/**
* 方法名：valueUnbound
* 級別：public
* @param HttpSessionBindingEvent 事件
* @return (無)
* @throws (無)
* 作用：關閉一個數據庫聯機，并輸出相關信息
*/
public void valueUnbound(HttpSessionBindingEvent event)
{
if(con != null)
close(); //呼叫close方法
System.out.println("會話級別的數據庫連接已經關閉！！！");
}
}
編譯這個Bean源文件。注意，編譯前要設定好classpath的路徑，使得它所包含的類庫中有javax.servlet.http.*包。
然后，建立兩個用來測試此Bean的jsp頁面文件DBBean1.jsp與DBBean2.jsp，它們的程序代碼差不多，都是用來顯示數據庫內容的，現在就只列出DBBean1.jsp的源文件，如下：
<%@ page contentType="text/html; charset=GB2312"
import="java.sql.*"%>
<HTML>
<HEAD>
<TITLE>利用Bean對象建立數據庫鏈接</TITLE>
</HEAD>
<BODY>
<CENTER>
<FONT SIZE = 5 COLOR = blue>
利用Bean對象建立數據庫鏈接
</FONT>
</CENTER>
<HR>
<P></P>
<CENTER>
<%--起始建立數據庫鏈接的Bean對象--%>
<jsp:useBean id="ConBean" scope="session"
class="j2ee.jsp.DBCon"/>
<%
Connection con = ConBean.getConnection();
//從Bean對象取得已完成建立的數據庫鏈接
Statement stmt = con.createStatement();
//建立Statement對象
ResultSet rs = stmt.executeQuery("SELECT product_name, price FROM products");
//建立ResultSet(結果集)對象，并執行SQL敘述
%>
<TABLE bgcolor=DodgerBlue>
<TR bgcolor=SkyBlue>
<TD><B>書 名</B></TD><TD><B>價 格</B></TD>
</TR>
<%
//利用while循環將數據表中的記錄列出
while (rs.next())
{
%>
<TR bgcolor=LightGoldenrodYellow>
<TD><B><%= rs.getString("product_name") %></B></TD>
<TD><B><%= rs.getString("price") %></B></TD>
</TR>
<%
}
rs.close(); //關閉記錄集
stmt.close(); //關閉Statement對象
%>
</TABLE>
</CENTER>
<a href="DBBean2.jsp">DBBean2.jsp</a>
</BODY>
</HTML>
posted @
2011-10-09 17:13 Java_liyadong 閱讀(1034) |
評論 (0) |
編輯 收藏
page指令
功能：設定整個JSP網頁的屬性和相關功能。
語法：<%@ page attribute1="value1" attribute2="value2" %>
page指令元素的屬性
language="language" 指定JSP Container要用什么語言來編譯JSP網頁，默認值為Java。
import="importList" 定義此JSP頁面可以使用哪些Java API。用逗號分隔列出一個或多個類名。此列表用于在生成的java servlet中創建相應的導入語句。默認情況下，JSP文件中會自動導入如下的類：java.lang.*;java.servlet.*;java.servlet.jsp.*;java.servlet.http.*
contentType="ctinfo" 表示將在生成servlet中使用的MIME類型和可選字符解碼。設置格式為contentType="MIME類型"或contentType="MIME類型;charset=編碼"。在JSP頁面默認情況下設置的字符編碼為ISO-8859-1，即contentType="text/html;charset=ISO-8859-1".
session="true|false" 指明JSP頁面是否需要一個HTTP會話，如果為true，那么產生的servlet將包含創建一個HTTP會話（或訪問一個HTTP會話）的代碼，缺省為true。
buffer="none|size in kb" 指定輸出流緩存的大小。值為none表示沒有緩存，直接輸出至客戶端的瀏覽器中，此屬性用來設定out對象緩存處理的緩沖區的大小。
authflush="true|false": 決定輸出流的緩沖區是否要自動清除。當值為true時緩存滿時將被自動刷新，當值為false時，緩沖區滿會拋出溢出異常。缺省值為true。
isThreadSafe="true|false" 如果值為true，則此JSP頁面可同時響應多個客戶的請求，如果為false則某個時刻只能處理一個客戶的請求。默認值為true。
info="text" 表示此JSP頁面的相關信息，可用getServletInfo()方法來獲得這個字符串。
errorPage="error_url" 表示如果發生異常錯誤，網頁會被重新指向一個URL頁面。錯誤頁面必須在其page指令元素中指定isErrorPage="true"
isErrorPage="true|false" 如果此頁面被用作處理異常錯誤的頁面，則為true。在這種情況下，頁面可被指定為另一頁面page指令元素中errorPage屬性的取值。指定此屬性為true將使exception隱含變量對此頁面可用。缺省值為false。
pageEncoding="ctinfo" 表示JSP頁面的編碼方式。
isELIgnored="true|false" 表示是否在此JSP網頁中執行或忽略EL表達式。如果為true，JSP Container將忽略EL表達式。
page指令的屬性值是在請求期間、運行期之前得出的。
不能將page指令像模板文本一樣條件性地插入到輸出中。因而下面的嘗試不管checkUserRequest方法的結果如何，都會產生Excel內容
<% boolean usingExcel=checkUserRequest(request);
If(usingExcel) {%>
<%@page contentType=”application/vnd.ms-excel”%>
<%}%>
我們可以使用scriptlet和常規的servlet方式——response.setContentType,如下面的片段所示：
<%String format=request.getParameter(“format”);
If((format!=null)&&(format.equals(“excel”))){
Response.setContentType(“application/vnd.ms-excel”);
}
%>
page指令作用于整個JSP頁面，同樣包括靜態的包含文件。但是page指令不能作用于動態的包含文件，比如 <jsp:include>
你可以在一個頁面中使用多個page指令，但是其中的屬性只能用一次，不過也有個例外，那就是import屬性。因為import屬性和Java中的import語句差不多，所以你能多次使用import屬性.
無論你把page指令放在JSP的文件的哪個地方，它的作用范圍都是整個JSP頁面。不過，為了JSP程序的可讀性，以及好的編程習慣，最好還是把它放在JSP文件的頂部.
include指令
功能：在JSP編譯時插入包含一個文件。包含的過程是靜態的，包含的文件可以是JSP、HTML、文本或是Java程序。
語法：<%@ include file="relativeURLspec" %>
include指令是對文件的靜態包含，所以如果兩個文件中均設置了page指令的contentType屬性將會出錯。
taglib指令
功能：使用標簽庫定義新的自定義標簽，在JSP頁面中啟用定制行為。
語法：<%@ taglib uri="tabLibraryURI" prefix"tagPrefix" %>
標簽元素：<jsp:directive.taglib uri="tabLibraryURI" prefix"tagPrefix" />
taglib指令元素的屬性
uri="tagLibraryURI" 標簽庫描述器的URI，主要是說是tagLibrary的存放位置。
prefix="tagPrefix" 用于標識在頁面后面部分使用定制標簽的唯一前綴。
posted @
2011-10-09 17:09 Java_liyadong 閱讀(287) |
評論 (0) |
編輯 收藏一、include動作指令
<jsp:include>標簽表示包含一個靜態的或者動態的文件。
語法：
<jsp:include page="文件路徑" flush="true" />
或者
<jsp:include page="path" flush="true">
<jsp:param name="參數名1" value="參數1值" />
...............
<jsp:param name="參數名n" value="參數n值" />
</jsp:include>
注：
1、flush="true" 必須使用flush為true，它默認值是false。
2、<jsp:param>子句能讓你傳遞一個或多個參數給動態文件，也可在一個頁面中使用多個<jsp:param>來傳遞多個參數給動態文件。
二、forward動作指令
<jsp:forward>標簽從一個JSP文件向另一個文件傳遞包含用戶請求的request對象。
語法：
<jsp:forward page="文件路徑" />
或者
<jsp:forward page="文件路徑">
<jsp:param name="參數名1" value="參數1值" />
...............
<jsp:param name="參數名n" value="參數n值" />
</jsp:forward>
三、useBean動作指令
<jsp:useBean>標簽表示用來在JSP頁面中創建一個BEAN實例并指定它的名字以及作用范圍。
語法：
<jsp:useBean id="name" scope="page | request | session | application" typeSpec />
其中typeSpec有以下幾種可能的情況：
class="包名.類名" | class="包名.類名" type="typeName" | beanName="包名.類名" type="typeName"
在JSP中使用bean，class屬性必須使用完全限定類名——包括包名的類名。不管你是否使用<%@ page import ...%>輸入包，都要滿足這個要求。
<jsp:useBean id=”book” class=”core.Book”/> 等價于 <%core.Book book=new core.Book();%>
僅當找不到相同id和scope的bean時，jsp:useBean元素才會實例化新的bean。如果存在相同id和scope的bean，則只是將已有的bean綁定到相關的變量(由id指定)。
我們可以不使用 <jsp:useBean…/>
轉而使用 <jsp:useBean>statements</jsp:useBean>
使用第二種形式的意義在于，jsp:useBean的起始標簽和結束標簽之間的語句只是在創建新的bean時執行，如果使用已有的bean，則不執行。
四、getProperty動作指令
<jsp:getProperty>標簽表示獲取BEAN的屬性的值并將之轉化為一個字符串，然后將其插入到輸出的頁面中。
語法：
<jsp:getProperty name="bean的名稱" property="屬性名稱" />
注：
1、在使用<jsp:getProperty>之前，必須用<jsp:useBean>來創建它。
2、不能使用<jsp:getProperty>來檢索一個已經被索引了的屬性。
3、能夠和JavaBeans組件一起使用<jsp:getProperty>，但是不能與Enterprise Java Bean一起使用。
五、setProperty動作指令
<jsp:setProperty>標簽表示用來設置Bean中的屬性值。
四種語法格式：
<jsp:setProperty name="bean的名稱" property="*" />
<jsp:setProperty name="bean的名稱" property="屬性名稱"/>
<jsp:setProperty name="bean的名稱" property="屬性名稱" param="參數值" />
<jsp:setProperty name="bean的名稱" property="屬性名稱" value="屬性值" />
第一種語法格式中，property="*"，應用這種格式要求bean屬性的名字與類型要和request對象中參數名稱與類型一致，一次用bean中的屬性來接收客戶輸入的數據，系統會根據名稱來自動匹配。
第二種語法格式則指設置其中匹配的一個bean的屬性。
第三種語法格式根據制定的request對象中的參數與屬性匹配。
第四種語法格式用來給bean的屬性賦值，屬性值的數據類型要與屬性的數據類型一致，否則會出錯。字符串轉換為其他數據類型的函數分別為：
轉換為boolean Boolean.valueof(String str).booleanValue()
轉換為byte Byte.valueof(String str).byteValue()
轉換為char Character.valueof(String str).charValue()
轉換為double Double.valueof(String str).doubleValue()
轉換為float Float.valueof(String str).floatValue()
轉換為int Integer.valueof(String str).intValue()
轉換為long Long.valueof(String str).longValue()
注：使用 jsp:setProperty 來為一個Bean的屬性賦值；可以使用兩種方式來實現。
1、在jsp:useBean后使用jsp:setProperty：
<jsp:useBean id="myUser" … />
…
<jsp:setProperty name="user" property="user" … />
在這種方式中，jsp:setProperty將被執行。
2、jsp:setProperty出現在jsp:useBean標簽內：
<jsp:useBean id="myUser" … >
…
<jsp:setProperty name="user" property="user" … />
</jsp:useBean>
在這種方式中，jsp:setProperty只會在新的對象被實例化時才將被執行。
在同一個setProperty動作指令中不能同時存在param和value參數。
六、plugin動作指令
這個動作指令用來在JSP中加載Java applet小程序。用<applet></applet>也可以是客戶端下載并運行Java applet小程序，但有的瀏覽器不支持，如果Java applet小程序使用了這樣的類，將無法執行。用plugin動作指令可以較好的解決這個問題。
語法：
<jsp:plugin
type="applet"
code="小程序的類文件"
codebase="小程序所在的位置"
[ height="小程序顯示高度" ]
[ width="小程序顯示寬度" ]
[ jreversion="虛擬機版本號" ]
[ <jsp:params>
[ <jsp:param name="parameterName" value="{parameterValue | <%= expression %>}" /> ]+
</jsp:params> ]
[ <jsp:fallback> 客戶端瀏覽器是否支持插件下載的提示信息</jsp:fallback> ]
</jsp:plugin>
注：
code參數是指小程序經過編譯后的字節碼文件，擴展名為.class。
codebase參數值出這個字解碼文件所在的位置，可以是相對路徑也可以是絕對路徑，但在這個參數中不需要文件名，只需要目錄路徑就可以了，如果自己嗎文件與調用的jsp文件在同一目錄下，則此參數可以省略。
posted @
2011-10-09 17:08 Java_liyadong 閱讀(1043) |
評論 (0) |
編輯 收藏
主要有四中方法：
1。<%-- 與 --%>
2。//
3。/**與**/
4。<!--與-->
在jsp文件中能用注釋為<!-- -->
而在jsp文件或HTML<% %>中能用的注釋為//、/** */、
<!--注釋內容-->:這種注釋方式客戶端可以查看到
<%--注釋內容--%>:這種注釋方式客戶端查看不到
JSP頁面注釋問題
jsp注釋： <%-- 注釋內容 --%> 通過原文件查看不到
html注釋： <!-- 注釋內容 --> 通過源文件可以查看到
在JSP里面進行多行注釋
用<!-- （里面寫代碼啊） -->。
posted @
2011-10-09 15:32 Java_liyadong 閱讀(6214) |
評論 (1) |
編輯 收藏