天空下的雨

首先，封装数据库操作，目的就是为了隐藏Java.sql包内的类，在编码中去掉核心的数据库操作代码。以杜绝直接数据库操作轻易带来的资源未释放问题。同时也减少了数据库操作的编码量。下面给大家一个简单的例子：

1、先用Bean来封装数据库操作

import Java.sql.*;
public class sql_data
{
    //声明变量
    String sDBDriver="sun.jdbc.odbc.JdbcOdbcDriver";   //数据库驱动
    String sConnStr="jdbc:odbc:book";    //使用桥对数据库连接
    Connection conn=null;
    ResultSet rs=null;

    //加载驱动
    public void sql_data()
    {
        try{
            class.forName(sDBDriver);
        }
        catch(Java.lang.ClassNotFoundException e)
        {
            System.err.println(e.getMessage());
        }
    }

    //数据插入
    public void executeInsert(String sql)
    {
        try
        {
            conn=DriverManager.getConnection(sConnStr);
            Statement stmt=conn.createStatement();
            stmt.executeUpdate(sql);
        }
        catch(SQLException ex)
        {
            System.err.println(ex.getMessage());
        }
    }

    //数据查询
    public ResultSet executeQuery(String sql)
    {
        rs=null;
        try
        {
            conn=DriverManager.getConnection(sConnStr);
            Statement stmt=conn.createStatement();
            rs=stmt.executeQuery(sql);
        }
        catch(SQLException ex)
        {
            System.err.println(ex.getMessage());
        }
    }

    //数据删除
    public void executeDelete(String sql)
    {
        try
        {
            conn=DriverManager.getConnection(sConnStr);
            Statement stmt=conn.createStatement();
            stmt.executeUpdate(sql);
        }
        catch(SQLException ex)
        {
            System.err.println(ex.getMessage());
        }
    }
}

2、在JSP页面中调用Bean：

……
<jsp:useBean id="sqlbean" class="book.sql_data"/>  <!-- 调用Bean的数据封装类 -->

<%!String sql,name;%>

<%

sqlbean.sql_data();   //连接数据库
sql="select * from table";
ResultSet rs=sqlbean.executeQuery(sql);

while(rs.next()){
  name=rs.getString("name");
%>

……
name1:<%=name%>  name2: <%=rs.getString("name")%>
……

<%
}
rs.close();
%>

分页每个项目里面差不多都会用到 
我以前耶找了很多个，刚刚找到一个很好用的分页 （baallynn ）

先是一个page的bean：
package com.leatherstore.other;
public class Page { 
    /** 是否有上一页 */
    private boolean hasPrePage; 
    /** 是否有下一页 */
    private boolean hasNextPage; 
    /** 每页的数量 */
    private int everyPage; 
    /** 总页数 */
    private int totalPage; 
    /** 当前页*/
    private int currentPage; 
    /** 起始点 */
    private int beginIndex; 
    /** 总记录数*/
    private int totalCount; 

public int getTotalCount() {
return totalCount;
}

public void setTotalCount(int totalCount) {
this.totalCount = totalCount;
} 
    public Page(){ 
    } 
    
      public Page(int everyPage){
        this.everyPage = everyPage;
    } 

    public Page(boolean hasPrePage, boolean hasNextPage, 
                    int everyPage, int totalPage,
                    int currentPage, int beginIndex,int totalCount) {
        this.hasPrePage = hasPrePage;
        this.hasNextPage = hasNextPage;
        this.everyPage = everyPage;
        this.totalPage = totalPage;
        this.currentPage = currentPage;
        this.beginIndex = beginIndex;
        this.totalCount = totalCount;
    } 
    public int getBeginIndex() {
        return beginIndex;
    } 
    public void setBeginIndex(int beginIndex) {
        this.beginIndex = beginIndex;
    } 
    public int getCurrentPage() {
        return currentPage;
    } 
    public void setCurrentPage(int currentPage) {
        this.currentPage = currentPage;
    } 

