简单工厂模式、工厂模式、抽象工厂模式

1.简单工厂模式：调用类只需要向工厂类请求方法，由工厂决定创建出哪个类的实例，而不需要关心被调用类的实现过程。

优势：调用类 和 被调用类分离，调用类需要时只需要向工厂请求，避免了调用类和被调用类之间的硬耦合。

缺陷：被调用类更改 工厂类也需要同步更改。

实例：

 public interface IAnimal
    {
        void Eat();
    }
    public class Cat : IAnimal
    {
        public void Eat()
        {
            Console.WriteLine("我是小猫咪，当然吃鱼了..");
        }
    }
    public class Dog : IAnimal
    {
        public void Eat()
        {
            Console.WriteLine("我是小狗狗，记得给我带骨头来啊..");
        }
    }

    public class AnimalFactory
    {
        public IAnimal GetAnimal(string animalType)
        {
            if (animalType=="cat")
            {
                return new Cat();
            }
            if (animalType=="dog")
            {
                return new Dog();
            }
            return null;
        }
    }

  class Program
    {
        static void Main(string[] args)
        {
            IAnimal animal;
            animal = new AnimalFactory().GetAnimal("cat");
            animal.Eat();
            Console.WriteLine("----------------");

            animal = new AnimalFactory().GetAnimal("dog");
            animal.Eat();
            Console.ReadLine();
        }
    }

2.工厂模式：如果我们不想在工厂类中加判断，可以为不同的类提供不同的工厂，不同的工厂生产不同的产品。

缺陷：调用类和工厂类之间存在硬编码耦合。

实例：

  public interface IAnimal
    {
        void Eat();
    }
    public class Cat : IAnimal
    {
        public void Eat()
        {
            Console.WriteLine("我是小猫咪，当然吃鱼了..");
        }
    }
    public class Dog : IAnimal
    {
        public void Eat()
        {
            Console.WriteLine("我是小狗狗，记得给我带骨头来啊..");
        }
    }

    public class CatFactory
    {
        public IAnimal GetAnimal()
        {
            
                return new Cat();
         }
    }

    public class DogFactory
    {
        public IAnimal GetAnimal()
        {

            return new Dog();
        }
    }

 class Program
    {
        static void Main(string[] args)
        {
            IAnimal animal;
            animal = new CatFactory().GetAnimal();
            animal.Eat();
            Console.WriteLine("----------------");

            animal = new DogFactory().GetAnimal();
            animal.Eat();
            Console.ReadLine();
        }
    }

3.抽象工厂： 使用简单工厂模式，需要在工厂类增加逻辑判断，而使用工厂模式，又造成了调用类和工厂类的硬编码耦合，所以我们可以在新建一个类，这个类不制造具体的被调用对象，而是只制造工厂对象。

实例：

  public interface IAnimal
    {
        void Eat();
    }
    public class Cat : IAnimal
    {
        public void Eat()
        {
            Console.WriteLine("我是小猫咪，当然吃鱼了..");
        }
    }
    public class Dog : IAnimal
    {
        public void Eat()
        {
            Console.WriteLine("我是小狗狗，记得给我带骨头来啊..");
        }
    }


    public  interface IFactory{
        IAnimal GetAnimal();
    }

    public class CatFactory:IFactory
    {
        public IAnimal GetAnimal()
        {
            
                return new Cat();
         }
    }

    public class DogFactory : IFactory
    {
        public IAnimal GetAnimal()
        {

            return new Dog();
        }
    }


    public class AbstractFactory
    {
        public IFactory GetFactory(string factoryname)
        {
            if (factoryname == "cat")
            {
                return new CatFactory();
            }
            if (factoryname == "dog")
            {
                return new DogFactory();
            }
            return null;
        }
    }

 class Program
    {
        static void Main(string[] args)
        {
            IFactory factory;
            factory = new AbstractFactory().GetFactory("cat");
            factory.GetAnimal().Eat();
            Console.WriteLine("----------------");

            factory = new AbstractFactory().GetFactory("dog");
            factory.GetAnimal().Eat();
            Console.ReadLine();
        }
    }