JAVA教程之Java项目中利用Hibernate处置数据
C#是不行的，比如说美国的航天飞船里就有java开发的程序以上是我的愚见，其实不管那种语言，你学好了，都能找到好的工作，数据|项目<P> 对象-干系映照（O/R映照）是很多软件开辟项目标罕见需求。数据耐久化过程当中所触及到的举动长短常有趣且易于堕落的。假如思索到不成制止的需求变更，我们就面对很年夜的贫苦：数据存储布局必需与源代码坚持同步。再加上移植性成绩，事变就变得十分庞大。而Hibernate能够匡助我们轻松地在永世性存储介质中保留数据，而不必要在选择存储、安装或设置范例方面华侈太多精神。Hibernate同意我们存储任何范例的对象，因而，使用程序不必要晓得其数据将利用Hibernate举行耐久化。固然，这里提到的任何事变都能够逆向使用：如今从存储器猎取已筹办好的对象是很寻常的事变。更新和删除数据也是云云。
入手下手之前
在入手下手之前，您必要Hibernate的刊行版，能够在Hibernateweb站点（www.hibernate.org）上找到它。我们将利用2.0.3版本。关于数据库，我们将利用HypersonicSQL1.7.1版本,它能够在hsqldb.sourceforge.net上找到。Hibernate还撑持很多开源或贸易数据库，比方MySQL、PostgreSQL、Oracle、DB2等。关于受撑持的任何数据库，安装这个教程都很复杂。完全列表拜见官方文档。
注重：假如您不但愿类被耐久化在数据库中（好比说，您只但愿举行串行化），那末HibernateAPI为您供应了net.sf.hibernate.persister.EntityPersister类和net.sf.hibernate.persister.ClassPersister接口。经由过程编写子类或完成它们，您能够编写本人的耐久化类，并依据必要利用它们。
下载了一切必须的安装包后，我们必需设置测试情况。基础上，我们所需做的就是把下载的.jar文件放到CLASSPATH中。这包含Hibernate刊行版中的hibernate2.jar和Hypersonic的lib/目次下的hsqldb.jar。Hibernate还必要其他的几个库，这些库都能够在＜hibernate-dist＞/lib目次中找到。并非该目次下的一切.jars文件都必要，可是假如您利用一切文件，也没有甚么害处。在我们入手下手研讨Hibernate之前，我们将起首界说我们的成绩域。
注重：Hibernate利用Apache的commons-logging。它是一个智能工具，假如找到log4j，它就会默许地利用它。Log4j是一个杰出的日记纪录库，我们将在这个教程中利用它。假如您还没有这个软件（您真的应当安装这个软件！），能够从Log4jhomepage下载，并将它增加到CLASSPATH中。利用Hibernate团队所供应的示例log4j.properties，它能够在＜hibernate-dist＞/src目次下找到。
成绩引进
每一个开辟职员都最少实行过一次相似的义务：创立一个定单，把一些产物放在个中，它就酿成定单项，然后保留该定单。
我们利用这些复杂的SQL命令来设置数据库：
CREATETABLEORDERS(IDVARCHARNOTNULLPRIMARYKEY,ORDER_DATETIMESTAMPNOTNULL,PRICE_TOTALDOUBLENOTNULL)CREATETABLEPRODUCTS(IDVARCHARNOTNULLPRIMARYKEY,NAMEVARCHARNOTNULL,PRICEDOUBLENOTNULL,AMOUNTINTEGERNOTNULL)CREATETABLEORDER_ITEMS(IDVARCHARNOTNULLPRIMARYKEY,ORDER_IDVARCHARNOTNULL,PRODUCT_IDVARCHARNOTNULL,AMOUNTINTEGERNOTNULL,PRICEDOUBLENOTNULL)
这个数据模子十分复杂。关于一个实践的“临盆质量”数据模子，我们会必要外键、索引、分外的字段等等。关于本教程，下面的数据模子就能够了。
Java代码
只管这些营业需求复杂且易于了解，可是编写一堆筹办好的语句的传统办法将很快使人腻烦。而Hibernate将会把我们束缚出来。我们所需的只是一组复杂的映照文件。但起首我们必要编写Java类。
注重：我们将把一切将要耐久化的类放到test.hibernate包中，把一切帮助类放到test包中。
Product
这个复杂的类只界说了需要的字段：ID、产物称号、产物代价和这类产物确当前库存量。因为Hibernate利用无格局的复杂JavaBeans，我们必要做的只是为每一个主要字段（在我们的示例中，一切字段都是主要字段）创立getter和setter办法，和默许的机关函数。
packagetest.hibernate;publicclassProduct{privateStringid;privateStringname;privatedoubleprice;privateintamount;publicStringgetId(){returnid;}publicvoidsetId(Stringstring){id=string;}//默许的机关函数及其他//为了简便起见，getter/setter办法没有显现//...}
我们还必要重写toString()办法。这将匡助我们利用复杂的System.out.println(obj)挪用来跟踪使用程序流：
publicStringtoString(){return""+name+"("+id+")price="+price+"amount="+amount;}
这就是全体的product类代码。但Product没有完成任何接口，也没有承继任何类，Hibernate又怎样晓得耐久化该范例的对象呢？谜底很复杂：Hibernate能够处置任何范例的Java对象，只需它可以遵守JavaBeans商定。
<P> Order
我们必要创立的下一个类是Order，它乃至比Product更复杂：它只包括ID、创立日期、总代价和该Order所包含的OrderItems的Set。固然，还必要创立getter和setter办法和默许的机关函数。
packagetest.hibernate;importjava.util.Date;importjava.util.HashSet;importjava.util.Set;publicclassOrder{privateStringid;privateDatedate;privatedoublepriceTotal;privateSetorderItems=newHashSet();//主动设置该Order的创立工夫publicOrder(){this.date=newDate();}publicStringgetId(){returnid;}publicvoidsetId(Stringstring){id=string;}//为了简便起见，其他getter/setter办法没有显现//...}
一样也要重写toString()办法。不要健忘对orderItems实行轮回！
OrderItem
这个类略微庞大一些，但仍旧很易懂。我们的营业需求决意我们必要必定量的产物，我们将会把它们放到一个定单中。那些产物将主动酿成定单项。这时候就必要自界说机关函数了。
packagetest.hibernate;publicclassOrderItem{/***创立无效的定单项。主动设置定单项的代价，并改正产物的库存可用量**@paramorder该定单项属于的定单*@paramproduct该定单项为哪一种产物而创立*@paramamount*/publicOrderItem(Orderorder,Productproduct,intamount){this.order=order;this.product=product;this.amount=amount;product.setAmount(product.getAmount()-amount);this.price=product.getPrice()*amount;}//还必要默许的机关函数来包管Hibernate事情/***空机关函数遵守JavaBeans商定**/publicOrderItem(){//空的默许机关函数}//字段privateStringid;privateProductproduct;privateOrderorder;privateStringproductId;privateStringorderId;privatedoubleprice;privateintamount;publicStringgetId(){returnid;}publicStringgetProductId(){returnproduct.getId();}publicStringgetOrderId(){returnorder.getId();}//其他getter/setter办法没有显现//...file://显现该定单项的便利体例publicStringtoString(){return"id="+id+"amount="+amount+"price="+price+"("+product+")";}}
如今我们有了反应数据库布局的一切类。余下的独一一件没有注释的事变就是怎样把产物放到一个定单中。只需把上面的办法增加到Order类中：
/***增加一项产物到定单中。产物主动成为一个定单项。*priceTotal被主动更新。**@paramp增加到该定单的产物*@paramamount增加的产物量*/publicvoidaddProduct(Productp,intamount){OrderItemorderItem=newOrderItem(this,p,amount);this.priceTotal=this.priceTotal+p.getPrice()*amount;this.orderItems.add(orderItem);}
启动Hibernate
在我们设想的使用程序中，基础的利用形式十分复杂：我们将创立一个Product，然后将其耐久化（大概换句话说，保留它）；我们将搜刮并加载一个已耐久化的Product，并确保其可使用；我们将会更新和删除Product。
创立和耐久化Product
如今我们终究用到Hibernate了。利用的场景十分复杂：
[*]创立一个无效的Product。
[*]在使用程序启动时利用net.sf.hibernate.cfg.Configuration猎取net.sf.hibernate.SessionFactory。
[*]经由过程挪用SessionFactory#openSession()，翻开net.sf.hibernate.Session。
[*]保留Product，封闭Session。
<P>
正如我们所看到的，这里没有提到JDBC、SQL或任何相似的工具。十分使人奋发！上面的示例遵守了下面提到的步骤：
packagetest;importnet.sf.hibernate.Session;importnet.sf.hibernate.SessionFactory;importnet.sf.hibernate.Transaction;importnet.sf.hibernate.cfg.Configuration;importtest.hibernate.Product;//用法：//javatest.InsertProductnameamountpricepublicclassInsertProduct{publicstaticvoidmain(String[]args)throwsException{//1.创立Product对象Productp=newProduct();p.setName(args);p.setAmount(Integer.parseInt(args));p.setPrice(Double.parseDouble(args));//2.启动HibernateConfigurationcfg=newConfiguration().addClass(Product.class);SessionFactorysf=cfg.buildSessionFactory();//3.翻开SessionSessionsess=sf.openSession();//4.保留Product，封闭SessionTransactiont=sess.beginTransaction();sess.save(p);t.commit();sess.close();}}
让我们来运转它！经由过程运转javatest.InsertProductMilk1001.99命令，拔出代价为1.99的100瓶牛奶。我们会失掉以下的输入日记：
Nov23,20039:05:50AMnet.sf.hibernate.cfg.Environment＜clinit＞INFO:Hibernate2.0.3Nov23,20039:05:50AMnet.sf.hibernate.cfg.Environment＜clinit＞INFO:hibernate.propertiesnotfoundNov23,20039:05:50AMnet.sf.hibernate.cfg.Environment＜clinit＞INFO:usingCGLIBreflectionoptimizerNov23,20039:05:50AMnet.sf.hibernate.cfg.Environment＜clinit＞INFO:JVMproxysupport:trueNov23,20039:05:50AMnet.sf.hibernate.cfg.ConfigurationaddClassINFO:Mappingresource:test/hibernate/Product.hbm.xmlExceptioninthread"main"net.sf.hibernate.MappingException:Resource:test/hibernate/Product.hbm.xmlnotfoundatnet.sf.hibernate.cfg.Configuration.addClass(Configuration.java:285)attest.FindProductByName.main(FindProductByName.java:24)
它没法事情。个中有两行特别让人感乐趣：
INFO:hibernate.propertiesnotfoundandResource:test/hibernate/Product.hbm.xmlnotfound.
固然，INFO行指出我们必要一个hibernate.properties设置文件。在这个文件中，我们设置要利用的数据库、用户名和暗码和其他选项。利用上面供应的这个示例来毗连后面提到的Hypersonic数据库：
hibernate.connection.username=sahibernate.connection.password=hibernate.connection.url=jdbc:hsqldb:/home/davor/hibernate/ordershibernate.connection.driver_class=org.hsqldb.jdbcDriverhibernate.dialect=net.sf.hibernate.dialect.HSQLDialect
得当地举行修正（比方，大概必要修正hibernate.connection.url），并保留到classpath中。
这很简单，但谁人test/hibernate/Product.hbm.xml资本是甚么呢？它是一个XML文件，界说了Java对象怎样被耐久化（映照）到一个数据库。在该文件中，我们界说数据存储到哪一个数据库表中，哪一个字段映照到数据库表的哪一个列，分歧的对象怎样相互联系关系，等等。让我们来看一下Product.hbm.xml。
＜?xmlversion="1.0"encoding="UTF-8"?＞＜!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD//EN""http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd"＞＜hibernate-mapping＞＜classname="test.hibernate.Product"table="products"＞＜idname="id"type="string"unsaved-value="null"＞＜columnname="id"sql-type="char(32)"not-null="true"/＞＜generatorclass="uuid.hex"/＞＜/id＞＜propertyname="name"＞＜columnname="name"sql-type="char(255)"not-null="true"/＞＜/property＞＜propertyname="price"＞＜columnname="price"sql-type="double"not-null="true"/＞＜/property＞＜propertyname="amount"＞＜columnname="amount"sql-type="integer"not-null="true"/＞＜/property＞＜/class＞＜/hibernate-mapping＞
它十分复杂且易于了解。几个细节出格使人感乐趣：
[*]＜classname="test.hibernate.Product"table="products"＞，指出正在映照一个名为test.hibernate.Product的类到表products。
[*]＜id＞元素及其子元素，界说Java类与数据库之间的毗连。
[*]＜property＞元素，界说每一个字段存储到哪一个列及其范例、称号等。
＜generatorclass="uuid.hex"/＞元素乍一看不太好了解。可是晓得了它是＜id＞的一个子元素后，它的感化就很分明了：因为使用程序不晓得它的数据怎样被耐久化（我们一向这么说），我们必要一个没有任何营业寄义的代办署理键匡助Hibernate利用对象。新创立的Products没有谁人id，Hibernate将为我们创立它们。我们选择利用UUID字符串，但它供应了很多ID天生器（按次的、限制局限的，乃至是用户指派的，等等），并且还能够编写本人的ID天生器。
如今，创立（复制、粘贴）Product.hbm.xml的内容，并把文件和test.hibernate.Product类放到统一个包内（比方，安排Product.java文件的目次），从头运转javatest.InsertProductMilk1001.99命令。如今我们看到更多的日记和...没有其他工具了！它运转一般吗？在Sessionsess=sf.openSession();前和sess.close()后增加System.out.println(p)，看一看Produc出了甚么成绩。从头运转程序。您将看到相似于以下内容的日记输入（ID数字一定会分歧的）：
Milk(null)price=1.99amount=100Milk(40288081f907f42900f907f448460001)price=1.99amount=100<P>
Hibernate为我们创立了Product的id！让我们看一下Product是不是存储到了数据库中。实行select*fromproducts，数据库前往相似于以下内容的输入：
ID|NAME|PRICE|AMOUNT|40288081f907f42900f907f448460001|Milk|1.99|100|
Product信息被乐成地拔出到了数据库中，我们乃至都还没有编写一行SQL语句！
拔出一些其他产物，比方面包、咖啡、啤酒等，如许就能够持续进修上面的教程。
<P> 查找和加载产物
查找和加载已耐久化的对象在Hibernate中十分复杂。利用它的查询言语，我们能够很简单地经由过程ID、称号或其他属性猎取一个对象（或对象集）。我们可以猎取完全的对象或它的一部分属性。Hibernate将处置余下的事情，最初，我们将具有相称有效的对象条理系统。我们来看一下test.FindProductByName类。
packagetest;importjava.util.List;importnet.sf.hibernate.Hibernate;importnet.sf.hibernate.Session;importnet.sf.hibernate.SessionFactory;importnet.sf.hibernate.cfg.Configuration;importtest.hibernate.Product;//用法：//javatest.FindProductByNamenamepublicclassFindProductByName{publicstaticvoidmain(String[]args)throwsException{//实行的查询Stringquery="selectproductfromproduct"+"inclasstest.hibernate.Product"+"whereproduct.name=:name";//搜刮的内容Stringname=args;//初始化Configurationcfg=newConfiguration().addClass(Product.class);SessionFactorysf=cfg.buildSessionFactory();//翻开会话Sessionsess=sf.openSession();//搜刮并前往Listlist=sess.find(query,name,Hibernate.STRING);if(list.size()==0){System.out.println("Noproductsnamed"+name);System.exit(0);}Productp=(Product)list.get(0);sess.close();System.out.println("Foundproduct:"+p);}}
在FindProductByName中有几点值得注重：
[*]有一个具有where子句的query字符串，这与尺度SQL语句很类似。
[*]初始化Hibernate的办法与第一个示例中一样。这一次，我们有设置文件和映照文件。
[*]sess.find()实行查询，并将供应的产物称号设置为范例Hibernate.STRING的搜刮参数。
[*]作为了局，我们失掉一个包括所找到的Product的java.util.List。
[*]利用Productp=(Product)list.get(0);我们用一般的范例转换办法猎取找到的对象。
<P>
实行javatest.FindProductByNameMilk，检察显现在把持台中的内容。
注重：查询是辨别巨细写的，以是搜刮小写的milk将不会前往任何了局。利用lower()或upper()SQL函数来启用不辨别巨细写的搜刮。在这类情形下，我们会在查询字符串中利用wherelower(product.name)=lower(:name)。关于查询的具体内容，请拜见文档。别的，假如不但愿显现一切的INFO日记信息，能够修正log4j.properties文件，将日记品级设置为warn。
更新和删除产物
到如今为止，您应当对Hibernate的事情体例有了一个基础的懂得，因而我们将延长冗杂的示例，只显现主要的部分。
为了在单个事件中将一切产物的代价进步10%，我们能够编写以下的内容：
doublepercentage=Double.parseDouble(args)/100;sess=sf.openSession();Transactiont=sess.beginTransaction();//列表包括产物Iteratoriter=list.iterator();while(iter.hasNext()){Productp=(Product)iter.next();p.setPrice(p.getPrice()*(1+percentage));sess.saveOrUpdate(p);}t.commit();sess.close();
最初，要删除Product，固然要挪用sess.delete(product)。假如数据库封闭了autocommit，不要健忘挪用commit()提交Transaction。
如今，我们已完成了针对单个对象的一切基础操纵――创立、读取、更新和删除。看上往相称风趣，但我们能够做得更好。如今我们来进修怎样利用对象集而不必要编写SQL语句。一切的邪术都经由过程映照文件完成。
<P> Orders，OrderItems
偶然一个一个地利用对象的确可行，可是我们但愿可以级联加载和更新。如今我们来看怎样做到这一点。
我们必要同时反省Order和OrderItem。就如后面所提到的，我们增加一项Product到一个Order中，它将酿成一个OrderItem。Order在外部保留一个OrderItem集。我们但愿保留Order，让Hibernate来做其他事情：保留OrderItem和更新所增加的Product的可用库存（数目）。听起来很庞大，但实践上十分复杂。Hibernate晓得怎样处置一对1、一对多、多对一和多对多体例中的相干对象。我们将从映照文件入手下手。
Order.hbm.xml
＜?xmlversion="1.0"encoding="UTF-8"?＞＜!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD//EN""http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd"＞＜hibernate-mapping＞＜classname="test.hibernate.Order"table="orders"＞＜idname="id"type="string"unsaved-value="null"＞＜columnname="id"sql-type="char(32)"not-null="true"/＞＜generatorclass="uuid.hex"/＞＜/id＞＜propertyname="date"＞＜columnname="order_date"sql-type="datetime"not-null="true"/＞＜/property＞＜propertyname="priceTotal"＞＜columnname="price_total"sql-type="double"not-null="true"/＞＜/property＞＜setname="orderItems"table="order_items"inverse="true"cascade="all"＞＜keycolumn="order_id"/＞＜one-to-manyclass="test.hibernate.OrderItem"/＞＜/set＞＜/class＞＜/hibernate-mapping＞
这个映照文件十分易于了解，除最初一个元素＜set＞。它暗示了分歧类之间的毗连，在我们的例子中，这些类是Order和OrderItem。属性和子元素很简单了解：一个Set范例的字段，名为orderItems（拜见下面的Order源代码），它包括范例为test.hibernate.OrderItem的对象，正如＜one-to-many＞子元素所注释的那样。这些对象被耐久化在表order_items中，order_id列包括OrderItem范例的对象的键。
cascade="all"是一个十分主要的属性。它注释了在利用毗连到的对象时，Hibernate怎样举措。在我们的例子中，当创立一个Order时，我们无疑但愿它一切的OrderItem也被创立；固然，当一个Order被删除时，我们也但愿它一切的OrderItem也被删除。Cascade属性另有别的三个选项（none、save-update和delete），我们将鄙人面的示例中看一下怎样利用它们。
OrderItem.hbm.xml
这个对象对照成心思。它的实例主动在Order中创立，基础上不会存在于其外。但是，因为它们在创立Order时期表Product，以是我们必要它们。假如一项产物的代价改动了，我们无疑不但愿一切相干的OrderItem和Order的代价被改动。我们必要的只是在OrderItem创立时更新Product的可用库存。最初，当一项Order被删除时，其OrderItem也被删除，但我们不克不及改动Product！听上往很庞大，出格是要编写一切这些SQL语句的话。但Hibernate把它们紧缩成了映照文件中的两行！
＜?xmlversion="1.0"encoding="UTF-8"?＞＜!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD//EN""http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd"＞＜hibernate-mapping＞＜classname="test.hibernate.OrderItem"table="order_items"＞＜idname="id"type="string"unsaved-value="null"＞＜columnname="id"sql-type="char(32)"not-null="true"/＞＜generatorclass="uuid.hex"/＞＜/id＞＜propertyname="orderId"insert="false"update="false"＞＜columnname="order_id"sql-type="char(32)"not-null="true"/＞＜/property＞＜propertyname="productId"insert="false"update="false"＞＜columnname="product_id"sql-type="char(32)"not-null="true"/＞＜/property＞＜propertyname="amount"＞＜columnname="amount"sql-type="int"not-null="true"/＞＜/property＞＜propertyname="price"＞＜columnname="price"sql-type="double"not-null="true"/＞＜/property＞＜many-to-onename="order"class="test.hibernate.Order"column="order_id"/＞＜many-to-onename="product"class="test.hibernate.Product"cascade="save-update"column="product_id"/＞＜/class＞＜/hibernate-mapping＞
到今朝为止，我们懂得了关于＜id＞和＜property＞元素的统统，但＜many-to-one＞是一个新元素。这个元素十分复杂。第一个＜many-to-one＞元素指出OrderItem的名为order的字段是test.hibernate.Order范例，而且经由过程表order_items的order_id列来援用（拜见class元素的table属性）。第二个many-to-one元素相似于第一个，除它具有cascade="save-update"属性。它在界说的内容之行进行注释。在这个例子中，我们假定Hibernate只在保留（创立）或更新（变动）OrderItem时传送Product的变动，而在删除时不传送变动。因而，上述的庞大SQL语句就被紧缩为单个属性！如今这个成绩办理了！
<P> 用法示例
创立一个定单。在该示例中，我们创立并耐久化一个定单。重复运转这个示例，检察产物数目在每次乐成创立定单后怎样变更。
//...Configurationcfg=newConfiguration().addClass(Product.class).addClass(Order.class).addClass(OrderItem.class);//...Orderorder=newOrder();order.addProduct(milk,3);order.addProduct(coffee,5);//...sess=sf.openSession();Transactiont=sess.beginTransaction();sess.save(order);t.commit();sess.close();System.out.println(order);//...
依照代价局限查找定单。在该示例中，我们将展现怎样利用一个带有两个参数的查询。Hibernate准确地加载具有得当定单项和产物的定单。
//...Stringquery="selectofromo"+"inclasstest.hibernate.Order"+"whereo.priceTotal＞:priceTotalLower"+"ando.priceTotal＜:priceTotalUpper";//...Queryq=sess.createQuery(query);q.setDouble("priceTotalLower",Double.parseDouble(args));q.setDouble("priceTotalUpper",Double.parseDouble(args));Listlist=q.list();//...sess.close();//...
删除必定代价局限内的定单。这是一个主要的示例。这里我们会看到Hibernate是一个何等智能的工具。正如后面所提到的，当删除一个定单时，其定单项也必要被删除，但不克不及改动产物。在运转该示例后，反省数据库，确认产物没有变更。
//...Stringquery="selectofromo"+"inclasstest.hibernate.Order"+"whereo.priceTotal＞:priceTotalLower"+"ando.priceTotal＜:priceTotalUpper";Transactiontx=sess.beginTransaction();sess.delete(query,newObject[]{newDouble(args),newDouble(args)},newType[]{Hibernate.DOUBLE,Hibernate.DOUBLE});tx.commit();sess.close();
停止语
本文展现了Hibernate有何等壮大。您已懂得到能够何等轻松地耐久化任何范例的Java对象、利用对象条理布局、处置汇合、利用事件。但Hibernate的功效不止于此。它能够处置利用提交和回滚的完全事件、承继、几品种型的汇合，并供应十分壮大的面向对象查询言语HQL，HQL撑持联系关系和联合、多态、子查询等。接上去您能够浏览Hibernate参考文档，并动手在一样平常事情中利用Hibernate。
手机用到的是用j2me所编出来的小程序。 让你能够真正掌握接口或抽象类的应用，从而在原来的Java语言基础上跃进一步，更重要的是，设计模式反复向你强调一个宗旨：要让你的程序尽可能的可重用。 在全球云计算和移动互联网的产业环境下，Java更具备了显著优势和广阔前景。 你快去找一份Java的编程工作来做吧（如果是在校学生可以去做兼职啊），在实践中提高自己，那才是最快的。不过你得祈祷在公司里碰到一个高手，而且他 还愿意不厌其烦地教你，这样好象有点难哦！还有一个办法就是读开放源码的程序了。我们知道开放源码大都出自高手，他们设计合理，考虑周到，再加上有广大的程序员参与，代码的价值自然是字字珠叽，铿锵有力（对不起，偶最近《金装四大才子》看多了）。 如果要向java web方向发展也要吧看看《Java web从入门到精通》学完再到《Struts2.0入门到精通》这样你差不多就把代码给学完了。有兴趣可以看一些设计模块和框架的包等等。 是一种使用者不需花费很多时间学习的语言 是一种简化的C++语言 是一种安全的语言，具有阻绝计算机病毒传输的功能 多重继承（以接口取代）等特性，增加了垃圾回收器功能用于回收不再被引用的对象所占据的内存空间，使得程序员不用再为内存管理而担忧。在 Java 1.5 版本中，Java 又引入了泛型编程（Generic Programming）、类型安全的枚举、不定长参数和自动装/拆箱等语言特性。 是一种由美国SUN计算机公司(Sun Microsystems, Inc.)所研究而成的语言 是一种突破用户端机器环境和CPU 其实说这种话的人就如当年小日本号称“三个月拿下中国”一样大言不惭。不是Tomjava泼你冷水，你现在只是学到了Java的骨架，却还没有学到Java的精髓。接下来你得研究设计模式了。
页:
[1]