2011年9月30日随笔档案 - Java-liyadong

2011年9月30日

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 阅读(243) | 评论 (0) | 编辑收藏

摘要: 类与对象【学习目标】本章主要介绍类类型的定义、构造函数与析构函数的定义与作用、友元函数与友元类的声明与作用、派生类的定义与作用、虚函数和多态性的概念、静态数据成员的声明与定义、模板类的定义与实例化等内容。通过本章的学习，要求同学们：掌握类的概念，类类型的定义格式，类与结构的关系，类与操作符重载，类的成员属性，类的封装性，类的继承性，构造函数和析构函数的作用，this指针的含义，类对象的... 阅读全文

posted @ 2011-10-09 22:03 Java_liyadong 阅读(316) | 评论 (0) | 编辑收藏

对象与类型

摘要: 1 类和结构类和结构可以看作是创建对象的模板。每个对象都包括数据，并提供处理和访问数据的方法。类定义了每个对象（实例）包含什么样的数据与功能1.1封装“封装”有时被称为面向对象的编程的第一个支柱或原则。根据封装的原则，类或结构可以指定其每个成员对于该类或结构外部的代码的可访问性。可将无意在类或程序集外部使用的方法和变量隐藏起来，以减小编码错误或遭恶意利用的可能性。1.2&n... 阅读全文

posted @ 2011-10-09 21:58 Java_liyadong 阅读(357) | 评论 (0) | 编辑收藏

Java变量和作用域

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 阅读(4111) | 评论 (0) | 编辑收藏

Java 的循环语句

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:

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 阅读(1052) | 评论 (0) | 编辑收藏

Java分支

分支语句根据一定的条件，动态决定程序的流程方向，从程序的多个分支中选择一个或几个来执行。分支语句共有两种：if语句和switeh语句

分支语句根据一定的条件，动态决定程序的流程方向，从程序的多个分支中选择一个或几个来执行。分支语句共有两种：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 阅读(396) | 评论 (0) | 编辑收藏

java运算符

运算符
同大多数的编程语言一样，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 阅读(222) | 评论 (0) | 编辑收藏

JAVA语法总结 - 基本数据类型

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 阅读(218) | 评论 (0) | 编辑收藏

简单java方法实例

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 阅读(208) | 评论 (0) | 编辑收藏

Java中的main()方法详解

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 阅读(203) | 评论 (0) | 编辑收藏

Java标识符

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 阅读(3283) | 评论 (0) | 编辑收藏

java内存分配

摘要: java内存分配栈、堆、常量池虽同属Java内存分配时操作的区域，但其适用范围和功用却大不相同。本文将深入Java核心，详细讲解Java内存分配方面的知识。Java内存分配与管理是Java的核心技术之一，之前我们曾介绍过Java的内存管理与内存泄露以及Java垃圾回收方面的知识，今天我们再次深入Java核心，详细介绍一下Java在内存分配方面的知识。一般Java在内存分配时会涉及到以下区域： ... 阅读全文

posted @ 2011-10-09 21:23 Java_liyadong 阅读(145) | 评论 (0) | 编辑收藏

forward与redirect 区别

这是我在网上找到的资料，本来我以为我知道他们的区别，认为主要是当前的请求变量是否继续有效，但看了这个，了解了请求的作用范围，才完全明白其中的原因，希望对大家有用。

不要仅仅为了把变量传到下一个页面而使用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>

<a href="b.jsp?id=1">指向b.jsp，而且还带了一个参数id=1。requestA-B现在诞生了</a>

</body>

</html>

b.jsp

<%@ page c %>

<html>

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>

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>

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 阅读(1297) | 评论 (0) | 编辑收藏

jsp静态包含和动态包含的区别

在网上看到很多说法：

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>
这是包含页面

<%--静态包含前引用被包含页面设置的属性 --%>
${name }静态包含前引用被包含页面设置的属性 
<%--包含页面设置属性 --%>

 <%request.setAttribute("pws","456") ;%>

 <%--<%@include file="MyJsp.jsp"%>此处因为MyJsp.jsp中定义了变量，固不可以重复包含 --%>
 <%-- --%><%@include file="MyJsp.jsp" %>

 ${name }包含静态页面之后引用属性 
 <%--此处没有you.jsp中没有定义变量，所以可以重复包含 --%>
 ${wangzhanming } 
 <%@include file="you.jsp" %>
 <%@include file="you.jsp" %>
 ${wangzhanming }

