设计模式----工厂模式

 

工厂模式详解

特点：

• 1、 隐藏复杂的逻辑处理过程， 只关心执行结果。

工厂模式有三种：

• 1、简单工厂，功能强大，但是可扩展性不强
• 2、工厂方法，独立分工，但是学习成本过高
• 3、抽象工厂，简单工厂和工厂方法的结合体

我们以汽车制造来说，假如一个4S店需要选购一批汽车，从宝马、奔驰、奥迪生产厂家拿到这些汽车。 
我们通过工厂模式来实现，4S店选购到这些汽车。

简单工厂模式

解刨：从一个厂家拿到宝马、奔驰、奥迪，同一套工艺标准。 
缺点：无法进行个性定制化。

定义工艺标准，也就是实现一个Car接口

public interface Car {
    String  getName();
}

生产奥迪车，同一个工厂，相同的标准

public class Audi implements Car{
    public String getName() {
        return "Audi";
    }
}

生产奔驰车，同一个工厂，相同的标准

public class Benz implements Car {
    public String getName() {
        return "Benz";
    }
}

生产宝马车，同一个工厂，相同的标准

public class Bmw implements Car{
    public String getName() {
        return "Bmw";
    }
}

工厂开始准备加工，定义了一个工厂类

public class SimpleFactory {
    public Car getCar(String name) {
        if ("Bmw".equalsIgnoreCase(name)) {
            return new Bmw();
        } else if ("Benz".equalsIgnoreCase(name)) {
            return new Benz();
        } else if ("Audi".equalsIgnoreCase(name)) {
            return new Audi();
        } else {
            System.out.println("这款汽车暂无生产");
            return null;
        }

    }
}

根据需要的汽车开始生产，定义一个测试类

public class SimpleFactoryTest {
    public static void main(String[] args) {
        // 实现统一管理、专业化管理
        Car car = new SimpleFactory().getCar("Bmw");
        System.out.println("该工厂生产了："+car.getName());
    }
}

工厂方法模式

解刨：定义一套公开标准，然后不同的汽车不同的厂家生产 
宝马工厂生产宝马，奔驰工厂生产奔驰，有自己的个性化定制。

缺点：有的时候我们只要一家厂商，要对多家厂商进行筛选

定义公开的标准，如质量ISO9001，定义公开的接口

public interface FunFactory {
    Car getCar();
}

宝马工厂按照公开的标准生产，然后自己做了一些定制化生产

public class BmwFactory implements FunFactory {
    public Car getCar() {
        return new Bmw();
    }
}

奔驰工厂按照公开的标准生产，然后自己做了一些定制化生产

public class BenzFactory implements FunFactory {
    public Car getCar() {
        return new Benz();
    }
}

奥迪工厂按照公开的标准生产，然后自己做了一些定制化生产

public class AudiFactory implements FunFactory {
    public Car getCar() {
        return new Audi();
    }
}

不同的工厂生产不同的汽车

public class FunFactoryTest {
    public static void main(String[] args) {
        FunFactory factory=new AudiFactory();
        System.out.println(factory.getCar());
        factory=new BmwFactory();
        System.out.println(factory.getCar());
        factory=new BenzFactory();
        System.out.println(factory.getCar());

    }
}

抽象工厂模式

抽象工厂模式不同于简单工厂模式和工厂方法模式：

1. 简单工厂模式的缺点是：一旦工厂需要添加新的产品是，需要修改工厂类代码，这违背了“对修改关闭，对扩展开放”的原则

2. 工厂方法模式是介于简单工厂模式和抽象工厂模式之间的一种模式，它克服了简单工厂模式的缺点，它将创建对象行工厂中剥离出来，工厂类只是一个接口或者抽象类，抽象工厂类不负责创建对象，只提供一个具体工厂必须实现的接口。

3. 但是工厂方法模式也存在弊端，工厂方法模式中每个具体工厂类只能生产一个产品，这明显不符合实际中的开发需求。抽象工厂模式很好的解决了这个问题。

4. 抽象工厂模式：提供一个创建产品的接口来负责创建相关或依赖的对象，而不具体明确指定具体类

下面就以生活中 “绝味” 连锁店的例子来实现一个抽象工厂模式。例如，绝味鸭脖想在江西南昌和上海开分店，但是由于当地人的口味不一样，在南昌的所有绝味的东西会做的辣一点，而上海不喜欢吃辣的，所以上海的所有绝味的东西都不会做的像南昌的那样辣，然而这点不同导致南昌绝味工厂和上海的绝味工厂生成所有绝味的产品都不同，也就是某个具体工厂需要负责一系列产品(指的是绝味所有食物)的创建工作，下面就具体看看如何使用抽象工厂模式来实现这种情况。

YaBo

package com.evior.Test2;

/**
 * 鸭脖
 */
public abstract class   YaBo {

    private String name;

    public String getName() {
        return name;
    }

    public YaBo() {
    }

    public void setName(String name) {
        this.name = name;
    }

    public YaBo(String name) {
        this.name = name;
        print();
    }

    public abstract void print();

}

YaJia

package com.evior.Test2;

public abstract class YaJia {
    private String name;


    public YaJia() {
    }

    public YaJia(String name) {
        this.name = name;
        print();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public abstract void print();
}

 NanChangeYaBo

package com.evior.Test2;

public class NanChangYaBo extends YaBo {


    public NanChangYaBo() {
        this.setName("南昌鸭脖");
        print();
    }

    @Override
    public void print() {
        System.out.println("南昌鸭脖");
    }
}

NanChangeYaJia

package com.evior.Test2;

public class NanChangYaJia extends YaJia {


    public NanChangYaJia() {
        this.setName("南昌鸭架");
        print();
    }

    @Override
    public void print() {
        System.out.println("南昌鸭架");
    }
}

WuHanYaBo

package com.evior.Test2;

public class WuHanYaBo extends YaBo {

    public WuHanYaBo() {
        this.setName("武汉鸭脖");
        print();
    }

    @Override
    public void print() {
        System.out.println("武汉鸭脖");
    }
}

WuHanYaJia

package com.evior.Test2;

public class WuHanYaJia extends YaJia {

    public WuHanYaJia() {
        this.setName("武汉鸭架");
        print();
    }

    @Override
    public void print() {
        System.out.println("武汉鸭架");
    }
}

NanChangeFactory

package com.evior.Test2;

public class NanChangeFactory extends AbstractYaFactory {
    @Override
    public YaBo createYaBo() {

        return new NanChangYaBo();
    }

    @Override
    public YaJia createYaJia() {
        return new NanChangYaJia();
    }
}

WuHanYaFactory

package com.evior.Test2;

public class WuHanYaFactory extends AbstractYaFactory {
    @Override
    public YaBo createYaBo() {


        return new WuHanYaBo();
    }

    @Override
    public YaJia createYaJia() {
        return new WuHanYaJia();
    }
}

测试

package com.evior.Test2;

public class Test {

    public static void main(String[] args) {
        //购买武汉鸭脖
        YaBo yaBo=new WuHanYaFactory().createYaBo();
        System.out.println(yaBo.getName());

        //购买南昌鸭架
        YaJia yaJia=new NanChangeFactory().createYaJia();
        System.out.println(yaJia.getName());

    }
}

结果: