業精于勤荒于嬉,行成于思毀于隨

一些資料:




http://www.csdn.net/subject/j2meTools/

http://news.csdn.net/news/newstopic/24/24127.shtml

有個輸家，就一定有個贏家。我是輸家，但我四周望了一圈，卻沒看到半個贏家，我想，贏家應該也是我了，你說呢?

vi命令是unix下常用而重要命令，可在全屏幕方式下編輯一個或多個文件。若在vi執行時?
沒有指定一個文件，那么vi命令會自動產生一個無名的空的工作文件。若指定的文件不存在，?
那么就按指定的文件名創建一個新的文件。若對文件的修改不保存的話，v?i命令并不改變原?
來文件的內容。?

　　注意：vi命令并不鎖住所編輯的文件，因此多個用戶可能在同時編輯一個文件，那么最后?
保存的文件版本將被保留。?

下面是vi命令使用的一些選項及含義：??????????

　　-c?sub-command?在對指定的文件編輯前，先執行指定的命令?sub-command?.?

　　-r?filename?恢復指定的文件filename?.??????????

　　-R?將指定的文件以只讀的方式放入編輯器中，這樣不會保存對文件的任何修?改。?

　　-y?number?將編輯窗口的大小設為number行。??????????

　　下面是vi編輯所處的三種模式：??????????

　　.命令模式?進入vi時所處的模式。在此模式下用戶可輸入各種子命令對進行*作，如刪除行、?
粘貼行、移向下一個字、移向不同行等。?

　　.文本輸入模式?在此模式下可以修改一行的內容并增添新行。在命令模式下鍵入a?、i?或?
c鍵可進入文本輸入模式，按Escape鍵可返回命令模式。?

　　.命令項模式?在此模式下，可以通過子命令輸入更多的參數。如：w子命令要求輸入一文?
件名，"/"子命令要求輸入一個查找項。用戶使用Escape鍵返回命令模式。?

下面是自命令模式下執行的，在同一行上移動的自命令：??????????

　　h?將光標左移一格。??????????

　　l?將光標右移一格。??????????

　　j?將光標下移一格。??????????

　　k?將光標上移一格。??????????

　　w?將光標移到下一個小字的前面。??????????

　　W?將光標移到下一個大字的前面。??????????

　　b?將光標移到前一個小字的前面。??????????

　　B?將光標移到前一個大字的前面。??????????

　　e?將光標移到下一個小字的后面。??????????

　　E?將光標移到前一個大字的后面。??????????

　　fc?把光標移到同一行的下一個c字符處。??????????

　　Fc?把光標移到同一行的前一個c字符處。??????????

　　tc?把光標移到同一行的下一個字符c的前一格。??????????

　　Tc?把光標移到同一行的前一個字符c的后一格。??????????

　　number|?把光標移到遞number列上。??????????

下面是命令模式下在行間移動的子命令：??????????

　　+或Enter?把光標移至下一行第一個非空白字符。??????????

　　-?把光標移至上一行第一個非空白字符。??????????

　　0?把光標移到當前行的第一個字符處。??????????

　　$?把光標移到當前行的最后一個字符處。??????????

　　H?把光標移到屏幕最頂端一行。??????????

　　L?把光標移到屏幕最底端一行。??????????

　　M?把光標移到屏幕中間。??????????

下面是命令模式下改變屏幕顯示的子命令：??????????

　　z-?把當前行作為屏幕的最后一行，并重新顯示屏幕。??????????

　　z.?把當前行作為屏幕的中間一行，并重新顯示屏幕。??????????

　　Ctrl+l?重新顯示屏幕當前內容。??????????

　　/pattern/z-?尋找pattern的下一個位置，并把所在行設為屏幕的最后一行。?

下面是在命令模式下用來顯示頁面的子命令：??????????

　　Ctrl?+?f向后滾一頁。??????????

　　Ctrl?+?d向后滾半頁。??????????

　　Ctrl?+?b向前滾一頁。??????????

　　Ctrl?+?u向前滾半頁。??????????

　　Ctrl?+?e屏幕向下滾一行。??????????

　　Ctrl?+?y屏幕項上滾一行。??????????

下面是在命令模式下用來查找字符串所使用的子命令：??????????

　　/pattern?向后尋找指定的pattern?,若遇到文件尾，則從頭再開始。?

　　？pattern?向前尋找指定的pattern?,若遇到文件頭，則從尾再開始。?

　　n?在上次指定的方向上，再次執行上次定義的查找。??????????

　　N?在上次指定的方向的相反方向上，再次執行上次定義的查找。??????????

　　/pattern/+number?將光標停在包含pattern的行后面第number行上。?

　　/pattern/-number?將光標停在包含pattern的行前面第number行上。?

　　%?移到匹配的"（）"或"{}"上。??????????

下面是在文本輸入模式下用來輸入文本的子命令（用戶可在任何時候按Escape返回到命令模式）：?

　　a?在光標之后開始輸入文本。??????????

　　A在行尾開始輸入文本。??????????

　　i在光標之前開始輸入文本。??????????

　　I在行首第一個非空白字符前輸入文本。??????????

　　o在光標所在行后插入一空行。??????????

　　O在光標所在行前插入一空行。??????????

下面是在命令模式下改變文本所使用的子命令（用戶可在任何的時候按Escape鍵返回到命令模式）：?

　　cc或S?修改一整行。??????????

　　C?改變一行光標位置以后的部分。??????????

　　cw?改變光標所在單詞。??????????

　　dd刪除當前行。??????????

　　D?刪除光標所在行光標后面的內容。??????????

　　dw刪除光標所在的單詞。??????????

　　J?把下一行內容加到本行行尾。??????????

　　rc把光符所在字符替換成c?.??????????

　　R?覆蓋本行內容。??????????

　　u恢復上一次的修改。??????????

　　x刪除光標所在的字符。??????????

　　~?改變光標所在出字符的大小寫。??????????

　　.?重復上一個*作。??????????

　　<<把當前行移到左邊。??????????

　　>>把當前行移到右邊。??????????

下面是用于文件中拷貝文本的字命令：??????????

　　p?將緩沖區內容取到光標所在行的下面一行。??????????

　　P?將緩沖區內容取到光標所在行的上面一行。??????????

　　"bd?將文本刪除至有名緩沖區b?.??????????

　　"bp?張貼有名緩沖區b中內容。??????????

　　yy把當前行放入緩沖區。??????????

　　Y?把當前行放入緩沖區。??????????

　　Yw把光標所在的單詞放入緩沖區。??????????

下面是用于保存文件的子命令：??????????

　　:w?回寫修改后的文件。??????????

　　:w?filename?當filename不存在時，把修改后的文件存為文件filename?,當文件filename?
存在時，報錯。?

　　!w?filename?如果文件filename存在時，把修改后的文件保存為文件filename?.?

下面列出了在vi編輯的多個文件之間切換所用的子命令：??????????

　　:n開始編輯vi激活的文件列表中的下一個文件。??????????

　　:n?filenames?指定將被編輯的新的文件列表。??????????

下面列出了用于在當前文件和另外一個文件間切換的子命令：??????????

　　:e?filename?使用filename激活vi?（在vi中裝入另一個文件filename）。?

　　e!重新裝入當前文件，若當前文件有改動，則丟棄以前的改動。??????????

　　:e+filename?使用filename激活vi?,并從文件尾部開始編輯。?

　　:e+number?filename?使用filename激活vi?,并在第number行開始編輯。?

　　:e#?開始編輯另外一個文件。??????????

下面是在本文件中加入其他文件代碼所使用的子命令：??????????

　　:r?filename讀取filename文件，并將其內容加到當前文件后。???

　　:r?!?command執行command文件，并將其輸出加到當前文件后。???

下面是vi中其他的子命令：??????????

　　ctrl+g?取得正在編輯文件的有關信息。??????????

　　:sh啟動sh?，從sh中返回可用exit或ctrl+d?.??????????

　　:!?Command?執行命令command?.??????????

　　!!重新執行上次的:!?Command子命令。??????????

　　:q退出vi?，若用戶對編輯的文件有所修改，系統不會讓用戶使用q命令退出。???

　　:q!退出vi而不管是否對文件有改動。??????????

　　ZZ或:wq?保存對文件的修改并退出vi?.??????????

　　用戶可在一個特殊的文件.exrc中定義特殊的vi命令。在vi中使用這些命令時，必須在該?
命令前加上一個冒號(?：)?。

?log4j雖然總的來說是比較容易使用的，但是要是想比較精通的操縱它還是有很多地方值得探討的。
??? 這幾天有空，把項目中大家用到的log4j實現的功能分了一下類，大致分為下面三類:
??? <1>所有的日志信息都輸出到log.log.
??? <2>對于一些特殊的日志（如啟動時候的日志），輸出到log/startup/startup.log.
??? <3>對于某些特殊包下面的日志，如com.aspire包下面的error信息都輸出到error.log???
??? 有了這幾個功能，相信對于大部分的系統都是夠用的了，下面這個例子就是實現了這幾個功能:
??? (至于其他的一些配置，如格式這些的就不說明,有很多這種資料)
???
??? ***********? log4j 配置文件? ************???
???
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="

<appender name="file" class="org.apache.log4j.RollingFileAppender">
?<param name="File" value="log.log"/>
?<layout class="org.apache.log4j.PatternLayout">
?<param name="ConversionPattern" value=" %d{ISO8601} [%c]- %m%n"/>
?</layout>
</appender>

<appender name="error" class="org.apache.log4j.RollingFileAppender">
??<param name="File" value="error.log"/>
??<param name="MaxBackupIndex" value="300"/>
??<param name="Encoding" value="GB2312"/>
??<param name="MaxFileSize" value="20MB"/>
??<layout class="org.apache.log4j.PatternLayout">
???<param name="ConversionPattern" value="%d{ISO8601} %p [%c] - [%m]%n"/>
??</layout>
??? <filter class="org.apache.log4j.varia.LevelRangeFilter">
??<!-- 過濾,只記錄error信息-->
??<param name="LevelMin" value="error"/>
??<param name="LevelMax" value="error"/>
??<param name="acceptOnMatch" value="true"/>
??? </filter>
</appender>
<appender name="startup" class="com.aspire.TimeSizeRollingFileAppender">
??<!--該類使自己從FileAppender派生，可以自己控制輸出文件的路徑 -->
??<param name="File" value="log/startup/startup.log" />
??<param name="Encoding" value="GBK" />
??<layout class="org.apache.log4j.PatternLayout">
???<param name="ConversionPattern" value="%m %d{ISO8601}- %m%n %p %l%n" />
??</layout>
</appender>

<logger name="biz.startup">
<!--Logger logger = Logger.getLogger("biz.startup") 可以這樣來調用本logger-->
??<level value="debug" />
??<appender-ref ref="startup" />
</logger>