    public int getEveryPage() {
        return everyPage;
    } 
    public void setEveryPage(int everyPage) {
        this.everyPage = everyPage;
    } 

    public boolean getHasNextPage() {
        return hasNextPage;
    } 

    public void setHasNextPage(boolean hasNextPage) {
        this.hasNextPage = hasNextPage;
    } 

    public boolean getHasPrePage() {
        return hasPrePage;
    } 

    public void setHasPrePage(boolean hasPrePage) {
        this.hasPrePage = hasPrePage;
    } 

    public int getTotalPage() {
        return totalPage;
    } 

    public void setTotalPage(int totalPage) {
        this.totalPage = totalPage;
    }
}

然后构建一个page的工厂PageUtil：
package com.leatherstore.other;
public class PageUtil {
/**
* Use the origin page to create a new page
*
* @param page
* @param totalRecords
* @return
*/
public static Page createPage(Page page, int totalRecords) {
return createPage(page.getEveryPage(), page.getCurrentPage(),
totalRecords);
}

/**
* the basic page utils not including exception handler
*
* @param everyPage
* @param currentPage
* @param totalRecords
* @return page
*/
public static Page createPage(int everyPage, int currentPage,
int totalRecords) {
everyPage = getEveryPage(everyPage);
currentPage = getCurrentPage(currentPage);
int beginIndex = getBeginIndex(everyPage, currentPage);
int totalPage = getTotalPage(everyPage, totalRecords);
boolean hasNextPage = hasNextPage(currentPage, totalPage);
boolean hasPrePage = hasPrePage(currentPage);

return new Page(hasPrePage, hasNextPage, everyPage, totalPage,
currentPage, beginIndex, totalRecords);
}

private static int getEveryPage(int everyPage) {
return everyPage == 0 ? 10 : everyPage;
}

private static int getCurrentPage(int currentPage) {
return currentPage == 0 ? 1 : currentPage;
}

private static int getBeginIndex(int everyPage, int currentPage) {
return (currentPage - 1) * everyPage;
}

private static int getTotalPage(int everyPage, int totalRecords) {
int totalPage = 0;

if (totalRecords % everyPage == 0)
totalPage = totalRecords / everyPage;
else
totalPage = totalRecords / everyPage + 1;

return totalPage;
}

private static boolean hasPrePage(int currentPage) {
return currentPage == 1 ? false : true;
}

private static boolean hasNextPage(int currentPage, int totalPage) {
return currentPage == totalPage || totalPage == 0 ? false : true;
}

}

然后建一个专用的bean：
package com.leatherstore.hibernate.domain;

import java.util.List;

import com.leatherstore.other.Page;

public class Result {
private Page page;  //分页信息
private List content;  //每页显示的集合 
    public Result() {
        super();
    } 
    public Result(Page page, List content) {
        this.page = page;
        this.content = content;
    } 
    public List getContent() {
        return content;
    } 
    public Page getPage() {
        return page;
    } 
    public void setContent(List content) {
        this.content = content;
    } 
    public void setPage(Page page) {
        this.page = page;
    }
}

然后在数据访问层写两个方法：
ProductDAO：
public List getProductByPage(Page page); 
public int getProductCount();  //返回数据的总数
ProductDAO的接口实现ProductDAOImpl：
//为了在spring里统一编程风格：我用的回调的方法
public List getProductByPage(final Page page) {
return this.getHibernateTemplate().executeFind(new HibernateCallback(){
public Object doInHibernate(Session session) throws HibernateException, SQLException {
Query query=session.createQuery("from Productinfo");
query.setFirstResult(page.getBeginIndex()); //hibernate分页的精髓   呵呵
    query.setMaxResults(page.getEveryPage());
    return query.list();
}
});
}

public int getProductCount() {
List list=this.getHibernateTemplate().find("select count(*) from Productinfo");
return ((Integer)list.iterator().next()).intValue();
}

然后是业务层：
IProduct：
public Result listProduct(Page page);
然后IProduct接口的实现：IProductImpl：
private ProductDAO productDAO;
public void setProductDAO(ProductDAO productDAO){
this.productDAO=productDAO;
}