<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 } 
</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">

</head>

<body>
这是定义变量的包含页面 
<%--被包含页面中设置范围属性 --%>
<%request.setAttribute("name","wzm"); %>
 ${name } 
 <%--被包含页面中引用包含页面的属性 --%>
 ${pws } 
</body>
</html>

不包含变量设置的被包含页面： you.jsp

<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<html>
<head>

</head>

<body>
 这是不定义变量的被包含页面 
 <%request.setAttribute("wangzhanming","haoren"); %>
 ${wangzhanming } 
 ${pws } 
</body>
</html>

posted @ 2011-10-09 17:36 Java_liyadong 阅读(11132) | 评论 (1) | 编辑收藏

JSP常用指令

一.指令元素
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>

错误原因：<%=exception.getMessage()%>

</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>
jspInit函数与jspDestroy函数的使用
</CENTER>
<HR> 
</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>
记录的分页显示
</CENTER>
<HR>

<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>目前在第
<%= ShowPage %>页, 共有

<%= PageCount %>页</H3>

<%
//利用For循环配合PageSize属性输出一页中的记录
for(int i = 1; i <= PageSize; i++)
{
 %>
 <TABLE border=1 bordercolor=RoyalBlue bgcolor=LightBlue>
 <TR><TD bgcolor=LightYellow width= 100>
 商品名</TD>
 <TD width= 100><%= rs.getString("product_name") %>
 </TD>
 <TD bgcolor=LightYellow width= 100>
 价格</TD>
 <TD width= 100><%= rs.getInt("price") %>
 </TD>
 <TD bgcolor=LightYellow width= 100>
 描述</TD>
 <TD width= 100><%= rs.getString("description") %>
 </TD>
 </TR>
 </TABLE> 
 <%
 //下面的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>
到

<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>
使用Beans
</CENTER>
<HR>

<H2>
<jsp:useBean id="login" scope="application"
 class="j2ee.jsp.LoginData"/>
<jsp:setProperty name="login"
 property="loginName" value="最后的决定"/>
<%
login.setPassword("123456"); //调用Bean对象的方法, 设定属性
%>

LoginName属性值为

<jsp:getProperty name="login" property="loginName"/>
 
Password属性值为

<%--以调用Bean对象方法的方式取得属性--%>
<%= login.getPassword() %>
</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());
%>

<%
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>

利用Bean对象建立数据库链接

</CENTER>
<HR>