<logger name="com.aspire" additivity="false">
<!--Log log = LogFactory.getLog(TestLog4j.class) 此時如果TestLog4j
??? 位于com.aspire包下面，那么使用本logger
?-->
??<level value="debug"/>
??<appender-ref ref="error"/>
</logger>
<root>
<level value="info"/>
<!-- 默認輸出到log.log-->
<appender-ref ref="file"/>
</root>
</log4j:configuration>

***********? log4j 配置文件結束 ************

**********? 派生的TimeSizeRollingFileAppender類*****
package com.aspire;

import org.apache.log4j.FileAppender;
import org.apache.log4j.spi.ErrorCode;
import java.io.File;
import java.io.IOException;

public class TimeSizeRollingFileAppender
??? extends FileAppender
??? implements ErrorCode {

? private final static String FS = System.getProperty("file.separator");
? public TimeSizeRollingFileAppender() {
? }
? public void setFile(String file) {
??? String val = file.trim();
??? File domain = new File(".");
??? try {
????? fileName = domain.getCanonicalPath() + FS + val;
??? }
??? catch (IOException ex) {
????? ex.printStackTrace();
??? }
? }
}

********** TimeSizeRollingFileAppender 類結束 ******

************ 調用示例 TestLog4j類 **************
package com.aspire;

import org.apache.log4j.Logger;
import org.apache.log4j.LogManager;
import org.apache.commons.logging.LogFactory;
import org.apache.log4j.xml.DOMConfigurator;
import org.apache.commons.logging.Log;

public class TestLog4j {
? private Logger logger = Logger.getLogger("biz.startup");
? private Log log = LogFactory.getLog(TestLog4j.class);

? public static void config(){
??? DOMConfigurator.configure("conf\\log4jConf.xml");
? }
? public void Test(){
??? /**
???? * error > warn > info > debug
???? */
??? logger.error("*****error*****");
??? logger.debug("****debug*****");
??? logger.warn("*****warn******");
??? logger.info("*****info******");
??? log.error("中華之崛起!");
? }
? public static void main(String [] argv){
??? TestLog4j t = new TestLog4j();
??? TestLog4j.config();
??? t.Test();
? }
}

***************? TestLog4j end ***********

很多時候，創建對象的時候，只是在某些屬性值上有區別，而大部分都很相似，但是這樣的對象的初始化相對來說比較復雜，而且
需要耗費較長的時間或資源，這種情況下，我們可以考慮使用Prototype模式。我覺得這種模式實用于這樣的情況:如果該類的用戶對于該
類的對象是怎么創建的，對類的內部結構這些都不關心的情況，并且該類的創建過程比較費時或資源時，可以考慮使用該模式。下面是該模式的
一個例子:

Prototype 類

package com.moonsoft;

import java.lang.Cloneable;
public class Prototype implements Cloneable {
?
?public String myname;
?
?Prototype(){
??System.out.println("start:"+System.currentTimeMillis());
??for( int i=0; i< 9999999; i++){???
??}
??System.out.println("end:"+System.currentTimeMillis());
?}
?
?public Object clone(){
??Object o = null;
??try{
???o = super.clone();???
??}
??catch(CloneNotSupportedException ex){
???ex.printStackTrace();
??}
??return o;
?}
?
?public void whoami(){
??System.out.println(myname);
?}
}


測試類

package com.moonsoft;

public class Test {
?
?public static void main(String [] argv){
??Prototype? p = new Prototype();
??p.whoami();
??p.myname = "loucy";
??Prototype? p1 = (Prototype)p.clone();
??p1.whoami();?
??
?}
}

如果一直為jsp的緩存問題困擾的話，可以試試在jsp中加入以下幾句話:

<head>
<meta http-equiv="Cache-Control" content="max-age=0" forua="true" />
<meta http-equiv="Cache-Control" content="no-cache" forua="true"/>
<meta http-equiv="Cache-Control" content="must-revalidate" forua="true" />
</head>

max-age=30 就表示緩存的最長存在時間是30s,no-cache表示無緩存，must-revalidate表示每次訪問必須重新驗證是否有更新！

? 馬上就要開始轉到新的項目組，做一個全新的項目了，對于HTTP協議需要一定的了解，所以周末自己用Java寫了一個簡單的web服務器試試，只能實現簡單的html文件瀏覽。

主要包括三個類:WebServer(監聽瀏覽器請求),SocketThread(處理瀏覽器請求的進程),StringUtil(實現一些公共的操作),下面是三個類的代碼.


----WebServer----
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class WebServer {
?
?public static void main(String[] argv) throws IOException {
??ServerSocket servSocket = new ServerSocket(StringUtil.LISTENING_PORT);
??try {
???while (true) {
????Socket socket = servSocket.accept();
????new SocketThread(socket).start();
???}
??} finally {
???servSocket.close();
??}
?}
}
---SocketThread------
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.Writer;
import java.net.Socket;

public class SocketThread extends Thread {
?private Socket socket = null;

?public SocketThread(Socket s) {
??this.socket = s;
?}

?public void run() {
??try {
???if (socket == null) {
????throw new Exception("==>SOCKET為空<==");
???}
???BufferedReader reader = new BufferedReader(new InputStreamReader(
?????socket.getInputStream()));
???String fileName = "";
???while (true) {
????String str = reader.readLine();
????if (str == null || str.length() <= 0) {
?????break;
????}
????//System.out.println("===>"+str);
????if (StringUtil.isGetRequestInfo(str)) {
?????fileName = StringUtil.getFileName(str);
?????break;
????}
???}
???//System.out.println("===>客戶機IP==>"+socket.getInetAddress().toString());
???//System.out.println("===>客戶機端口==>"+socket.getPort());???
???/*
??? BufferedWriter writer = new BufferedWriter(new
??? OutputStreamWriter(socket.getOutputStream()));
??? */
???PrintStream outputStream = new PrintStream(socket.getOutputStream());
???File file = new File(StringUtil.WEBPATH + fileName);
???if (file.exists()) { //如果文件存在
????StringUtil.sendHttpHead(outputStream, file);
????StringUtil.sendFile(outputStream, file);
????outputStream.flush();
???} else { //文件沒找到，返回404頁面
????StringUtil.send404Page(outputStream);
????outputStream.flush();
???}
??} catch (Exception e) {
???e.printStackTrace();
??} finally {
???try {
????socket.close();
???} catch (Exception e) {
???}
??}
?}

}



---StringUtil-----
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.PrintStream;

/**
?* @author xiaoliang
?*/
public class StringUtil {

?// 服務器監聽的端口
?public static final int LISTENING_PORT = 8080;

?// 服務器文件的位置
?public static final String WEBPATH = "E:";

?/**
? * 判斷該字符串是不是瀏覽器發送過來的請求頭信息
? * @param str
? * @return
? */
?public static boolean isGetRequestInfo(String str) {
??if (str == null || str.length() <= 0)
???return false;
??boolean isGetStr = true;
??if (str.indexOf("GET") != 0) {
???isGetStr = false;
??}
??if (str.indexOf("HTTP/") <= 0) {
???isGetStr = false;
??}
??return isGetStr;
?}

?/**
? * 獲得請求信息中的文件名,默認為index.html
? *
? * @param str
? * @return
? */
?public static String getFileName(String str) {
??String fileName = "index.html", s;
??int httpIndex = str.lastIndexOf("HTTP/");
??s = str.substring(3, httpIndex);
??s = s.trim();
??if (s != null && s.length() > 0 && s.indexOf(".") > 0) {
???fileName = s;
??}
??return fileName;
?}

?/**
? * 發送文件到客戶端
? *
? * @param out
? * @param file
? */
?public static void sendFile(PrintStream out, File file) {
??try {
???DataInputStream in = new DataInputStream(new FileInputStream(file));
???int length = (int) file.length();
???byte[] buffer = new byte[length];
???in.readFully(buffer);
???out.write(buffer, 0, length);
???in.close();
??} catch (Exception e) {
???e.printStackTrace();
??}
?}

?/**
? * 發送返回的頭部信息
? * @param out
? */
?public static void sendHttpHead(PrintStream outputStream, File file) {
??try {
???outputStream.println("HTTP/1.0200OK");
???outputStream.println("Content_Type:text／htm1");
???outputStream.println("Content_Length:" + file.length());
???outputStream.println("Server:moon webserver 1.0");
???outputStream.println("");
??} catch (Exception e) {
???e.printStackTrace();
??}
?}

?/**
? * 返回404頁面
? * @param out
? */
?public static void send404Page(PrintStream out) {
??try {
???out.println("HTTP ／1.0 404 no found");
???out.println("Content_type:text/html");
???out.println("");
???out.println("Error404:file not found!");
??} catch (Exception e) {
???e.printStackTrace();
??}
?}
?
?public static void main(String[] argv) {
??String str = "GET /11.html HTTP/1.1";
??str = StringUtil.getFileName(str);
??System.out.println("==>" + str + "<==");
??File file = new File(StringUtil.WEBPATH + str);
??if (file.exists()) {
???System.out.println("exists");
??} else {
???System.out.println("not exists");
??}
?}

}

FileUpload 組件使用注意:
1>
首先創建一個HTML頁面。注意，凡是要上載文件的表單都必須設置enctype屬性，且屬性的值必須是multipart/form-data，同時請求方法必須是POST.
<form name="myform" action="fileuploaddemo.jsp"  method="post" enctype="multipart/form-data">
 
2>commons-fileupload-1.1.jar和commons-io-1.1.jar 兩個包都要引入，
因為在parseRequest(request)的類有關繼承于DiskFileItem類。

3>示例
      //檢查表單是否正確
      boolean isMultipart = FileUpload.isMultipartContent(request);
      DiskFileItemFactory  factory = new DiskFileItemFactory();
      ServletFileUpload upload = new ServletFileUpload(factory);
      //文件最大，設為-1表示不受限制
      upload.setSizeMax(4096);
      //解析請求，把解析的結果放在一個List里面
      List items = upload.parseRequest(request);
      //緩存大小，設為-1表示不受限制
      factory.setSizeThreshold(4096);
      //設置臨時目錄
      factory.setRepository(new File("D:\\temp"));
      Iterator iter = items.iterator();
      while( iter.hasNext() ){
        FileItem item  = (FileItem)iter.next();
        //檢查是一個普通的表單域還是File組件
        if( !item.isFormField() ){
          System.out.println("FileName:==>"+item.getName());
          System.out.println("FieldName:==>"+item.getFieldName());
          System.out.println("Size:==>"+item.getSize());
          //item.getName 返回的是完整的文件名，如:E:\\xx\11.doc
          //所以這里用一個fullFile來取文件名
          File fullFile  = new File(item.getName());
          File uploadedFile = new File("D:\\ftp\\",fullFile.getName());
          item.write(uploadedFile);
        }
      }

從一個表users中查詢記錄，如果是寫成
select  i from  users as  i  where i.name=?1則編譯EJB的時候會報錯，但是如果把users 首字母大寫就OK了。
select  i from  Users as  i  where i.name=?1

