Java設計模式中有23中模式，下面只對其中五種常用的設計模式進行介紹：

1.單例模式（有的書上說叫單態模式其實都一樣） ：

該模式主要目的是使內存中保持1個對象。

具體看看下面的例子：

package org.sp.singleton;  
 
//方法一  
public class Singleton {  
//將自身的實例對象設置為一個屬性,并加上Static和final修飾符  
private static final Singleton instance = new Singleton();  
//將構造方法設置成私有形式  
private Singleton() {  
}  
//通過一個靜態方法向外界提供這個類的實例  
public static Singleton getInstance() {  
   return instance;  
}}//方法二  
class Singleton2 {  
 
private static Singleton2 instance2 = null;  
 
public static synchronized Singleton2 getInstance() {  
 
   if (instance2 == null)  
    instance2 = new Singleton2();  
   return instance2;  
}  
} 

注：這二個Java設計模式實現了一樣的功能，但個人推薦采用***種方法。

2.工廠模式

該Java設計模式主要功能是統一提供實例對象的引用。

具體看看下面的例子：

view plaincopy to clipboardprint?  
public class Factory{     
public ClassesDao getClassesDao(){     
   ClassesDao cd = new ClassesDaoImpl();     
   return cd;     
}     
}     
  interface ClassesDao{     
public String getClassesName();     
    
}     
  class ClassesDaoImpl implements ClassesDao {     
public String getClassesName(){     
   System.out.println("A班");     
}     
}     
  class test     
{     
public static void main(String[] args){     
   Factory f = new Factory();     
   f.getClassesDao().getClassesName();     
}     
}  public class Factory{  
public ClassesDao getClassesDao(){  
   ClassesDao cd = new ClassesDaoImpl();  
   return cd;  
}  
}interface ClassesDao{  
public String getClassesName();  
 
}class ClassesDaoImpl implements ClassesDao {  
public String getClassesName(){  
   System.out.println("A班");  
}  
}class test  
{  
public static void main(String[] args){  
   Factory f = new Factory();  
   f.getClassesDao().getClassesName();  
}  
} 

這個是最簡單的例子了，就是通過工廠方法通過接口獲取對象的引用

3.建造模式

該模式其實就是說，一個對象的組成可能有很多其他的對象一起組成的，比如說，一個對象的實現非常復雜，有很多的屬性，而這些屬性又是其他對象的引用，可能這些對象的引用又包括很多的對象引用。封裝這些復雜性，就可以使用建造模式。

4.門面模式

這個模式個人感覺像是Service層的一個翻版。比如Dao我們定義了很多持久化方法，我們通過Service層將Dao的原子方法組成業務邏輯，再通過方法向上層提供服務。門面模式道理其實是一樣的。

具體看看這個例子：

view plaincopy to clipboardprint?  
interface ClassesDao{     
public String getClassesName();     
    
}     
  class ClassesDaoImpl implements ClassesDao {     
public String getClassesName(){     
   return "A班";     
}     
}     
  interface ClassesDao2{     
public String getClassesName();     
    
}     
  class ClassesDaoImpl2 implements ClassesDao {     
public String getClasses2Name(){     
   return "B班";     
}     
}     
  class ServiceManager     
{     
private ClassesDao cd = new ClassesDaoImpl();     
private ClassesDao2 cd2 = new ClassesDaoImpl2();     
public void printOut(){     
   System.out.println(cd.getClassesName()+"   "+cd2.getClassesName());     
}     
};  interface ClassesDao{  
public String getClassesName();  
 
}class ClassesDaoImpl implements ClassesDao {  
public String getClassesName(){  
   return "A班";  
}  
}interface ClassesDao2{  
public String getClassesName();  
 
}class ClassesDaoImpl2 implements ClassesDao {  
public String getClasses2Name(){  
   return "B班";  
}  
}class ServiceManager  
{  
private ClassesDao cd = new ClassesDaoImpl();  
private ClassesDao2 cd2 = new ClassesDaoImpl2();  
public void printOut(){  
   System.out.println(cd.getClassesName()+"   "+cd2.getClassesName());  
}  
}; 

雖然這個例子不全，但基本意思已經很明顯了。

5.策略模式

這個模式是將行為的抽象，即當有幾個類有相似的方法，將其中通用的部分都提取出來，從而使擴展更容易。

具體看這個例子：

view plaincopy to clipboardprint?  
package org.sp.strategy;       
/**    
* 加法具體策略類    
* @author 無盡de華爾茲    
*    
*/    
public class Addition extends Operation {       
@Override    
public float parameter(float a, float b) {     
   return a+b;     
}      
}       
package org.sp.strategy;       
/**    
* 除法具體策略類    
* @author 無盡de華爾茲    
*    
*/    
public class Division extends Operation {       
@Override    
public float parameter(float a, float b) {     
   return a/b;     
}      
}      
package org.sp.strategy;      
/**    
* 乘法具體策略類    
* @author 無盡de華爾茲    
*    
*/    
public class Multiplication extends Operation{      
@Override    
public float parameter(float a, float b) {     
   return a*b;     
}       
}       
package org.sp.strategy;     
    
/**    
* 減法具體策略類    
* @author 無盡de華爾茲    
*    
*/    
public class Subtration extends Operation {     
    
@Override    
public float parameter(float a, float b) {     
   return a-b;     
}       
}        
package org.sp.strategy;       
/**    
* 抽象策略類也可以使用接口來代替    
* @author 無盡de華爾茲    
*    
*/    
public abstract class Operation {     
    
public abstract float parameter(float a, float b);     
}      
package org.sp.strategy;     
    
/**    
* 策略環境類     
* @author 無盡de華爾茲    
*    
*/    
public class Condition {      
public static final Addition add = new Addition();       
public static final Subtration sub = new Subtration();       
public static final Multiplication mul = new Multiplication();     
public static final Division div = new Division();     
    
}     
package org.sp.strategy;     
    
/**    
* 測試客戶端    
* @author 無盡de華爾茲    
*    
*/    
public class Client {     
    
public static void main(String[] args) {     
   float a = 100;     
   float b = 25;     
       
   System.out.println(Condition.div.parameter(a, b));     
}       
}   

以上便是對Java設計模式中五種常用的設計模式進行介紹。

【編輯推薦】

1. 對Java編程思想的忠告
2. 和我共同了解Java是什么
3. 著名的Java論壇和網站
4. 2009年十大Java技術解決方案
5. 2008最值得學習的五種JAVA技術