Java的基本符号（token）
Java的单词符号有五种：keyword、标识符、常量、分隔符和操作符。
Java的字符集
Java 採用一种称为unicode的字符集，该字符集合是一种新的编码标准。与常见的ASCII码的差别在于：
unicode使用16位二进制而不是8位来表示一个字符。
unicode字符集中添加了很多非拉丁语字符。
标识符
Java标识符必须以字母。数字，美元符号"$"，下划线"_"组成。标识符第一个字符不可用数字。
Java语言对字母的大写和小写是敏感的，在语法中严格区分大写和小写。
keyword
keyword是为特定目的而保留的保留字，程序猿不要将keyword作为自己的标识符。 Java的keyword有：
abstract boolean break byte case catch char class continue do double else extends false
find finally float for implements import instanceof int interface long native new null
package private public return short static super switch synchronized this throw true try void while
常量
常量可分为整型常量，浮点数常量，字符常量。字符串常量和布尔常量。
整型常量：可分为int型和long型两种，缺省为int型，long型数值后加L。
整型常量可用10、8和16进制表示。
如：123（十进制） 052（八进制） 0x3c（十六进制）
浮点数常量：有单精度和双精度之分。缺省为双精度，单精度在数值后加f。
另外，浮点数常量也可用普通计数法和科学计数法来表示。
如：1.23f 1.1E-2
字符常量：用‘ ‘括起来的一个字符。如‘a‘，‘H‘。
使用16位的unicode字符集。
Java 语言可使用转义字符‘“‘来标记特殊字符。如‘“n‘表示换行符。
字符串常量用" "包含，如"Hello World"。
布尔常量仅仅有两个值，true和false。
分隔符
分隔符起分隔单词符号的作用。
包含分号";"、花括号"{}"和空白符号。
Java的凝视
Java的凝视有三种形式：
单行凝视
如：//Comment on one line
多行凝视
如：/* Comment on one
or more lines */
文档凝视
如：/** Document
Comment */
Java的数据类型和变量
Java的基本数据类型
Java的基本数据类型有8种，见下表：
数据类型 类别 宽度（位） 取值范围
boolean 逻辑型 1 true/false
char 文字型 16
byte 整数类型 8 -27 ~ 27-1
short 整数类型 16 -215 ~ 215-1
int 整数类型 32 -231 ~ 231-1
long 整数类型 64 -263 ~ 263-1
float 浮点型 32
double 浮点型 64
Java的变量
Java的变量在使用前必须声明。
如 int radios, color;
Java为全部基本数据类型的变量作了提前定义(预设置的值)。如
类型名 boolean char byte short int long float double
预置值 false ‘“u0000‘ (byte)0 (short)0 0 0L 0.0f 0.0
数据类型的转换
Java是一种强类型的语言，在赋值和參数传递时。都要求类型的匹配。类型转换有三种情况：自己主动转换、强制转换和使用类的方法转换。
自己主动转换：往往低精度类型到高精度类型能自己主动转换。
如： byte b1=10, b2=20；
int b3=b1+b2；
强制转换：高精度类型到低精度类型必须强制转换。
这时数据可能会丢失部分信息。
如：char key=(char)(12+55) //变量key被赋值为unicode值为67的字符‘c‘
方法转换：如
String str = "123";
int a = Integer.parseInt(str);
使用Integer类的方法parseInt将String转换为相应的整数。
Java编程的习惯约定
为了提高程序的可读性，Sun公司推荐在Java编程时使用下面的习惯约定：
类名（classes）：有一个或若干个名词组成，开头大写，名词间的区分也用大写，其它小写。
如：class AccountBook
class ComplexVariable
接口（Interfaces）：规则同类名。
如：Interface Account
方法（methods）： 由一个或多个动词组成，开头小写，动词间区分用大写，其它小写。
如：balanceAccount()
变量：小写字母开头，单词间用大写字母分隔
如：currentCustomer
常量：全部字母大写。单词间用下划线区分
如：MAXIMUM_SIZE
Java的操作符
依据操作对象的个数操作符可分为一元、二元或三元操作符。依据操作符的功能，又可分为算术、逻辑、关系等操作符。
算术操作符
一元： + - ++ --
二元： + - * / %
值得注意的是 ++ 和-- 操作符，
如：int a。x=1，y=5。
a = ++x。b=y++。
此时a的值为2（先加1，后赋值），b的值为5（先赋值。后加1）。
二元操作符两側的操作对象数据类型不先自己主动进行类型转换，再进行操作。
赋值操作符与复合赋值操作符
可将 变量 = 变量 op 表达式
写成 变量 op = 表达式
如：x+=20 与 x=x+20 结果一致，但更简洁。
注意：= 与 = = 的不同。
位操作符和移位操作符
位操作符
&（按位与） |（按位或） ^（按位异或）
移位操作符
E<<n 左移n位。空位补0，相当于E*2
E>>n 右移n位，空位用原最高位的位值补足，相当于E/2
E>>>n 右移n位，空位补0
关系操作符
关系操作符共六个：
>（大于） >=（大于等于） <（小于）<=（小于等于） !=（不等于） = =（相等）
关系操作符的结果为boolean型数据（true或false）。
注：= = 操作符仅仅有在比較两方均全然一致时。其值为true。如比較的是两个对象。即使两个对象的内容同样，结果也为false。
仅仅有这两个对象为同一对象时才为true。
逻辑操作符
逻辑操作符的操作对象和结果均为boolean型，共六个：
。（逻辑非） && （逻辑与） ||（逻辑或）
^（逻辑并或） & （逻辑与） | （逻辑或）
按位与‘&‘也可作为逻辑与使用，但未作优化，而‘&&‘操作符是经过优化的。对‘|‘操作符也类似。
其它操作符
条件操作符 E1?
E2:E3
表达式E1若成立，运行表达式E2，否则运行E3。
逗号操作符
","可用于分隔语句。
如 int x,y;
for (x=0,y=0;x<10;x++) {...};
操作符的优先级和结合规则
优先级：
一元 〉算术 〉移位 〉关系 〉按位 〉逻辑 〉三元 〉（复合）赋值 〉逗号
结合规则：
除一元、三元和赋值操作符是自右至左结合外，其它均自左至右结合。
语句的分类
Java语句按是否改变运行的状态可分为运行语句(如表达式语句)和非运行语句(如声明语句)。不论什么语句的末尾都以“；”结束。
运行语句按其组成可分三类：
空语句
仅仅有一个语句结束符“。” 。无不论什么内容。
基本语句（单语句）
独立的、完整的不能再切割为更小的可运行单元。
复合语句（块语句）
包括在{ }内的一条或若干条语句。
Java的基本语句的结构可分为4类：
（1）顺序结构语句 （2）分支语句 （3）循环语句 （4）例外处理语句
后三种语句又称为流控制语句，我们将主要介绍分支语句和循环语句，而例外处理语句包含try、catch、finally以及throw语句。
这些语句是Java所特有的。
我们将在后面作专门的介绍。
分支语句
分支语句包含if-else, break, switch, return等语句。分支语句提供了一种控制机制。使得程序能够跳过一些语句，转去运行特定的语句。
条件语句 if-else.
if-else语句依据判定条件的真假来运行两种操作中的一种,其格式为:
if (boolean-expression)
statement1;
else
statement2;
当中，要注意的有：
布尔表达式boolean-expression是随意一个返回布尔型数据的表达式(这比C、C++的限制要严格)。
每一个单一的语句后都必须有分号。
语句statement1, statement2能够是复合语句，这时要用花括号{}。{}外面不加分号。
else子句是任选的。
若布尔表达式的值为true，则程序运行statement1，否则运行statement2。
if-else语句的一种特殊形式为:
if (expression1){
statement1
} else if (expression2){
statement2
}……
}else if (expressionN){
statementN
}
else子句不能单独作为语句使用，它必须和if配对使用。else总是与离它近期的if配对。能够通过使用花括号{}来改变配对关系。
例3.1: 比較两个数的大小,并按从小到大的次序输出。
public class CompareTwo{
public static void main (String args[]){
double d1=23.4;
double d2=35.1;
if (d2＞=d1)
System.out.println(d2+"＞="+d1);
else
System.out.println(d1+"＞="+d2);
}
}
例3.2：推断某一年是否为闰年。
闰年的条件是符合以下二者之中的一个: ①能被4整除,但不能被100整除; ②能被400整除。
public class LeapYear{
public static void main (String args[]){
int year=1989; //method1
if ((year%4==0 && year%100!=0) || (year%400==0))
System.out.println(year+"is a leap year.");
else
System.out.println(year+"is not a leap year.");
year=2000; //method2
boolean leap;
if (year%4 != 0)
leap=false;
else if (year%100 != 0)
leap=true;
else if (year%400 != 0)
leap=false;
else
leap=true;
if(leap==true)
System.out.println(year+" is a leap year.");
else
System.out.println(year+"is not a leap year.");
}
}
该例中，方法1用一个逻辑表达式包括了全部的闰年条件。方法2使用了if-else语句的特殊形式。
多分支语句switch
switch语句是一种多分支选择语句。它可依据switch中表达式的值，来运行多个操作中的一个，它的一般格式例如以下：
switch (expression){
case value1: statement1;
break;
case value2: statement2;
break;
…………
case valueN: statemendN;
break;
[default: defaultStatement;]
}
表达式expression能够返回任一简单类型的值(如整型、字符型)，多分支语句把表达式返回的值与每一个case子句中的值（一个常量）相比。
假设匹配成功，则运行该case子句后的语句序列。
default子句是任选的。当表达式的值与任一case子句中的值都不匹配时。程序运行default后面的语句。
假设表达式的值与任一case子句
中的值都不匹配且没有default子句。则程序不做不论什么操作，直接跳出switch语句。
break语句用来在运行完一个case分支后，使程序跳出switch语句，即终止switch语句的运行。
switch语句的功能能够用if-else来实现，但在某些情况下，使用switch语句更简炼，且程序的运行效率提高。
例3.3 依据考试成绩的等级打印出百分制分数段。
public class GradeLevel {
public static void main(String args[]){
System.out.println("“nOutPut is:");
char grade=‘C‘; //normal use
switch (grade){
case ‘A‘: System.out.println(grade+"is 85～100");
break;
case ‘B‘: System.out.println(grade+"is 70～84");
break;
case ‘C‘: System.out.println(grade+"is 60～69");
break;
case ‘D‘: System.out.println(grade+"is ＜60");
break;
default: System.out.println("inputerror");
}
}
}
break语句
在switch语中。break语句用来终止switch语句的运行。使程序在switch语句后的第一个语句開始运行。
在Java中，能够为每一个代码块加一个括号。一个代码块一般是用花括号{}括起来的一段代码。加标号的格式例如以下:
BlockLabel: {codeBlock}
break语句的另外一种使用情况就是跳出它所指定的块，并从紧跟该块的第一条语句处运行。
其格式为: break BlockLabel;
比如:
a: {…… //标记代码块a
b: {…… //标记代码块b
c: {…… //标记代码块c
break a;
……//will not be executed
}
……//will not be executed
}
……//will not be executed
}
…… //execute from here
与C、C++不同, Java中没有goto语句来实现随意的跳转, 由于goto语句破坏程序的可读性, 并且影响编译的优化。Java用break来实
现goto语句所特有的一些功能。
返回语句return
return语句用于从当前运行的方法中退出, 并返回到调用该方法的语句处继续程序的运行。
返回语句有两种格式:
return expression
返回一个值给调用该方法的语句, 返回值的数据类型必须与方法声明中的返回值类型一致。能够使用强制类型转换来使类型一致。
return
当方法说明中用void声明返回类型为空时, 能够使用这样的格式, 它不返回不论什么值。不带參数的return语句有时可省略。
return语句通经常使用在一个方法体的最后。
循环语句
循环语句包含 while, do-while, for, continue 等语句。
循环语句的作用是重复运行一段代码。直到满足循环终止条件为止。
一个循环一般应包含四部分内容：
初始化部分(initialization): 用来设置循环的一些初始条件，计数器清零等。
循环体部分(body): 这是重复循环的一段代码，能够是单一的一条语句，也能够是复合语句。
迭代部分(iteration): 这是在当前循环结束。下一次循环開始前运行的语句，经常常使用来使计数器加1或减1。
终止部分(termination): 一般是一个布尔表达式，每一次循环要对该表达式求值，以验证是否满足循环终止条件。
以下分别介绍Java中的while语句，do-while语句和for语句。
while语句
while语句的一般格式为：
[初始化]
while (条件表达式E){
语句S; //循环体
}
当条件表达式E的值为true时，循环运行花括号里的语句S。S中包含迭代部分。
while语句首先计算条件表达式E是否成立，当条件成立(true)时，才去运行循环中的语句。所以有可能循环体一次也不运行。
do-while语句
do-while语句的一般格式为:
[初始化]
do {
语句S; //循环体
} while (条件表达式E);
do-while语句首先运行循环体, 然后再计算终止条件, 若结果为true, 则循环运行语句S, 直到条件表达式E的结果为false。
与while语句不同的是, do-while语句的循环体至少运行一次。
for语句
for语句的一般格式为:
for (初始表达式; 条件表达式; 迭代表达式) {
语句S; //循环体
}
for语句运行时，首先运行初始化操作。然后推断终止条件是否满足，假设满足。则运行循环体中的语句。最后运行迭代部分。
完毕一次循环后。又一次推断终止条件。
能够在for语句的初始化部分声明变量。它的作用域为整个for语句。
for语句通经常使用来运行循环次数确定的情况(如对数组元素进行操作)。
在初始化部分和迭代部分能够使用逗号语句来分隔多个操作。比如:
for (i=0,j=10; i＜j; i++,j--) {
……
}
continue语句
continue语句用来结束本次循环, 跳过循环体中以下尚未运行的语句, 接着进行终止条件的推断, 以决定是否继续循环。
也能够用continue跳转到括号指明的外层循环中,这时的格式为
continue outerLable;
例3.4：下例分别用while、do-while和for语句实现累计求和。
public class Sum{
public static void main(String args[]){
System.out.println("“n**while statement**");
int n=10,sum=0; ∥initialization
while (n＞0){ ∥termination
sum+=n; ∥body
n--; ∥iteration
}
System.out.println("sum is"+sum);
System.out.println("“n**do_while statement**");
n=0; ∥initialization
sum=0;
do{
sum+=n; ∥body
n++; ∥iteration
} while(n＜=10); ∥termination
System.out.println("sum is"+sum);
System.out.println("“n**for statement**");
sum=0;
for (int i=1;i＜=10;i++){
sum+=i;
}
System.out.println("sum is"+sum);
}
}
能够从中来比較这三种循环语句,从而在不同的场合选择合适的语句。
数组
数组是有序数据的集合, 数组中的每一个元素具有同样的类型。
数组名和下标可唯一地确定数组中的元素。
数组可分为一维数组和多维数组。
一维数组
声明方式：
type arrayName[];
或 type[] arrayName;
type能够是Java中随意的数据类型, arrayName为数组名。
如: int intArray[];
声明了一个名为intArray的整型数组, 数组中的每一个元素为int型数据。
Java在数组的声明中并不为数组元素分配内存, 因此 [ ] 中不用指出数组中元素个数, 即数组长度。
在訪问数组的不论什么元素之前，我们必须为它分配内存空间, 这可用new操作符, 其格式例如以下：
arrayName = new type[arraySize];
当中。arraySize指明数组的长度。
如: intArray = new int; 为该数组分配了3个int型整数所需的内存空间。
通常, 这两部分能够合在一起, 格式例如以下:
type arrayName[] = new type[arraySize];
如: int intArray[] = new int;
用new操作符为数组分配内存空间后，就能够引用数组中的每个元素。数组元素的引用方式为: arrayName[index]
当中: index为数组下标，它能够为整型常数或表达式。如a, b(i为整型), c[6*I]等。下标从0開始, 一直到数组的长度减1。
对于上面样例中的intArray数组来说。它有3个元素，分别为:
intArray[0], intArray[1], intArray。（注意: 没有intArray。
）
另外，与C、C++中不同。Java对数组元素要进行越界检查以保证安全性。
对于每一个数组都有一个属性length指明它的长度。
比如: intArray.length指明数组intArray的长度。
数组的初始化
对数组元素能够依照上述的样例进行赋值。也能够在定义数组的同一时候进行初始化。
如: int a[]={1,2,3,4,5};
用逗号(,)分隔数组的各个元素。系统自己主动为数组分配一定的内存空间。
例3.5：数组的使用：
public class ArrayTest{
public static void main(String args[]){
int i;
int a[]=new int;
for (i=0;i＜5;i++)
a=i;
for (i=a.length-1;i＞=0;i--)
System.out.println("a["+i+"]="+a);
}
}
多维数组
与C、C++一样, Java中多维数组可被看作数组的数组。比如二维数组就可看成是一个特殊的一维数组, 该数组的每一个元素又
是一个一维数组。以下我们主要以二维数组为例来说明多维数组。
二维数组的声明方式例如以下:
type arrayName[][];
如: int intArray[][];
与一维数组一样,这时对数组元素也没有分配内存空间，同要使用运算符new来分配内存,然后才干够訪问每一个元素。
对二维数组中每一个元素。引用方式为:
arrayName[index1][index2]
当中index1、index2为下标, 可为整型常数或表达式, 如a等。
数组每一维的下标也都从0開始。
在声明二维数组的同一时候也可对它进行初始化。
如:int a[][]={{2,3},{1,5},{3,4}};
定义了一个3×2的数组,并对每一个元素赋值。
数组的越界
假设使用数组分量时，其下标超过规定的值，则会发生数组的越界。
这时，尽管程序能通过编译，但在执行时会产生一个
名为ArrayIndexOutOfBoundsException 的例外，所以编程时要注意检查数组下标。
1．VO是用newkeyword创建，由GC回收的。
PO则是向数据库中加入新数据时创建。删除数据库中数据时削除的。
而且它仅仅能存活在一个数据库连接中，断开连接即被销毁。
2．VO是值对象，精确点讲它是业务对象，是存活在业务层的。是业务逻辑使用的。它存活的目的就是为数据提供一个生存的地方。
PO则是有状态的，每一个属性代表其当前的状态。它是物理数据的对象表示。使用它，能够使我们的程序与物理数据解耦。而且能够简化对象数据与物理数据之间的转换。
3．VO的属性是依据当前业务的不同而不同的，也就是说，它的每个属性都一一相应当前业务逻辑所须要的数据的名称。
PO的属性是跟数据库表的字段一一相应的。
PO对象须要实现序列化接口。
-------------------------------------------------
PO是持久化对象。它仅仅是将物理数据实体的一种对象表示，为什么须要它？由于它能够简化我们对于物理实体的了解和耦合，简单地讲，能够简化对象的数据转换为物理数据的编程。
VO是什么？它是值对象，准确地讲，它是业务对象，是生活在业务层的，是业务逻辑须要了解。须要使用的。再简单地讲。它是概念模型转换得到的。
首先说PO和VO吧。它们的关系应该是相互独立的。一个VO能够仅仅是PO的部分，也能够是多个PO构成，相同也能够等同于一个PO（当然我是指他们的属性）。正由于这样，PO独立出来，数据持久层也就独立出来了，它不会受到不论什么业务的干涉。又正由于这样，业务逻辑层也独立开来，它不会受到数据持久层的影响。业务层关心的仅仅是业务逻辑的处理。至于怎么存怎么读交给别人吧！
只是，另外一点。假设我们没有使用数据持久层。或者说没有使用hibernate。那么PO和VO也能够是同一个东西，尽管这并不好。
----------------------------------------------------
java的(PO,VO,TO,BO,DAO,POJO)解释
PO(persistant object) 持久对象
在o/r映射的时候出现的概念，假设没有o/r映射，没有这个概念存在了。
通常相应数据模型(数据库),本身还有部分业务逻辑的处理。
能够看成是与数据库中的表相映射的java对象。
最简单的PO就是相应数据库中某个表中的一条记录，多个记录能够用PO的集合。PO中应该不包括不论什么对数据库的操作。
VO(value object) 值对象
通经常使用于业务层之间的数据传递，和PO一样也是只包括数据而已。但应是抽象出的业务对象,能够和表相应,也能够不,这依据业务的须要.个人认为同DTO(传输数据对象),在web上传递。
TO(Transfer Object)。传输数据对象
在应用程序不同tie(关系)之间传输的对象
BO(business object) 业务对象
从业务模型的角度看,见UML元件领域模型中的领域对象。封装业务逻辑的java对象,通过调用DAO方法,结合PO,VO进行业务操作。
POJO(plain ordinary java object) 简单无规则java对象
纯的传统意义的java对象。就是说在一些Object/Relation Mapping工具中。可以做到维护数据库表记录的persisent object全然是一个符合Java Bean规范的纯Java对象。没有添加别的属性和方法。
我的理解就是最主要的Java Bean，仅仅有属性字段及setter和getter方法！。
DAO(data access object) 数据訪问对象
是一个sun的一个标准j2ee设计模式。这个模式中有个接口就是DAO。它负持久层的操作。为业务层提供接口。
此对象用于訪问数据库。
通常和PO结合使用，DAO中包括了各种数据库的操作方法。通过它的方法,结合PO对数据库进行相关的操作。夹在业务逻辑与数据库资源中间。配合VO, 提供数据库的CRUD操作...
O/R Mapper 对象/关系 映射
定义好全部的mapping之后，这个O/R Mapper能够帮我们做非常多的工作。
通过这些mappings,这个O/R Mapper能够生成全部的关于对象保存，删除，读取的SQL语句，我们不再须要写那么多行的DAL代码了。
实体Model(实体模式)
DAL(数据訪问层)
IDAL(接口层)
DALFactory(类工厂)
BLL(业务逻辑层)
BOF Business Object Framework 业务对象框架
SOA Service Orient Architecture 面向服务的设计
EMF Eclipse Model Framework Eclipse建模框架
----------------------------------------
PO：全称是
persistant object持久对象
最形象的理解就是一个PO就是数据库中的一条记录。
优点是能够把一条记录作为一个对象处理，能够方便的转为其他对象。
BO：全称是
business object:业务对象
主要作用是把业务逻辑封装为一个对象。这个对象能够包含一个或多个其他的对象。
比方一个简历，有教育经历、工作经历、社会关系等等。
我们能够把教育经历相应一个PO。工作经历相应一个PO，社会关系相应一个PO。
建立一个相应简历的BO对象处理简历。每一个BO包括这些PO。
这样处理业务逻辑时。我们就能够针对BO去处理。
VO
value object值对象
ViewObject表现层对象
主要相应界面显示的数据对象。对于一个WEB页面。或者SWT、SWING的一个界面。用一个VO对象相应整个界面的值。
DTO
Data Transfer Object传输数据对象
主要用于远程调用等须要大量传输对象的地方。
比方我们一张表有100个字段，那么相应的PO就有100个属性。
可是我们界面上仅仅要显示10个字段，
client用WEB service来获取数据，没有必要把整个PO对象传递到client，
这时我们就能够用仅仅有这10个属性的DTO来传递结果到client，这样也不会暴露服务端表结构.到达client以后，假设用这个对象来相应界面显示，那此时它的身份就转为VO
POJO
plain ordinary java object 简单java对象
个人感觉POJO是最常见最多变的对象，是一个中间对象，也是我们最常打交道的对象。
一个POJO持久化以后就是PO
直接用它传递、传递过程中就是DTO
直接用来相应表示层就是VO
DAO
data access object数据訪问对象
这个大家最熟悉，和上面几个O差别最大。基本没有互相转化的可能性和必要.
主要用来封装对数据库的訪问。通过它能够把POJO持久化为PO，用PO组装出来VO、DTO
-----------------------------------------------------------------
PO:persistant object持久对象,能够看成是与数据库中的表相映射的java对象。最简单的PO就是相应数据库中某个表中的一条记录，多个记录能够用PO的集合。 PO中应该不包括不论什么对数据库的操作.
VO:value object值对象。通经常使用于业务层之间的数据传递，和PO一样也是只包括数据而已。
但应是抽象出的业务对象,能够和表相应,也能够不,这依据业务的须要.个人认为同DTO(传输数据对象),在web上传递.
DAO:data access object数据訪问对象，此对象用于訪问数据库。通常和PO结合使用。DAO中包括了各种数据库的操作方法。通过它的方法,结合PO对数据库进行相关的操作.
BO:business object业务对象,封装业务逻辑的java对象,通过调用DAO方法,结合PO,VO进行业务操作;
POJO:plain ordinary java object 简单无规则java对象,我个人认为它和其它不是一个层面上的东西,VO和PO应该都属于它.
---------------------------------------------
VO：值对象、视图对象
PO：持久对象
QO：查询对象
DAO：数据訪问对象
DTO：传输数据对象
----------------------------------------
struts 里的 ActionForm 就是个VO;
hibernate里的 实体bean就是个PO,也叫POJO;
hibernate里的Criteria 就相当于一个QO;
在使用hibernate的时候我们会定义一些查询的方法,这些方法写在接口里,能够有不同的实现类.而这个接口就能够说是个DAO.
----------------------------------------
PO或叫BO，与数据库最接近的一层，是ORM中的O，基本上是数据库字段相应BO中的一个属性，为了同步与安全性考虑，最好仅仅给DAO或者Service调用，而不要用packcode,backingBean,或者BO调。
DAO。数据訪问层，把VO。backingBean中的对象能够放入。。。。
DTO，非常少用。基本放入到DAO中。仅仅是起到过渡的作用。
QO，是把一些与持久性查询操作与语句放入。
。
VO，V层中用到的基本元素与方法等放当中。假设要其调用BO。则要做BO转换VO。VO转换BO操作。
VO的优点是其页面的元素属性多于BO，可起到非常好的作用。
。
。
。
-----------------------------------------
楼上的不正确吧，PO是持久化对象。
BO＝business object—业务对象。
PO能够严格相应数据库表，一张表对映一个PO。
BO则是业务逻辑处理对象，我的理解是它装满了业务逻辑的处理，在业务逻辑复杂的应用中实用。
VO：value object值对象、view object视图对象
PO：持久对象
QO：查询对象
DAO：数据訪问对象——同一时候还有DAO模式
DTO：传输数据对象——同一时候还有DTO模式
Math.round(11.5)等於多少? Math.round(-11.5)等於多少?
Math.round(11.5)返回（long）12，Math.round(-11.5)返回（long）-11; tring s = new String("xyz");创建了几个String Object?
两个对象，一个是“xyx”,一个是指向“xyx”的引用对象s。
short s1 = 1; s1 = s1 + 1;有什么错?
short s1 = 1; s1 += 1;有什么错? short s1 = 1; s1 = s1 + 1;有错，s1是short型，s1+1是int型,不能显式转化为short型。可改动为s1 = (short)(s1 + 1) 。
short s1 = 1; s1 += 1正确。
sleep() 和 wait() 有什么差别? 搞线程的最爱
sleep()方法是使线程停止一段时间的方法。在sleep 时间间隔期满后，线程不一定马上恢复运行。这是由于在那个时刻，其他线程可能正在运行并且没有被调度为放弃运行，除非(a)“醒来”的线程具有更高的优先级。 (b)正在运行的线程由于其他原因而堵塞。 wait()是线程交互时，假设线程对一个同步对象x 发出一个wait()调用，该线程会暂停运行，被调对象进入等待状态。直到被唤醒或等待时间到。