在EJB容器中，SessionBean主要有兩種：無狀態（stateless）和有狀態（stateful）。
1、無狀態EJB，類似Servlet，它只提供一個引用(Bean instance)，被所有客戶端使用，不保留某個客戶的單獨信息。
例如：在某無狀態EJB中，有一個數據成員（變量） i_count （整型，用于訪問計數，初始值為0，訪問一次累加1），它是公共的。某客戶端訪問后，值累加為1。另一個客戶端訪問時是已經變化了的值為1。

2、有狀態EJB，類似數據庫的Connect鏈接，也類似線程守護，它提供引用池(Bean instance pool)，每個客戶端會有單獨的信息。
例如：在某有狀態EJB中，有一個數據成員（變量） i_count （整型，用于訪問計數，初始值為0，訪問一次累加1），它對每個客戶端來說是隔離的。某客戶端訪問后，值累加為1。另一個客戶端訪問時還是原來的值為0。

這里提到的數據成員（變量） i_count ，在EJB規范中稱作：conversational state 。對它的要求也很多的，例如類型為 Serializable objects。還有，還要在ejbActivate()，ejbPassivate()，ejbRemove()等生命周期約定的方法中處理。詳見EJB規范吧。

我的感想：在看第一遍書時，還一點感覺都沒有，根本就看不明白SessionBean中的session與Servlet容器中的session有什么區別。
動手編程后，才感覺到EJB只是比Servlet更規范，更重量而已。真正的區別就是接口協議一個是基于HTTP，一個是基于RMI/IIOP。Servlet與無狀態的SessionBean在Session上是一樣的控制。Servlet中的Session對象與有狀態的SessionBean是一樣的控制。
對于應用，例如有一個購物車，要記錄正在采購的物品信息，沒有EJB時，我們一般是存在Servlet容器中的session中。有了EJB，則可以存儲在有狀態的SessionBean中，并且該次有狀態的sessionBean的instance還得保存在Servlet的session中。這樣的好處是：至少可以減輕Servlet容器的負載。



轉自:
http://zengabo.blogchina.com/blog/527365.html

1.將ibatis 的jar 包添加到工程中

2.先新建一個xml文件 SqlMap.xml,在這個文件中定義使用了哪些ibatis資源文件
<?xml version="1.0" encoding="gb2312"?>
<!DOCTYPE sql-map-config PUBLIC "-//iBATIS.com//DTD SQL Map Config 1.0//EN"
    "<sql-map-config>
  <sql-map  resource="com/montersoft/ibatis/common/monter.xml"/>
</sql-map-config>

3.定義資源文件monter.xml
<?xml version="1.0" encoding="gb2312"?>
<!DOCTYPE sql-map
    PUBLIC "-//iBATIS.com//DTD SQL Map 1.0//EN"
    "<sql-map name="monter">
   <result-map name="monterInfo" class="java.util.HashMap">
     <property name="id"  column="id" type="VARCHAR"/>
     <property name="name" column="name" type="VARCHAR"/>
     <property name="age"  column="age"  type="NUMBERIC"/>
   </result-map>  
   <dynamic-mapped-statement name="monter_getByPk" result-map="monterInfo">
   select id,name,age from monter where id = #id#
   </dynamic-mapped-statement>
</sql-map>

**注意dynamic-mapped-statement的name 必須唯一

4.定義一個公共類來生成SqlMap
package com.montersoft.ibatis.common;
import java.io.Reader;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.ibatis.common.resources.Resources;
import com.ibatis.db.sqlmap.SqlMap;
import com.ibatis.db.sqlmap.XmlSqlMapBuilder;
public class SqlMapUtil { 
 private static Log loger = LogFactory.getLog(SqlMapUtil.class);
 public  static SqlMap  sqlMap ; 
 public static SqlMap loadSqlMap(){
  Reader reader = null;
  try{
   reader = Resources.getResourceAsReader("com/montersoft/ibatis/common/SqlMap.xml");
   return XmlSqlMapBuilder.buildSqlMap(reader);
  }
  catch(Exception e){   
   loger.error("there is a error=>"+e.getMessage());
  }
  return null;
 } 
 public static SqlMap getSqlMap(){
  if( sqlMap == null )
   sqlMap = loadSqlMap();
  return sqlMap;
 } 
}
5.再新建DAO,Vo,
public interface  IVO { 
}
public class MonterVo implements IVO{ 
 public String id ;
 public String name;
 public int age;
 ...省去 get ,set 方法
}
public class MonterDao { 
   public IVO getBkPK(Connection conn,IVO vo) throws Exception{
    try{    
    Object map  =  SqlMapUtil.getSqlMap().
       getMappedStatement("monter_getByPk").executeQueryForObject(conn,vo);
    return   copyMap2Vo(map);
    }
    catch(Exception e){       
        throw new Exception(e.getMessage());
    }
   }  
   private IVO copyMap2Vo(Object map){
    MonterVo vo = new MonterVo();
  try{
   BeanUtils.copyProperties(vo,map);
  }
  catch(Exception e){
   e.printStackTrace();
  }
  return vo;
 }
}

6.至此就建立了一個簡單的ibatis示例.

通過weblogic的數據源獲得數據庫連接的方法:

package com.moonsoft.datasource;

import javax.naming.NamingException;
import java.util.Hashtable;
import javax.naming.InitialContext;
import java.sql.Connection;
import javax.sql.DataSource;
import java.sql.SQLException;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class TestDataSource {

  public static String WEB_URL = "t3://localhost:9000";
  public static String DATA_SOURCE = "JDBCDS";
  public static String weblogic_context_factory =
      "weblogic.jndi.WLInitialContextFactory";
  public TestDataSource() {
  }
  public static Object lookUp() throws NamingException {
    Hashtable env = new Hashtable();
    env.put(InitialContext.INITIAL_CONTEXT_FACTORY, weblogic_context_factory);
    env.put(InitialContext.PROVIDER_URL, WEB_URL);
    InitialContext tempContext = new InitialContext(env);
    return tempContext.lookup(DATA_SOURCE);
  }
  public static Connection getConnection() throws SQLException {
    Connection conn = null;
    try {
      DataSource ds = (DataSource) lookUp();
      if (ds == null) {
        throw new SQLException("查詢到空數據源!");
      }
      conn = ds.getConnection();
    }
    catch (NamingException ex) {
      ex.printStackTrace();
    }
    return conn;
  }
  public static void releaseConnection(Connection conn, PreparedStatement sta,
                                       ResultSet rs) {
    try {
      if (rs != null) {
        rs.close();
      }
      if (sta != null)
        sta.close();
      if (conn != null)
        conn.close();
    }
    catch (Exception ex) {
      ex.printStackTrace();
    }
  }
  public static void testSearch() {
    Connection conn = null;
    PreparedStatement sta = null;
    ResultSet rs = null;
    try {
      conn = getConnection();
      String sql = "select * from admin_config where config_name like ?";
      sta = conn.prepareStatement(sql);
      sta.setString(1,"%Sms%");
      rs = sta.executeQuery();
      if (rs != null) {
        while (rs.next()) {
          System.out.println(rs.getString(1));
        }
      }
    }
    catch (Exception ex) {
      ex.printStackTrace();
    }
    finally {
      releaseConnection(conn,sta,rs);
    }
  }
  public static void main(String [] argv){
    testSearch();
  }
}

如果是在需求還沒確定或者是在兩個類實現相近功能時候，會大量使用下面的方式:
--抽象類,注意其中的newInstance方法的實現
package com.moonsoft.design;
public  abstract class Moon {
  public static Moon newInstance(String classStr){
    Class re;
    try {
      re =  Class.forName(classStr);
      return (Moon)re.newInstance();
    }
    catch (Exception ex) {
      ex.printStackTrace();
    }
    return null;
  }
  public abstract void  println();
}
--從Moon類派生出來的一個字類，提供println方法的一種實現方式
package com.moonsoft.design;
public class Moon1 extends Moon {
  public void println(){
    System.out.println("I am moon1");
  }
  public void myprintln(){
    System.out.println("I am moon1 myprintln");
  }
}
--從Moon類派生出來的另一個字類，提供println方法的另一種實現方式
package com.moonsoft.design;
public class Moon2 extends Moon {
   public void println(){
    System.out.println("I am moon2!");
  }
}
--調用
 Moon moon = Moon.newInstance("com.moonsoft.design.Moon1");
 moon.println();
 或
 Moon moon = Moon.newInstance("com.moonsoft.design.Moon2");
 moon.println();

如要在JSP頁面上有一個鏈接，Url值是通過參數輸入的,用JSP標簽的實現步驟(當然實際中不會用標簽來完成這么簡單的功能):

<一>.先從javax.servlet.jsp.tagext.BodyTagSupport派生一個新的類，并重載它的doStartTag()方法.如果是想要傳入參數的話，則還要在Bean中加入想要的變量，如這里要傳入一個url值，所以添加一個參數:linkUrl. 最后代碼如下:

package com.moonsoft.jsptag;
import javax.servlet.jsp.tagext.BodyTagSupport;
import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.JspException;
public class UrlLinkTag extends BodyTagSupport  {
  private String linkUrl;
  public UrlLinkTag() {
  }
  public String getLinkUrl() {
    return linkUrl;
  }
  public void setLinkUrl(String linkUrl) {
    this.linkUrl = linkUrl;
  }
  public int doStartTag() throws JspException{
    try {
      this.pageContext
          .getOut().print("<a href=\'"+linkUrl+"\' >"+linkUrl+"</a>");
    }
    catch (Exception ex) {
      ex.printStackTrace();
    }
    return 0;
  }
}

<二>新建一個tld文件,內容如下:
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN"
 " <taglib>
        <tlibversion>1.0</tlibversion>
 <jspversion>1.1</jspversion>
 <shortname>buttons</shortname>
 <uri>http://www.borland.com/jbuilder/internetbeans.tld</uri>
 <info>
 JSP tag extensions for InternetBeans Express
  </info>
    <tag>
 <name>urllink</name>
 <tagclass>com.moonsoft.jsptag.UrlLinkTag</tagclass>
 <bodycontent>jsp</bodycontent>
 <attribute>
  <name>linkUrl</name>
  <required>true</required>
  <rtexprvalue>true</rtexprvalue>
 </attribute>
    </tag>
   </taglib>
  
<三>在web.xml中引入這個taglib,在其中加入:

<taglib>
    <taglib-uri>/moon</taglib-uri>
    <taglib-location>/WEB-INF/classes/com/moonsoft/jsptag/UrlLinkTag.tld</taglib-location>
</taglib>

<四>在jsp中引入這個標簽
<%@ taglib uri="/moon" prefix="mylinkurl" %>
這里uri是和web.xml中配置的taglib-uri對應的，prefix值只是在本jsp頁面作為標示用.

