工厂模式（Factory Pattern）
工厂模式是最常用的软件设计模式之一，工厂模式属于创建型的设计模式。它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。


意图

工厂模式的意图在于他的创建过程延迟到子类中去实现。工厂模式定义一个接口，让子类自己决定实例化哪一个工厂类。


关键代码

创建过程在子类中执行。


3.例子

图形-圆形、正方形、长方形
public interface shape {
	public void draw();
}

public class Circle implements shape{
	@Override
	public void draw() {
		System.out.println("I draw a Circle！");
	}
}
public class Square implements shape{
@Override
public void draw() {
	System.out.println("I draw a Square!");
	}
}
public class Rectangle implements shape{
	@Override
	public void draw() {
		System.out.println("I draw a Rectangle!");
	}	
}
public static void main(String[] args) {
	ShapeFactory shapeFactory = new ShapeFactory();
	shape shape1 = shapeFactory.getShape("Circle");
	shape1.draw();
}

输出：  I draw a Circle！

4. 优缺点：

优点：1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事

常用的软件设计模式的Java实现——让编程从野生到飞起_野生技术协会_科技_bilibili_哔哩哔哩  https://www.bilibili.com/video/av7596511/
转载于:https://www.cnblogs.com/startnow/p/7617709.html

单例模式：即一个类只有一个实例，在类里自己创建自己的实例。

优点：

（1）单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。

（2）因为类控制了实例化过程，所以类可以灵活更改实例化过程。尤其是在C++中，每次new都要delete，而是用单例模式可以避免忘记delete造成的内存泄漏，只在本类的内部delete实例就可以了

（3）方便对实例进行管理，减少重复的代码，减少内存开销

缺点：

（1）应为内部实例化的对象为静态全局变量，因此没有接口，不能继承

（2）与单一职责原则（这个之后会做详细介绍）冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

该模式可以应用在很多编程语言上，这里以C#为例

//单例模式的一般实现
public class TxtManager
 {
    //私有对象记录唯一实例
   private static TxtManager instance;
 
   //让构造函数为 private，这样该类就不会被实例化
   private TxtManager(){}
 
   //获取唯一可用的对象的公有方法
   public static TxtManager getInstance()
   {
        if(null == instance)
        {
            instance = new TxtManager();
        }
      return instance;
   }
}


//调用
public class SingleDemo 
{
      //编译时错误：构造函数 SingleObject() 是不可见的
      //SingleObject object = new SingleObject();
 
      //获取唯一可用的对象
      TxtManager object = TxtManager.getInstance();
}

 

刚参加工作的时候，丝毫没有面向对象的思想，所有分支都使用一堆的if...else...，现在回头看以前的代码，着实low。但是只要一心想着进步的人，一定是会总结和反省的，为什么以前的代码出现bug这么难维护，功能扩展那么难，代码难得到复用，过了段时间连自己写的代码都不知道什么意思。都说女孩子逻辑思维比不上男孩子，工作几年并没这种感觉，区别在于总结和分析罢了，只要比别人多一点耐心，多一点总结，一年之后就会发现那些和你同一起点的人已经远远被你甩在后面，不废话了，今天大猪蹄：简单工厂模式，告别眼花缭乱的if...else。

简单工厂模式：顾名思义，最少有一个生产产品的机器存在的工厂，有了这个工厂，当你需要某一对象时，传入一个正确的参数，就可以获取你所需要的对象，而无需知道其创建细节

优点：把分支封装在工厂类里，让工厂类判断用户需要什么对象，然后创建出什么对象，不用把分支代码开发出来，模块清晰化，各个部分各司其职

缺点：依然需要在工厂类的添加分支语句只是把if...else...改成了switch...case...，在添加新的产品时，既需要添加新的产品类，也需要修改工厂类的代码，这里就显得耦合性较高，不过这个问题也是有办法解决的，这个留到后面章节再讲

写一个特别简单的例子，客户需要根据名字获取不同类型的水果，如果是刚毕业的我，一定会写成下面这样：

        static void Main(string[] args)
        {
            Console.Write("请输入水果名称：");
            string fruitName = Console.ReadLine;
                switch (fruitName)
                {
                    case "Apple"://苹果
                        Console.Write("你要的苹果\t");
                        break;
                    case "Banana": //香蕉
                        Console.Write("你要的香蕉\t");
                        break;
                    default:
                        Console.Write("这里没有你要的水果\t");
                        break;
                }
        }

   简单工厂模式设计如下，包含以下几个类，用户类、工厂类、抽象产品类、具体产品类

//抽象产品类
public class FruitType
{
    public virtual void ShowFruit();
}


//苹果类
Class Apple:FruitType
{
    public override void ShowFruit()
    {
        Console.Write("你要的苹果\n\t");
    }
}


//香蕉类
Class Banana:FruitType
{
    public override void ShowFruit()
    {
        Console.Write("你要的香蕉\n\t");
    }
}


//工厂类
public class FruitFactory
{
    public static FruitType CreateFruit(string fruit)
    {
        FruitType fruitType = null;
        switch(fruitType)
        {
            case "apple":
                    fruitType = new Apple();
                    break;
            case "banana":
                    fruitType = new Banana();
                    break;
        }
        return fruitType;
    }
}

//客户类
Class Client
{
    FruitType fruitType;
    fruitType = FruitFactory.CreateFruit("apple");
    fruitType.ShowFruit();
}