设计模式之工厂模式（简单工厂，工厂方法，抽象工厂）

前语：在工厂模式中常常会分不清楚（简单工厂和工厂方法，抽象工厂）三者之前的区别，在学习设计模式时也容易混淆，这里对三者进行学习；

工厂模式：顾名思义，客户希望通过工厂（一个或一系列方法）去生产（一个或者一系列产品的实例）

本质：工厂模式是创建者模式，创建对象实例；

一.简单工厂

　　简单工厂类（SimpleFactory）通过接受参数的形式，调用getShape()方法区得到想要创建的对象；

      如图所示：

 优点：简单而且粗暴的创建对象，通过参数可以创建任何实现了接口的对象

 缺点：（1）当对象类过多，简单工厂就会很臃肿，不利于简单工厂的维护 （2）不符合开放封闭原则，每次增加一个产品子类，就需要修改简单工厂

 简单写了一下实现代码：但是不是按照上述UML关系图

产品接口Food的代码如下

public interface Food {
    void eat();
}

实现产品接口的类Apple.class

public class Apple implements   Food {
    @Override
    public void eat() {
        System.out.println("当前吃是苹果");
    }
}

实现产品接口的类Pear.class

public class Pear implements Food {
    @Override
    public void eat() {
        System.out.println("当前正在吃梨子");
    }
}

实现产品接口的类Banana.class

public class Banana implements Food{
    @Override
    public void eat() {
        System.out.println("当前正在吃香蕉");
    }
}

简单工厂方法SimpleFactory.class

public class SimpleFactory {

    private Food food=null;

    public Food getFood(String FoodName){
        if(FoodName=="" || FoodName==null){
            return null;
        }

        switch (FoodName){
            case "Banana": food =new Banana();break;
            case "Apple" : food =new Apple(); break;
            case "Pear"  : food =new Pear();break;
            default: food=null;break;
        }
        return food;
    }
}

方法运行Main

//简单工厂
//1.对象类型 有多种子类
//2.工厂只有 一个
//3.对象的创建延迟到工厂实例中
public class Main {

    public static void main(String[] args) {
        //Client 客户来吃水果
        Food food =null;

        SimpleFactory factory =new SimpleFactory();

        food=factory.getFood("Pear");

        food.eat();
    }
}

运行结果：

 二.工厂方法

工厂方法为每一个对象提供一种产品提供一个工厂，用于该类的实例化；

如下UML所示为工厂方法。

 

工厂方法的实现过程代码：

Food接口

public interface  Food {
     void eat();
}

Factory接口

public interface Factory {
    Food create();
}

Apple.class类

public class Apple implements   Food {
    @Override
    public void eat() {
        System.out.println("当前吃是苹果");
    }
}

Banana.class类

public class Banana implements Food{

    @Override
    public void eat() {
        System.out.println("当前正在吃香蕉");
    }
}

与之对应的工厂

AppleFactory.class

public class AppleFactory implements  Factory {
    @Override
    public Food create() {
        return new Apple();
    }
}

BananaFactory.clsss

public class BananaFactory implements  Factory{
    @Override
    public Food create() {
        return new Banana();
    }
}

工厂方法调用

  public static void main(String[] args) {

        Food food =null;

        Factory factory =null;

        /****************/
        String foodName="Apple";
        switch (foodName){

            case "Apple":factory =new AppleFactory();break;
            case "Banana":factory =new BananaFactory();break;
            default:factory =null;
        }
        /***************/

        food =factory.create();

        food.eat();
    }

在调用方法上仍然扩展性不足，但是可以采取反射技术弥补

运行结果：

优点：（1）与简单工厂相比，提高了工厂的扩展性，符合开放封闭原则；

缺点：（2）实现起来较之于简单工厂复杂，无法生存一系列产品

三.抽象工厂

抽象工厂是对于产品系列而言

比如衣服分为帽子，T恤从种类上分，从品牌的角度分为LiNing,Nike,针对这种情况需要创建一个产品族的对象，可以采取抽象工厂的方法

以此为思路，创建的抽象工厂UML为：

具体代码实现

Hat接口

//帽子
public interface Hat {
     void put();
}

Shirt接口

//T恤
public interface Shirt {
    void wear();
}

Shop接口

public interface Shop {

    Hat SellHat();

    Shirt SellShirt();

    static Shop setShop(String typeName){

        try {
            Class c =Class.forName(typeName);

            Shop shop=(Shop) c.newInstance();

            return shop;
        }catch (Exception e) {
            throw new RuntimeException();
        }
    }
}

LiNingHat.class帽子类

public class LiningHat implements   Hat {
    @Override
    public void put() {
        System.out.println("穿上李宁的帽子");
    }
}

LiNingShirt.clas李宁的T恤

public class LiningShirt implements Shirt {

    @Override
    public void wear() {
        System.out.println("穿上李宁的T桖");
    }
}

Nike的帽子NikeHat.class

public class NikeHat implements Hat{
    @Override
    public void put() {
        System.out.println("穿上耐克的帽子");
    }
}

Nike的T恤NikeShirt.class

public class NikeShirt implements   Shirt{
    @Override
    public void wear() {
        System.out.println("穿上耐克的T桖");
    }
}

李宁的商店LiNingShop.class

public class LiningShop implements   Shop{

    @Override
    public Hat SellHat() {
        return new LiningHat();
    }

    @Override
    public Shirt SellShirt() {
        return new LiningShirt();
    }
}

Nike的商店NikeShop.class

//Nike商店
public class NikeShop implements   Shop {
    @Override
    public Hat SellHat() {
        return new NikeHat();
    }

    @Override
    public Shirt SellShirt() {
        return new NikeShirt();
    }
}

调用抽象工厂的过程

public static void main(String[] args) {
        Hat hat =null;
        Shirt shirt =null;

        Shop shop =Shop.setShop("v3.LiningShop");

        hat =shop.SellHat();
        shirt =shop.SellShirt();

        hat.put();
        shirt.wear();
    }

调用结果：

优点：可以针对一系列对象

确定：只针对一系列对象

总结：

简单工厂：针对同一级别的不同对象（扩展性较差）

工厂方法：针对同一级别的固定对象(开放修改接口，扩展性好)

抽象工厂：针对不同系列的全部对象（不支持单个产品扩展，只支持产品族扩展）

使用总结：（1）工厂模式中，工厂类采取的单例模式

　　　　　（2）工厂类的基类可以是接口也可以是抽象类

　　　　　（3）调用工厂采取的是指针和引用