下面就可以在jsp中使用這個標簽了:

<mylinkurl:urllink linkUrl="

這里面的mylinkurl為在本jsp頁面中設置的prefix值，urllink為tld文件中tag name,linkUrl為輸入的參數

這樣就在jsp頁面上加入了一個:
<a >http://www.baidu.com</a>鏈接

 現在正在做的項目中涉及大量的Excel文件導出導入操作,都是使用Java Excel來操作。

Java Excel是一開放源碼項目，通過它Java開發人員可以讀取Excel文件的內容、創建新的Excel文件、更新已經存在的Excel文件。下面我寫了一個簡單的例子，展示基本的讀取，新建，更新(包括常見格式的設置:字體，顏色，背景,合并單元格)，拷貝操作，有這些其實已經基本足夠應付大部分問題了。下面是例的源代碼:

import java.io.*;
import java.util.Date;

import jxl.*;
import jxl.format.Colour;
import jxl.format.UnderlineStyle;
import jxl.read.biff.BiffException;
import jxl.write.*;
import jxl.format.UnderlineStyle;
import jxl.format.CellFormat;;

public class OperateExcel {
 
 /**
  * Read data from a excel file
  */
 public static void  readExcel(String excelFileName){
  Workbook  rwb = null;  
  try{
   InputStream stream = new FileInputStream(excelFileName);
   rwb = Workbook.getWorkbook(stream);
   Sheet  sheet = rwb.getSheet(0);
   Cell   cell  = null;
   int columns = sheet.getColumns();
   int rows    = sheet.getRows();
   for( int i=0 ; i< rows ; i++ )
    for( int j=0 ; j< columns ; j++){
     //attention: The first parameter is column,the second parameter is row.  
     cell = sheet.getCell(j,i);    
     String str00 = cell.getContents();
     if( cell.getType() == CellType.LABEL )
       str00 += " LAEBL";
     else if( cell.getType() == CellType.NUMBER)
       str00 += " number";
     else if( cell.getType() == CellType.DATE)
       str00 += " date"; 
     System.out.println("00==>"+str00);
    } 
   stream.close();
  }
  catch(IOException e){  
   e.printStackTrace();
  }
  catch(BiffException e){
   e.printStackTrace();
  } 
  finally{  
   rwb.close();
  }
 }
 /**
  * create a new excelFile
  * @param excelFileName create name
  */
 public static void createExcelFile(String excelFileName){
  try{
   WritableWorkbook wwb = Workbook.createWorkbook(new File(excelFileName));
   WritableSheet     ws  = wwb.createSheet("sheet1",0);
   //also,The first parameter is  column,the second parameter is row.
   // add normal label data
   Label label00 = new Label(0,0,"Label00");
   ws.addCell(label00);
   //add font formating data   
   WritableFont  wf = new WritableFont(WritableFont.TIMES, 18, WritableFont.BOLD , true);
   WritableCellFormat wff = new WritableCellFormat(wf);
   Label label10 = new Label(1,0,"Label10",wff);
   ws.addCell(label10);
   //add color font formating data
   WritableFont wf_color = new WritableFont(WritableFont.ARIAL,10,WritableFont.NO_BOLD,false,UnderlineStyle.DOUBLE_ACCOUNTING,Colour.RED);
   WritableCellFormat wff_color = new WritableCellFormat(wf_color);
   wff_color.setBackground(Colour.GRAY_25); //set background coloe to gray  
   Label label20 = new Label(2,0,"Label20",wff_color);   
   ws.addCell(label20);
   
   //合并單元格
   WritableFont wf_merge = new WritableFont(WritableFont.ARIAL,10,WritableFont.NO_BOLD,false,UnderlineStyle.DOUBLE_ACCOUNTING,Colour.GREEN);
   WritableCellFormat wff_merge = new WritableCellFormat(wf_merge);
   wff_merge.setBackground(Colour.BLACK);
   Label label30 = new Label(3,0,"Label30",wff_merge);   
   ws.addCell(label30);
   Label label40 = new Label(4,0,"Label40");
   ws.addCell(label40);
   Label label50 = new Label(5,0,"Label50");
   ws.addCell(label50);
     //合并 (0,3) (4,0)
     //attention : 如果合并后面的列不為空,那么就把后面格的內容清空,格式也是按前一個單元格的格式
   ws.mergeCells(3,0,4,0);
   
   //添加Number格式數據
   jxl.write.Number labelN = new jxl.write.Number(0, 1, 3.1415926);
   ws.addCell(labelN);
   
   //添加帶有formatting的Number對象
   jxl.write.NumberFormat nf = new jxl.write.NumberFormat("#.##");
   jxl.write.WritableCellFormat wcfN = new jxl.write.WritableCellFormat(nf);
   jxl.write.Number labelNF = new jxl.write.Number(1, 1, 3.1415926, wcfN);
   ws.addCell(labelNF);
   
   //添加Boolean對象
   jxl.write.Boolean labelBoolean = new jxl.write.Boolean(2,1,false);
   ws.addCell(labelBoolean);
   
   //添加DateTime對象
   DateTime labelDT = new DateTime(3,1,new Date());
   ws.addCell(labelDT);
   
   //添加帶有格式的DataTime數據
   DateFormat dtf = new DateFormat("yyyy-MM-dd hh:mm:ss");
   WritableCellFormat wcfDt = new WritableCellFormat(dtf);   
   wcfDt.setBackground(Colour.YELLOW);
   DateTime labelDT_format =  new DateTime(4,1,new java.util.Date(),wcfDt);
   ws.addCell(labelDT_format);
   ws.mergeCells(4,1,5,1); //比較長,用兩列來顯示     
   
   wwb.write();
   wwb.close();
  }
  catch(IOException e){
   e.printStackTrace();
  }
  catch(WriteException e){
   e.printStackTrace();
  }  
 }
 /**
  * 如何更新Excel文件
  * @param fileName
  */
 public static void updateExcel(String fileName){  
  try{
   jxl.Workbook rw = jxl.Workbook.getWorkbook(new File(fileName));
   WritableWorkbook wwb = Workbook.createWorkbook(new File(fileName),rw);
   //這里其實執行的是一次copy操作,把文件先讀到內存中,修改后再保存覆蓋原來的文件來實現update操作
   WritableSheet ws  = wwb.getSheet(0);
   WritableCell wc = ws.getWritableCell(0,0);
   if( wc.getType() == CellType.LABEL){
    Label l = (Label)wc;
    l.setString(wc.getContents()+"_new");
   }
   wwb.write();
   wwb.close();
  }
  catch(IOException e){
   e.printStackTrace();
  }
  catch(WriteException e){
   e.printStackTrace();
  } 
  catch(BiffException e){
   e.printStackTrace();
  }
 }
 /**
  * 如何copy Excel文件
  * @param fileName
  */
 public static void copyExcel(String sourFileName,String destFileName){  
  try{
   jxl.Workbook rw = jxl.Workbook.getWorkbook(new File(sourFileName));
   WritableWorkbook wwb = Workbook.createWorkbook(new File(destFileName),rw);
   wwb.write();
   wwb.close();
  }
  catch(IOException e){
   e.printStackTrace();
  }
  catch(WriteException e){
   e.printStackTrace();
  } 
  catch(BiffException e){
   e.printStackTrace();
  }
 }
 
 public static void main(String [] argv){
  //OperateExcel.readExcel("E:\\test.xls");
  //OperateExcel.createExcelFile("E:\\test1.xls");
  //OperateExcel.updateExcel("E:\\test.xls");
  OperateExcel.copyExcel("E:\\test.xls","E:\\moon.xls");
 }

}

在編程中可能回碰到一些到實際運行時才指定要調用的方法的需要，最典型的是Struct的DispatchAction類，
它能根據用戶頁面請求參數的不同來調用不同的方法來處理用戶請求。我下面寫了一個簡單的例子來簡單演示其
實現方法:

package learn;
import java.lang.NoSuchMethodException;
import java.lang.reflect.Method;
import java.util.Date;
public class TestMethod{
    protected Class clazz = this.getClass();
    protected Class[] no_parameter = {};  //方法無參數
    protected Class[] string_parameter = {String.class}; //以String 為參數
    protected Class[] int_parameter = {int.class};  //以int為參數
    protected Class[] multi_parameter = {String.class,Date.class}; //多個參數,第一個為String,第二二個為Date   
   
    public void method1(){
      System.out.println("method1");
    }
   
    public void method2(String str){
      System.out.println("method2=>"+str);
    }
   
    public void method3(int i){
      System.out.println("method2=>"+i);
    }
   
    public void method4(String str,Date date){
      System.out.println("method4=>"+str+"==="+date.toLocaleString());
    }
   
    public void execute(String methodName,int type,java.util.List list) throws Exception{
      try {
        Method  m = getMethod(methodName,type);
        int size = (list != null )? list.size():0;
        Object o [] = new Object[size];
        for( int i =0 ; i< size ; i++ )
          o[i] = list.get(i);  //準備參數
        m.invoke(this,o);
      }
      catch (Exception ex) {
        ex.printStackTrace();
        throw new Exception(ex.getMessage());
      }
    }
   
    private Method getMethod(String name,int type)throws NoSuchMethodException{
        Method m = null;
        switch(type){
          case 1:
            m = clazz.getMethod(name,no_parameter);
            break;
          case 2:
            m = clazz.getMethod(name,string_parameter);
            break;
          case 3:
            m = clazz.getMethod(name,int_parameter);
            break;
          case 4:
            m = clazz.getMethod(name,multi_parameter);
            break;
          default:
            m = clazz.getMethod(name,no_parameter);
        }
        return m;
    }
   
    public static void main(String [] argv){
      TestMethod testMethod = new TestMethod();
      try{
        java.util.List list = new java.util.ArrayList();
        testMethod.execute("method1", 1, list);
        list.add("http://m.tkk7.com/minmoon");
        testMethod.execute("method2", 2, list);
        list.clear();
        list.add("mailTo:xiaoliang@aspire-tech.com");
        list.add(new Date());
        testMethod.execute("method4",4,list);
      }
      catch(Exception e){
        e.printStackTrace();
      }
    }
}

其中幾個關鍵的地方說明一下:
  clazz.getMethod(name,multi_parameter);  其中multi_parameter是要根據實際方法的參數來定義的。
  m.invoke(this,o);   o是要傳入方法的參數列表。

原型模式定義:
用原型實例指定創建對象的種類,并且通過拷貝這些原型創建新的對象.

Prototype模式允許一個對象再創建另外一個可定制的對象，根本無需知道任何如何創建的細節,工作原理是:通過將一個原型對象傳給那個要發動創建的對象，這個要發動創建的對象通過請求原型對象拷貝它們自己來實施創建。

如何使用?
因為Java中的提供clone()方法來實現對象的克隆,所以Prototype模式實現一下子變得很簡單.