public Result listProduct(Page page) {
int totalRecords = this.productDAO.getProductCount();
page = PageUtil.createPage(page, totalRecords);
        List products = this.productDAO.getProductByPage(page);     
        return new Result(page, products);
}
然后再代理层：
ProductProxy：
IProduct pro=(IProduct)AppContext.getInstance().getappcontext().getBean("productServicewithTran");

public Result productlist(Page page){
try{
return pro.listProduct(page);
}catch(DataAccessException ex){
ex.printStackTrace();
return null;
}
}

呵呵 终于到productAction啦
显示前方法的代码
Page page = new Page();   //实例化一个page对象
page.setEveryPage(10);    //设置每页显示的条数
page.setCurrentPage(1);    //为第一页
Result result = pdp.productlist(page);
request.setAttribute("page", pageinfo);
request.setAttribute("productlist", list);
return mapping.findForward("showProduct");
接着就是jsp页面了
<logic:iterate id="product" name="productlist">
//中间迭代所要显示的数据
</logic:iterate>
<tr>
    <td width="80" height="30">&nbsp;</td>
    <logic:equal value="true" name="page" property="hasPrePage">
    <td width="150" height="30"><div align="right"><a href="../product.do?method=showProductByTag&index=first&msg=${msg }">首页</a></div></td>
    <td width="80" height="30"><div align="center"><a href="../product.do?method=showProductByTag&index=prew&pageno=${page.currentPage -1}&msg=${msg }">上一页</a></div></td>
    </logic:equal>
    <logic:notEqual value="true" name="page" property="hasPrePage">
    <td width="150" height="30"><div align="right">首页</div></td>
    <td width="80" height="30"><div align="center">上一页</div></td>
    </logic:notEqual>
    <logic:equal value="true" name="page" property="hasNextPage">
    <td width="80" height="30"><div align="center"><a href="../product.do?method=showProductByTag&index=next&pageno=${page.currentPage +1 }&msg=${msg }">下一页</a></div></td>
    <td width="80" height="30"><div align="center"><a href="../product.do?method=showProductByTag&index=end&pageno=${page.totalPage }&msg=${msg }">尾页</a></div></td>
    </logic:equal>
    <logic:notEqual value="true" name="page" property="hasNextPage">
    <td width="80" height="30"><div align="center">下一页</div></td>
    <td width="80" height="30"><div align="center">尾页</div></td>
    </logic:notEqual>
    <td height="30" colspan="3"><div align="center">页次${page.currentPage }/${page.totalPage }&nbsp;&nbsp;&nbsp;共${page.totalCount }条记录</div>      <div align="center"></div></td>
  </tr>
可以显示相应的页面信息
然后productAction里面的showProductByTag代码如下：
Page page = new Page();
page.setEveryPage(10);
String pagemark = request.getParameter("goto");
if (pagemark == null) {
String state = request.getParameter("index");
String pageno = request.getParameter("pageno");
System.out.println("pageno=" + pageno);
if ("first".equals(state)) {
page.setCurrentPage(1);
Result result = pdp.productlist(page);
request.setAttribute("page", result.getPage());
request.setAttribute("productlist", result.getContent());
} else if ("prew".equals(state)) {
page.setCurrentPage(Integer.parseInt(pageno));
Result result = pdp.productlist(page);
request.setAttribute("page", result.getPage());
request.setAttribute("productlist", result.getContent());
} else if ("next".equals(state)) {
page.setCurrentPage(Integer.parseInt(pageno));
Result result = pdp.productlist(page);
request.setAttribute("page", result.getPage());
request.setAttribute("productlist", result.getContent());
} else if ("end".equals(state)) {
page.setCurrentPage(Integer.parseInt(pageno));
Result result = pdp.productlist(page);
request.setAttribute("page", result.getPage());
request.setAttribute("productlist", result.getContent());
}
} else {
page.setCurrentPage(Integer.parseInt(pagemark));
Result result = pdp.productlist(page);
request.setAttribute("page", result.getPage());
request.setAttribute("productlist", result.getContent());
}
return mapping.findForward("showProduct");

