三种工厂模式（java实现）

//20210117
写在前面：刚期末考试完，考了面向对象，里边儿有23个设计模式，我寻思着考完挨个儿实现一下，本文先实现三个工厂模式————简单工厂、工厂模式、抽象工厂模式

一、简单工厂模式

• 简单的仅有一个的大工厂，工厂里根据分支条件来判断要生产的产品
• 源码如下

//大工厂接口
public interface Factory {
    Production product(String type);
}

//产品接口
public interface Production {
    void des();
}

//工厂实现类
public class ConcreteFactory implements Factory{
    public Production product(String type){
        if(type.equals("email")){
            return new ConcreteProduction_1();
        }else if(type.equals("sms")){
            return new ConcreteProduction_2();
        }else{
            System.out.println("请选择正确的类型");
            return null;
        }
    }
}

//产品实现类1
public class ConcreteProduction_1 implements Production{
    public void des(){
        System.out.println("使用短信发送");
    }
}

//产品实现类2
public class ConcreteProduction_2 implements Production{
    public void des(){
        System.out.println("使用邮件发送");
    }
}

//测试主方法
public static void main(String[] args) {
        Factory factory = new ConcreteFactory();
        Production email = factory.product("email");
        Production sms = factory.product("sms");
        email.des();
        sms.des();
    }

• 输出如下
  

二、工厂模式

• 小工厂，将生成不同产品的工厂分别抽象出来，再根据不同的工厂生产产品
• 源码如下

//工厂接口
public interface Factory {
    Production product();
}

//产品接口
public interface Production {
    void des();
}

//工厂实现类1
public class ConcreteFactory_1 implements Factory{
    public Production product(){
        return new ConcreteProduction_1();
    }
}

//工厂实现类2
public class ConcreteFactory_2 implements Factory{
    public Production product(){
        return new ConcreteProduction_2();
    }
}

//产品实现类1
public class ConcreteProduction_1 implements Production {
    public void des(){
        System.out.println("生产芒果饮料。。。");
    }
}

//产品实现类2
public class ConcreteProduction_2 implements Production {
    public void des(){
        System.out.println("生成苹果饮料。。。");
    }
}

//测试主方法
public static void main(String[] args) {
        Factory mangoFactory = new ConcreteFactory_1();
        Factory appleFactory = new ConcreteFactory_2();
        Production mango = mangoFactory.product();
        Production apple = appleFactory.product();
        mango.des();
        apple.des();
    }

• 输出如下
  

三、抽象工厂模式

• 抽象工厂，在工厂的概念上再抽象一层，即生成工厂的工厂，被生成的工厂再生成相应的产品
• 源码如下

//工厂抽象类
public abstract class AbstractFactory {
    public abstract Color getColor(String color);
    public abstract Shape getShape(String shape);
}

//颜色接口
public interface Color {
    void fill();
}

//形状接口
public interface Shape {
    void draw();
}

//工厂制造者
public class FactoryProducer {
    public static AbstractFactory getFactory(String choice){
        if(choice.equalsIgnoreCase("SHAPE")){
            return new ShapeFactory();
        }else if(choice.equalsIgnoreCase("COLOR")){
            return new ColorFactory();
        }else{
            System.out.println("::请输入正确工厂名称");
            return null;
        }
    }
}

//实现工厂之颜色工厂
public class ColorFactory extends AbstractFactory{
    @Override
    public Shape getShape(String shape) {
        return null;
    }

    @Override
    public Color getColor(String color) {
        if(color == null){
            return null;
        }
        if(color.equalsIgnoreCase("Red")){
            return new Red();
        }else if (color.equalsIgnoreCase("Green")){
            return new Green();
        }
        return null;
    }
}

//实现工厂之形状工厂
public class ShapeFactory extends AbstractFactory{
    public Shape getShape(String shapeType){
        if(shapeType == null){
            return null;
        }
        if(shapeType.equalsIgnoreCase("CIRCLE")){
            return new Circle();
        }else if (shapeType.equalsIgnoreCase("RECTANGLE")){
            return new Rectangle();
        }else if(shapeType.equalsIgnoreCase("SQUARE")){
            return new Square();
        }
        return null;
    }

    public Color getColor(String color){

        return null;
    }
}

//具体形状之圆形实现类
public class Circle implements Shape{
    public void draw(){
        System.out.println("Inside Circle::draw() method.");
    }
}

//具体形状之正方形实现类
public class Square implements Shape{
    public void draw() {
        System.out.println("Inside Square::draw() method");
    }
}

//具体形状之长方形实现类
public class Rectangle implements Shape{
    public void draw(){
        System.out.println("Inside Rectangle::draw() method...");
    }
}

//具体颜色之红色实现类
public class Red implements Color{
    public void fill(){
        System.out.println("Inside Red:fill() method.");
    }
}

//具体颜色之绿色实现类
public class Green implements Color{
    public void fill(){
        System.out.println("Inside Green::fill() method");
    }
}

//测试主方法
public static void main(String[] args) {
        AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
        AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
        Shape circle = shapeFactory.getShape("Circle");
        Color red = colorFactory.getColor("red");
        circle.draw();
        red.fill();
    }

• 输出如下
  

总结

• 三者的关系是，简单工厂最简单，工厂将简单工厂的分支抽象成具体的工厂，抽象工厂将实现的小工厂集合起来；当然，可以继续往上抽象————生产出生产不同类别工厂的工厂（可以有多个，依据统一接口或者抽象类实现）

以上
希望对大家有所帮助