以勺子為例：

public abstract class AbstractSpoon implements Cloneable { 　　String spoonName; 　　public void setSpoonName(String spoonName) {this.spoonName = spoonName;} 　　public String getSpoonName() {return this.spoonName;} 　　public Object clone() 　　{ 　　　　Object object = null; 　　　　try { 　　　　　　object = super.clone(); 　　　　} catch (CloneNotSupportedException exception) { 　　　　　　System.err.println("AbstractSpoon is not Cloneable"); 　　　　} 　　　　return object; 　　} }

有個具體實現(ConcretePrototype):

public class SoupSpoon extends AbstractSpoon { 　　public SoupSpoon() 　　{ 　　　　setSpoonName("Soup Spoon"); 　　} }

調用Prototype模式很簡單:

AbstractSpoon spoon = new SoupSpoon();
AbstractSpoon spoon2 = spoon.clone();

當然也可以結合工廠模式來創建AbstractSpoon實例。

在Java中Prototype模式變成clone()方法的使用，由于Java的純潔的面向對象特性，使得在Java中使用設計模式變得很自然，兩者已經幾乎是渾然一體了。這反映在很多模式上，如Interator遍歷模式。



原文出處:http://www.jdon.com/designpatterns/prototype.htm

看看寫的很好,就拿來引用一下,不用自己寫的那么累^_^.

Factory method,工廠方法模式，定義一個用于創建對象的接口，讓字類決定實例化哪一個類。也就是使一個類的實例化延遲到其子類，提供一種方法使對象創建變得多態。
下面是我寫的一個例子，如有兩種工人，car worker和bus worker,所生成的產品分別是car 和 bus,我按照Factory method 的實現如下:

--先定義car 和 bus 的父類，都是一種產品
package Factory;
public class Product {
 
 public  void whoami(){
  System.out.println("I am a product!");
 }
}

--Car 類
package Factory;
public class Car extends Product { 
 public Car() {
 } 
 public void whoami(){
  System.out.println("I am a car!");
 } 
}
--Bus 類
package Factory;
public class Bus extends Product { 
 public Bus() {
 } 
 public void whoami(){
  System.out.println("I am a bus!");
 }
}
--定義CarWorker和BusWorker的父類 worker
package Factory;
public abstract class Worker { 
 private Product theProduct;
 public abstract Product  createProduct(); 
 public void work(){
  theProduct = createProduct();
 }
 public void showMessage(){
  this.theProduct.whoami();
 }
}
--Carworker
package Factory;
public class CarWorker extends Worker { 
 public Product createProduct(){
   return new Car();
 }
}
--BusWorker
package Factory;
public class BusWorker extends Worker { 
 public Product  createProduct(){
  return new Bus();
 }
}
--下面看看具體的調用
package Factory;
public class TestAll {

 public static void main(String [] argv){ 
  Worker  worker = new CarWorker();
  worker.work();
  worker.showMessage();
  
  Worker  worker1 = new BusWorker();
  worker1.work();
  worker1.showMessage(); 
 } 
}
可以看到雖然這樣實現有一些麻煩，如新加一種產品時，就必須從Product類創建一個子類，但是這樣做的
好處也是顯而易見的，會給你系統帶來更大的可擴展性和盡量少的修改量,再添加一種產品一種工人的時候，對以前的代碼是不必做任何修改的。

<個人觀點，僅作參考>

 

  Singleton模式為單態模式或者叫孤子模式,保證一個類只有一個實例，并提供一個訪問它的全局訪問點。
  Singleton模式的使用范圍比較廣泛，對于一些類來說，只有一個實例是很重要的。比如，你要論壇中

的帖子計數器，每次瀏覽一次需要計數，單態類能否保持住這個計數，并且能synchronize的安全自動加

1，如果你要把這個數字永久保存到數據庫，你可以在不修改單態接口的情況下方便的做到。
下面是一個簡單的示例程序:
package Singleton;
public class TestSingleton { 
 private static TestSingleton  testSingleton = null;
 protected int  count = 0; 
 public static synchronized  TestSingleton getInstance(){
   if( testSingleton ==   null)
    testSingleton = new TestSingleton();
   return testSingleton;
 }
 public void addCount(){
  count ++;
 }
 public void showCount(){
  System.out.println("count :"+count);
 }  
}
我們還可以在這個基礎上做一個擴展，如從上面例子中的TestSingleton類擴展出多個子類，在

getInstance方法中控制要使用的是哪個子類，具體實現代碼如下:

-----TestSingleton.java
package Singleton;
public class TestSingleton { 
 private static TestSingleton  testSingleton = null;
 protected int  count = 0; 
 public static synchronized  TestSingleton getInstance(){
   if( testSingleton ==   null)
    testSingleton = new SubTestSingleton ();
   return testSingleton;
 }
 public void addCount(){
  count ++;
 }
 public void showCount(){
  System.out.println("TestSingleton count :"+count);
 }  
}

-----SubTestSingleton.java
public class SubTestSingleton extends TestSingleton{
 public void showCount(){
  System.out.println("SubTestSingleton count :"+count);
 }
}

<以上為個人見解,歡迎大家評論!>

  最近對面向對象的設計的23種經典的設計模式做了一個研究,接下來的Blog中我會按我的理解做個簡單介紹并提供我寫的示例代碼,歡迎大家的評論,共同提高.
  
   

Oracle數據庫查詢一個月的記錄的sql語句:

select LASTUPDTIME from spprereg where
    (to_date('2005-5-1','YYYY-mm-dd')-LASTUPDTIME)<0  and
    (LAST_DAY(to_date('2005-5-1','YYYY-mm-dd'))-LASTUPDTIME)>0

這是我的一個朋友寫的，轉給大家看看。

　從某種意義上來說，打工真是害人不淺，長期的打工固化了人的思維，淡化了人的責任感，扼殺了人的創新思維，沒有成本概念，缺乏長遠規劃。最為關鍵的是，打工打得越久，看問題的視角就越悲觀，自己也就越自卑。
   
　　一群老板聚在一起，大家所交流的話題大多是商業環境，以及如何更好地發展生意等等。向對方展示的也是自己光輝燦爛的一面和發展的一面。
   
　　一群打工者聚集在一起，牢騷往往占了多數，罵老板刻薄，埋怨工作量大且與收入不對稱等等，很少有打工者對自己目前的狀況滿意的，向對方展示的也更多的是自己沒有得到重用沒有得到發揮的一面。當然，有牢騷未必是不重視自己的工作，因為“嫌貨的才是買貨的”。留心一下你就會發現，人在跳槽前反而異常平靜，而成天把跳槽掛嘴邊的人一般是那些一直做下去的人。
   
　　為什么打工者會選擇用語言而不是實干來獲得心理平衡呢？這與打工者抱著一個什么樣的心態在打工密不可分。
   
　　筆者從1994年出道，打了四年工，跳出來自己開公司當老板，因根基不穩，一年后破產，又出來打工，四年后，又跳出來開公司當老板。在每次從打工者到老板，又由老板到打工者的轉換過程中，都難免要經歷一次耗時數月的心態調整和角色轉換，逼著自己進行換位思考，每次的轉換與脫一次皮也差不了多少。
   
　　生意后來做大了，打算讓太太來幫我接管我原來的那家公司，我自己重開一家，可太太打了八年工，接管公司后卻把公司搞得亂七八糟。追查原因，原來太太還是按照打工的那一套在管理公司，我又足足花了兩年時間來幫助太太實現由一個打工者向老板的轉換。由此想到，如今報紙雜志電視上招商廣告到處飛，好像有點資本就可以當老板了，好像老板可以速成？其實這就是許多創業以失敗告終的原因。
   
　　根據自己在老板與打工者角色之間不斷轉換的過程，我總結出以下老板與打工者心態的幾點不同：
   
　　長遠目標與短期行為
   
　　作為一個真正意義上的老板，知道自己最終想要什么，要達到目標需要經過哪些過程，具備長遠眼光，擁有戰略意識。而作為打工者，著眼點也就是當前這兩三年，往往第一考慮的還是安全感，如何保住現有的飯碗，自然不會想得太遠，也不會太高。而且，很少有打工者能進行換位思考，站到老板的角度去看問題和考慮問題。也就造成很多打工者很難與老板溝通。
   
　　解決問題與完成工作
   
　　老板對一件工作的完成定義是指把某件事徹底被解決，今天能搞定的一定不拖到明天。而打工者會習慣性地把工作按照天數來分解，每天只完成部分工作，下班時間一到心里就習慣性地想回家，剩下的工作明天再做，在公司里多待一分鐘都不愿意。
   
　　單個環節與整個系統
   
　　打工者接到一個指派工作任務后，進行處理或是分解后轉交給其他同事，然后在他看來，這事就差不多算完了，反正他負責的這塊已經做完了，至于轉交出去的工作是否被保質保量按時完成，那就不是他要操心的范圍了。長此以往，許多打工者已經習慣只管自己的二畝三分地，嚴重缺少整體系統概念。而老板常?？吹氖钦麄€任務的完成。
   
　　推脫責任與承擔失敗
   
　　在一個企業或是公司里，我們最常見到的就是在出現事故后，老板要追查責任人，大家異常統一、步調一致地互相推卸責任，極少有人會站出來承認自己工作的不足。打工打久了，遇到問題首先想到的是回避，然后就是設法推給別人。這樣一來，打工者也就愈加不可能從失敗和失利中學習、吸取教訓。其實，老板們的成長就是從一個個自己承擔失敗，并從中總結分析了問題原因所在、積累經驗而來的。
   
　　個人意識與聯合力量
   
　　很多的打工者腦海中都存在著個人英雄主義，總希望在一些事情上表露一下，在老板面前表表功，為了不被其他同事搶了功勞，所以有時候就會冒一定的風險（當然是以公司的資源為成本的）一個人單槍匹馬干點什么出來，當然，要是出了婁子，最后還得由公司承擔，很少有打工者們會從降低成本及風險、或是提高效率的角度出發，去主動聯合其他同事，共同完成某項任務。
   
　　大手大腳與成本概念
   
　　作為老板，公司的每一分錢的支出都會算作是成本，省下來的就是利潤，所以，精打細算是許多老板的習慣性思維和行為。而打工者們卻是大方得很，反正公司的資產是老板的，只要自己工作方便順手，浪費點又算什么，以至于許多打工者在自己做老板的時候，還改變不了在打工時養成的大手大腳的習慣。
   
　　辦事一條線和思維多樣化
   
　　條條大路通羅馬，完成工作不止一種方法，但打工者長期打工生涯下來，已經習慣了用單一思維去考慮問題，A事就用A類解決辦法，B事就用B類解決辦法，很少會去用超越性的思維來從多角度多方向來探討問題的解決辦法。
   