完了，大功告成了！ 虽然代码多了点，但我觉得这样挺好的。

　　有许多标准和实践准则可适用于Java开发者，但此处要说的，是每个Java开发者需坚守的基本原则。

　　一、为代码加注释。虽然每个人都知道这点，但有时却不自觉忘了履行，今天你“忘了”加注释了吗？虽然注释对程序的功能没什么“贡献”，但过一段时间，比如说两星期之后或者更长，回过头来看看自己的代码，说不定已经记不住它是干什么的了。如果这些代码是你个人的，那还算是走运了，不幸的是，当然了，大多数时候都是别人的不幸，很多时候大家都是在为公司写代码，写代码的人也许早已经离开了公司，但别忘了一句古话，有来有往嘛，为他人，也为我们自己，请为你的代码加上注释。

　　二、不要让事情复杂化。程序员有时候总是对简单问题想出复杂的解决方案，比如说，在只有五个用户的程序中引入EJB、对程序实现了并不需要的框架（framework），之类的还有属性文件、面向对象解决方案、多线程等等。为什么要这样做呢？也许我们并不知道是否这样会更好，但这样做也许可以学到一些新东西，或者让自己更感兴趣一些。如果是不知道为什么这样做，建议多请教经验丰富的程序员，如果是为了个人的目的，麻烦让自己更专业一点。

　　三、始终牢记——“少即是好（Less is more）并不总是对的”。代码效率虽然很重要，但在许多解决方案中，编写更少的代码并不能改善这些代码的效率，请看下面这个简单的例子：

if(newStatusCode.equals("SD") && (sellOffDate == null ||
todayDate.compareTo(sellOffDate)＜0 || (lastUsedDate != null &&
todayDate.compareTo(lastUsedDate)＞0)) ||
(newStatusCode.equals("OBS") && (OBSDate == null ||
todayDate.compareTo(OBSDate)＜0))){
newStatusCode = "NYP";
}

　　能看明白if条件语句是干什么的吗？能想出来是谁写的这段代码吗？如果把它分成两段独立的if语句，是不是更容易理解呢，下面是修改后的代码：

if(newStatusCode.equals("SD") && (sellOffDate == null ||
todayDate.compareTo(sellOffDate)＜0 || (lastUsedDate != null &&
todayDate.compareTo(lastUsedDate)＞0))){
newStatusCode = "NYP";
}else
if(newStatusCode.equals("OBS") && (OBSDate == null ||
todayDate.compareTo(OBSDate)<0))
{
newStatusCode = "NYP";
}

　　是不是读起来容易多了呢，在此只是多加了一个if和两个花括号，但代码的可读性与可理解性就一下子提高了一大截。

　　四、请不要硬编码。开发者经常有意“忘记”或忽略掉这点，因为有些时候开发日程逼得实在太紧。其实，多写一行定义静态变量的代码能花多少时间呢？

public class A {
public static final String S_CONSTANT_ABC = "ABC";
public boolean methodA(String sParam1){
if (A.S_CONSTANT_ABC.equalsIgnoreCase(sParam1)){
return true;
}
return false;
}
}

　　现在，每次需要将“ABC”与其他变量进行比较时，不必记住实际代码，直接引用A.S_CONSTANT_ABC就行了，而且在今后需要进行修改时，也可在一处修改，不会翻遍整个源代码逐个修改了。

　　五、不要“创造”自己的框架（framework）。确切来说，有数以千计的各种框架存在，而且大多数是开源的，这些框架都是优秀的解决方案，可用于日常程序开发中，我们只需使用这些框架的最新版本就行了，至少表面上要跟上形势吧。被大家广为接受的最为明显的一个例子就是Struts了，这个开源web框架非常适合用在基于web的应用程序中。是不是想开发出自己的Struts呢，还是省点力气吧，回头看看第二条——不要让事情复杂化。另外，如果正在开发的程序只有3个窗口，就不要使用Struts了，对这种程序来说，不需要那么多的“控制”。

