设计模式_工厂模式

Define an interface for creating on object, but let subclasses decide which class to instantiate Factory Method lets a class defer instantiation to subclasses.

定义一个用于创建对象的接口，让子类决定实例化哪一类。

抽象产品类Product : 产品的抽象，归纳 

抽象创建类Creator : 基于抽象层面，关心的只是抽象层，而不关心子类。类似于接口编程

public abstract class Product {
//产品类的公共方法
public void method1(){
//业务逻辑处理
}
//抽象方法
public abstract void method2();
}

public abstract class Creator {
/*
* 创建一个产品对象，其输入参数类型可以自行设置
* 通常为String、Enum、Class等，当然也可以为空
*/
public abstract <T extends Product> T createProduct(Class<T> c);
}

public class ConcreteCreator extends Creator {
public <T extends Product> T createProduct(Class<T> c){
Product product=null;
try {
product = (Product)Class.forName(c.getName()).newInstance();
} catch (Exception e) {
//异常处理
}
return (T)product;
}
}

例子:  造人 ，人类大致分为白种人，黑种人，黄种人 ，这三种人统称为人类Human，抽象归纳为接口Human，人的肤色，语言，文化不同，暂且俩个公共业务方法talk()和getColoe()，在此基础上，产品抽象类已经构思完成，工厂抽象类就在这里，使用反射，多态，泛型技术面向接口编程。  

ad

public interface Human {
 public void getColor();
 public void talk();
}

public class WhiteMan implements Human {
 public void getColor() {
  System.out.println("白种人");
 }
 public void talk() {
  System.out.println("English");
 }
}

public abstract class AbstractFactory {
 public abstract <T extends Human> T createHuman(Class<T> c);
}

public class HumanFactory extends AbstractFactory {

 @Override
 public <T extends Human> T createHuman(Class<T> c) {
  Human human=null;
  try {
   human=(Human)Class.forName(c.getName()).newInstance();
  } catch (Exception e) {
   System.out.println("生产人失败");
  }  
  return (T)human;
 }
}

 public static void main(String[] args) {
  AbstractFactory factory=new HumanFactory();
  WhiteMan whiteMan= factory.createHuman(WhiteMan.class);
  whiteMan.getColor();
  whiteMan.talk();
 }

优点:扩展性好，面向接口编程，拥抱变化，代码结构清晰。

核心思想 :  归纳出一类产品，其中的公共业务，那些不同，那些相同，根据这些写出抽象接口，然后扩展就变得非常简单了。   

扩展1: 替代单例模式

扩展2: 仿写JDBC连接池(个人胡思乱想) 

public class SingletonFactory {
 private static  Emperor emperor;   //参照上一篇博客
 
 static{
  try {
   Class cl=Class.forName(Emperor.class.getName()); //获取class对象
   Constructor constructor=cl.getDeclaredConstructor();    //获取构造方法
   constructor.setAccessible(true);      	 //设置构造方法为可访问
   emperor=(Emperor) constructor.newInstance();    //实例化
  } catch (Exception e) {
   e.printStackTrace();
  }
 }
 
 public static Emperor getEmperor(){
  return emperor;
 } 
} 

public class JDBCPool {
 private static final Map<String,Connection> prMap=new HashMap();
 private final static int MaxConections=5;  //最大连接数
 
 public static synchronized Connection createConnection(String connName){
  Connection con=null;
  if(prMap.size()<MaxConections){    
   con=new Connection();
   prMap.put(connName, con);
  } 
  return con;
 }
}

我是菜鸟，我在路上。