<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>书名</TD><TD>价 格</TD>
 </TR>
 <%
 //利用while循环将数据表中的记录列出
 while (rs.next())
 {
 %>
 <TR bgcolor=LightGoldenrodYellow>
 <TD><%= rs.getString("product_name") %></TD>
 <TD><%= rs.getString("price") %></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 阅读(1030) | 评论 (0) | 编辑收藏

JSP指令

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 阅读(281) | 评论 (0) | 编辑收藏

JSP动态指令

一、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中使用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 阅读(1041) | 评论 (0) | 编辑收藏

JSP中使用注释

主要有四中方法：

1。<%-- 与 --%>

2。//

3。/**与**/

4。

在jsp文件中能用注释为

而在jsp文件或HTML<% %>中能用的注释为//、/** */、

:这种注释方式客户端可以查看到

<%--注释内容--%>:这种注释方式客户端查看不到

JSP页面注释问题

jsp注释： <%-- 注释内容 --%> 通过原文件查看不到

html注释：  通过源文件可以查看到

在JSP里面进行多行注释

用。

posted @ 2011-10-09 15:32 Java_liyadong 阅读(6212) | 评论 (1) | 编辑收藏

Servlet生命周期

Servlet是一种可以在Servlet容器中运行的组件，那么理所当然就应该有一个从创建到销毁的过程，这个过程我们可以称之为Servlet生命周期。Servlet的生命周期可以分为加载、实例化、初始化、处理客户请求和卸载五个阶段，体现在方法上主要是init（）、service（）和destroy（）三个方法。生命周期的具体说明如下：

Servlet容器完成加载Servlet类和实例化一个Servlet对象
init（）方法完成初始化工作，该方法由Servlet容器调用完成
service（）方法处理客户端请求，并返回响应结果
destroy（）方法在Servlet容器卸载Servlet之前被调用，释放一些资源

加载并初始化Servlet

在前面已经说过Servlet容器完成加载和实例化Servlet的工作，该工作既可以在容器启动时完成，也可以在容器收到请求时完成，或者是两者之间的某个时间启动。之后需要初始化Servlet，即读取配置信息、读取初始化参数等，这些基本上在整个生命周期中只需要执行一次。关于init（）方法已经在积累GenericServlet中提供缺省实现，如果不需特殊处理则没有必要再进行定义，否则要重写。

处理客户端请求

当容器接收到客户端请求时，Servlet引擎将创建一个ServletRequest请求对象和一个ServletResponse响应对象，然后把这两个对象作为参数传递给对应Servlet对象的service方法。

该方法是一个重点实现的方法，ServletRequest对象可以获得客户端发出请求的相关信息，如请求参数等，ServletResponse对象可以使得Servlet建立响应头和状态代码，并可以写入响应内容返回给客户端。

在此说明一点，当Servlet中有doGet（）或者doPost（）方法时，那么service方法就可以省略，默认为调用这两个方法。

卸载Servlet

Servlet的卸载是由容器本身定义和实现，在卸载Servlet之前需要调用destroy（）方法，以让Servlet自行释放占用的系统资源。虽然Java虚拟机提供了垃圾自动回收处理机制，但是有一部分资源却是该机制不能处理或延迟很久才能处理的，如关闭文件，释放数据库连接等。

Servlet生命周期的五个阶段是相互关联的，后面几个阶段建立在前面阶段的基础之上，在使用Servlet的时候可以根据自己的需要灵活处理。

posted @ 2011-10-08 20:40 Java_liyadong 阅读(262) | 评论 (0) | 编辑收藏

==与equal的区别

总结
1、= =操作符比较的是操作符两端的操作数是否是同一个对象；另外= =操作符两边的操作数必须是同一类型的（可以是父子类之间）才能编译通过。
2、String的equals()方法比较的是两个String对象的内容是否一样
3、= =比较的是地址，如果是具体的阿拉伯数字的比较，值相等则为TRUE，如：
int a=10 与 long b=10L 与 double c=10.0都是相同的（为true），因为他们都指向地址为10的堆栈；如下题111；
 String s= "hello";
String t = "hello";
char c[] = {'h','e','l','l','o'}
Which return true?
A. s.equals(t);
B. t.equals(c);
C. s==t;
D. t.equals(new String("hello"));
E. t==c.
答案：(acd)
题目：哪些返回true。
这个在前面第10题的equals()方法和==操作符的讨论中论述过。==操作符比较的是操作符两端的操作数是否是同一个对象，而String的equals()方法比较的是两个String对象的内容是否一样，其参数是一个String对象时才有可能返回true，其它对象都返回假。需要指出的是由于s和t并非使用new创建的，他们指向内存池中的同一个字符串常量，因此其地址实际上是相同的（这个可以从反编译一个简单的测试程序的结果得到，限于篇幅不列出测试代码和反编译的分析），因此答案c也是正确的。

Given the following class:
public class Sample{
long length;
public Sample(long l){ length = l; }
public static void main(String arg[]){
Sample s1, s2, s3;
s1 = new Sample(21L);
s2 = new Sample(21L);
s3 = s2;
long m = 21L;
}
}
Which expression returns true?
A. s1 == s2;
B. s2 == s3;
C. m == s1;
D. s1.equals(m).
答案：(b)//D不对，只有String的equals()方法才比较值；
题目：给出下面的类：  …
哪个表达式返回true。
前面已经叙述过==操作符和String的equals()方法的特点，另外==操作符两边的操作数必须是同一类型的（可以是父子类之间）才能编译通过。

再看以下几道
17. float f=4.2F;
Float g=new Float(4.2F);
Double d=new Double(4.2);
Which are true?
A. f= =g   B. g= =g   C. d= =f   D. d.equals(f)  E d.equals(g)  F. g.equals(4.2);
答案：B
 93. Click the exhibit button:
1. public class X {
2. public static void main (String[]args)  {
3. String s1 = new String (“true”);
4. Boolean b1 = new Boolean (true);
5. if (s2.equals(b1))   {
6. System.out.printIn(“Equal”);
7.       } 8.      } 9.     }
What is the result?
A. The program runs and prints nothing.
B. The program runs and prints “Equal.”
C. An error at line 5 causes compilation to fail.
D. The program runs but aborts with an exception.
答案：A

比较下题，小心使用equals 和 = =的区别；
 93. Click the exhibit button:
1. public class X {
2. public static void main (String[]args)  {
3. String s1 = new String (“true”);
4. Boolean b1 = new Boolean (true);
5. if (s2 = = b1) { //= =操作符两边的操作数必须是同一类型的（可以是父子类之间）才能编译通过
6. System.out.printIn(“Equal”);
7.       } 8.      } 9.     }
What is the result?
A. The program runs and prints nothing.
B. The program runs and prints “Equal.”
C. An error at line 5 causes compilation to fail.
D. The program runs but aborts with an exception.
答案：C
 111. Given:
1. public class Foo {
2. private int val;
3. public foo(int v) (val = v;)  }
4. public static void main (String [] args)  {
5. Foo a = new Foo (10);
6. Foo b = new Foo (10);
7. Foo c = a;
8. int d = 10;
9. double e = 10.0;
10. }
11. }
Which three logical expressions evaluate to true? (Choose Three)
A.(a ==c)
B.(d ==e)
C.(b ==d)
D.(a ==b)
E.(b ==c)
F.(d ==10.0)
答案：ABF //= =比较的是地址，他们都指向地址为10的堆栈；