　　六、不要使用println及字符串连接。通常为了调试方便，开发者喜欢在可能的所有地方都加上System.out.println，也许还会提醒自己回过头来再来删除，但有些时候，经常会忘了删除或者不愿意删除它们。既然使用System.out.println是为了测试，那么测试完之后，为什么还要留着它们呢，因为在删除时，很可能会删除掉真正有用的代码，所以不能低估System.out.println危害啊，请看下面的代码：

public class BadCode {
public static void calculationWithPrint(){
double someValue = 0D;
for (int i = 0; i ＜10000; i++) {
System.out.println(someValue = someValue + i);
}
}
public static void calculationWithOutPrint(){
double someValue = 0D;
for (int i = 0; i ＜ 10000; i++) {
someValue = someValue + i;
}
}
public static void main(String [] n) {
BadCode.calculationWithPrint();
BadCode.calculationWithOutPrint();
}
}

　　从测试中可以发现，方法calculationWithOutPrint()执行用了0.001204秒，作为对比，方法calculationWithPrint()执行可是用了10.52秒。

　　要避免浪费CPU时间，最好的方法是引入像如下的包装方法：

public class BadCode {
public static final int DEBUG_MODE = 1;
public static final int PRODUCTION_MODE = 2;
public static void calculationWithPrint(int logMode){
double someValue = 0D;
for (int i = 0; i ＜ 10000; i++) {
someValue = someValue + i;
myPrintMethod(logMode, someValue);
}
}
public static void myPrintMethod(int logMode, double value) {
if (logMode ＞ BadCode.DEBUG_MODE) { return; }
System.out.println(value);
}
public static void main(String [] n) {
BadCode.calculationWithPrint(BadCode.PRODUCTION_MODE);
}
}

　　另外，字符串连接也是浪费CPU时间的一个大头，请看下面的示例代码：

public static void concatenateStrings(String startingString) {
for (int i = 0; i ＜ 20; i++) {
startingString = startingString + startingString;
}
}
public static void concatenateStringsUsingStringBuffer(String startingString) {
StringBuffer sb = new StringBuffer();
sb.append(startingString);
for (int i = 0; i ＜ 20; i++) {
sb.append(sb.toString());
}
}

　　在测试中可发现，使用StringBuffer的方法只用了0.01秒执行完毕，而使用连接的方法则用了0.08秒，选择显而易见了。

　　七、多关注GUI（用户界面）。再三强调，GUI对商业客户来说，与程序的功能及效率同等重要，GUI是一个成功程序的最基本部分，而很多IT经理往往都没注意到GUI的重要性。在现实生活中，许多公司可能为了节省开支，没有雇用那些有着设计“用户友好”界面丰富经验的网页设计者，此时Java开发者只能依赖他们自身的HTML基本功及在此领域有限的知识，结果，很多开发出来的程序都是“计算机友好”甚于“用户友好”。很少有开发者同时精通软件开发及GUI设计，如果你在公司“不幸”被分配负责程序界面，就应该遵守下面三条原则：

　　1、 不要再发明一次轮子，即不做无用功。现有的程序可能会有类似的界面需求。
　　2、 先创建一个原型。这是非常重要一步，用户一般想看到他们将使用的东西，而且可以先利用这个原型征求用户的意见，再慢慢修改成用户想要的样子。
　　3、 学会换位思考。换句话来说，就是从用户的角度来审查程序的需求。举例来讲，一个汇总的窗口可以跨页或者不跨页，作为一个软件开发者，可能会倾向于不跨页，因为这样简单一些。但是，从用户的角度来看，可能不希望看到上百行数据都挤在同一页上。

　　八、文档需求不放松。每个商业需求都必须记录在案，这可能听上去像童话，似乎在现实生活中很难实现。而我们要做的是，不管开发时间多紧迫，不管最终期限多临近，对每个商业需求都必须记录在案。

