设计模式之抽象工厂设计模式

1.介绍

    抽象工厂模式是一种软件设计模式，它提供了一种创建一系列相关或依赖对象的方式，而无需指定具体类。它将抽象工厂和具体工厂的实现分离开来，使得客户端和工厂的实现分离开来。该模式使得系统更具有灵活性和可扩展性，能够从更高的层面来管理对象的创建。
在抽象工厂模式中，抽象工厂定义了创建一系列相关对象的接口，每个具体工厂则实现了这些接口并负责创建相应的具体对象。这些具体工厂类应该能够创建与其主题相关的对象，并且应该具有相同的接口以便于客户端调用。客户端只需要知道抽象工厂提供的接口，并且不需要知道具体的实现。
抽象工厂模式常用于需要创建一组相关对象的情况，比如需要创建一组具有相同主题的界面元素。相比于简单工厂模式，抽象工厂模式更加抽象化和灵活，也更加复杂。

2.解决问题

抽象工厂模式主要解决的问题是一个系统需要一些有关联的产品对象，这些对象之间有一定的约束关系，不仅需要创建这些对象，而且需要保证它们之间的约束关系正确。
在这种情况下，使用抽象工厂模式可以将这些对象的创建过程分离出来，使得客户端不需要直接面对对象创建的复杂性，也不需要了解这些对象之间的约束关系。客户端只需要向抽象工厂对象发出请求，抽象工厂再负责创建符合约束关系的对象。
同时，抽象工厂模式还可以让系统更加灵活。例如，如果需要添加一种新的产品对象或者更改产品对象的约束关系，只需要实现一个新的具体工厂即可，而不需要修改客户端的代码。
总之，抽象工厂模式可以有效地解决多个相关对象的创建问题，并且可以让系统更加灵活、可扩展，使得客户端使用起来更加方便。

废话不多说，开整~

1.创建一个水果类和产地接口

/**
 * @Author: mark
 * @Description: 水果接口
 * @Date: 2023/06/08/10:06
 * @Version: 1.0
 */
public interface Fruit {

    void choice();

}

/**
 * @Author: mark
 * @Description: 产地接口
 * @Date: 2023/06/08/10:12
 * @Version: 1.0
 */
public interface Place {

    void placeIn();

}

2.并各自实现水果和产地接口

/**
 * @Author: mark
 * @Description: TODO
 * @Date: 2023/06/08/10:08
 * @Version: 1.0
 */
public class Apple implements Fruit {
    @Override
    public void choice() {
        System.out.print("this is apple==========>");
    }
}

/**
 * @Author: mark
 * @Description: TODO
 * @Date: 2023/06/08/10:08
 * @Version: 1.0
 */
public class Banana implements Fruit {
    @Override
    public void choice() {
        System.out.print("this is banana==========>");
    }
}

/**
 * @Author: mark
 * @Description: TODO
 * @Date: 2023/06/08/10:08
 * @Version: 1.0
 */
public class Pear implements Fruit {
    @Override
    public void choice() {
        System.out.print("this is Pear==========>");
    }
}

/**
 * @Author: mark
 * @Description: TODO
 * @Date: 2023/06/08/10:13
 * @Version: 1.0
 */
public class China implements Place {
    @Override
    public void placeIn() {
        System.out.println("make in China");
    }
}

/**
 * @Author: mark
 * @Description: TODO
 * @Date: 2023/06/08/10:13
 * @Version: 1.0
 */
public class Japan implements Place {
    @Override
    public void placeIn() {
        System.out.println("make in japan");
    }
}

/**
 * @Author: mark
 * @Description: TODO
 * @Date: 2023/06/08/10:13
 * @Version: 1.0
 */
public class Usa implements Place {
    @Override
    public void placeIn() {
        System.out.println("make in Usa");
    }
}

3. 为水果和产地创建抽象工厂类

/**
 * @Author: mark
 * @Description: 为水果和产地创建抽象工厂类
 * @Date: 2023/06/08/10:16
 * @Version: 1.0
 */
public abstract class AbstractFactory {

    public abstract Fruit getFruit(String fruit);
    public abstract Place getPlace(String fruit);

}

4.创建水果工厂 和产地并继承抽象工厂类

/**
 * @Author: mark
 * @Description: 创建水果工厂 并继承抽象工厂类
 * @Date: 2023/06/08/10:18
 * @Version: 1.0
 */
public class FruitFactory extends AbstractFactory{
    @Override
    public Fruit getFruit(String fruit) {
        if (fruit.equals("apple")){
            return new Apple();
        }
        if (fruit.equals("pear")){
            return new Pear();
        }
        if (fruit.equals("banana")){
            return new Banana();
        }
        return null;
    }

    @Override
    public Place getPlace(String fruit) {
        return null;
    }
}

/**
 * @Author: mark
 * @Description: 创建产地工厂
 * @Date: 2023/06/08/10:20
 * @Version: 1.0
 */
public class PlaceFactory extends AbstractFactory{
    @Override
    public Fruit getFruit(String fruit) {
        return null;
    }

    @Override
    public Place getPlace(String fruit) {
        if (fruit.equals("apple")){
            return new Japan();
        }
        if (fruit.equals("pear")){
            return new Usa();
        }
        if (fruit.equals("banana")){
            return new China();
        }
        return null;
    }
}

5.创建一个工厂的生成器 通过传参来选择需要的工厂

/**
 * @Author: mark
 * @Description: 创建一个工厂的生成器 通过传参来选择需要的工厂
 * @Date: 2023/06/08/10:26
 * @Version: 1.0
 */
public class ProduceFactory {

    public static AbstractFactory getFactory(String param){
        if (param.equals("place")){
            return new PlaceFactory();
        }
        if (param.equals("fruit")){
            return new FruitFactory();
        }
        return null;
    }

接下来小测一下

    //使用ProduceFactory来获取AbstractFactory，通过传递类型信息获取实体类对象

    public static void main(String[] args) {
        //获取水果工厂
        AbstractFactory fruit = ProduceFactory.getFactory("fruit");
        //获取apple对象
        Fruit apple = fruit.getFruit("apple");
        apple.choice();
        //获取产地工厂
        AbstractFactory place= ProduceFactory.getFactory("place");
        place.getPlace("apple").placeIn();
        //===================example========================
        Fruit pear = fruit.getFruit("pear");
        pear.choice();
        place.getPlace("pear").placeIn();

        Fruit banana = fruit.getFruit("banana");
        banana.choice();
        place.getPlace("banana").placeIn();
    }