5.抽象工厂模式

设计模式 > 创建型模式 设计模式 创建型模式
发布时间 :
字数:1.2k 阅读 : 评论:
  1. 5.创建型模式-抽象工厂模式
    1. 5.1 基础知识
      1. 学习难度：4
      2. 使用频率：5
      3. 总分：7
      4. 定义
      5. 说人话
      6. 结构图
      7. 实现步骤
      8. 说明
    2. 5.2 模版代码
      1. 产品接口A和A类具体产品类
      2. 产品接口B和B类具体产品类
      3. 抽象工厂接口和具体工厂
      4. 客户端
    3. 5.3 CSharp实践
      1. 实践需求
      2. 动物接口和具体动物类
      3. 食物接口和具体食物类
      4. 抽象动物和食物工厂接口和具体工厂类
      5. 客户端代码
    4. 5.4 Unity实践
      1. 实践需求
      2. 立方体产品接口和具体立方体类
      3. 球产品接口和具体球类
      4. 原始模型抽象工厂接口和具体颜色模型工厂
      5. 客户端
      6. 运行结果

5.创建型模式-抽象工厂模式

5.1 基础知识

学习难度：4

使用频率：5

总分：7

定义

抽象工厂模式（Abstract Factory Pattern），提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

说人话

提供多个产品接口，一个工厂能创建不同产品接口的产品。

结构图

实现步骤

  • 多个产品接口：定义不同的展示产品方法
  • 多个具体产品类：实现不同的产品接口
  • 抽象工厂接口：定义多个创建产品方法，分别创建实现不同产品接口的产品
  • 多个具体工厂类：实现工厂接口，不同工厂返回不同产品
  • 客户端：实例化具体工厂，得到不同产品并展示

说明

和工厂方法模式相比有更多的产品接口。同时工厂接口中定义能创建实现不同产品接口的产品的方法。

5.2 模版代码

产品接口A和A类具体产品类

public interface IProductA
{
    void Show();
}

public class ProductA1:IProductA
{
    public void Show()
    {
        Console.WriteLine("我是ProductA1");
    }
}

public class ProductA2:IProductA
{
    public void Show()
    {
        Console.WriteLine("我是ProductA2");
    }
}

产品接口B和B类具体产品类

public interface IProductB
{
    void Show();
}

public class ProductB1:IProductB
{
    public void Show()
    {
        Console.WriteLine("我是ProductB1");
    }
}

public class ProductB2:IProductB
{
    public void Show()
    {
        Console.WriteLine("我是ProductB2");
    }
}

抽象工厂接口和具体工厂

public interface IAbstractFactory
{
    IProductA CreateProductA();
    IProductB CreateProductB();
}

class Factory1 : IAbstractFactory
{
    public IProductA CreateProductA()
    {
        return new ProductA1();
    }

    public IProductB CreateProductB()
    {
        return new ProductB1();
    }
}

class Factory2 : IAbstractFactory
{
    public IProductA CreateProductA()
    {
        return new ProductA2();
    }

    public IProductB CreateProductB()
    {
        return new ProductB2();
    }
}

客户端

class Program
{
    static void Main(string[] args)
    {
        // 使用工厂1创建1类产品
        IAbstractFactory factory1 = new Factory1();
        IProductA productA1 = factory1.CreateProductA();
        IProductB productB1 = factory1.CreateProductB();
        productA1.Show();//我是ProductA1
        productB1.Show();//我是ProductB1

        // 使用工厂2创建2类产品
        IAbstractFactory factory2 = new Factory2();
        IProductA productA2 = factory2.CreateProductA();
        IProductB productB2 = factory2.CreateProductB();
        productA2.Show();//我是ProductA2
        productB2.Show();//我是ProductB2
    }
}

5.3 CSharp实践

实践需求

使用抽象工厂模式创建了猫和狗和它们对应的食物

动物接口和具体动物类

public interface IAnimal
{
    void Speak();
}

public class Dog:IAnimal
{
    public void Speak()
    {
        Console.WriteLine("狗汪汪叫！");
    }
}

public class Cat:IAnimal
{
    public void Speak()
    {
        Console.WriteLine("猫喵喵叫！");
    }
}

食物接口和具体食物类

public interface IFood
{
    void Feed();
}

public class DogFood:IFood
{
    public void Feed()
    {
        Console.WriteLine("喂狗狗吃狗粮！");
    }
}

public class CatFood:IFood
{
    public void Feed()
    {
        Console.WriteLine("喂猫咪吃猫粮！");
    }
}

抽象动物和食物工厂接口和具体工厂类

public interface IAnimalAndFoodFactory
{
    IAnimal CreateAnimal();
    IFood CreateFood();
}

