工厂方法模式，抽象工厂模式，简单实例分析

为了更好地理解这两个模式，自己假设了如下场景，可能有些牵强，但应该还好。嘿嘿。

 

Acer，Lenovo两家本本制造商，假设原来有一OEM两个牌子的本本都做，这时，无论你想买那种牌子的，都可以直接向OEM购买。

可是后来该OEM商发现，如果一次同时做很多个牌子的本本，有些不利于管理，而且，如果以后要加入新的品牌的话，要有许多设备上的改动，等等原因，于是，它决定衍生出些子厂，每个子厂只做一种牌子的本本，而OEM核心总部，只负责制定规范，即，每个子厂要完成的所有任务。

 

该OEM的初始状态，就是静态工厂方法的场景，自己负责一切生产任务，根据外界的需求，去制造本本。

后来，为了便于管理，和把引入新品牌后产生的变动降到最低，采取了工厂方法模式。即，核心的工厂不再负责创建等具体动作，把这些派发给自己的子工厂。而核心工厂，仅负责制定规范。

 

1.工厂方法模式

 

首先，定义产品接口，Laptop，当然，也可以是个抽象类。

package factoryMethod;

abstract public class Laptop {

    private String mark;

    public Laptop(String str){

        this.mark = str;

    }

    abstract public String getId();

    public void echoMark(){

        System.out.println("this is a "+mark+" Laptop");

    }

}

有了产品接口，我们就可以去定义那个核心工厂接口

package factoryMethod;

public interface LaptopFactory {

    public Laptop produce();

    public void service();

}

如代码所示，核心工厂规定了它子类要完成的行为，即，制造本本，和售后服务。

下面，是具体产品类，比如Acer品牌的本本

package factoryMethod;

public class AcerLaptop extends Laptop {


    private static final String mark = "Acer";
    protected static int initId;

    public AcerLaptop() {
        super(AcerLaptop.mark);
        AcerLaptop.initId = 10001;
    }

    public String getId() {

        return "Acer--"+(AcerLaptop.initId++);

    }

}

再来个Lenovo的本本

package factoryMethod;

public class LenovoLaptop extends Laptop {

    private static final String mark = "Lenovo";
    protected static int initId;

    public LenovoLaptop() {

        super(LenovoLaptop.mark);
        LenovoLaptop.initId = 20001;
    }

    public String getId() {

        return "Lenovo--"+(LenovoLaptop.initId++);

    }

}

其实Laptop定义的抽象方法没什么具体意义，该例子只为描述工厂方法模式。

 

下面，来定义具体工厂，Acer的，和Lenovo的，里面的方法同样没什么太大意义，只为测试。

 

 

package factoryMethod;

public class AcerFactory implements LaptopFactory {

    @Override
    public Laptop produce() {

        return new AcerLaptop();//生产Acer的本本

    }

    @Override
    public void service() {

        System.out.println("welcom to Acer hotline ");

    }

}

public class LenovoFactory implements LaptopFactory{

    public Laptop produce(){

        return new LenovoLaptop();//生产lenovo的本本

    }

    public void service(){

        System.out.println("welcom to Lenovo hotline ");

    }

}

来一个测试类。

package factoryMethod;

public class Client {

        public static void main(String[] args) {

            LenovoFactory lf = new LenovoFactory();
            AcerFactory af= new AcerFactory();
            Laptop lt1 = lf.produce();
            Laptop lt2 = lf.produce();
            Laptop lt3 = af.produce();
            Laptop lt4 = af.produce();


            lf.service();
            System.out.println(lt1.getId());
            System.out.println(lt2.getId());
            System.out.println("--------------");
            af.service();
            System.out.println(lt3.getId());
            System.out.println(lt4.getId());

        }
}

打印结果如下

welcom to Lenovo hotline
Lenovo--20001
Lenovo--20002
--------------
welcom to Acer hotline
Acer--10001
Acer--10002

过了一段时间，该OEM决定除了做本本，也做手机。而且OEM核心工厂决定改变下现有策略，每个子工厂做同一品牌的两个产品，例如，子工厂A做Acer的手机和本本。

这时，有了同族产品的概念，即某些产品是一个产品族的，这里就是指同一个品牌的。

 

为了完成这一变更，就要是用抽象工厂方法了。这个要比前一个复杂一些，所以先画了一个uml图。

 

 

 

-工厂接口，AbstractFatory，指定了子类要实现的制造本本，制造手机的方法

-具体工厂类，AcerFactory，LenovoFactory，均实现了上述方法，每个具体工厂负责一个产品族。

-MobilePhone抽象类，指定Phone产品的一些属性特征，Laptop同理。

-Phone与Laptop属于不同等级的产品，但是同一品牌的Phone和Laptop是同一产品族的产品，在此例中。

 

这里就不再罗列代码了，uml图可以比较清晰的说明每个角色间的关系。

总结起来，引用百度百科的一句话，抽象工厂模式使用同一个 工厂等级结构负责不同产品等级结构产品对象的创建。

 

----------------------------------------------------------------------------