　　從某種意義上來說，打工真是害人不淺，長期的打工固化了人的思維，淡化了人的責任感，扼殺了人的創新思維，沒有成本概念，缺乏長遠規劃。最為關鍵的是，打工打得越久，看問題的視角就越悲觀，自己也就越自卑。
   
　　所以提醒各位，即使一時不能當老板，也要抱著老板的心態去打工

“嫁個有錢人”不如自己成為有錢人，你想發財嗎？你知道如何成為有錢人嗎？

1、做你真正感興趣的事——你會花很多時間在上面，因此你一定要感興趣才行，如果不是這樣的話，你不愿意把時間花在上面，就得不到成功。

2、自己當老板。為別人打工，你絕不會變成巨富，老板一心一意地縮減開支，他的目標不是使他的職員變成有錢人。

3、提供一種有實效的服務，或一種實際的產品。你要以寫作、繪畫或作曲變成百萬富翁的機會可以說是無限小，而你要在營造業、房地產、制造業發大財的機會比較大。記住，出版商賺的錢比作家多得多。

4、如果你堅持要用自己的靈感來創業？最好選擇娛樂業，在這方面，發財的速度相當快，流行歌曲和電視最理想。

5、不論你是演員或商人，盡量增加你的觀眾。在小咖啡館唱歌的人，所賺的錢一定比不上替大唱片公司灌唱片的人，地方性的商人，不會比全國性的商人賺的錢多。

6、找出一種需要，然后滿足它。社會越變越復雜，人們所需要的產品和服務越來越多，最先發現這些需求而且滿足他們的人，是改進現有產品和服務的人，也是最先成為富翁的人。

7、不要不敢采用不同的方式——新的方法和新產品，會造成新的財富。但必須確定你的新方法比舊方法更理想，你的新方法必
想致富,請栽搖錢 引爆數碼影像!
中華川菜火鍋大聯 加盟樂可可天天樂

須增進產品外觀、效率、品質、方便或者降低成本。

8、如果你受過專業教育，或者有特殊才能，充分利用它。如果你燒得一手好菜，而卻要去當泥水匠，那就太笨了。

9、在你著手任何事情之前，仔細地對周圍的情形研究一番。政府機關和公共圖書館，可以提供不少資料，先做研究，可以節省你不少時間和金錢。

10、不要一直都想著發大財，不如你想想如何改進你的事業，您應該常常問自己的是：“我如何改良我的事業？”如何使事業進行順利，財富就會跟著而來。

11、可能的話，進行一種家庭事業，這種方法可以減少費用，增進士氣，利潤的分配很簡單，利潤能夠得到充分的利用，整個事業控制也較容易。

12、盡可能減少你的費用，但不能犧牲你的品質，否則的話，你等于是在慢性自殺，賺錢的機會不會大。

13、跟同行的朋友維持友誼——他們可能對你很有幫助。

14、把盡量多的時間花在事業上。一天12小時、一星期6天是最低要求，一天14小時到18小時很平常，一星期工作7天最好了。你必須先犧牲家庭和社會上的娛樂，直到你事業站穩為止。也只有到那時候，你才能把責任分給別人。

15、不要不敢自己下決心。聽聽別人的贊美和批評，但你自己要下決心。

16、不要不敢說實話。拐彎抹角，只會浪費時間，心里想什么就說什么，而且要盡可能地直截了當地、明確地說出來。

17、不要不敢承認自己的錯誤。犯了錯誤并不是一種罪行，犯錯不改才是罪過。

18、不要因為失敗就裹足不前。失敗是難免的，也是有價值的，從失敗中，你會學到正確的方法論。

19、不要在不可行的觀念上打轉。一發現某種方法行不通，立即把它放棄。世界上有無數的方法，把時間浪費在那些不可行的方法上是無可彌補的損失。

20、不要冒你承擔不起的風險。如果你損失10萬元，若損失得起的話，就可以繼續下去，但如果你賠不起5萬元，而一旦失敗的話，你就完蛋了。

21、一再投資，不要讓你的利潤空閑著，你的利潤要繼續投資下去，最好投資別的事業或你控制的事業上，那樣，才能錢滾錢，替你增加好幾倍的財富。

22、請一位高明的律師——他會替你節約更多的金錢和時間，比起你所給予的將要多的多。

23、請一位精明的會計師。最初的時候，你自己記賬，但除非你本身是個會計師，你還是請一位精明的會計師，可能決定你的成功和失敗——他是值得你花錢的。

24、請專家替你報稅。一位機靈的稅務專家，可又替你免很多的稅。

25、好好維持你的健康和你的平靜心靈——否則的話，擁有再多的錢也沒有什么意思。

多疑，敏感，天真，猶豫不決，膽怯，多慮

-如果有就趕快克服它。

 

1.了解你的精力充沛期。通常人們在早晨9點左右工作效率最高，可以把最困難的工作放到這時來完成。

　　2.集中一天中的頭兩個小時來處理手頭的工作并不接電話、不開會、不受打擾。這樣可以事半功倍。

　　3.立刻回復重要的郵件，將不重要的丟棄。若任它們積累成堆，反而更費時間。

　　4.做個任務清單，將所有的項目和約定記在效率手冊中。手頭一定要帶著效率手冊以幫助自己按計劃行事。

　　5.學會高效地利用零碎時間，用來讀點東西或是構思一個文件，不要發呆或做白日夢。

　　6.把瑣碎的工作寫在單子上，以便有零碎時間時馬上去做。

　　7.并非每件工作都值得精工細做，有些事只要過得去就可以了。一遍又一遍地寫些瑣碎的備忘錄不是高效利用時間的做法。

　　8.減少回電話的時間。如果你需要傳遞的只是一個信息，不妨在工作以外的時間在錄音電話上留言，或是發個電子郵件。

　　9.如果有人在電話中喋喋不休地講話，你可以禮貌地結束電話。

　　10.對可能打來的電話做到心中有數，這樣在你接到所期待的電話后便可迅速找到所需要的各種材料，不必當時亂翻亂找。

　　11.學習上網高效搜尋的技能，以節省上網查詢的時間。把你經常要瀏覽的網站收集起來以便隨時找到。

　　12.用國際互聯網簡化商業旅行的安排。多數飯店和航線可以網上查詢和預訂。

　　13.只要情況允許就可委派別人分擔工作。事必躬親會使自己疲憊不堪，而且永遠也做不完。不妨請同事幫忙，或讓助手更努力地投入。

　　14.做個靈活的日程表，當你需要時便可以忙中偷閑。例如，在中午加班，然后早一小時離開辦公室去健身，或是每天工作10個小時，然后用星期五來赴約會、看醫生。

　　15.在離開辦公室之前開列次日工作的清單，這樣第二天早晨一來便可以全力以赴。

Java中支持方法名相同，但是方法參數不同而自動去選擇執行哪一個方法，如print(int i)和print(String str),雖然方法名相同，但是參數不同。象這里的int和String 參數差異比較大所以看起來這種重載沒什么差別，但是如果是類型差別不大， 會出現什么情況呢？

   看下面的代碼：

    public void f(float i){
        System.out.println("float");
    }

    public viod f(double i){
       System.out.println("double");
   }

    那么執行 f(5)會輸出什么呢？5是被認為是float類型還是double類型還是會報錯呢？執行結果是 float 。原來在這種情況下，該數據類型能被轉為一個較大的數據類型，比5較大的數據類型是float,其次才到double,所以輸出結果是float。還有一個特殊的情況就是如果輸入類型為char,如這里我們執行f('a'),

不要以為這會出錯，其實是不會出錯的，因為如果沒有發現一個準確的char于它匹配，那么它就把這個char轉換成int類型，如果沒有int類型和它匹配，在去尋找較大的數據類型，這里它找到了float,所以這里執行flaot('a')輸出的還是 float。

  下面再討論另外一種情況，譬如說下面這種情況:

   定義了下面一個方法：

  public void f(int i){
    System.out.println("int ");
}

  如果執行f(100.99)會不會在這種數據類型大于這種重載方法期待的變量時會怎么處理呢？會不會把這種較大的數據類型縮小到期待的數據類型？編譯一下，很遺憾出錯了，在這種情況下是出錯的。

這么快就12點半了，睡覺了~~~不然明天早晨爬不起來了。

雖然Java中goto語句只是java的一個保留字，沒有起任何作用，但是我今天在使用continue和break語句時，還是發現了其中又goto語句的影子。因為continue和break語句都支持跳到一個Label的位置。下面是具體的用法：

  inner:
  for( int  i = 0 ; i<3 ;i++ ){
   System.out.println("iiii===>"+i); 
   for( int j =0 ; j<5; j++ ){
    if( j == 1 )
      continue  inner;
    System.out.println("j===>"+j); 
   }
  }

上面一段語句的輸出為

iiii===>0
j===>0
iiii===>1
j===>0
iiii===>2
j===>0

一般的 continue語句都是跳出當前循環，但是這個會跳出到標記inner的位置。

 

Java中檢查兩個對象是否相等，這個看起來很簡單的事情但是實際做起來不一定是一個簡單的事情。我們可能首先想到的是＝＝運算符號，但是這個運算符真的能比較兩個對象么？我們先看下面一段代碼：

   public static void main(String [] argv ){

        Integer    A = new Integer(47);

       Integer     B = new Integer(47);

      System.out.println( A == B ) ;

     System.out.println( A != B );

}

可能你覺得輸出的結果是true false ,但是結果正好相反，是：false,true。不要覺得奇怪，因為＝＝實際比較的是兩個對象的句柄，而不是對象的內容，所以 A==B輸出為false,    而A != B  輸出為false.

可能以為equals方法能幫我們解決這個問題，那么來試一下，

class Value {
  int i;
}

public class EqualsMethod2 {
  public static void main(String[] args) {
    Value v1 = new Value();
    Value v2 = new Value();
    v1.i = v2.i = 100;
    System.out.println(v1.equals(v2));
  }
} ///:~
結果輸出的并不是我們所希望的true,而是false,這是因為類默認的equal方法是直接比較句柄的，而不是我們所希望的比較內容，所以我們不得不發現我們要比較兩個類的內容我們不得不在類中重寫equal()方法來實現比較兩個類的內容。

 

原出處:http://dev.csdn.net/article/20/20614.shtm

(1) 類名首字母應該大寫。字段、方法以及對象（句柄）的首字母應小寫。對于所有標識符，其中包含的所有單詞都應緊靠在一起，而且大寫中間單詞的首字母。例如：
ThisIsAClassName
thisIsMethodOrFieldName
若在定義中出現了常數初始化字符，則大寫static final基本類型標識符中的所有字母。這樣便可標志出它們屬于編譯期的常數。
Java包（Package）屬于一種特殊情況：它們全都是小寫字母，即便中間的單詞亦是如此。對于域名擴展名稱，如com，org，net或者edu等，全部都應小寫（這也是Java 1.1和Java 1.2的區別之一）。

(2) 為了常規用途而創建一個類時，請采取“經典形式”，并包含對下述元素的定義：

