Java設計模式

   Java設計模式：

（一）、工廠模式      

問題：工廠模式
分析：（一）、工廠模式是咱們在java設計模式中是隨處可見的模式，例如著名的Jive論壇就使用了大量的工廠模式
爲何工廠模式會如此受到？由於工廠模式至關於建立實例對象的NEW，咱們經常根據類Class生成實例對象，
例如：A a=new A();所以，之後若建立多個實例對象，能夠考慮使用工廠模式。
(二)、在簡單建立實例化對象（A a=new A()）的狀況下，咱們考慮實例化參數之類，方便修改，就能夠再也不實例化對象
再去作修改。
（三）、在建立實例化對象時，是根據需求而建立，例如，一個媽媽她今年生了一個兒子，能夠實例化一個對象，若明年她接着又
生兩個兒子，不可能又實例化，就能夠把媽媽這個類抽象成一個接口對象類，無論她生多少個兒子，均可以實現這個接口對象類便可。
如：Simpole son=new SonSimple(),Simpole son2=new Son2Simpole();
以上的例子都是傳統的程序，如果考慮到如今的工廠設計模式，就不會那麼繁瑣及死板。
結果：代碼示例

public class Factory{

　　public static Sample creator(int which){

　　//getClass 產生Sample 通常可以使用動態類裝載裝入類。
　　if (which==1)
　　　　return new SampleA();
　　else if (which==2)
　　　　return new SampleB();

　　}

}

（二）、抽象工廠模式

問題：抽象工廠
分析：在剛剛操做完工廠模式實例以後，咱們有時須要改變需求，就是不知只有一個媽媽這個抽象接口，還新增了一個媽媽抽象接口，則其須要用
到抽象工廠模式來封裝在一個接口類中。再去繼承該接口實現其中的屬性方法。
結果：代碼示例：

public abstract class Factory{

　　public abstract Sample creator();

　　public abstract Sample2 creator(String name);

}

public class SimpleFactory extends Factory{

　　public Sample creator(){
　　　　.........
　　　　return new SampleA
　　}

　　public Sample2 creator(String name){
　　　　.........
　　　　return new Sample2A
　　}

}

public class BombFactory extends Factory{

　　public Sample creator(){
　　　　......
　　　　return new SampleB 
　　}

　　public Sample2 creator(String name){
　　　　......
　　　　return new Sample2B
　　}

}

（三）、單例模式

問題：單例模式
分析：單例模式在程序中的做用是保證在Java應用中，一個類只有一個實例存在，在之後項目的不少操做中，好比
數據庫的鏈接都須要這樣單線程操做。還有，單例模式可以被狀態化，這樣，多個單態類在一塊兒能夠作一個狀態倉庫
同樣向外提供服務。好比，你在一個論壇遊覽器評論了一條信息，每次遊覽該論壇都會計數，單態類能保持這個狀態
計數，而且單線程能自動加1。你能夠在不修改單態接口的狀況下方便作到。

結果：代碼示例：

public class Singleton {

　　private Singleton(){}
　　//在本身內部定義本身一個實例，是否是很奇怪？
　　//注意這是private 只供內部調用

　　private static Singleton instance = new Singleton();

　　//這裏提供了一個供外部訪問本class的靜態方法，能夠直接訪問　　
　　public static Singleton getInstance() {
　　　　return instance; 　　
　　 } 
}

第二種形式：
public class Singleton {
　　private static Singleton instance = null;

　　public static synchronized Singleton getInstance() {

　　if (instance==null)
　　　　instance＝new Singleton();
　　return instance; 　　}

}

（四）、建造者模式

  問題:建造者模式
  分析：建造者模式是一步一步建立的一個複雜對象，該模式相似於抽象工廠模式，是爲了構建複雜的過程和部件
，是解耦過程和部件。由於一個複雜對象有不少複雜部分組成，例如：汽車是由方向盤、輪胎等部件組成完成的。

  結果：代碼示例：

  

public interface Builder {
　　//建立部件A　　好比建立汽車車輪
　　void buildPartA(); 
　　//建立部件B 好比建立汽車方向盤
　　void buildPartB(); 
　　//建立部件C 好比建立汽車發動機
　　void buildPartC(); 

　　//返回最後組裝成品結果 (返回最後裝配好的汽車)
　　//成品的組裝過程不在這裏進行,而是轉移到下面的Director類中進行.
　　//從而實現瞭解耦過程和部件
　　Product getResult();

}
------
public class Director {

　　private Builder builder;

　　public Director( Builder builder ) { 
　　　　this.builder = builder; 
　　} 
　　// 將部件partA partB partC最後組成複雜對象
　　//這裏是將車輪 方向盤和發動機組裝成汽車的過程
　　public void construct() { 
　　　　builder.buildPartA();
　　　　builder.buildPartB();
　　　　builder.buildPartC();

　　}

}
---
public class ConcreteBuilder implements Builder {

　　Part partA, partB, partC; 
　　public void buildPartA() {
　　　　//這裏是具體如何構建partA的代碼

　　}; 
　　public void buildPartB() { 
　　　　//這裏是具體如何構建partB的代碼
　　}; 
　　 public void buildPartC() { 
　　　　//這裏是具體如何構建partB的代碼
　　}; 
　　 public Product getResult() { 
　　　　//返回最後組裝成品結果
　　}; 
}
----

public static void main(String[] args) {

ConcreteBuilder builder = new ConcreteBuilder();
Director director = new Director( builder );

director.construct();
Product product = builder.getResult();

}

（五）、原型模式

問題：原型模式
分析：定義:指定建立對象的種類，而且經過拷貝這些原型建立新對象，原型模式容許一個對象能夠建立寧一個對象，根本無須知道它建立的過程，
而工做原理是經過原型對象傳給那個要建立對象的對象，這個要發動建立對象的對象經過請求原型對象拷貝它們來建立對象。

結果：代碼示例：

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;
　　}
}
---- 具體實現類
public class SoupSpoon extends AbstractSpoon
{ 
　　public SoupSpoon()
　　{
　　　　setSpoonName("Soup Spoon"); 
　　}
}

 今晚，就暫時闡述這些設計模式，明天再繼續。