設計模式筆記(一)之工廠模式、單例模式

一、工廠模式

(1)簡單工廠模式：

1 public interface IProduct {
2 
3     public void saleProduct();
4 
5 }

創建一個產品介面，有一個賣產品的方法。

1 public class ProductA implements IProduct{
2 
3     public void saleProduct(){
4         System.out.println("漢堡");
5     }
6 }

產品A實現產品介面，賣漢堡。

1 public class ProductB implements IProduct {
2 
3     @Override
4     public void saleProduct() {
5         // TODO Auto-generated method stub
6         System.out.println("薯條");
7     }
8 
9 }

產品B實現產品介面，賣薯條。

 1 public class Creator {
 2 
 3     public IProduct createFactory(int i){
 4         switch(i){
 5             case 1:
 6                 return new ProductA();
 7             case 2:
 8                 return new ProductB();
 9             default:
10                 return null;
11         }        
12     }
13     
14 }

創造者是簡單工廠模式的核心：返回值類型是IProduct介面，通過測試類傳來的形參確定返回哪個對象。

1 public class TestProduct {
2 
3     public static void main(String[] args) {
4         Creator c=new Creator();
5         c.createFactory(2).saleProduct();
6     }
7 }

測試類：輸出薯條。

(2)方法工廠模式：

(圖片來自於網路)

1 public interface Light {
2 
3     public void TurnOn();
4     public void TurnOff();
5 }

創建一個產品介面。

 1 public class TubeLight implements Light {
 2 
 3     @Override
 4     public void TurnOn() {
 5         // TODO Auto-generated method stub
 6         System.out.println("rabbit1");
 7     }
 8 
 9     @Override
10     public void TurnOff() {
11         // TODO Auto-generated method stub
12 
13     }
14 
15 }

 1 public class BulbLight implements Light {
 2 
 3     @Override
 4     public void TurnOn() {
 5         // TODO Auto-generated method stub
 6         System.out.println("rabbit2");
 7     }
 8 
 9     @Override
10     public void TurnOff() {
11         // TODO Auto-generated method stub
12 
13     }
14 
15 }

分別有兩個產品類實現這個介面。

1 public interface Creator {
2 
3     public Light factory();
4     
5 }

創建工廠介面，返回值是產品介面。

1 public class TubeCreator implements Creator{
2 
3     @Override
4     public Light factory() {
5         // TODO Auto-generated method stub
6         return new TubeLight();
7     }
8 
9 }

1 public class BulbCreator implements Creator {
2 
3     @Override
4     public Light factory() {
5         // TODO Auto-generated method stub
6         return new BulbLight();
7     }
8 
9 }

工廠類實現工廠介面，返回與該工廠對應產品的對象。

 1 public class Client {
 2     public static void main(String[] args) {
 3         
 4         Creator create=new BulbCreator();
 5         Light bulblight=create.factory();
 6         bulblight.TurnOn();
 7         
 8         Creator create1=new TubeCreator();
 9         Light tubelight=create1.factory();
10         tubelight.TurnOn();
11     }
12     
13     
14 }

顧客來賣東西了：通過工廠類來生產產品。

(3)抽象工廠模式：

1 public abstract class AbstractProductA {
2 
3     public abstract void show();
4 }

1 public abstract class AbstractProductB {
2     public abstract void show();
3 }

創建兩個抽象產品A,B.

 1 public class ProductA extends AbstractProductA{
 2 
 3     @Override
 4     public void show() {
 5         // TODO Auto-generated method stub
 6         System.out.println("A");
 7     }
 8 
 9     
10 }

1 public class ProductB extends AbstractProductB{
2 
3     @Override
4     public void show() {
5         // TODO Auto-generated method stub
6         System.out.println("B");
7     }
8 
9 }

兩個具體的產品分別繼承了它們。

1 public interface AbstractFactory {
2 
3     public AbstractProductA createProductA();
4     
5     public AbstractProductB createProductB();
6 }

抽象工廠里有兩個方法，返回值分別是抽象產品A,抽象產品B.

 1 public class ConcreteFactory implements AbstractFactory{
 2 
 3     @Override
 4     public ProductA createProductA() {
 5         // TODO Auto-generated method stub
 6         return new ProductA();
 7     }
 8 
 9     @Override
10     public ProductB createProductB() {
11         // TODO Auto-generated method stub
12         return new ProductB();
13     }
14 
15 }

具體的工廠實現了抽象工廠介面。註意：這裡的返回值類型不是AbstractProductA 和AbstractProductB。而是它們的兒子ProductA 和 ProductB。 

 1 public class Test {
 2 
 3     public static void main(String[] args) {
 4         ConcreteFactory f1=new ConcreteFactory();
 5         ProductA a=f1.createProductA();
 6         a.show();
 7         
 8         ConcreteFactory f2=new ConcreteFactory();
 9         ProductB b=f2.createProductB();
10         b.show();
11     }
12 }

測試類：工廠生產產品。

二、單例模式的四種寫法：

(1)

 1 public class Single1 {
 2 //不支持多線程
 3     private Single1(){
 4         
 5     }
 6     private static Single1 me;
 7     public static Single1 getInStance(){
 8         if(me==null){
 9             me=new Single1();
10         }
11         return me;
12     }
13     
14 }

(2)

 1 public class Single2 {
 2 //支持多線程，效率低。
 3     private Single2(){
 4         
 5     }
 6     private static Single2 me; 
 7     public static synchronized Single2 getInStance(){
 8         if(me==null){
 9             me=new Single2();
10         }    
11         return me;
12     }
13     
14 }

(3)

 1 public class Single3 {
 2 
 3     private Single3(){
 4         
 5     }
 6     private static class SingletonHolder{
 7         private static final Single3 me=new Single3();
 8     } 
 9     
10     public static final Single3 getInStance(){
11         
12         return SingletonHolder.me;
13     }    
14 }

(4)

 1 public class Single4 {
 2 
 3     private Single4(){
 4         
 5     }
 6     private volatile static Single4 me;
 7     
 8     public static Single4 getInStance(){
 9         if(me==null){
10             synchronized(Single4.class){
11                 if(me==null){
12                     me=new Single4();
13                 }
14             }
15         }
16         return me;
17     }
18     
19 }

 本貼純屬個人的學習和理解，如有錯誤望各位大神指正。