equals()
hashCode()
toString()
clone()（implement Cloneable）
implement Serializable

(3) 對于自己創建的每一個類，都考慮置入一個main()，其中包含了用于測試那個類的代碼。為使用一個項目中的類，我們沒必要刪除測試代碼。若進行了任何形式的改動，可方便地返回測試。這些代碼也可作為如何使用類的一個示例使用。

(4) 應將方法設計成簡要的、功能性單元，用它描述和實現一個不連續的類接口部分。理想情況下，方法應簡明扼要。若長度很大，可考慮通過某種方式將其分割成較短的幾個方法。這樣做也便于類內代碼的重復使用（有些時候，方法必須非常大，但它們仍應只做同樣的一件事情）。

(5) 設計一個類時，請設身處地為客戶程序員考慮一下（類的使用方法應該是非常明確的）。然后，再設身處地為管理代碼的人考慮一下（預計有可能進行哪些形式的修改，想想用什么方法可把它們變得更簡單）。
(6) 使類盡可能短小精悍，而且只解決一個特定的問題。下面是對類設計的一些建議：
■一個復雜的開關語句：考慮采用“多形”機制
■數量眾多的方法涉及到類型差別極大的操作：考慮用幾個類來分別實現
■許多成員變量在特征上有很大的差別：考慮使用幾個類

(7) 讓一切東西都盡可能地“私有”——private。可使庫的某一部分“公共化”（一個方法、類或者一個字段等等），就永遠不能把它拿出。若強行拿出，就可能破壞其他人現有的代碼，使他們不得不重新編寫和設計。若只公布自己必須公布的，就可放心大膽地改變其他任何東西。在多線程環境中，隱私是特別重要的一個因素——只有private字段才能在非同步使用的情況下受到保護。

(8) 謹惕“巨大對象綜合癥”。對一些習慣于順序編程思維、且初涉OOP領域的新手，往往喜歡先寫一個順序執行的程序，再把它嵌入一個或兩個巨大的對象里。根據編程原理，對象表達的應該是應用程序的概念，而非應用程序本身。

(9) 若不得已進行一些不太雅觀的編程，至少應該把那些代碼置于一個類的內部。

(10) 任何時候只要發現類與類之間結合得非常緊密，就需要考慮是否采用內部類，從而改善編碼及維護工作（參見第14章14.1.2小節的“用內部類改進代碼”）。

(11) 盡可能細致地加上注釋，并用javadoc注釋文檔語法生成自己的程序文檔。

(12) 避免使用“魔術數字”，這些數字很難與代碼很好地配合。如以后需要修改它，無疑會成為一場噩夢，因為根本不知道“100”到底是指“數組大小”還是“其他全然不同的東西”。所以，我們應創建一個常數，并為其使用具有說服力的描述性名稱，并在整個程序中都采用常數標識符。這樣可使程序更易理解以及更易維護。

(13) 涉及構建器和異常的時候，通常希望重新丟棄在構建器中捕獲的任何異常——如果它造成了那個對象的創建失敗。這樣一來，調用者就不會以為那個對象已正確地創建，從而盲目地繼續。

(14) 當客戶程序員用完對象以后，若你的類要求進行任何清除工作，可考慮將清除代碼置于一個良好定義的方法里，采用類似于cleanup()這樣的名字，明確表明自己的用途。除此以外，可在類內放置一個boolean（布爾）標記，指出對象是否已被清除。在類的finalize()方法里，請確定對象已被清除，并已丟棄了從RuntimeException繼承的一個類（如果還沒有的話），從而指出一個編程錯誤。在采取象這樣的方案之前，請確定finalize()能夠在自己的系統中工作（可能需要調用System.runFinalizersOnExit(true)，從而確保這一行為）。

(15) 在一個特定的作用域內，若一個對象必須清除（非由垃圾收集機制處理），請采用下述方法：初始化對象；若成功，則立即進入一個含有finally從句的try塊，開始清除工作。

(16) 若在初始化過程中需要覆蓋（取消）finalize()，請記住調用super.finalize()（若Object屬于我們的直接超類，則無此必要）。在對finalize()進行覆蓋的過程中，對super.finalize()的調用應屬于最后一個行動，而不應是第一個行動，這樣可確保在需要基礎類組件的時候它們依然有效。

(17) 創建大小固定的對象集合時，請將它們傳輸至一個數組（若準備從一個方法里返回這個集合，更應如此操作）。這樣一來，我們就可享受到數組在編譯期進行類型檢查的好處。此外，為使用它們，數組的接收者也許并不需要將對象“造型”到數組里。

(18) 盡量使用interfaces，不要使用abstract類。若已知某樣東西準備成為一個基礎類，那么第一個選擇應是將其變成一個interface（接口）。只有在不得不使用方法定義或者成員變量的時候，才需要將其變成一個abstract（抽象）類。接口主要描述了客戶希望做什么事情，而一個類則致力于（或允許）具體的實施細節。

(19) 在構建器內部，只進行那些將對象設為正確狀態所需的工作。盡可能地避免調用其他方法，因為那些方法可能被其他人覆蓋或取消，從而在構建過程中產生不可預知的結果（參見第7章的詳細說明）。

(20) 對象不應只是簡單地容納一些數據；它們的行為也應得到良好的定義。

(21) 在現成類的基礎上創建新類時，請首先選擇“新建”或“創作”。只有自己的設計要求必須繼承時，才應考慮這方面的問題。若在本來允許新建的場合使用了繼承，則整個設計會變得沒有必要地復雜。

(22) 用繼承及方法覆蓋來表示行為間的差異，而用字段表示狀態間的區別。一個非常極端的例子是通過對不同類的繼承來表示顏色，這是絕對應該避免的：應直接使用一個“顏色”字段。

(23) 為避免編程時遇到麻煩，請保證在自己類路徑指到的任何地方，每個名字都僅對應一個類。否則，編譯器可能先找到同名的另一個類，并報告出錯消息。若懷疑自己碰到了類路徑問題，請試試在類路徑的每一個起點，搜索一下同名的.class文件。

(24) 在Java 1.1 AWT中使用事件“適配器”時，特別容易碰到一個陷阱。若覆蓋了某個適配器方法，同時拼寫方法沒有特別講究，最后的結果就是新添加一個方法，而不是覆蓋現成方法。然而，由于這樣做是完全合法的，所以不會從編譯器或運行期系統獲得任何出錯提示——只不過代碼的工作就變得不正常了。

(25) 用合理的設計方案消除“偽功能”。也就是說，假若只需要創建類的一個對象，就不要提前限制自己使用應用程序，并加上一條“只生成其中一個”注釋。請考慮將其封裝成一個“獨生子”的形式。若在主程序里有大量散亂的代碼，用于創建自己的對象，請考慮采納一種創造性的方案，將些代碼封裝起來。

(26) 警惕“分析癱瘓”。請記住，無論如何都要提前了解整個項目的狀況，再去考察其中的細節。由于把握了全局，可快速認識自己未知的一些因素，防止在考察細節的時候陷入“死邏輯”中。

(27) 警惕“過早優化”。首先讓它運行起來，再考慮變得更快——但只有在自己必須這樣做、而且經證實在某部分代碼中的確存在一個性能瓶頸的時候，才應進行優化。除非用專門的工具分析瓶頸，否則很有可能是在浪費自己的時間。性能提升的隱含代價是自己的代碼變得難于理解，而且難于維護。

(28) 請記住，閱讀代碼的時間比寫代碼的時間多得多。思路清晰的設計可獲得易于理解的程序，但注釋、細致的解釋以及一些示例往往具有不可估量的價值。無論對你自己，還是對后來的人，它們都是相當重要的。如對此仍有懷疑，那么請試想自己試圖從聯機Java文檔里找出有用信息時碰到的挫折，這樣或許能將你說服。

(29) 如認為自己已進行了良好的分析、設計或者實施，那么請稍微更換一下思維角度。試試邀請一些外來人士——并不一定是專家，但可以是來自本公司其他部門的人。請他們用完全新鮮的眼光考察你的工作，看看是否能找出你一度熟視無睹的問題。采取這種方式，往往能在最適合修改的階段找出一些關鍵性的問題，避免產品發行后再解決問題而造成的金錢及精力方面的損失。

(30) 良好的設計能帶來最大的回報。簡言之，對于一個特定的問題，通常會花較長的時間才能找到一種最恰當的解決方案。但一旦找到了正確的方法，以后的工作就輕松多了，再也不用經歷數小時、數天或者數月的痛苦掙扎。我們的努力工作會帶來最大的回報（甚至無可估量）。而且由于自己傾注了大量心血，最終獲得一個出色的設計方案，成功的快感也是令人心動的。堅持抵制草草完工的誘惑——那樣做往往得不償失。

(31) 可在Web上找到大量的編程參考資源，甚至包括大量新聞組、討論組、郵寄列表等。下面這個地方提供了大量有益的鏈接：

  Java中c中的指針的概念，但是我在使用中還是碰到過一些問題，如我把一個一個對象A賦值給對象B時，這兩個對象有一個改變，那么另外一個也相應的改變。下面分別談談這可能發生問題的幾種情況:

<一>從“一個對象到另一個對象的賦值”，如:

        Class  A = new Class();

       Class  B  = A;

       這種情況實際把句柄從一個地方復制到另外一個地方，這種情況下對象B和A實際指向的是同一個句柄，更新B會影響到A,同樣更新A也會影響到B。

<二>把對象作為方法的參數傳遞到一個方法中。Java方法的參數傳遞可以分成兩種：一種是值傳遞，這種一般是簡單的數據類型，如int,long,double,char這些等；一種類似是c中的引用傳遞，就是把對象作為一個引用傳遞給方法參數，在這種情況下，在方法中把這個傳入的參數對象改變，那么相應的傳入這個參數引用的對象也相應的改變。如:

     Number A = new Number();
     A.num   = 9;
     test(A);

     方法定義:

    public  void   test(Number n){
      n.num = 99;
    }

   那么A的num值會變成99.

<三>;把對象保存在ArrayList中.如果把一個對象保存在一個AyyayList中，如果這個對象再發生改變，那么在這個ArrayList中保存的對象也會改變，說白了還是兩個還是公用同一個句柄.如:

   Number A = new Number();
     A.num = 100;
     java.util.ArrayList list = new ArrayList();
     list.add(A);
     A.num = 999;
     Number B = (Number)list.get(0);
     System.out.println(B.num);

那么輸出為999,對象A的更改影響到了ArrayList中的保存的對象.

 

你看過老鷹嗎？咱們生活在都市的人，大概很少有機會看到老鷹。根據鳥類生態學家的研究，老鷹是一種奇特的飛禽，因為它們都把窩巢筑在樹梢，或是懸崖陡巖上，通用動物很難直接攻擊它。

