浅析java设计模式之抽象工厂模式

抽象工厂模式

描述：
抽象工厂模式可以理解为将工厂模式中的多个不同维度的工厂封装成一个总工厂，抽象工厂模式就好像是富士康，富士康里有制作球类的工厂或者制作形状的工厂，制作球类的工厂又可以制作篮球和足球，制作形状的工厂又可以制作圆形和方形的工厂。像这样把生产不同类型的物品的工厂抽象成一个抽象概念的工厂，从这个抽象的工厂去获取具体生产的工厂并生成最终具体的货物的模式就是抽象工厂模式。

常用场景：
在系统具有多个获取对象的工厂，并且这些工厂生产的东西在一定场景下具有一定的联系的情况下，可以将工厂再次封装为一个总的抽象工厂。
比如衣厂，裤厂，鞋厂，将三者抽象为服装厂

项目结构：

实现：
1.球类的接口类

/**
 * @author Carl
 * @version 1.0
 * @date 2020/8/4 14:03
 * @description 工厂模式的接口类
 **/
public interface Ball {
    void doSomething();
}

2.球类工厂的实现类-篮球类

/**
 * @author Carl
 * @version 1.0
 * @date 2020/8/4 14:05
 * @description ball接口类的实现类
 **/
public class MyBasketball implements Ball {
    @Override
    public void doSomething() {
        System.out.println("get a basketball");
    }
}

3.球类工厂的实现类-足球

/**
 * @author Carl
 * @version 1.0
 * @date 2020/8/4 14:05
 * @description ball接口类的实现类
 **/
public class MyBasketball implements Ball {
    @Override
    public void doSomething() {
        System.out.println("get a basketball");
    }
}

4.球类工厂

import com.yzj.dobetter.designPattern.abstractFactoryPattern.AbstractFactory;

/**
 * @author Carl
 * @version 1.0
 * @date 2020/8/4 14:07
 * @description
 **/
public class BallFactory extends AbstractFactory {
    @Override
    public Object build(String whichBall){
        if("basketball".equals(whichBall)){
            return new MyBasketball();
        }else if ("football".equals(whichBall)){
            return new MyFootball();
        }else {
            return null;
        }
    }
}

5.图形的接口类

/**
 * @author Carl
 * @version 1.0
 * @date 2020/8/4 14:27
 * @description
 **/
public interface Shape {
    void doSomething();
}

6.图形的实现类-圆

/**
 * @author Carl
 * @version 1.0
 * @date 2020/8/4 14:28
 * @description
 **/
public class Circle implements Shape {
    @Override
    public void doSomething() {
        System.out.println("get a circle");
    }
}

7.图形的实现类-正方形

/**
 * @author Carl
 * @version 1.0
 * @date 2020/8/4 14:28
 * @description
 **/
public class Square implements Shape{
    @Override
    public void doSomething() {
        System.out.println("get a square");
    }
}

8.图形工厂

import com.yzj.dobetter.designPattern.abstractFactoryPattern.AbstractFactory;

/**
 * @author Carl
 * @version 1.0
 * @date 2020/8/4 14:31
 * @description
 **/
public class ShapeFactory extends AbstractFactory {
    @Override
    public Object build(String whichName) {
        if("circle".equals(whichName)){
            return new Circle();
        }else if("square".equals(whichName)){
            return new Square();
        }else {
            return null;
        }
    }
}

9.工厂封装类

import com.yzj.dobetter.designPattern.abstractFactoryPattern.ball.BallFactory;
import com.yzj.dobetter.designPattern.abstractFactoryPattern.shape.ShapeFactory;

/**
 * @author Carl
 * @version 1.0
 * @date 2020/8/4 14:34
 * @description
 **/
public class AllFactory {
    public static AbstractFactory getFactory(String factoryName){
        if("shapeFactory".equals(factoryName)){
            return new ShapeFactory();
        }else if("ballFactory".equals(factoryName)){
            return new BallFactory();
        }else {
            return null;
        }
    }
}

10.抽象工厂类

/**
 * @author Carl
 * @version 1.0
 * @date 2020/8/4 14:10
 * @description
 **/
public abstract class AbstractFactory {
    public abstract Object build(String name);
}

11.测试类

import com.yzj.dobetter.designPattern.abstractFactoryPattern.ball.MyBasketball;
import com.yzj.dobetter.designPattern.abstractFactoryPattern.ball.MyFootball;
import com.yzj.dobetter.designPattern.abstractFactoryPattern.shape.Circle;
import com.yzj.dobetter.designPattern.abstractFactoryPattern.shape.Shape;
import com.yzj.dobetter.designPattern.abstractFactoryPattern.shape.Square;

/**
 * @author Carl
 * @version 1.0
 * @date 2020/8/4 14:37
 * @description
 **/
public class Domain {
    public static void main(String[] args) {
        AbstractFactory shapFactory = AllFactory.getFactory("shapeFactory");
        Shape circle = (Circle) shapFactory.build("circle");
        circle.doSomething();
        Shape square = (Square) shapFactory.build("square");
        square.doSomething() ;

        AbstractFactory ballFactory = AllFactory.getFactory("ballFactory");
        MyBasketball myBasketball = (MyBasketball) ballFactory.build("basketball");
        myBasketball.doSomething();
        MyFootball myFootball = (MyFootball) ballFactory.build("football");
        myFootball.doSomething();
    }
}

12.测试结果

get a circle
get a square
get a basketball
get a football

说明：
1.工厂类ShapeFactory类和BallFactory类都继承自抽象工厂类abstratFactory。
2.AllFactory.getFactory()方法根据名称返回具体的工厂类。
3.通过获得的工厂进行最终想获取的对象的实例创建。