　　 九、单元测试、单元测试、单元测试。关于什么是单元测试的最好方法，在此不便细说，只是强调，单元测试一定要完成，这也是编程中最基本的原则。当然了，如果有人帮你做单元测试自然是最好，如果没有，就自己来做吧，当创建一个单元测试计划时，请遵守以下三条最基本的原则：

　　1、 先于编写类代码之前编写单元测试。
　　2、 记录单元测试中的代码注释。
　　3、 测试所有执行关键功能的公有方法，这里不是指set和get方法，除非它们是以自己独特方式执行set和get方法。

　　十、质量，而不是数量。有些时候因为产品问题、期限紧迫、或一些预料之外的事情，导致常常不能按时下班，但一般而言，公司不会因为雇员经常加班而对之表扬和奖励，公司只看重高质量的工作。如果遵守了前九条原则，你会发现自己写出的代码bug少且可维护性高，无形中质量提高了一大步。

现在把它分享出来吧，

第一步：进入安装Tomcat文件夹 >> conf 目录>> 找到 server.xml

修改server.xml配置文件，在Server标签中加入URIEncoding="UTF-8"

<Server URIEncoding="UTF-8" port="8005" shutdown="SHUTDOWN">

第二步：建立一个.filter的类，实现过滤字符

Fil .java

package sun.filter;
import java.io.IOException;
import javax.servlet.*;

public class Fil implements Filter {

 public void destroy() 
         {
            }

 public void doFilter(ServletRequest arg0, ServletResponse arg1,
   FilterChain arg2) throws IOException, ServletException
            {
                  // 将Request 、Response都转化为utf-8编码
                   arg0.setCharacterEncoding("UTF-8");  
                  arg1.setCharacterEncoding("UTF-8");                
                  arg2.doFilter(arg0, arg1);
            }

 public void init(FilterConfig arg0) throws ServletException
          {
              }        
}

第三步： 在网站配置文件web.xml, 为了更好理解把我的给帖出来

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
 xmlns="http://java.sun.com/xml/ns/j2ee"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
 http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
 
  <filter>
  <filter-name>encoding</filter-name>
  <filter-class>sun.filter.Fil</filter-class>
  </filter>
 
  <servlet>
    <servlet-name>userpass</servlet-name>
    <servlet-class>sun.sta.userpass</servlet-class>
  </servlet>