Given the following code, what test would you need to put in place of
the comment line?
//place test here to result in an output of the string Equal
public class EqTest{
  public static void main(String argv[]){
   EqTest e=new EqTest();
  }

EqTest(){
   String s="Java";
   String s2="java";//小心大小写
   //place test here {
    System.out.println("Equal");
    }else
    {
    System.out.println("Not equal");
   }
  }
}
1) if(s==s2)
2) if(s.equals(s2)
3) if(s.equalsIgnoreCase(s2))
4)if(s.noCaseMatch(s2))
答案：3）//小心大小写

posted @ 2011-10-08 16:36 Java_liyadong 阅读(6376) | 评论 (0) | 编辑收藏

JavaBean总结

一、 javabean 是什么？

Bean的中文含义是“豆子”，顾名思义，JavaBean是指一段特殊的Java类，

就是有默然构造方法,只有get,set的方法的java类的对象.

专业点解释是：

JavaBean定义了一组规则
JavaBean就是遵循此规则的平常的Java对象

满足这三个条件:
1.执行java.io.Serializable 接口
　2.提供无参数的构造器
3.提供getter 和 setter方法访问它的属性.

简单地说，JavaBean是用Java语言描述的软件组件模型，其实际上是一个类。这些类遵循一个接口格式，以便于使函数命名、底层行为以及继承或实现的行为，可以把类看作标准的JavaBean组件进行构造和应用。

JavaBean一般分为可视化组件和非可视化组件两种。可视化组件可以是简单的GUI元素，如按钮或文本框，也可以是复杂的，如报表组件；非可视化组件没有GUI表现形式，用于封装业务逻辑、数据库操作等。其最大的优点在于可以实现代码的可重用性。JavaBean又同时具有以下特性。

易于维护、使用、编写。

可实现代码的重用性。

可移植性强，但仅限于Java工作平台。

便于传输，不限于本地还是网络。

可以以其他部件的模式进行工作。

对于有过其他语言编程经验的读者，可以将其看作类似微软的ActiveX的编程组件。但是区别在于JavaBean是跨平台的，而ActiveX组件则仅局限于Windows系统。总之，JavaBean比较适合于那些需要跨平台的、并具有可视化操作和定制特性的软件组件。

