工厂模式解析-优快云博客

工厂模式是一种创建型模式。。。其中创建型模式包括：单例，工厂，建造者，原型四种
/* 为什么要工厂方法：
1.因为我想控制产生交通工具的生产过程
2.工厂模式符合OCP原则，也就是开闭原则，
3。抽象工厂还有个最大优点，高内聚，低耦合，内聚都高到new的地方都转移到了一个类中来维护
工厂的共性是：能生产多种产品，所以要具体产品类和抽象产品类，当然有一个具体工厂哈
工厂模式分为三种：
简单工厂模式(有些人又把简单工厂模式看成是工厂方法模式的一种特例)，
工厂方法模式，
抽象工厂模式。
*/
-------------------------没有工厂的时候-------------------------------------------------
//当你控制了他的生产过程之后，像这样的代码就可以解耦了
UserDao userDao = new UserDaoImpl(); //这个代码是依赖于UserDaoImpl的实现的，如果想要换个类，那么这个地方时需要改动的，也就是说用到的地方要改，被用到的地方也要改。。
---------------------------工厂来了-----------------------------------------------
简单工厂模式：优点：工厂类中包含了必要的逻辑判断(switch或者if/else)，根据客户端的选择条件动态实例化相关的类，对客户端来说，去除了与具体产品的依赖。。。问题：因为需求变更后，我们需要修改原有的工厂类(至少要加case条件吧)，这样违背了开放-封闭原则。
还有优点，他们转移了new,使得更换对象不需要大幅度修改。。。
它具有三个角色：抽象产品角色，具体产品角色，工厂类角色（new 的管理者）
一个工厂生产一种类别的产品。。。。。。。。
暴发户只要在车里面说一句："开车"就可以了
//抽象产品角色
public interface Car{
public void drive();
}
具体产品角色
public class Benz implements Car{
public void drive(){
System.out.println("Driving Benz");
}
}
public class BMW implements Car{
public void drive(){
System.out.println("Driving BMW");
}
}
//工厂类角色
public class Driver{
public static Car driverCar(String s){
if(s.equals("Benz"))return new Benz();
if(s.equals("BMW"))return new BMW();
}
}
//例子二
public class SimplePizzaFactory{
public Pizza createPizza(String type){
Pizza p = null; //抽象产品类
if(type.equals("cheese")){
p = new CheesePizza();//具体产品类
}else if(type.equals("pepperoni")){
p = new PepperoniPizza();
}else if(type.equals("veggie")){
p = new VeggiePizza();
}
return p;
}
}
---------------------------忧郁的分割线----------------------------------------------
下面是工厂方法：
工厂方法模式就是为了去除简单工厂中的if/else或者switch/case来做的，他定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
但是但是但是：工厂方法模式实现时，客户端需要决定实例化哪一个工厂，也就是说,工厂方法把简单工厂的内部逻辑判断已到了客户端代码来进行。。。。
我们想想他存在的意义，如果制造一辆汽车的过程只是一个new xxxCar();那么不要使用工厂，如果制造汽车的过程是 xxxxx;xxxxxx;xxxxx;.....; new xxxCar();xxxxx; 那么使用工厂方法模式，他可以使得知道汽车的这一系列的过程被封在起来，因为制造工厂的过程简单。。。
组成：抽象工厂角色(工厂就开始抽象了哈)，具体工厂角色，抽象产品角色，具体产品角色
//抽象工厂角色
public interface Driver{
public Car driverCar();
}
//具体工厂角色
public class BenzDriver implements Driver{
public Car driverCar(){
return new Benz();
}
}
//具体工厂角色
public class BMWDriver implements Driver{
public Car driverCar(){
return new BMW();
}
}
...产品类省略
使用：
Driver driver = new BenzDriver();
Car car = driver.driverCar();
对比简单工厂模式： Car car = Driver.driverCar("benz");
-----------------抽象工厂---------------------------------------------------------
/*
因为我们想让一个工厂生产不同的产品，
比如说我们想产生不同的交通工具，那么就要有不同的交通工具工厂的实现，每一个具体的工厂负责他对应的产品的控制
*/
public abstract class Factory{
public abstract Vihecle create();
//这里使得所有工厂产生的产品有一个共性，他们还只能产生Vihecle的子类，或者让他们产生有Moveable接口的东西也可以
}
public class CarFactory extends Factory{
public Vihecle create(){
}
}
/**
如果一个工厂里面不是产生一个产品，而是产生一系列的产品
*/
public class DefaultFactory{
public void createCar(){}
public void createAK47(){}
public void createApple(){}
}
/*
如果要扩展的话，上面的写法不好。。。
所以创建一个他们的父亲工厂，其实实质和工厂方法是一样的，只不过多了几个工厂而已
嘿嘿。。。换皮肤的软件就是这么搞的
*/
public abstract class Factory{
public abstract void createVehicle();
public abstract void createWeapon();
public abstract void createFood(){};
}
/*
工厂和抽象工厂最大的区别：工厂利于扩展产品，但要扩展产品系列的话则会导致工厂泛滥，
抽象工厂利于产生产品系列，但对于扩展产品来说（比如要加一个Flower,则不但要改Factory而且要改所有Factory的子类）
*/
-----------------配置文件与工厂的配合----------------------------------------------------------
//下面是利用配置文件来指定类的工厂。。。。模拟Spring的Bean工厂
//我们把要new 的东西放入配置文件中，这里配置文件里是这样 aakey=com.zhe.Car
public class Test{
public Car create(){
Properties p = new Properties();
p.load(Test.class.getClassLoader()
.getResourceAsStream("com/zhe/a.properties"));
String classString = p.getProperty("aakey");
Object o = Class.forName(classString ).getInstance();
//注意会调用空的构造函数
Car car = (Car)o;
car.run();
}
}
//下面采用Spring自己的Bean工厂
//这时的配置文件是：applicationContext.xml
//里面 <bean id="aakey" value="com.zhe.Car" />哈哈，这就是所谓的Ioc依赖注入
public class Test{
public Car create(){
BeanFactory f =
new ClassPathXmlApplicationContext("applicationContext.xml");
Object o = f.getBean("aaKey");
Car car = (Car)o;
car.run();
}
}
//-----------------------------------------------------------------
<<设计模式之禅>>-----抽象工厂
为什么要有抽象工厂？所有设计模式都是为了使得代码重用，那么具体的工厂在生产过程中一定会有某些地方是一样的，那么就应该把他们提取出来，所以抽象工厂里面放的东西就是所有工厂的共性而已。。
//这个接口规定了每个具体工厂的能力，规定了每个具体工厂要做什么事情
public interface HumanFactory{
public Human createYellowHuman();
public Human createWhiteHuman();
public Human createBlackHuman();
}
//下面是抽象工厂登场
public abstract class AbstractHumanFactory implements HumanFactory{
protected Human createHuman(HumanEnum human){ //定义了所有工厂制造人类的统一过程，他的目的其实就是为了减少代码量
Human h = null;
if(!human.getValue().equals("")){
try{
h = (Human)Class.forName(human.getValue()).newInstance();
}catch(Exception e){
}
}
return h;
}
}
public class MaleHumanFactory extends AbstractHumanFactory{
public Human createBlackHuman(){
return super.createHuman(HumanEnum.BlackMaleHuman);
}
public Human createWhiteHuman(){
return super.createHuman(HumanEnum.WhiteMaleHuman);
}
public Human createYellowHuman(){
return super.createHuman(HumanEnum.YellowMaleHuman);
}
}
注意：我们把枚举看成是定义的static变量也可以，只不过他的好处是不用判断输入参数是否为空，长度为0等边界条件
public enum HumanEnum{
YellowMaleHuman("com.zhe.yellowHuman.YellowMaleHuman");
YellowFemaleHuman("com.zhe.yellowHuman.YellowFemaleHuman");
WhiteMaleHuman("com.zhe.whiteHuman.WhitewMaleHuman");
WhiteFemaleHuman("com.zhe.whiteHuman.WhiteFemaleHuman");
private String value = "";
private HumanEnum(String value){
this.value = value;
}
public String getValue(){
return this.value;
}
}
转自：http://z466459262.iteye.com/blog/709059