设计模式之工厂模式

UML类图：

特点：
1.非接口/抽象类，定义create()方法，利用if/switch创建对象并返回
2.create()方法通常是静态的（static修饰），所以也叫静态工厂

以创建产品为例：

public interface Product {
    //声明类所需继承的共同接口，也可以是抽象类
}

public class ProductOne implements Product {
    
}

public class ProductTwo implements Product {
    
}

public class SimpleFactory {
    public static Product createProduct(ProductTypeEnum type) {
        if (ProductTypeEnum.one.equals(type)) {
            return new ProductOne();
        } else if (ProductTypeEnum.two.equals(type)) {
            return new ProductTwo();
        }
        return null;
    }
}

public class Client {
     public static void main(String[] args) {
         //调用Factory的静态方法生成所要的类
         SimpleFactory.createProduct(ProductTypeEnum.one);
         SimpleFactory.createProduct(ProductTypeEnum.two);
     }
 }

使用反射机制实现：

public class SimpleFactoryReflection {
    private static final Map productMap = new HashMap<>();
    ;

    public static void addProductKey(ProductTypeEnum typeEnum, Class product) {
        projectMap.put(typeEnum, product);
    }

    public static ProductOne getProduct(Product typeEnum) throws InstantiationException, IllegalAccessException {
        Class productClass = productMap.get(typeEnum);
        return (ProductOne) productClass.newInstance();
    }
}

缺点：
1.扩展性差（每增加一种产品都要去修改createProduct方法）
2.不同产品需要不同额外参数时不支持

UML类图：

特点：
1.提供产品类接口和工厂类接口（也可以是抽象类，即抽象产品和抽象工厂）
2.不同产品由不同工厂实现类实例化

抽象化工厂类：

public abstract class FactoryMethod {
    protected abstract Product createProduct();
}

再创建具体产品工厂类继承 抽象工厂类，实现createProduct方法

public class FactoryOne extends FactoryMethod {
    @Override
    protected Product createProduct() {
        return new ProductOne();
    }
}
public class FactoryTwo implements FactoryMethod {
    @Override
    protected Product createProduct() {
        return new ProductOTwo();
    }
}
    

缺点：
1.类的数量过多，增加复杂度和理解难度
2.抽象产品只能生产一种产品

UML类图：

特点：抽象工厂模式是工厂方法模式的升级版本，用来创建一组相关或者相互依赖的对象

例：不同商品赠送不同礼物，创建Gift接口

public interface Gift {
     //声明产品赠品的接口，当然也可以是抽象类
}

//ProductOne的礼物
public class GiftOne implements Gift {
     public GiftOne() {
        System.out.println("GiftOne");
     }
}

//ProductTwo的礼物
public class GiftTwo implements Gift {
     public GiftTwo() {
        System.out.println("GiftTwo");
     }
}

public interface Factory {
    public Product createProduct();
    public Gift createGift();
}

public class FactoryA implements Factory {
    @Override
    public Product createProduct() {
       return new ProductA();
    }
    @Override
    public Gift createGift() {
        return new GiftA();
    }
}

public class FactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
    @Override
    public Gift createGift() {
       return new GiftB();
    }
}

缺点：当产品族中新增一个产品时，所有工厂类都需要进行修改，增加系统抽象性和理解难度