JavaBean组件与EJB（Enterprise JavaBean，企业级JavaBean）组件完全不同。EJB 是J2EE的核心，是一个用来创建分布式应用、服务器端以及基于Java应用的功能强大的组件模型。JavaBean组件主要用于存储状态信息，而EJB组件可以存储业务逻辑。

2 使用JavaBean的原因

程序中往往有重复使用的段落，JavaBean就是为了能够重复使用而设计的程序段落，而且这些段落并不只服务于某一个程序，而且每个JavaBean都具有特定功能，当需要这个功能的时候就可以调用相应的JavaBean。从这个意义上来讲，JavaBean大大简化了程序的设计过程，也方便了其他程序的重复使用。

JavaBean传统应用于可视化领域，如AWT（窗口工具集）下的应用。而现在，JavaBean更多地应用于非可视化领域，同时，JavaBean在服务器端的应用也表现出强大的优势。非可视化的JavaBean可以很好地实现业务逻辑、控制逻辑和显示页面的分离，现在多用于后台处理，使得系统具有更好的健壮性和灵活性。JSP + JavaBean和JSP + JavaBean + Servlet成为当前开发Web应用的主流模式。

3 JavaBean的开发

在程序设计的过程中，JavaBean不是独立的。为了能够更好地封装事务逻辑、数据库操作而便于实现业务逻辑和前台程序的分离，操作的过程往往是先开发需要的JavaBean，再在适当的时候进行调用。但一个完整有效的JavaBean必然会包含一个属性，伴随若干个get/set（只读/只写）函数的变量来设计和运行的。JavaBean作为一个特殊的类，具有自己独有的特性。应该注意以下3个方面。

JavaBean类必须有一个没有参数的构造函数。

JavaBean类所有的属性最好定义为私有的。

JavaBean类中定义函数setXxx() 和getXxx()来对属性进行操作。其中Xxx是首字母大写的私有变量名称。

posted @ 2011-10-08 16:25 Java_liyadong 阅读(191) | 评论 (0) | 编辑收藏

Java关键字