　　可是，老鷹是怎么搭筑窩巢的呢？生態學家用望遠鏡仔細觀察后發現，母鷹先用尖嘴銜著一些荊棘放置在底層，再叼來一些尖銳的小石子鋪放在荊棘上面。乍看之下，總覺得用銳利的小石子當材料來筑巢，是很突兀、怪異的，這怎么能筑出一個溫暖、舒適的窩巢呢？不過，母鷹后來又銜一些枯草、羽毛或獸皮覆蓋在小石子上，做成一個能孵蛋的窩。

　　小鷹孵化、出生后，住在窩巢里，母鷹按時叼回來小蟲、肉食，喂入雛鷹嗷嗷待哺的小嘴中；母鷹天天供應食物，也細心保護，以防敵人入侵。后來，小鷹慢慢長大、羽毛漸豐，這時，母鷹認為，該是小鷹學習"自我獨立"的時候了！

　　可是，有什么辦法能讓小鷹不再眷戀始終被母鷹呵護、舒適無比的窩巢呢？有的，母鷹開始"攪動窩巢"，讓巢上的枯草、羽毛掉落，而暴露出尖銳的小石子和荊棘；小鷹被刺痛得哇哇叫，可是母鷹又很無情地加以驅逐、揮趕，小鷹只好忍痛振起雙翅，離巢他飛。

　　母鷹殘忍、無情嗎？不，母鷹深愛著它生養的小鷹！

　　但是，母鷹更渴望它疼愛的小鷹能成為四處翱翔的飛鷹，因此，必須無情地逼著小鷹飛離舒適的窩，勇敢地學習獨立；即使小鷹在剛開始跌跌撞撞，母鷹仍偷偷地在旁照顧看護它，直到小鷹能展翅高飛、直上青天！

　　我在美國念博士班時，常搭飛機來回美臺兩地。有一次，我匆忙地趕上臺北飛往舊金山的班機，查找座位后，發現身旁已經坐著一位30來歲的小姐。她身穿長褲，對著我微微一笑。漫長的飛行，我和她開始閑聊。她說，小時候家窮，父母又離異，所以國小畢業后就沒再讀書，只好跟人家學做裁縫；20多年過去了，現在經濟能力好轉，雖然想多念點書，可是沒學歷，不能念大學，于是只好趁暑假時間到美國念暑期美語學校，藉此拓展視野。

　　這小姐臉龐清秀，不疾不徐地對我說："我們客家人有一句諺語━━窮人莫斷豬，富人莫斷書；我啊，現在不是窮人了，但也不是什么富人，只是覺得自己必須多讀點書，畢竟人生不像錄影帶、錄音帶，可以倒帶重來，所以我希望盡可能地多充實自己！"

　　聊著聊著，飛機已經飛行了3小時左右，這時，她禮貌地對著坐在走道旁的我說："對不起，可不可以借我過一下，我想上洗手間？""噢，好！"我說，隨即起身讓她走過。

　　只見這小姐用手扭轉一下長褲里的硬硬東西，然后慢慢地站起來……她一跛一跛地、緩緩地從我眼前走過，再跛著腳，走向前端的盥洗室。天哪，身軀嬌小的她，竟是一位小兒麻痹患者，她寬松的長褲里，裝著的是支撐她站起來走路的鐵鞋！

　　當她走回座位時，我對她說："你可以請空姐幫你安排前面好一點的座位呀！""不用啦！我已經習慣了，這小問題難不倒我！"她笑笑地對我說："到美國念書3個月，要自己解決的問題還很多呢！"

　　我常在想，有時，小鷹不一定都有母鷹喂食、呵護，也不一定會有同樣殘酷無情的母鷹逼它離巢他飛，但是孤苦無依的小鷹必須懂得━━要含淚堅強地站起來，自己飛、不斷地飛，飛往屬于自己的一片晴空與藍天。

　　其實，人生就如同"一大碗蔬菜湯"，如果沒經過攪動，鮮美好料就會"一直沉在碗底"。就像小鷹一樣，母鷹無情地攪動窩巢，才逼得它必須獨立展翅飛翔；可是，它不能搶劫超商、不能跳樓自殺，還是必須靠自己"獨立更生"，才有食物吃??！人，似乎很少聽說因為太勤勞、流汗太多，而被汗水淹沒的！

　　我們必須辛勤地"攪動自己"，讓鮮美的"蔬菜好料"浮現━━讓內在的才華、能力美麗呈現。

　　所以，告訴自己━━"我，一定要做最棒的我！"

       今天看了一篇文章，覺得很有啟發。一個好的程序員不只是要寫出好的代碼，而且要學會寫寫文檔和與別人交流，如果不能寫文檔和與別人交流，那么再好的代碼別人也無法看懂。

        還有可能是自己的一個弊病－－自己感興趣的東西自己就喜歡做，但是自己不喜歡的東西就不喜歡做，但是工作中不可能都是自己喜歡的東西，喜歡的東西也要做好，那么才能是一個合格的程序員。

* 1.定義方式的不同:
 *   <1>abstract類定義:
 *      public abstract class test{
 *          abstract void method1();
 *          abstarct void method2();
 *      }
 *   <2>interface類定義:
 *     public interface test{
 *         void method1();
 *         void method2();
 *     }
 * 2.abstract class類是表示一種繼承關系，一個類只能繼承一個abstract類,而一個類可以通過implements實現
 *   多個接口.
 *
 * 3.abstract類我們可以定義默認的方法，如可以在里面定義一個方法:
 *   public abstract class test{
 *          abstract void method1();
 *          abstarct void method2();
 *          public void print(){
 *            System.out.println("print");
 *          }
 *      }
 *   但是interface里面的方法都不能有body.
 *
 * 4.在Interface類中,所有的數據成員都是靜態的不能被修改的。
 *   而abstract類可以有自己的數據成員

昨天開始學習structs，計劃用2周來大致上把握Structs,大致覺得structs的優勢在于提高web開發的速度，尤其是在大型的項目中，但是前期的設計可能要花很多的時間來計劃每個頁面對應到哪個ActionForm和Action,計劃好每個頁面跳轉的頁面。覺得其中主要的思想就是MVC,這種方式的好處就是：

一。多個視圖可以公用一個模型，如同一個web程序可能有多種用戶界面，瀏覽器或wap。把邏輯層和表示層分開。提高代碼的重用性。

二?？刂破骱鸵晥D保持獨立，要更改控制，只要去更改控制器部分就可以了，與視圖無關。



對例子看了一下實現的，覺得大致流程是這樣的：

從頁面上的標記.do的名稱，從struct-config.xml中取出對應該Form處理的ActionForm,執行取變量或Validate之后，再轉給Action來處理，執行完畢后再跳轉到下一個頁面。



 加油，一定要2周搞定它.

　那件事至今一想起來，我就臉紅，一臉紅就羞愧。

　　三年前，初入職場。那時的我，新鮮的不行，見到老板的車就閃躲不及，見到老板本人簡直像老鼠見了貓。那天中午，剛吃完單位統一訂送的盒飯，一抬頭就撞到老板。老板笑容可掬地問："sunny，你幫我問問快餐店還有沒有盒飯送？或者，你聯系一下周主任，，拜托他回來時給我帶一份。"

　　"哦……哦。"對老板的交代我受寵若驚，此前，老板可從未直接給我交代過什么任務。我很興奮。

　　趕緊抬頭看鐘，已經是午后一點，時間不早了。迅速給快餐店打電話，真是不巧，他們準備的盒飯早已賣完。我急得滿頭冒汗，哦，對了再聯系周主任。更不巧，周主任外出就餐，他的手機放在辦公桌上。天啊！

　　我爆汗，折騰半天，臉紅紅的，走進老板辦公室說："很抱歉，我沒能聯系上周主任，快餐店也……"我支吾著，心里的那份難受，真的是無以復加。看看時間已接近兩點，可老板還沒有吃上飯，而我，又沒幫上什么忙。我十分羞愧。

　　事后，我不時地想起那次的尷尬。其實我只要變換一下方式---如果我向其他同事多要幾家快餐店的電話，如果我索性放下電話親自跑到快餐店去，來回也不過半小時。只要我多動一點腦筋，靈活一點，主動一點，想方設法解決問題，而不是把問題原封不動地踢給老板，都不至于使老板在兩點之后才去就餐，我的心情也不會變得灰溜溜的了。

　　為什么我不主動一點??？！這次事件之后，我得到了一個很深刻的教訓。

　　不久以后，我再次遇到了相似的情形。老板打電話要接李助理，是我接的電話。我看看李助理的辦公室，說："她外出尚未回來。"先前的事情在腦袋里一閃，我馬上想到自己又在犯老毛病了，總不至于要老板自己翻電話簿聯系李助理吧。我立即補充一句："我馬上Call她，請她與您聯系。"老板說："我找她是有急事，不過換別人也行。"我響亮地說："我們這里有小張、小池、還有我，您需要哪一位？"

　　老板的聲音聽起來很悅耳："就你吧，你把……準備好給我。"

　　我在客戶服務部工作了三年，接了三年電話。但我發現：漸漸地，我和同事們接電話的方式有了些微妙的差別。我聽到他們習慣說"沒有"，"不清楚"，"不是"，"時間安排不過來"，諸如此類。三年前，我和他們一樣，而一個人在三年里不可能沒有一點變化。

　　有一次，我接到一個電話，這個客戶希望我們能派出最有經驗的王工為他們解決產品故障，而王工恰好被派出去還沒有返回?？蛻羰沁@樣問的："請問王工在嗎？"

　　三年前的我習慣這樣回答："他出去了，什么時候能回來還不一定。"

　　三年后的我這樣回答："他出去了，請問您有什么事嗎？"

　　三年后的我還會這樣回答："我們這里還有幾位有經驗的工程師，他是張工、鄭工、程工。張工的特長是…… 程工的特長是…… "

　　主動地為客戶提供更多信息，盡可能讓對方有更多選擇，這就是我在接電話過程中的一個小小秘訣。當然，客戶會在我的勸說下欣然選擇一位工程師，而我也不會被動地干著急，一味傻等著王工回來。

　　三年后，老板找我談話，問我愿不愿擔任客服部主管。我詫異，我不過是一直在接電話，沒什么特長。

　　老板卻說："不同的人，哪怕接一個小小的電話也會有大大的不同。就沖你接電話的方式，我相信你能領導好一個客服部。我看你的第一把火就從接電話培訓開始吧。"

　　不由分說，我成了主管。當我把我的那次盒飯經歷跟下屬分享時，我發現，職場上不乏接電話、訂盒飯等等雞毛蒜皮的小事，可誰又敢說，這些小事不能煉就一個優秀的職業人？

　　老板給出的只是一個命令或吩咐。怎么琢磨，怎么做，那就是你自己的事情。你如果只需要一個命令與吩咐，就能夠做好事情，解決問題，那便是真正的能力。

　　細節，往往是成就一個人素質的最重要的東西。