1，简单工厂

工厂模式，简单的说就是一个对象的产生原来是自己通过new关键字自己构造出来的，现在通过一个方法，来管理对象的产生的过程，需要这个对象的时候，想这个方法要，这个方法就是一个工厂.

 
  
  1. 第一个类
  2. package com.soukenan.factory;  
  3.  
  4. //产品类  
  5. public class Product {  
  6.  
  7. }  
 
  
第二个类：工厂类
 
  
  1. package com.soukenan.factory;  
  2.  
  3. //工厂类  
  4. public class Factory {  
  5.     //工厂方法  
  6.     public static Product createProduct(){  
  7.         return new Product();  
  8.     }  
  9. }  
 
  
简单工厂模式的应用
 
  
  1. package com.soukenan.factory;  
  2.  
  3. public class Main {  
  4.     public static void main(String[] args) {  
  5.         //原来需要用到类Product的时候，通过new关键字直接构造一个Product的对象  
  6.         Product p = new Product();  
  7.           
  8.         //这个是应用的工厂模式，将Product的对象的产生交给了一个工厂（方法）来管理  
  9.         //增加的程序的可扩展性  
  10.         Product p2 = Factory.createProduct();  
  11.           
  12.     }  
  13. }  
 
  
在这里涉及到一个单例和多例的概念,单例就是说当你从工厂中取对象的时候，取到的都是同一个对象，多例的意思就是说当你从工厂中取对象的时候取的都是新的对象。
 
  
数据库连接池就是用到了多例的工厂模式
 
  
 
  
  1. package com.soukenan.factory;  
  2.  
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5. import java.util.Random;  
  6.  
  7. //工厂类  
  8. public class Factory {  
  9.     private static  Product p = new Product();  
  10.     private static List<Product> products = new ArrayList<Product>();  
  11.     //应用单例的工厂方法  
  12.     public static Product createProduct(){  
  13.         return p;  
  14.     }  
  15.     //应用多例的工厂方法  
  16.     public static Product getProduct(){  
  17.         //这里从products集合里取出一个Product对象来 这里模拟随机取出一个  
  18.         Random r =new Random();  
  19.         int i = r.nextInt();  
  20.         return products.get(i);  
  21.     }  
  22. }  
 
  
2,应用了多态的工厂模式
 
  
增加的功能：工厂可以生产产品
 
  
产品接口
 
  
 
  
  1. package com.soukenan.polymorphicfactory;  
  2.  
  3. public interface Product {  
  4.     //一些列的方法  
  5. }  
 
  
产品A
 
  
 
  
  1. package com.soukenan.polymorphicfactory;  
  2.  
  3. public class ProductA implements Product {  
  4.  
  5. }  
 
  
产品B
 
  
 
  
  1. package com.soukenan.polymorphicfactory;  
  2.  
  3. public class ProductB implements Product {  
  4.  
  5. }  
 
  
工厂接口
 
  
 
  
  1. package com.soukenan.polymorphicfactory;  
  2.  
  3. public interface Factory {  
  4.     Product createProduct();  
  5. }  
 
  
生产产品A的工厂
 
  
 
  
  1. package com.soukenan.polymorphicfactory;  
  2.  
  3. public class FactoryA implements Factory {  
  4.  
  5.     @Override 
  6.     public Product createProduct() {  
  7.         return new ProductA();  
  8.     }  
  9.  
  10. }  
 
  
生产产品B的工厂
 
  
 
  
  1. package com.soukenan.polymorphicfactory;  
  2.  
  3. public class FactoryB implements Factory {  
  4.  
  5.     @Override 
  6.     public Product createProduct() {  
  7.         return new ProductB();  
  8.     }  
  9.  
  10. }  
 
  
工厂的应用
 
  
 
  
  1. package com.soukenan.polymorphicfactory;  
  2.  
  3. public class Main {  
  4.     public static void main(String[] args) {  
  5.         //这里应用了多态的工厂，需要生产其他的产品，只需要换掉实现类即可  
  6.         // Factory factory = new FactoryB();  
  7.         Factory factory = new FactoryA();  
  8.           
  9.         factory.createProduct();  
  10.     }  
  11. }