class DogFactory : IAnimalAndFoodFactory
{
    public IAnimal CreateAnimal()
    {
        return new Dog();
    }

    public IFood CreateFood()
    {
        return new DogFood();
    }
}

class CatFactory : IAnimalAndFoodFactory
{
    public IAnimal CreateAnimal()
    {
        return new Cat();
    }

    public IFood CreateFood()
    {
        return new CatFood();
    }
}

客户端代码

class Program
{
    static void Main(string[] args)
    {
        // 使用狗工厂创建狗和狗粮
        IAnimalAndFoodFactory dogFactory = new DogFactory();
        IAnimal dog = dogFactory.CreateAnimal();
        IFood dogFood = dogFactory.CreateFood();
        dog.Speak();//狗汪汪叫！
        dogFood.Feed();//喂狗狗吃狗粮！

        // 使用猫工厂创建猫和猫粮
        IAnimalAndFoodFactory catFactory = new CatFactory();
        IAnimal cat = catFactory.CreateAnimal();
        IFood catFood = catFactory.CreateFood();
        cat.Speak();//猫喵喵叫！
        catFood.Feed();//喂猫咪吃猫粮！
    }
}

5.4 Unity实践

实践需求

使用抽象工厂模式实现创建不同颜色的立方体和球

立方体产品接口和具体立方体类

public interface IProductCube
{
    void CreateCube();
}

public class ProductCubeRed : IProductCube
{
    public  void CreateCube()
    {
        GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
        Renderer cubeRenderer = cube.GetComponent<Renderer>();
        cubeRenderer.material.color = Color.red;
        cube.transform.position = new Vector3(Random.Range(-3, 3), Random.Range(-3, 3), Random.Range(-3, 3));
    }
}


public class ProductCubeBlue : IProductCube
{
    public void CreateCube()
    {
        GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
        Renderer cubeRenderer = cube.GetComponent<Renderer>();
        cubeRenderer.material.color = Color.blue;
        cube.transform.position = new Vector3(Random.Range(-3, 3), Random.Range(-3, 3), Random.Range(-3, 3));
    }
}

球产品接口和具体球类

public interface IProductSphere
{
    void CreateSphere();
}

public class ProductSphereRed : IProductSphere
{
    public void CreateSphere()
    {
        GameObject sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        Renderer sphereRenderer = sphere.GetComponent<Renderer>();
        sphereRenderer.material.color = Color.red;
        sphere.transform.position = new Vector3(Random.Range(-3, 3), Random.Range(-3, 3), Random.Range(-3, 3));
    }
}

public class ProductSphereBlue : IProductSphere
{
    public void CreateSphere()
    {
        GameObject sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        Renderer sphereRenderer = sphere.GetComponent<Renderer>();
        sphereRenderer.material.color = Color.blue;
        sphere.transform.position = new Vector3(Random.Range(-3, 3), Random.Range(-3, 3), Random.Range(-3, 3));
    }
}

原始模型抽象工厂接口和具体颜色模型工厂

public interface IAbstractFactoryPrimitiveModel
{
    IProductCube CreateProductCube();
    IProductSphere CreateProductSphere();
}

public class FactoryRed : IAbstractFactoryPrimitiveModel
{
    public  IProductCube CreateProductCube()
    {
        return new ProductCubeRed();
    }

    public  IProductSphere CreateProductSphere()
    {
        return new ProductSphereRed();
    }
}


public class FactoryBlue : IAbstractFactoryPrimitiveModel
{
    public  IProductCube CreateProductCube()
    {
        return new ProductCubeBlue();
    }

    public  IProductSphere CreateProductSphere()
    {
        return new ProductSphereBlue();
    }
}

客户端

public class TestAbstractFactoryPattern : MonoBehaviour
{
    private void Start()
    {
        IAbstractFactoryPrimitiveModel factoryRed = new FactoryRed();
        
        IProductCube cubeRed = factoryRed.CreateProductCube();
        cubeRed.CreateCube();
        
        IProductSphere sphereRed = factoryRed.CreateProductSphere();
        sphereRed.CreateSphere();

        
        IAbstractFactoryPrimitiveModel factoryBlue = new FactoryBlue();
        
        IProductCube cubeBlue = factoryBlue.CreateProductCube();
        cubeBlue.CreateCube();
        
        IProductSphere sphereBlue = factoryBlue.CreateProductSphere();
        sphereBlue.CreateSphere();
    }
}

运行结果

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 785293209@qq.com

赏

©2016-2024 Tao

Built with Hexo and 3-hexo theme

×

喜欢就点赞,疼爱就打赏