设计模式（五）工厂模式（Factory）

转载请标明出处：
http://blog.csdn.net/qq_34707744/article/details/79206653

本文出自:【生平少年】

定义

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

UML图

个人理解：比如一个A类中定义了若干方法，而在另一个B类中需要调用A类其中的一个方法，当然，我们可以直接 new，但是，这样做的结果就是将A类的所有方法都引用了进来，此时，不仅违背了java面对对象的编程思想，还与A类的复杂构造逻辑耦合。但是如果我们此时向A类中传递一个参数或多个参数，只引用我们所需要的的方法，此时需要创建一个接口。这种模式便称之为工厂模式。它能够有效的避免方法的暴露。当然，根据业务逻辑而定。

分类

代码以生产手机和 PAD 为例：

手机车间

//定义一个手机抽象类
abstract class phone {
    // 手机品牌
    public abstract void phoneModel();
}

生产手机的机器

//三星手机（继承phone抽象类）放在生产手机的车间
class samsungPhone extends phone {
    @Override
    public void phoneModel() {System.out.println("三星手机开始生产...");}
}
//华为手机
class huaweiPhone extends phone {
    @Override
    public void phoneModel() {System.out.println("华为手机开始生产...");}
}
//苹果手机
class iphone extends phone {
    @Override
    public void phoneModel() {System.out.println("苹果手机开始生产...");}
}

1、简单工厂：

简单工厂模式其实不是一个设计模式，反而比较像一种编程习惯。主要我们定义一个非常简单的类主要负责帮我们生产不同的产品

class SimpelPhoneFactory {
    //三星手机
    public static final int TYPE_SUM = 1;
    //华为手机
    public static final int TYPE_HUAWEI = 2;
    //苹果手机
    public static final int TYPE_APPLE = 3;
    public static phone createPhones(int type) {
        switch (type) {
            case TYPE_SUM:return new samsungPhone();
            case TYPE_HUAWEI:return new huaweiPhone();
            case TYPE_APPLE:
            default: return new iphone();
        }
    }
}

测试

public static void main(String[] args) {
//简单工厂
 phone iphone = SimpelPhoneFactory.createPhones(SimpelPhoneFactory.TYPE_APPLE);
 iphone.phoneModel();
 }

结果

 苹果手机开始生产...

2、简单工厂（反射实现）：

利用反射Class.forName(clz.getName()).newInstance()实现的简单工厂

class StaticPhoneFactory {
    public static <T extends phone> T createPhoen(Class<T> tClass) {
        T t = null;
        try { t = (T) Class.forName(tClass.getName()).newInstance();
        } catch (Exception e) { e.printStackTrace();}
        return t;
    }
}

测试

public static void main(String[] args) {
//简单工厂
 phone sumsangPhone = phoneFactory.createSamsang();
    sumsangPhone.phoneModel();
 }

结果

华为手机开始生产...

3、方法工厂

通过定义不同的方法，然后随机调用实现，例如 Controller 层调用 Servers 层中的方法。

class phoneFactory {
   /**
     * 生产samsang手机
     */
    public static phone createSamsang() {return new samsungPhone();}
    /**
     * 生产huawei手机
     */
    public static phone createHuawei() {return new huaweiPhone();}
    /**
     * 生产ipone手机
     */
    public static phone createIpone() {return new iphone();}
}

测试

public static void main(String[] args) {
//简单工厂
 phone sumsangPhone = phoneFactory.createSamsang();
 sumsangPhone.phoneModel();
 }

结果

 三星手机开始生产...

4、普通工厂

把简单工厂中具体的工厂类，划分成两层：抽象工厂层+具体的工厂子类层

//手机工厂（抽象工厂）
abstract class PhoneFactory {public abstract phone create();}
//Samsang手机工厂
class SamsangFactory extends PhoneFactory {
    @Override
    public phone create() {return new samsungPhone();}
}
//Huawei手机工厂
class HuaiweiFactory extends PhoneFactory {
    @Override
    public phone create() { return new huaweiPhone();}
}
//ipone工厂
class Ipone extends PhoneFactory {
    @Override
    public phone create() { return new iphone();}
}

测试

public static void main(String[] args) {
     //普通工厂
    PhoneFactory phoneFactory = new SamsangFactory();
    phone phone = phoneFactory.create();
    phone.phoneModel();
 }

结果

 三星手机开始生产...

5、抽象工厂

用于多个产品一起生产。为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类

//除手机外，还卖电脑
abstract class Pad {
    /**
     * 平板品牌
     */
    public abstract void Modle();
}

//三星平板
class SamsangPad extends Pad {

    @Override
    public void Modle() {System.out.println("开始生产三星平板电脑...");}
}

//ipad
class IPad extends Pad {
    @Override
    public void Modle() { System.out.println("开始生产apple平板电脑...");}
}

//抽象工厂
abstract class AbstractPadFactory {
    /**
     * 生产手机
     */
    public abstract phone createPhone();
    /**
     * 生产Pad
     */
    public abstract Pad createPad();
}


//AppleStore
class AppleStore extends AbstractPadFactory{
    //卖ipone
    @Override
    public phone createPhone() {return new iphone();}
    //卖ipad
    @Override
    public Pad createPad() { return new IPad();}
}

//SamsangStore
class SamsangStore extends AbstractPadFactory{
    //卖三星手机
    @Override
    public phone createPhone(){ return new samsungPhone();}
    //卖三星平板
    @Override
    public Pad createPad() {return new SamsangPad();}
}

测试

public static void main(String[] args) {
    //抽象工厂
    AbstractPadFactory abstractPadFactory = new AppleStore();
    abstractPadFactory.createPhone().phoneModel();
    abstractPadFactory.createPad().Modle();

    abstractPadFactory= new SamsangStore();
    abstractPadFactory.createPhone().phoneModel();
    abstractPadFactory.createPad().Modle();

结果

苹果手机开始生产...
开始生产apple平板电脑...
三星手机开始生产...
开始生产三星平板电脑...

比较

内容	简单工厂	简单工厂(反射)	方法工厂	普通工厂	抽象工厂
特点	一个具体的类，通过createPhones方法利用if或者 switch创建产品并返回，静态	一个具体的类，通过createPhones方法利用反射机制生成对象返回	不同产品，提供不同的生产方法	把简单工厂中具体的工厂类，划分成抽象工厂层和具体的工厂子类层	多产品系
优点	简单，易理解	较简单工厂，代码简单	容错率高，方便	松耦合，面向对象（具体方法）	面向对象，多产品实现共同生产
缺点	扩展性差，紧耦合	使用发射，效率低下	代码较复杂	每次新增一个具体产品类，也要同时新增一个具体工厂类	容易造成紧耦合

---

THE END