<filter-mapping>
     <filter-name>encoding</filter-name>
      <url-pattern>/*</url-pattern>
    </filter-mapping>
   
  <servlet-mapping>
    <servlet-name>userpass</servlet-name>
    <url-pattern>/userpass</url-pattern>
  </servlet-mapping>

  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

在一些文章发布系统中，常常用到批量删除。

这时就用到SQL语句：delete from 表名 where 字段名 in （参数1，参数2，参数3......）

用checkbox控件传值是一个很好的选择，但是在取值过程中与ASP有些不同，ASP直接使用

request.Form(checkbox的名字)就能实现：   参数1，参数2，参数3......    格式的排列

在JSP中还需要一定处理，以下为实现的一种方式，代码如下：

客户端：

<BODY>
<CENTER><H4>checkBox批量删除</H4></CENTER>
<HR>
   <FORM METHOD="POST" ACTION="test.jsp">
   <INPUT TYPE="checkbox" NAME="name" value="1"> 条目1<BR>
   <INPUT TYPE="checkbox" NAME="name" value="2"> 条目2<BR>
   <INPUT TYPE="checkbox" NAME="name" value="3"> 条目3<BR>
   <INPUT TYPE="checkbox" NAME="name" value="4"> 条目4<BR>
   <INPUT TYPE="checkbox" NAME="name" value="5"> 条目5<BR>
   <INPUT TYPE="checkbox" NAME="name" value="6"> 条目6<BR>
   <INPUT TYPE="checkbox" NAME="name" value="7"> 条目7<BR>
   <INPUT TYPE="submit" value="提交">
   </FORM>
</BODY>

服务器端：

<%@ page language="java" import="java.util.*" pageEncoding="GBK"%>
<%
String[] name=request.getParameterValues("name");//取值，字符串数组存值
String str=name[0].toString();
for(int i=1;i<name.length;i++){
str=str+","+name[i];   //转化为字符串，添加逗号
}
out.print("str=");
out.print(str);
%>
 

用java写的基于Socket的简单即时通讯程序,用户可以注册并登录,也可以作为游客身份使用.
 

public class Reverse
{
    public static void main()
            {
                 if(args.length>0)
                 {
                     StringBuffer a = new StringBuffer(args[0]);
                     a = a.reverse();
                     System.out.println(a);                
                 }
                 else
                   {
                     System.out.println("输入错误");
                 } 
            }

}

　　目前，JAVA是开发人员的热宠，很多论坛都有不少热爱JAVA的开发人员，也有不少想成为JAVA程序员，但苦于不知道该如何学习，也不清楚该学些什么知识才能成为一个JAVA程序员。本人在这里抛砖引玉，和大家讨论成为一个JAVA初级程序员应该具有的知识，与大家共享。

　　个人认为想成为一个合格的JAVA初级程序员应该具备如下知识：

　　一、面向对象的知识：JAVA是一个面向对象的开发语言，因此熟悉面向对象对学习JAVA很有必要，您要了解：什么是对象，什么是类;什么是封装，什么是多态，什么是继承;什么是抽象类，什么是接口。了解了概念后，您还需要这些概念是如何体现的，如类和对象有什么区别?类是如何封装的?

　　二、JAVA语法：如果您已经有了开发经验，恭喜您，您学习JAVA语法来将比较容易。如果您有C++等面向对象语言的开发经验，您只需简单的翻看一下介绍JAVA的相关书籍就可以了。如果您是新手，没有关系，您下些工夫，好好研究一本JAVA初级教程之类的书就可以了。

　　学习了JAVA语法，加上面向对象的知识，只有您用心，您就可以写出来比较好的JAVA代码了。如果您再抽出时间熟悉一下JAVA编程规范，您代码的水平就应该不俗了。

　　三、JSP和HTML：在我国的绝大多数公司，做JAVA程序员都少不了和JSP以及HTML打交道。因此，想成为JAVA程序员就不可避免的要熟悉JSP和HTML，您最好能知道JSP的几个内置对象，如Session，Request，Reponse，，以及常用的JSP标签，如include,userBean等。尽管一些工具会帮您生成HTML代码，但您还是要熟悉比如title，，，，等。如果您再熟悉一下JS和CSS就更好了，那会使您制作的页面更友好。

　　四、WebServer:熟悉了以上三种，可以肯定的说您已经可以制作出来JSP页面了，您也可以在您的页面里使用自己开发的JAVA类(JAVABEAN)了，但您的页面总要跑起来才能看到您要的效果，这就要求您必须熟悉一种WebServer，比如：TOMCAT，RESIN等。您要熟悉如何发布您的应用，如何利用WebServer的数据库资源等。

　　五、开发工具：大家都知道，开发工具可以帮助您更好更快地开发，因此熟悉几种开发工具很有必要。目前JAVA的开发工具比较流行的有JBuilder,IDEA,Eclipse，HTML的开发工具有Dreamweaver等。

　　六、熟悉一种框架：熟悉一种框架其实是成为JAVA程序员的一种可选知识，但目前开发B/S结构的应用的开发小组，都差不多会采用一种框架来构建自己的应用系统。框架都会有许多可重用的代码，良好的层次关系和业务控制逻辑，基于框架的开发使你可以省出很多的开发成本。目前比较流行的框架有Struts和WAF等。

public class Helloworld
{
      public static void main(String[] args)
      {
        System.out.println("User.Mag");
      }
}

class User
{
      static String Mag = "hello world!";

}

发现几个网站可以下些代码参考：http://www.java-cn.com/  http://www.ibook8.com/

今天，在一篇博客文章中说： 打印10万个hello,world，Java比C++快25倍，下面是引用：