关键字	含义
Abstract	一个Java语言中的关键字，用在类的声明中来指明一个类是不能被实例化的，但是可以被其它类继承。一个抽象类可以使用抽象方法，抽象方法不需要实现，但是需要在子类中被实现
Boolean	布尔类型，只有true或者false
Break	停止，并跳出本层循环
Byte	8bit (位)，也就是8个1/0表示，即二进制
Byvalue
Case	Java语言的关键字，用来定义一组分支选择，如果某个值和switch中给出的值一样，就会从该分支开始执行。
Catch	Java的一个关键字，用来声明当try语句块中发生运行时错误或非运行时异常时运行的一个块。
Char	Java语言的一个关键字，用来定义一个字符类型
Class	类
Const	在Java中,const是作为保留字以备扩充,同样的保留字以备扩充还有goto. 你可以用final关键字.final也可以用于声明方法或类,被声明为final的方法或类不能被继承一般C里是const java用final
Continue	一个Java的关键字，用来打断当前循环过程，从当前循环的最后重新开始执行，如果后面跟有一个标签，则从标签对应的地方开始执行。
Default	一个Java的关键字，配合switch跟case使用，但case中没有找到匹配时，则输出或者为default后面的语句。
Do	一个Java语言的关键字，用来声明一个循环，这个循环的结束条件可以通过while关键字设置
Double	一个Java语言的关键字，用来定义一个double类型的变量
Else	一个Java语言的关键字，如果if语句的条件不满足就会执行该语句。
Extends	extends 继承　类X 通过extend 类Y来添加功能，或者添加变量，或者添加方法，或者覆盖类Y的方法。一个接口extends另外一个接口来添加方法。
False	假的
Final	一个Java语言的关键字。你只能定义一个实体一次，以后不能改变它或继承它。更严格的讲：一个final修饰的类不能被子类化，一个final修饰的方法不能被重写，一个final修饰的变量不能改变其初始值。
Finally	一个Java语言的关键字，用来执行一段代码不管在前面定义的try语句中是否有异常或运行时错误发生。
Float	一个Java语言的关键字，用来定义一个浮点数变量
For	一个Java语言的关键字，用来声明一个循环。程序员可以指定要循环的语句，推出条件和初始化变量。
Goto	虽然为Java关键字，但是仅在C语言里面使用，Java不提供Goto语句
If	Java编程语言的一个关键字，用来生成一个条件测试，如果条件为真，就执行if下的语句。
Implements	Java(TM)编程语言的一个关键字，在类的声明中是可选的，用来指明当前类实现的接口。
Import	Java(TM)编程语言的一个关键字，在源文件的开始部分指明后面将要引用的一个类或整个包，这样就不必在使用的时候加上包的名字。
Instaceof	一个二操作数的Java(TM)语言关键字，用来测试第一个参数的运行时类型是否和第二个参数兼容。
Int	Java(TM)的一个关键字，用来定义一个整形变量
Interface	Java(TM)的一个关键字，用来定义一系列的方法和常量。它可以被类实现，通过implements关键字。
Long	Java语言的一个关键字，用来定义一个long类型的变量
Native	本地方法。
New	Java语言的一个关键字，用来创建一个新的方法
Null	Java语言的一个关键字，当String类型没赋值时，该变量的值为Null
Package	Java语言的一个关键字，包的意思
Private	Java语言的一个关键字，用在方法或变量的声中。它表示这个方法或变量只能被这个类的其它元素所访问。
Protected	Java语言的一个关键字，在方法和变量的声明中使用，它表示这个方法或变量只能被同一个类中的，子类中的或者同一个包中的类中的元素所访问。
Public	Java语言的一个关键字，在方法和变量的声明中使用，它表示这个方法或变量能够被其它类中的元素访问。
Return	Java语言的一个关键字，用来结束一个方法的执行。它后面可以跟一个方法声明中要求的值。
Short	Java语言的关键字，用来定义一个short类型的变量。
Static	Java语言的关键字，用来定义一个变量为类变量。类只维护一个类变量的拷贝，不管该类当前有多少个实例。"static" 同样能够用来定义一个方法为类方法。类方法通过类名调用而不是特定的实例，并且只能操作类变量。
Super	父类
Switch	Java语言的关键字，是一个选择语句，与case，default，break一起使用。
Synchronized	线程同步
This	Java语言的关键字，用来代表它出现的类的一个实例。this可以用来访问类变量和类方法。
Threadsafe
Throw	Java语言的关键字，允许用户抛出一个exception对象或者任何实现throwable的对象
Throws	Java语言的关键字，用在方法的声明中来说明哪些异常这个方法是不处理的，而是提交到程序的更高一层。
Transient	Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。
True	真的
Try	Java语言的关键字，用来定义一个可能抛出异常语句块。如果一个异常被抛出，一个可选的catch语句块会处理try语句块中抛出的异常。同时，一个finally语句块会被执行，无论一个异常是否被抛出。
Void	Java语言的关键字，用在Java语言的方法声明中说明这个方法没有任何返回值。"void"也可以用来表示一句没有任何功能的语句。
volatile	Java语言的关键字，用在变量的声明中表示这个变量是被同时运行的几个线程异步修改的。
while	Java语言的一个关键字，用来定义一段反复执行的循环语句。循环的退出条件是while语句的一部分。

posted @ 2011-10-06 21:53 Java_liyadong 阅读(216) | 评论 (0) | 编辑收藏

js 之Math random()、ceil()、floor()、round()

Math.random()

返回 0 ~ 1 之间的随机数。

Math.round()
四舍五入取整。
Math.ceil()
返回值：返回大于或等于x，并且与之最接近的整数。
注：如果x是正数，则把小数“入”；如果x是负数，则把小数“舍”。
Math.floor()
返回值：返回小于或等于x，并且与之最接近的整数。
注：如果x是正数，则把小数“舍”；如果x是负数，则把小数“入”。

posted @ 2011-09-30 10:37 Java_liyadong 阅读(3076) | 评论 (0) | 编辑收藏

常用链接

留言簿

随笔档案

搜索

最新评论

阅读排行榜

评论排行榜