1.       普通用户可以通过系统浏览商品（按类别）

2.       普通用户可以通过系统搜索商品（按类别、价位、日期等）

3.       普通用户可以通过系统下订单（享受市场价）

4.       普通用户可以注册成为系统会员（免费注册）

5.       会员可以浏览和检索商品

6.       会员可以下订单（享受会员价）

7.       会员可以浏览自己下过的订单

8.       会员可以管理自己的信息（自服务系统）

a)         修改密码

b)        修改送货地址

c)        修改联系方式

9.       会员可以分级别

1)      不同级别享受不同等级的优惠

2)      通过购物的金额确定级别

10.   管理员通过后台进行会员管理

              1）会员浏览

              2）会员历史订单浏览

              3）会员删除

        4）指定会员级别

11. 管理员通过后台进行产品分类的管理

              1）浏览、添加、删除、修改

12. 管理员通过后台进行产品管理

              1）新增产品

              2）产品上柜

              3）产品下柜

              4) 产品销量浏览

              5）产品搜索

              6）产品删除

              7）产品修改

13. 管理员通过后台进行订单的管理

              1）订单查询

              2）修改订单状态

              3）订单搜索

              4）订单跟踪

              5）订单提醒

Ricer网上商城—架构分析与设计

逻辑架构

       JSP + JavaBeans + Database

              JSP负责表现

              JavaBeans负责业务逻辑

              Database负责持久保持数据

物理架构

       Web服务器一台

              配置

       Database服务器一台

              配置

技术解决方案

       Web Server—Tomcat5.5

       Database—MySQL5.0

Ricer网上商城—业务逻辑分析

1.         会员类

1）    包装系统会员

2）    与订单类有一对多的关系

2.         管理员类

1）    包装系统管理员

3.         产品类

1）    包装产品的信息

2）    与订单是多对多的关系

4.         类别类

1）    包装产品的类别

2）    树状结构

3）    与产品是一对多的关系

5.         订单类

1）    包装订单的信息

2）    与产品是多对多的关系

3）    与会员是多对已的关系

6.         购物车类

1）    包装购物车的信息

2）    与产品是多对多的关系

RiKeR网上商城—业务逻辑设计

1.         User

a)         properties

                         i.              id

                       ii.              username

                      iii.              password

                     iv.              phone

                       v.              addr

                     vi.              rdate

b)        methods

                         i.              getOrders()

                       ii.              save()

                      iii.              change()

                     iv.              delete

                       v.              static search()

2.         Administrator

a)         properties

                         i.              usernae

                       ii.              password

b)        methods

                         i.              login()

3.         Product

a)         properties

                         i.              id

                       ii.              name

                      iii.              descr

                     iv.              normalPrice

                       v.              memberPrice

                     vi.              pdate

                    vii.              category

2)    methods

       i.     getCategory()

       ii.     getSalesCount()

iii.                  save()、change()、search()等

4.         Category

a)         properties

                         i.              id

                       ii.              name

                      iii.              descr

                     iv.              pid(parent:Category)

b)        methods

                         i.              getProductCounts()

                       ii.              save()、change()等

5.         SalesOrder&SaleItem

a)         properties

                         i.              id

                       ii.              userid

                      iii.              addr

                     iv.              SalesItem[]

                       v.              odate

b)        methods

                         i.              getTotalPrice()

                       ii.              save()、change()等

                      iii.              getSalesItems()

6.         SalesOrder&SaleItem

a)         properties

                         i.              id

                       ii.              productID

                      iii.              unitPrice

                     iv.              pCount

b)        methods

                         i.              getTotalPrice()

                       ii.              save()、change()等

7.         ShoppingCart&CartItem

a)         properties

                         i.              userid

                       ii.              CartItem[]

b)        methods

                         i.              getTotalPrice()

                       ii.              save()、change()等

                      iii.              getCartItems()

8.         ShoppingCart&CartItem

a)         properties

                         i.              productID

                       ii.              unitPrice

                      iii.              pCount

b)        methods

                         i.              getTotalPrice()

RiKeR网上商城—数据库设计

RiKeR网上商城—界面设计

前台

1.         首页index.jsp

a)         显示某类商品

b)        根据id显示图片

c)        搜索

d)        注册

e)         登录

f)         自服务

2.    搜索界面       search.jsp

3.    搜索结构       searchresult.jsp

4.    注册

       a)    注册页面       register.jsp

       b)  注册成功       registerok.jsp

       c)    注册失败       registererr.jsp

5.    登录

       a)    login.jsp

       b)    loginok.jsp

       c)    loginerr.jsp

6.    自服务    selfservice.jsp

       a)    changepassword.jsp

       b)    changepasswordok.jsp

       c)    changepassworderr.jsp

       d)    changeinfo.jsp

       e)    changeinfook.jsp

       f)     changeinfoerr.jsp

7.    购物

       a)    购物车浏览    cart.jsp

       b)    结帐       buy.jsp

后台（admin目录下）

1.    登录页面       login.jsp

2.    首页       index.jsp

       a)    用户管理

       b)    产品管理

       c)    类别管理

       d)    订单管理

3.    用户管理

       a)    显示用户       userlist.jsp

       b)    删除用户       userdelete.jsp

       c)    搜索用户       usersearch.jsp

4.    产品管理

       a)    productlist.jsp

       b)    productadd.jsp

       c)    productchange.jsp

       d)    productdelete.jsp

       e)    productSearch.jsp

5.    类别管理

       a)    categorylist.jsp

       b)    categoryadd.jsp

       c)    categorydelete.jsp

       d)    categorychange.jsp

6.    订单管理

       a)    订单浏览       salesorderlist.jsp

       b)    订单处理       salesorderdeal.jsp

RiKeR网上商城—开发环境搭建

开发工具

       Eclipse3.2

Web Server

       Tomcat5.5

Database

       MySQL

SCM

       CVS

RiKeR网上商城—开发

先写用户

再写分类

然后写产品

接下来购物

最后订单处理

其他功能

RiKeR网上商城—开发安排

V0.1

       用户—JavaBeans前台/后台

V0.2

分类—JavaBeans前台/后台

……

RiKeR网上商城—文档编纂

需求描述文档

系统分析与设计

数据库设计

开发接口API docs&源代码注释

用户帮助（前台）

管理员手册（后台）

测试文档

 <input type=text size=4 name="pageNo" value=<%=pageNo%> /> 这/>

<select name="pageNo" onchange="document.form1.submit()">
  <%
  for(int i=1; i<=totalPages; i++) {
  %>
  <option value=<%=i %> <%=(pageNo == i) ? "selected" : ""

%>>第<%=i %>页
  <%
  }
  %>
 </select>
中</select>

一、编程规范 不管是用什么语言一定要有一个规范的写法。。

密码:<input type="password" name="password"><br>

如果你要加入 JavaScript 的验证 你一定要加一个 id 属性

密码:<input type="password" name="password" id="password"><br>

name 属性是在页面传递值的时候用 ，id 则是在 本页面用

第二、 在找页面中的某个元素的时候 我不建议你这样写

password1=document.form1.password1.value;

建议你写成这样
var password
password = document.getElementById('password');
得到 password 以后

if(password.value==null||password==""){
... ...
return false;
}

最后

OnSubmit="check()"

OnSubmit = ... 需要的是一个 true 或者 false

所以你就要 check() 的返回值 再返回给 onsubmit

onsubmit="return check()"

==================>

1.树状结构的存储与展现-递归方式
2.JavaScript css html jsp结合运用
3.分页
4.前台、后台
5.Session初步
6.功能完成与健壮之间的区别

首先我们给出一个看似无关却非常重要的概念：属性集的闭包。
令α为一属性集。我们称在函数依赖集F下由α函数确定的所有属性的集合为F下α的闭包，记为α+ 。
下面给出一个计算α+的算法，该算法的输入是函数依赖集F和属性集α，输出存储在变量result中。
算法一：
result:=α;
while(result发生变化)do
    for each 函数依赖β→γ in F do
    begin
        if β∈result then result:=result∪γ;
    end

属性集闭包的计算有以下两个常用用途：
·判断α是否为超码，通过计算α+（α在F下的闭包），看α+ 是否包含了R中的所有属性。若是，则α为R的超码。
·通过检验是否β∈α+，来验证函数依赖是否成立。也就是说，用属性闭包计算α+，看它是否包含β。

（请原谅我用∈符号来表示两个集合之间的包含关系，那个表示包含的符号我找不到，大家知道是什么意思就行了。）

看一个例子吧，2005年11月系分上午37题：

● 给定关系R(A1，A2，A3，A4)上的函数依赖集F={A1→A2，A3→A2，A2→A3，A2→A4}，R的候选关键字为________。
（37）A. A1 　B. A1A3 　C. A1A3A4 　D. A1A2A3

首先我们按照上面的算法计算A1+ 。
result=A1，
由于A1→A2，A1∈result，所以result=result∪A2=A1A2
由于A2→A3，A2∈result，所以result=result∪A3=A1A2A3
由于A2→A4，A2∈result，所以result=result∪A3=A1A2A3A4
由于A3→A2，A3∈result，所以result=result∪A2=A1A2A3A4

通过计算我们看到，A1+ =result={A1A2A3A4}，所以A1是R的超码，理所当然是R的候选关键字。此题选A 。

●设关系模式R<U, F>，其中U=｛A, B, C, D, E｝，F＝{A→BC，C→D，BC→E，E→A｝，则分解ρ={R1（ABCE），R2（CD）｝满足 （43） 。
（43） A．具有无损连接性、保持函数依赖
              B．不具有无损连接性、保持函数依赖
              C．具有无损连接性、不保持函数依赖
              D．不具有无损连接性、不保持函数依赖

再做保持依赖的判断。
A→BC，BC→E， E→A都在R1上成立（也就是说每一个函数依赖左右两边的属性都在R1中），C→D在R2上成立，因此给分解是保持依赖的。

选A。

再看一个复杂点的例题。2007年5月数工40-41题。

●给定关系模式R<U, F>，U=｛A, B, C, D, E｝，F＝{B→A，D→A，A→E，AC→B｝，其候选关键字为
（40）  ，则分解ρ={R1（ABCE），R2（CD）｝满足 （41） 。
（40） A．ABD
              B．ABE
              C．ACD
              D．CD
（41） A．具有无损连接性、保持函数依赖
              B．不具有无损连接性、保持函数依赖
              C．具有无损连接性、不保持函数依赖
              D．不具有无损连接性、不保持函数依赖

看见了吧，和前面一题多么的相像！
对于第一问，分别计算ABCD四个选项的闭包，
（ABD）+ = { ABDE }
（ABE）+ = { ABE }
（ACD）+ = { ABCDE }
（CD）+ = { ABCDE }
选D。

再做保持依赖的判断。
B→A，A→E，AC→B在R1上成立，D→A在R1和R2上都不成立，因此需做进一步判断。
由于B→A，A→E，AC→B都是被保持的（因为它们的元素都在R1中），因此我们要判断的是D→A是不是也被保持。

对于D→A应用算法二：
result=D
对R1，result∩R1=ф（空集，找不到空集的符号，就用这个表示吧），t=ф，result=D
再对R2，result∩R2=D，D+ =ADE ，t=D+ ∩R2=D，result=D
一个循环后result未发生变化，因此最后result=D，并未包含A，所以D→A未被保持，该分解不是保持依赖的。

 

500){this.resized=true;this.style.width=500;}" resized="true">

　　(1) A. P(S1) B．P(S2) C．P(Sn) D．P(Sn)、P(S1)

　　(2) A．P(Sn)、V(S2) B．P(Sn)、V(S1) C．P(S2)、V(S1) D.V(S1)、P(S2)

　　(3) A．P(S1)、V(S2) B．P(Sn)、V(S1) C．P(S2)、V(S1) D． V(S1)、 P(S2)

　　答案：（1）C （2）D （3）A

　　解析：这是一道考查PV操作的题，所以首先得弄清楚那些地方需要互斥、那些地方需要同步。题目中给出了两类进程：顾客进程与收银元进程，由于超市是顾客进程之间的公有资源，而且超市里限制最多允许有n个顾客购物，所以要设置一个公有信号量Sn，初值是n，顾客进程在进入超市时要执行P(Sn)，离开超市时要执行V(Sn)操作。顾客购物后要到收银员处付款，因此顾客进程与收银员进程之间是同步的关系，一次只允许一个顾客进程付款，整个超市只有一个收银员进程收费，所以需要为顾客进程设置一个私有信号量S2，为收银员进程设置一个私有信号量S1，由于开始时没有顾客去付款，收银员也没有收费，所以S1和S2的初值为0。当有顾客买完东西去付款时执行V(S1)，通知收银员进程有顾客付款，此时收银员进程执行P(S1)操作后就可进入收费，收费完成后收银元进程执行V(S2)，以通知顾客收费完毕，此时顾客执行P(S2)就可离开收银台，在离开超市时需执行V(Sn)，释放资源。

　　复习提示：PV操作在操作系统中处于很重要得地位，要想合适的运用PV操作，必须很好的理解进程之间的互斥与同步，即那些进程之间是互斥的，那些进程之间是同步的。

2005年上半年程序员试题
●某系统中有一个缓冲区，进程P1不断地生产产品送入缓冲区，进程P2不断地从缓冲区取产品消费。假设该缓冲区只能容纳一个产品。进程P1与P2的同步模型如下图所示：

(这个图就是教程中常见的那个图)

    P1                             P2           
  __|                            __|
 |  生产一个产品                 |  P(S2)
 |  P(S1)                        |  从缓冲区取一个产品
 |  产品送缓冲区                 |  V(S1)
 |  V(S2)                        |  消费            
 |__|                            |__|
  
为此，应设信号量S1的初值为__(18)__，信号量S2的初值为__(19)__。
(18)　A．-2 　　　　B．-1 　　　　C．0 　　　　D．1
(19)　A．-2 　　　　B．-1 　　　　C．0 　　　　D．1
答案：(18)D (19)C

分析：

资源S是这个资源初始状态拥有的数目，也就是没有任何操作，刚开始的时候资源的可用数。
简单的例子，一个盘子可以放8个苹果，一次只能一个人拿一个苹果或者放一个苹果，则设置两个资源S1、S2分别表示盘子中苹果的数量和取放苹果的许可，则S1初始值为8，S2为1。

以下一定要记住：
P操作
S = S-1
S<0 阻塞

V操作
S= S+1
S 〈=0  唤醒

S1、S2分别是P1、P2对缓冲区操作的开关，S1=1表示初始状态P1进程可以对缓冲区进行操作，而对于S2=0正好阻止了P2进程对缓冲区的操作！在刚开始的时候缓冲区为空，其允许P1在其中放入产品，但不能让P2取出产品，所以才产生这样的结果

 P一次什么什么就减一个。如果你P的玩意是0.那P下面的东西就不开工了。
V 一次什么就加一次
 
这个同步有s1 s2.
s1肯定是为1的。缓冲区可以放几个东西就应该是几.
你P了p1 一次以后。 代表向缓冲区里放了东西。s1 = 0了。表示缓冲区不能放东西了。进程时并行了。假设这句执行完了后跳到第二个程序中去。是p(s2) 刚肯定不行。所以s2一定要为初始要为0. 要等待第一个放进缓冲区的事做完后V(s2)把s2标志位搞醒

●某仓库有两名发货员，一名审核员。当顾客提货时，只要发货员空闲,允许顾客进入仓库提货，顾客离开时，审核员检验顾客提货是否正确。其工作流程如下图所示。为了利用PV操作正确地协调他们之间的工作，设置了两个信号量S1和S2，且S1的初值为2，S2的初值为1。图中的a应填写____(25)___；图中的b、c和d应分别填写____(26)____。
 

500){this.resized=true;this.style.width=500;}">

 
供选择的答案：
(25)A.P(S1)　　　　　 B.P(S2) 　　　　　C.V(S1) 　　　　　D.V(S2)
(26)A.P(S2)、V（S2）和V（S1） 　　　　B.P（S1）、V（S1）和V（S2）
　　C.V（S1）、P(S2)和V(S2)　　　　　 D.V（S2）、P（S1）和V（S1）

分析：

顾客来了,要看看是否有发货员.即发货员资源是否存在.
所以用P(S1)   若S1>0表示,存在(无论多少)
              若S1<=0表示,不存在,进程阻塞.

提完货.这说明,肯定用发货员了.肯定还有人等着提货.这时,应该释放发货员.
所以用V(S1)

然后,要审货.
可能有人正在审呢,所以用P(S2)意思和上面相同.
审完货.要释放,可能有人正等着审呢.所以用V(S2)释放审货员.
完毕.

PV原语实现进程间互斥与同步 

PV原语的含义
　　P操作和V操作是不可中断的程序段，称为原语。PV原语及信号量的概念都是由荷兰科学家E.W.Dijkstra提出的。信号量sem是一整数，sem大于等于零时代表可供并发进程使用的资源实体数，但sem小于零时则表示正在等待使用临界区的进程数。
　　P原语操作的动作是：
　　（1）sem减1；
　　（2）若sem减1后仍大于或等于零，则进程继续执行；
　　（3）若sem减1后小于零，则该进程被阻塞后进入与该信号相对应的队列中，然后转进程调度。
　　V原语操作的动作是：
　　（1）sem加1；
　　（2）若相加结果大于零，则进程继续执行；
　　（3）若相加结果小于或等于零，则从该信号的等待队列中唤醒一等待进程，然后再返回原进程继续执行或转进程调度。
　　PV操作对于每一个进程来说，都只能进行一次，而且必须成对使用。在PV原语执行期间不允许有中断的发生。
用PV原语实现进程的互斥
　　由于用于互斥的信号量sem与所有的并发进程有关，所以称之为公有信号量。公有信号量的值反映了公有资源的数量。只要把临界区置于P(sem)和V(sem)之间，即可实现进程间的互斥。就象火车中的每节车厢只有一个卫生间，该车厢的所有旅客共享这个公有资源：卫生间，所以旅客间必须互斥进入卫生间，只要把卫生间放在P(sem)和V(sem)之间，就可以到达互斥的效果。以下例子说明进程的互斥实现。
　　例1
　　生产围棋的工人不小心把相等数量的黑子和白子混装载一个箱子里，现要用自动分拣系统把黑子和白子分开，该系统由两个并发执行的进程组成，功能如下：
　　（1）进程A专门拣黑子，进程B专门拣白子；
　　（2）每个进程每次只拣一个子，当一个进程在拣子时不允许另一个进程去拣子；
　　分析：
　　第一步：确定进程间的关系。由功能（2）可知进程之间是互斥的关系。
　　第二步：确定信号量及其值。由于进程A和进程B要互斥进入箱子去拣棋子，箱子是两个进程的公有资源，所以设置一个信号量s，其值取决于公有资源的数目，由于箱子只有一个，s的初值就设为1。
　　实现：
　　begin
　　s:semaphore;
　　s:=1;
　　　cobegin
　　　　process A
　　　　begin
　　　　L1: P(s);
　　　　　拣黑子；
　　　　　V(s);
　　　　　goto L1;
　　　　end;
　　　　process B
　　　　begin
　　　　L2:P(s);
　　　　　拣白子；
　　　　　V(s);
　　　　　goto L2;
　　　　end;
　　　coend;
　　end;
　　判断进程间是否互斥，关键是看进程间是否共享某一公有资源，一个公有资源与一个信号量相对应。确定信号量的值是一个关键点，它代表了可用资源实体数。如下实例：
　　例2
　　某车站售票厅，任何时刻最多可容纳20名购票者进入，当售票厅中少于20名购票者时，厅外的购票者可立即进入，否则需要在外面等待。每个购票者可看成一个进程。
　　分析：第一步：确定进程间的关系。售票厅是各进程共享的公有资源，当售票厅中多于20名购票者时，厅外的购票者需要在外面等待。所以进程间是互斥的关系。第二步：确定信号量及其值。只有一个公有资源：售票厅，所以设置一个信号量s。售票厅最多容纳20个进程，即可用资源实体数为20，s的初值就设为20。
　　实现：
　　begin
　　s:semaphore;
　　s:=20;
　　cobegin
　　　process PI(I=1,2,……)
　　　　begin P(s);
　　　　　进入售票厅；
　　　　　购票；
　　　　　退出；
　　　　　V(s);
　　　　end;
　　　coend
        当购票者进入售票厅前要执行P(s)操作，执行后若s大于或等于零，说明售票厅的人数还未满可进入。执行后若s小于零，则说明售票厅的人数已满不能进入。这个实现中同时最多允许20个进程进入售票厅购票，其余进程只能等待。
用PV原语实现进程的同步
　　与进程互斥不同，进程同步时的信号量只与制约进程及被制约进程有关而不是与整组并发进程有关，所以称该信号量为私有信号量。利用PV原语实现进程同步的方法是：首先判断进程间的关系为同步的，且为各并发进程设置私有信号量，然后为私有信号量赋初值，最后利用PV原语和私有信号量规定各进程的执行顺序。下面我们将例1增添一个条件，使其成为进程间是同步的。
　　例3
　　在例1的基础之上再添加一个功能：
　　（3）当一个进程拣了一个棋子（黑子或白子）以后，必让另一个进程拣一个棋子（黑子或白子）。
　　分析：
　　第一步：确定进程间的关系。由功能（1）（2）（3）可知，进程间的关系为同步关系。第二步：确定信号量及其值。进程A和B共享箱子这个公有资源，但规定两个进程必须轮流去取不同色的棋子，因而相互间要互通消息。对于进程A可设置一个私有信号量s1，该私有信号量用于判断进程A是否能去拣黑子，初值为1。对于进程B同样设置一个私有信号量s2，该私有信号量用于判断进程B是否能去拣白子，初值为0。当然你也可以设置s1初值为0，s2初值为1。
　　实现:
　　begin
　　s1,s2:semaphore;
　　s1:=1;s2:=0;
　　cobegin
　　　process A
　　　begin
　　　L1: P(s1);
　　　　拣黑子；
　　　　V(s2);
　　　　goto L1;
　　　end;   
　　　process B
　　　begin
　　　L2:P(s2);
　　　　拣白子；
　　　　V(s1);
　　　　goto L2;
　　　end;
　　coend;
　　end;
　　另外一个问题就是P原语是不是一定在V原语的前面？回答是否定的。下面看一个例子。
         例4
　　设在公共汽车上，司机和售票员的活动分别是：司机：启动车辆，正常行车，到站停车。售票员：上乘客，关车门，售票，开车门，下乘客。用PV操作对其控制。
　　分析：
　　第一步：确定进程间的关系。司机到站停车后，售票员方可工作。同样，售票员关车门后，司机才能工作。所以司机与售票员之间是一种同步关系。
　　第二步：确定信号量及其值。由于司机与售票员之间要互通消息，司机进程设置一个私有信号量run，用于判断司机能否进行工作，初值为0。售票员进程设置一个私有信号量stop，用于判断是否停车，售票员是否能够开车门，初值为0。
　　实现：
　　begin stop ,run:semaphore
　　stop:=0;run:=0;
　　cobegin
　　　driver: begin
　　　L1: P(run);
　　　　启动车辆；
　　　　正常行车；
　　　　到站停车；
　　　　 V(stop);
　　　　goto  L1;
　　　end;
　　　conductor:begin
　　　L2:上乘客；
　　　　关车门；
　　　　V(run);
　　　　售票；
　　　　P(stop);
　　　　开车门；
　　　　下乘客；
　　　　goto L2;
　　　end;
　　　coend;
　　end;
　　用PV操作还可以实现进程同步与互斥的混合问题，典型的如：多个生产者和多个消费者共享容量为n的缓存区。这个例子在很多书中都有介绍，在这里就不说了。

• 只有通过大量的实践才能不断的培养编程感觉
• 编程是有感觉的，就好象英语阅读一样，是有语感的
• 每天都要编写代码，不断培养编程感觉

通过实践来增强对理论的理解

• 没有实践的理论是空虚的理论
• 没有理论的实践是盲目的实践
• 实践是检验真理的唯一标准

打破同学以往在程序设计学习中存在的误区

• 误区一：注重理论，轻视实践：学习新知识前想把关于这方面的理论全部掌握后再去实践，大错特错
• 解决方法：在了解理论后，就立即去实践，实践驱动理论的学习，这样掌握理论才更加扎实，不容易忘记

误区二：不善于做笔记，不善于总结。

解决方法：人总是有忘性的，今天记得很牢的东西，过一星期也许就完全忘记了，用笔记下来，好记性不如烂笔头，不要太相信自己的记忆

误区三：不善于思考，遇到问题首先想到问别人

解决方法：勤于思考，在学习的道路上会遇到大量问题，这些遇到的问题是你的宝贵财富。遇到问题时首先想为什么会出现该错误，尤其在程序中，应该学会看错误提示，根据提示去寻找错误的根源，实在不行再去问同学，问老师

因为自己寻找错误的过程是最好的学习过程，这个错误一旦被自己解决掉，首先得到的是极大的满足感，另外会留下深刻的印象，这是看书所得不到的，有过这种经历的同学才会有这种体会。即使没有解决也会从这个过程中学到很多东西，这种感觉是：只可意会，不可言传。

误区四：容易骄傲，以为自己会点技术就得意起来

解决方法：做人要谦虚，学习程序设计更要谦虚。要知道山外有山，人外有人，只有谦虚才会督促自己不断的去学习，编程水平的提高才会一点点上去的

误区五：没有耐心，怕麻烦，思考时间不够长

解决方法：没有耐心是写不好程序的，写程序是不仅是知识的体现，更是耐心与毅力的体现，任何程序开始都会有错误的，耐心寻找错误体现一个人的编程素养。要多思考，多去想，脑子越用越灵

误区六：想慢慢学好技术，一步一个脚印，踏踏实实，严重错误

解决方法：技术的发展日新月异，尤其在软件方面。学习一门新的技术，开始时不必面面俱到，先把hello world写出来再说，要“趁热打铁”，会的东西，仔细看；不会的东西，硬着头皮去看，实在不行就跳过。

误区七：不看英文，只看中文

解决方法：很多帮助文件，比如最重要的JDK帮助文件都是英文的，只有习惯看英文才能进步快，中文的翻译很多都是文不对题，看了还不如不看，看英文虽然慢，可是过了不久，你就会发现英文也没那么难懂

实践，实践，还是实践

即使书上有代码，也要把它敲出来，敲代码也是有感觉的

看明白 ！= 运行出来，是两个概念

希望大家在每次学习后都能有质的提高，而不仅仅学会了一些新技术，更要学会程序设计的一般方法，一般思想。也许你工作后未必从事J2EE或者.NET相关的工作，但是掌握了学习的方法，学习任何其他的技术都不是什么难事

WebWork是由OpenSymphony组织开发的，致力于组件化和代码重用的拉出式MVC模式J2EE Web框架。WebWork目前最新版本是2.2，现在的WebWork2.x前身是Rickard Oberg开发的WebWork，但现在WebWork已经被拆分成了Xwork1和WebWork2两个项目。Xwork简洁、灵活功能强大，它是一个标准的Command模式实现，并且完全从web层脱离出来。Xwork提供了很多核心功能：前端拦截机（interceptor），运行时表单属性验证，类型转换，强大的表达式语言（OGNL – the Object Graph Notation Language），IoC（Inversion of Control倒置控制）容器等。

WebWork2建立在Xwork之上，处理HTTP的响应和请求。WebWork2使用ServletDispatcher将HTTP请求的变成Action(业务层Action类), session（会话）application（应用程序）范围的映射，request请求参数映射。WebWork2支持多视图表示，视图部分可以使用JSP, Velocity, FreeMarker, JasperReports，XML等

1 XWork提供了普通的(generic)命令模式(command pattern)框架
2 同时也是一个反转控制(Inversion of Control, IoC)容器.

 除了上述特性外, WebWork还为其它功能如

1 创建可复用的用户界面模版(UI template)
2 表单(form)控制
3 用户界面主题(UI theme)
4 国际化
5 表单参数与JavaBean的动态映射
6 健壮的客户端及服务器端校验(validation)

提供了强有力的支持.

WebWork 2 : 什么是WebWork

WebWork是一个强大的基于Web的MVC框架, 它构建在一个命令模式框架XWork之上. WebWork的特性包括

1  ：用于处理或代理 请求的分发器(Dispatcher)

2  ：支持多种视图技术(JSP, Velocity, JasperReports, XML, FreeMarker)的结果类型

3  ：一个小而强大的JSP标签库和Velocity宏定义

4  ：分发器调用XWork活动来访问和操作模型(Model)并为视图显示模型数据提供方便的途径.

 WebWork真正的优势在于它强调简洁和协作能力的根本理念. 使用WebWork将有助于

1 ：最小化代码

2 ：允许开发人员更多的关注业务逻辑(business logic)和建模(modeling)

3 ：不是诸如编写Servlet之类的事情. 

一 ：特性

1 ：灵活的校验(validation)框架, 允许使用XML文件定义校验并通过截取器(Interceptor)在运行时自动应用到活动类(Action class), 从而达到校验与活动类之间的完全解藕(decoupled). 新版本还支持客户端校验. 

2 ：类型转化(Type conversion)可以很容易的将对象从一个类转换成另一个类型。
 
3 ：强大的表达式语言(Expression Language, EL)建立在OGNL基础之上, 允许:

1 遍历动态对象图
2 执行对象方法
3 使用值栈(ValueStack)实现对多个JavaBean属性的透明访问
4 Webwork也可以使用JSTL. 

4 ：使用反转控制(Inversion of Control, IoC)管理组件(component)生命周期和依赖关系, 不需要编写注册类创建组件, 组件客户也不需要主动获取组件实例(instance). 

5 ：Velocity模版, 使得开发人员可以很容易的定制Web页面的外观(look & feel). 

6 ：截取器(Interceptors)可以动态截取活动(Action)执行前后的处理过程, 这

1 简化了活动的代码
2 提高了代码复用能力

7 ：支持国际化(I18n). 

8 ：可以方便的与其他第三方软件集成, 包括Hibernate, Spring, Pico, Sitemesh. 

9 ：支持多种视图技术如: 

1 JSP
2 Velocity
3 FreeMarker
4 JasperReports
5 XML

10 ：使用包(Packages)和名空间(Namespaces)管理数以百计的活动. 


二 ：背景与目的
WebWork是一个开放源代码项目, 目标是为在短时间内构建复杂网站提供易于理解和维护的工具及开发框架. Java是一个平台以及基于该平台的语言, 尽管他支持although it supports many others as the language in which systems are built, such as JavaScript and XML.

WebWork在构架上基于最佳实践和那些已被证实有价值的设计模式. 它还基于一个强烈的动机: 尽可能的简单, 并具有维护上的灵活性(这实际上是一个困难的平衡).

它也鼓励用户使用恰当的, 符合需要的方式工作. [It also encourages you, as a user, to do things the way you seem fit for your needs.] WebWork能以多种方式配置和使用, 哪种方式更适合于你依赖于使用环境. 下面是一个例子, WebWork支持多种不同的HTML生成技术如:

1 JSP
2 Velocity模版引擎
3 XSLT

它们之间在理念上和技术上都存在很大的差别, 但都能为WebWork所用, 同时, 不同的用户确实需要这些不同的方式. "你不能那么做"是我们尽可能避免的一句话, 而"我们不能"往往是因为有另一个更好, 更适合的工具.

三 ：WebWork对MVC Model-1和Model-2的支持

Web应用开发框架的最重要的一个任务是支持

1 逻辑
2 内容
3 表现

相分离的理念. 如果没有做到这一点, 通常会导致维护上的问题, 如果开发团队结构复杂(因为每一个团队成员通常只负责应用的某一方面(aspect)), 还会使应用的开发变得更加困难. 达到分离目的的一般方法是采用MVC(Model-View-Controller)设计模式. 该模式鼓励使用分离的代码来处理：

1 模型(model, 即 " 业务逻辑 " )
2 控制器(controller, 即 " 应用逻辑 " )
3 视图(view). 

这样分离之后, 下一个问题是:

控制器的代码与表现部分如何交互

 有两种常用的设计模型可以做到这一点, 它们分别被称为Model-1和Model-2. 这两种模型将在下文描述.

Model-1 ：
Model-1方式的基本想法是在表示层(presentation layer)如JSP或模版中调用控制器代码. 如果你正在使用JSP, 这意味着你可以通过两种方式执行你的WebWork活动：

1 使用 " webwork:action " 标签调用执行
2 使用 " webwork:bean " 标签像调用JavaBeans一样执行活动.

Model-2 ：
在Model-2方式中

1 哪些代码调用控制器
2 哪些视图进行展示

由第三方决定, 通常是一个servlet分发器. 分发器解码HTTP请求中的URL, 然后决定执行哪些代码. 一个包含控制器代码的Java对象被获取并执行, 从而完成对某个应用逻辑和业务逻辑的处理. 当执行结束后, 分发器将请求转交(forward)给一个视图处理器(如一个JSP), 它使用前一个处理的数据绘制结果视图.

四 ：如何选择使用?
由于

1 控制器逻辑
2 表现生成

完全解藕, 使得根据执行情况来显示不同结果页面成为可能. 例如, 如果处理出现错误就可以显示一个错误页面而不显示正常的结果页面.

Model-1方式的优点如下.

1 ：不需要建立代码与表示之间的映射关系. 
2 ：易于察看JSP或模版中执行了哪些代码. 
3 ：如果页面中的一部分要求某个处理过程只允许成功(否则系统失灵), 
          那么这些代码调用和表现部分的代码(如JSP标签库和HTML)不必分离到新的活动和JSP页面中处理过程. 这样可以提高性能和可读性. 

Model-2方式的优点如下.

1 ：代码和表现彻底分离. 同一个表现页面可以被多个不同的活动复用, 
      这些活动可以访问不同的数据但使用相同的方式展示. 

2 ：如果一个活动可能导致多种状态, 如 " 成功 " ,  " 需要重新输入 " , 或 " 出现错误 " , 
      那么使用Model - 2方式可以很容易的将这些状态映射到不同的页面. 

选择使用的首要原则是:

当代码仅仅是获取并显示数据(这被称为read - type code)时使用Model - 1

只要当模型是由活动或一个处理流程所改变时就应当使用Model - 2 . 

OGNL是WebWork,XWork中的底层支持组件.非常强大的函数库.

package org.riker.news.control;

import java.io.IOException;

import java.io.PrintWriter;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.riker.news.data.NewsDataBean;

import org.riker.news.logic.NewsLogicBean;

public class DetailServlet extends HttpServlet {

       /**

        * Constructor of the object.

        */

       public DetailServlet() {

              super();

       }

       /**

        * Destruction of the servlet. <br>

        */

       public void destroy() {

              super.destroy(); // Just puts "destroy" string in log

              // Put your code here

       }

       /**

        * The doPost method of the servlet. <br>

        *

        * This method is called when a form has its tag value method equals to post.

        *

        * @param request the request send by the client to the server

        * @param response the response send by the server to the client

        * @throws ServletException if an error occurred

        * @throws IOException if an error occurred

        */

       public void doPost(HttpServletRequest request, HttpServletResponse response)

                     throws ServletException, IOException {

              String newsid = request.getParameter("newsid");

              NewsDataBean bean = new NewsLogicBean().detail(newsid);

              if(bean!=null) {

                     request.setAttribute("bean",bean);

                     request.getRequestDispatcher("main/detail.jsp").forward(request, response);

              } else {

                     request.getRequestDispatcher("main/error.jsp").forward(request, response);

              }

       }

       /**

        * Initialization of the servlet. <br>

        *

        * @throws ServletException if an error occure

        */

       public void init() throws ServletException {

              // Put your code here

       }

}

2、NewsLogicBean.java，写公共的，修改relevant，写deleteNews()方法

package org.riker.news.logic;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.ArrayList;

import java.util.List;

import org.riker.news.comm.DataSource;

import org.riker.news.data.NewsDataBean;

public class NewsLogicBean {

       private int allRows;

       private int curPage = 1;

       private int rowPerPage = 5;

       private int allPages;

       public List findAll() {

              List list = new ArrayList();

              Statement st = null;

              ResultSet rs = null;

              try {

                     st = DataSource.getConnection().createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);

                     rs = st.executeQuery("select newsid, newstitle, newscontent, newscount, newsdate from news order by newsdate desc");

                     rs.last();

                     this.allRows = rs.getRow();

                     if(this.allRows%this.rowPerPage==0) {

                            this.allPages = this.allRows/this.rowPerPage;

                     } else {

                            this.allPages = this.allRows/this.rowPerPage + 1;

                     }

                     if(this.curPage == 1) {

                            rs.beforeFirst();

                     } else {

                            rs.absolute((this.curPage - 1) * this.rowPerPage);

                     }

                     int i = 0;

                     while(rs.next() && i < this.rowPerPage) {

                            NewsDataBean bean = new NewsDataBean();

                            bean.setNewsid(rs.getString(1));

                            bean.setNewstitle(rs.getString(2));

                            bean.setNewscontent(rs.getString(3));

                            bean.setNewscount(rs.getString(4));

                            bean.setNewsdate(rs.getString(5));

                            list.add(bean);

                            i++;

                     }

              } catch (SQLException e) {

                     e.printStackTrace();

              }

              return list;

       }

       public int insertNews(String newsTitle, String newsContent) {

              return modify("insert into news(newstitle, newscontent, newscount, newsdate) values ('"+newsTitle+"', '"+newsContent+"', 0, now()");

       }

       public int modify(String sql) {

              int result = 0;

              Statement st = null;

              try {

                     st = DataSource.getConnection().createStatement();

                     result = st

                                   .executeUpdate(sql);

              } catch (Exception e) {

                     // TODO: handle exception

              } finally {

                     try {

                            st.close();

                     } catch (SQLException e) {

                            // TODO Auto-generated catch block

                            e.printStackTrace();

                     }

              }

              return result;

       }

       public int deleteId(String newsid) {

              return modify("delete from news where newsid="+newsid);

       }

       public int updateNews(String newsid, String newsTitle, String newsContent) {

              return modify("update news set newstitle='"+newsTitle+"', newscontent='"+newsContent+"' where newsid="+newsid);

       }

       public NewsDataBean findById(String newsid) {

              NewsDataBean bean = new NewsDataBean();

              Statement st = null;

              ResultSet rs = null;

              try {

                     st = DataSource.getConnection().createStatement();

                     rs = st.executeQuery("select newsid, newstitle, newscontent, newscount, newsdate from news where newsid=" + newsid);

                     rs.last();

                     if(rs.next() ) {

                            bean.setNewsid(rs.getString(1));

                            bean.setNewstitle(rs.getString(2));

                            bean.setNewscontent(rs.getString(3));

                            bean.setNewscount(rs.getString(4));

                            bean.setNewsdate(rs.getString(5));

                     }

              } catch (SQLException e) {

                     e.printStackTrace();

              }

              return bean;

       }

       public NewsDataBean detail(String newsid) {

              NewsDataBean bean = new NewsDataBean();

              Statement st = null;

              ResultSet rs = null;

              try {

                     st = DataSource.getConnection().createStatement();

                     st.executeUpdate("update news set newscount=newscount+1 where newsid="+newsid);

                     rs = st.executeQuery("select newsid, newstitle, newscontent, newscount, newsdate from news where newsid=" + newsid);

                     rs.last();

                     if(rs.next() ) {

                            bean.setNewsid(rs.getString(1));

                            bean.setNewstitle(rs.getString(2));

                            bean.setNewscontent(rs.getString(3));

                            bean.setNewscount(rs.getString(4));

                            bean.setNewsdate(rs.getString(5));

                     }

              } catch (SQLException e) {

                     e.printStackTrace();

              }

              return bean;

       }

       public static void main(String[] args) {

              List list = new NewsLogicBean().findAll();

              System.out.println(list.size());

       }

       public int getCurPage() {

              return curPage;

       }

       public void setCurPage(int curPage) {

              this.curPage = curPage;

       }

       public int getAllPages() {

              return allPages;

       }

       public int getAllRows() {

              return allRows;

       }

       public int getRowPerPage() {

              return rowPerPage;

       }

}

       3、DeleteServlet.java，去COPY过来跳转的语

句。==>查看新闻详细，中间，新建DetailServlet.java，注意此时为doGet（

地址栏的提交）==>NewsLogicBean.java写COPY上面Insert的public

NewsDataBean detail(String newsid) {}==>DetailServlet.java写COPY过来

FindByIdServlet.java中NewsDataBean bean = new NewsLogicBean

().findById(newsid)，modified it==>

package org.riker.news.control;

import java.io.IOException;

import java.io.PrintWriter;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.riker.news.data.NewsDataBean;

import org.riker.news.logic.NewsLogicBean;

public class DetailServlet extends HttpServlet {

       /**

        * Constructor of the object.

        */

       public DetailServlet() {

              super();

       }

       /**

        * Destruction of the servlet. <br>

        */

       public void destroy() {

              super.destroy(); // Just puts "destroy" string in log

              // Put your code here

       }

       /**

        * The doPost method of the servlet. <br>

        *

        * This method is called when a form has its tag value method equals to post.

        *

        * @param request the request send by the client to the server

        * @param response the response send by the server to the client

        * @throws ServletException if an error occurred

        * @throws IOException if an error occurred

        */

       public void doPost(HttpServletRequest request, HttpServletResponse response)

                     throws ServletException, IOException {

              String newsid = request.getParameter("newsid");

              NewsDataBean bean = new NewsLogicBean().detail(newsid);

              if(bean!=null) {

                     request.setAttribute("bean",bean);

                     request.getRequestDispatcher("main/detail.jsp").forward(request, response);

              } else {

                     request.getRequestDispatcher("main/error.jsp").forward(request, response);

              }

       }

       /**

        * Initialization of the servlet. <br>

        *

        * @throws ServletException if an error occure

        */

       public void init() throws ServletException {

              // Put your code here

       }

}

       4、用insert.jsp复制新建detail.jsp，引

入NewsDataBean Package，写标签 <jsp:useBean id="news"

class="org.riker.news.logic.NewsLogicBean"/>，这么做没必要！！WHY？

因为DetailServlet.java中request.setAttribute("bean",bean);已经放入

bean了，所以直接NewsDataBean bean = (NewsDataBean)

request.getAttribute("bean");注意request.getAttribute("bean")，然后格

式化，更美观些，用JavaScript返回，<a href="javascript:history.back

()">返回</a>。

<%@ page contentType="text/html;charset=GBK" import="org.riker.news.data.*"%>

<html>

 <head>

    <title></title>

 </head>

 <body>

 <%

  NewsDataBean bean = (NewsDataBean)request.getAttribute("bean");

 %>

  <h2 align="center">

  <%=bean.getNewstitle()%>               发布时间：<%=bean.getNewsdate()%>

  </h2>

  <%=bean.getNewscontent()%>点击的次数：<%=bean.getNewscount()%>

 <hr>

    <a href="javascript:history.back()">返回</a>

 </div>

 </body>

</html>

java中没显示的和c++中的指针,但是他有地址的概念的.而且所有我们申明的"对象"其实就是地址(或叫句柄),给他赋值就是把他指向一个内存单元.当然也可以改变他的指向.其实我们"对象"的赋值操作全是地址在变东,对象还是没有变的.那也许有人会说那样的话不是会产生很多没有"对象"(句柄)的内存区域.是的是会产生,但是java的垃圾收集机制会给我们回收这样的内存"泄漏".所以我们只关心我们操作的对象就行,其他的我们不用的对象的后事垃圾收集会给我们干.帅

明白了在java中的"对象"而非我们c++中理解的对象.而实际上是指针(句柄)那多态当然可以实现.

下面举个"对象"赋值(引用)的例子说明,全是地址在变,而非真的内存单元.

public class Number {
   private int number;

   public Number( int number ) {
      this.number = number;
   }

   public int getNumber() {
      return this.number;
   }

   public void setNumber( int number ) {
      this.number = number;
   }

   public static void main( String[] args ) {
      Number one = new Number( 1 );
      Number two = new Number( 2 );
      System.out.println( "Beginning: " );
      System.out.println( "One = " + one.getNumber() );
      System.out.println( "Two = " + two.getNumber() );

      // Assign two to one
      two = one;//在这里two这个句柄的值(即某个对象的地址)改成one这个句柄的值了.从而two和one指同时//向one以前指向的那个内存单元(对象).而two 以前指向的那个对象现在为没有句柄连接的对象了.可能要被垃圾收集
      System.out.println( "\nAfter assigning two to one: " );
      System.out.println( "One = " + one.getNumber() );
      System.out.println( "Two = " + two.getNumber() );

      // Change the value of two
      two.setNumber( 3 );//two和one指向同一个单元,所以他对改单元的改变,one能感知.
      System.out.println( "\nAfter modifying two: " );
      System.out.println( "One = " + one.getNumber() );
      System.out.println( "Two = " + two.getNumber() );
   }
}
运行结果:

Beginning:
One = 1
Two = 2

After assigning two to one:
One = 1
Two = 1

After modifying two:
One = 3
Two = 3

下面进行概括总结..

1．指针

JAVA语言让编程者无法找到指针来直接访问内存无指针，并且增添了自动的内存管理功能，从而有效地防止了c／c++语言中指针操作失误，如野指针所造成的系统崩溃。但也不是说JAVA没有指针，虚拟机内部还是使用了指针，只是外人不得使用而已。这有利于Java程序的安全。

2．多重继承

c++支持多重继承，这是c++的一个特征，它允许多父类派生一个类。尽管多重继承功能很强，但使用复杂，而且会引起许多麻烦，编译程序实现它也很不容易。Java不支持多重继承，但允许一个类继承多个接口(extends+implement)，实现了c++多重继承的功能，又避免了c++中的多重继承实现方式带来的诸多不便。

3．数据类型及类

Java是完全面向对象的语言，所有函数和变量部必须是类的一部分。除了基本数据类型之外，其余的都作为类对象，包括数组。对象将数据和方法结合起来，把它们封装在类中，这样每个对象都可实现自己的特点和行为。而c++允许将函数和变量定义为全局的。此外，Java中取消了c／c++中的结构和联合，消除了不必要的麻烦。

4．自动内存管理

Java程序中所有的对象都是用new操作符建立在内存堆栈上，这个操作符类似于c++的new操作符。下面的语句由一个建立了一个类Read的对象，然后调用该对象的work方法：

Read r＝new Read()；

r.work()；



语句Read r＝new Read()；在堆栈结构上建立了一个Read的实例。Java自动进行无用内存回收操作，不需要程序员进行删除。而c十十中必须由程序贝释放内存资源，增加了程序设计者的负扔。Java中当一个对象不被再用到时，无用内存回收器将给它加上标签以示删除。JAVA里无用内存回收程序是以线程方式在后台运行的，利用空闲时间工作。

5．操作符重载

Java不支持操作符重载。操作符重载被认为是c十十的突出特征，在Java中虽然类大体上可以实现这样的功能，但操作符重载的方便性仍然丢失了不少。Java语言不支持操作符重载是为了保持Java语言尽可能简单。

6．预处理功能

Java不支持预处理功能。c／c十十在编译过程中都有一个预编泽阶段，即众所周知的预处理器。预处理器为开发人员提供了方便，但增加丁编译的复杂性。JAVA虚拟机没有预处理器，但它提供的引入语句(import)与c十十预处理器的功能类似。

7. Java不支持缺省函数参数，而c十十支持

在c中，代码组织在函数中，函数可以访问程序的全局变量。c十十增加了类，提供了类算法，该算法是与类相连的函数，c十十类方法与Java类方法十分相似，然而，由于c十十仍然支持c，所以不能阻止c十十开发人员使用函数，结果函数和方法混合使用使得程序比较混乱。

Java没有函数，作为一个比c十十更纯的面向对象的语言，Java强迫开发人员把所有例行程序包括在类中，事实上，用方法实现例行程序可激励开发人员更好地组织编码。

8 字符串

c和c十十不支持字符串变量，在c和c十十程序中使用Null终止符代表字符串的结束，在Java中字符串是用类对象(strinR和stringBuffer)来实现的，这些类对象是Java语言的核心，用类对象实现字符串有以下几个优点：

(1)在整个系统中建立字符串和访问字符串元素的方法是一致的；

(2)J3阳字符串类是作为Java语言的一部分定义的，而不是作为外加的延伸部分；

(3)Java字符串执行运行时检空，可帮助排除一些运行时发生的错误；

(4)可对字符串用“十”进行连接操作。

9“goto语句

“可怕”的goto语句是c和c++的“遗物”，它是该语言技术上的合法部分，引用goto语句引起了程序结构的混乱，不易理解，goto语句子要用于无条件转移子程序和多结构分支技术。鉴于以广理由，Java不提供goto语句，它虽然指定goto作为关键字，但不支持它的使用，使程序简洁易读。

l0．类型转换

在c和c十十中有时出现数据类型的隐含转换，这就涉及了自动强制类型转换问题。例如，在c十十中可将一浮点值赋予整型变量，并去掉其尾数。Java不支持c十十中的自动强制类型转换，如果需要，必须由程序显式进行强制类型转换。

11.异常

JAVA中的异常机制用于捕获例外事件，增强系统容错能力

try{／／可能产生例外的代码

}catch(exceptionType name){

//处理

}

其中exceptionType表示异常类型。而C++则没有如此方便的机制。

class test{
public:void test1();
private:void test2();
};

注意这里的写法.最后那个大括号后面必须要跟一个分号的.JAVA则不用.我一开始及其不适应.
然后在cpp文件中来定义

void test::test1(){
cout << "aaa";
}
void test::test2(){
cout << "bb";
}

注意:这里大括号后面有没有带分号都没关系.

4.C++中对函数的调用方法也灵活.

test t;
t.test2();
----------------
test* t = new test();
t->test2();

其实我还是喜欢test t = new test();t.test2()

5.编译器的解析.如果没有引入头文件的话你必须把main()函数放到文件的最下面.

void main(){
test();
}
void test(){
cout << "aa";
}

这样写编译器会报找不到test()方法的.这个是C遗留下的问题.解决方法就是引入头文件,或者把main写到最后.或者在main前面声明一下:

void test();
void main(){
test();
}
void test(){
cout << "aa";
}

这种做法就和引入头文件差不多了.

6.析构函数.这个特性很有用,在类消失的最后一刻自动调用这个种类型的函数来做一些清除操作

7.争议比较大的声明指针类型.
int* pt=0;
int *pt=0;
这个星号是紧跟着类型呢还是紧跟着变量名呢.由于C++的灵活度太高.这两种写法都没错误.但按理来说紧跟着类型应该会好一些.因为我们是在声明一个指针类型的变量.但如果按下面的写法:
int* pt,pt1;
你说pt1是指针类型吗,答案是不是.遇到这种情况就要把*号紧跟着变量名了
int *pt,*pt1;

耐心点，接下来的是精华

 

main 函数
C++
//自由浮动的函数
int main( int argc, char* argv[])
{
    printf( "Hello, world" );
}
Java
// 每个函数(方法)都必须是一个类的一部分;当java <class>运行是一个特定类的主函数会被调用
// (因此你可以让每个类都有一个main函数，这在写单元测试是很有用)
class HelloWorld
{
    public static void main(String args[])
    {
        System.out.println( "Hello, World" );
    }
}

类的声明
除了 Java 不要求用分号外几乎是相同的。
C++
    class Bar {};
   
Java
    class Bar {}
   

方法声明
   都相同的, 除了在Java,方法必须总是某个类的一部分并且可能public/private/protected 作为修饰

构造函数和析构函数
构造函数都是相同的 (即类的名字), Java没有准确意义上的的析构函数

静态成员函数和变量
方法声明是相同的, 但 Java 提供静态初始化块来来初始化静态变量 (不需要在源文件中声明):
class Foo
{
    static private int x;
    // 静态初始化块
    { x = 5; }
}

对象的声明
C++
    // 在栈中
    myClass x;
 
    //或者在堆中
    myClass *x = new myClass;
   
Java
   // 总是在对堆中声明
    myClass x = new myClass();
   

继   承
C++
    class Foo : public Bar
    { ... };
   
Java
    class Foo extends Bar
    { ... }
   

访问级别 (abstraction barriers)
C++
   public:
        void foo();
        void bar();
   
Java
    public void foo();
    public void bar();
   

虚函数
C++
    virtual int foo(); // 或者非虚函数写作 int foo();
   
Java
    // 函数默认的就是虚函数; 用final关键字防止重载
    int foo(); // 或者, final int foo();

内存管理
大体上是相同的--new 来分配， 但是 Java没有 delete，因为它有垃圾回收器。

NULL vs null
C++
    // 初始化一个指针为 NULL
    int *x = NULL;
   
Java
   // 编译器将捕获使用未初始化的引用
   //但是如果你因需要初始化一个引用而赋一个null，那么这是无效的
    myClass x = null;
   

布尔型
Java有一点罗嗦: 你必须写 boolean而不止是 bool.
C++
   bool foo;
Java
     boolean foo;

常   量
C++
    const int x = 7;
   
Java
    final int x = 7;
   

抛异常
首先，Java在编译器强制抛异常—如果你的方法可能会抛异常你必需明确报告
C++
     int foo() throw (IOException)
Java
     int foo() throws IOException

数     组
C++
    int x[10];
    // 或
    int *x = new x[10];
    // 使用 x,然后归还内存
    delete[] x;
   
Java
    int[] x = new int[10];
    // 使用 x, 内存有垃圾回收器回收或
    //或在程序生命周期尽头归还给系统
   

集合和迭代器
C++
迭代器是类的成员。范围的开始是<容器>.begin(), 结束是 <容器>.end()。 用++ 操作符递增,  用 *操作符访。 
    vector myVec;
    for ( vector<int>::iterator itr = myVec.begin();
          itr != myVec.end();
          ++itr )
    {
        cout << *itr;
    }
   
Java
迭代器只是一个接口。 范围的开始是 <集合>.iterator，你必须用itr.hasNext()来查看是否到达集合尾。 使用itr.next()(是在C++中使用操作符++ 和*操作的结合)来获得下一个元素。 
    ArrayList myArrayList = new ArrayList();
    Iterator itr = myArrayList.iterator();
    while ( itr.hasNext() )
    {
        System.out.println( itr.next() );
    }
 
    // 或, 在Java 5中
    ArrayList myArrayList = new ArrayList();
    for( Object o : myArrayList ) {
        System.out.println( o );
    }
    
 

   
抽象类
C++
    // 只需要包含一个纯虚函数
    class Bar { public: virtual void foo() = 0; };
   
Java
    // 语法上允许显示的声明!
    abstract class Bar { public abstract void foo(); }
 
    // 或者你也可以声明一个接口
    interface Bar { public void foo(); }
 
    // 然后让一个类继承这个接口:
    class Chocolate implements Bar
    {
        public void foo() { /* do something */ }
    }
   
引用 vs  指针
C++
    //引用不可改变,通过使用指针来获得更多的灵活性
    int bar = 7, qux = 6;
    int& foo = bar;
   
Java
    // 引用是可变的，仅存储对象地址;
    //没有指针类型
    myClass x;
    x.foo(); // error, x is a null “pointer”
 
    // 注意你要总是用 . 来访问域
   
编 译
C++
    // 编译
    g++ foo.cc -o outfile
    // 运行
    ./outfile
   
Java
   // 编译foo.java文件中的类成<classname>.class    javac foo.java
    // 通过调用<classname>中的静态main方法来运行
    java <classname>
   
注   释
两种语言是一样的 (// 和 /* */ 可以用)

       慎重选取程序设计语言，一旦选了，就心无旁骛地坚持学到底；创建一些企业级的应用程序

       要脚踏实地，快餐式的学习不可取，这点非常重要，时刻保证质量第一；引用小学班主任的话“一步一个脚印”，遵循发展的规律来学，循序渐进地去学习，千万！绝对！！不能幻想三两下马上就搞定一门语言，激情固然总要，但前述更为大大地重要。工具（IDE）固然重要，Java语言本身才是本质的问题

       多动手实践，不要夸夸其谈，动手是最好最快的消化方式；发现相关的细节的问题，发现一些只有当我们动手去敲击键盘时才会遇到的种种问题

       多参考程序代码，汲取营养；吸收编程思想，包括设计、架构的思想；考虑别人是怎么发现问题、分析问题、解决问题的；思路流程，思想非常非常地重要，这点再怎么强调都不过分，这点也是学习编程的一个“捷径”

       加强英文阅读能力，习惯成自然；作为“英语高手”的我在这方面也不能麻痹大意，不能疏忽，不能放松自己，也要老老实实地掌握一些专业词汇

       求人不如求己（万不得已才请教别人，或者利用搜索），又涉及到老生常谈的一个问题了“浮躁”，读了这么多书，有“智慧”的我非常的不应该在这里犯迷糊了！！碰到问题，自己尝试独立解决，认真的好好去思考，用尽各种办法，各种途径，这个解决问题的过程其实就是提高自己能力，提高自己实力的过程，我们应该感谢这样的过程

       多读好书，读一流的书，做一流的人；何为“好书”，其实就是适合自己的书，当然我本人喜欢同一方面的书多读几本，这样更有掌控感。LSY学长好像说过“适合自己的才是最好的”这话现在是最好的应用了

       使用合适的工具，工具和某项新技术、新观念的诞生便是为了世界的更美好一些

        以上为个人愚见，还请各位兄弟指教！

----joahon学长

--》关键字：持续学习，破釜沉舟

·面向对象的特征有哪些方面

       ·抽象：过程、数据的抽象。

       ·封装：现实的世界就是一个封装的世界，通过一个受保护的借口来访问，类似地，封装了过程和数据。

       ·继承：“一种联结类的层次模型，允许和鼓励类的重用”，子类从父类继承方法和（实例）变量，并可以根据需要增加方法和变量。

       ·多态：“允许不同类的对象对同一事件做出响应”，参数化、包含多态性。

·final、finally、finalize的区别

       ·final：1、修饰类时，表示此类不能被继承，也不会从其他类继承；用了final就不能出现abstract，否则矛盾；2、修饰方法和变量时，修饰变量时只能初始化一次，且不能再修改，方法的话不能被重载。

       ·finally：try{..}catch(..){..}中用来执行任何的清除操作。

       ·finalize：Garbage Collector在收集垃圾之前，用finalize方法来整理系统资源或者执行相关清理操作。finalize是java.lang包中Object类定义的方法，因此被所有的类继承。

System.gc() ;

Runtime.getRuntime().gc() ;