1 工厂模式

思考场景：
  有一位同学想要购买笔记本，他到商场发现有两款电脑他比较喜欢，一款是Macbook pro，另一款是Surface pro ，根据以上场景类图可以表示为：

interface IComputer{
    
    //省略方法前的 public abstract
    void printComputer();
}
class MacbookProComputerImpl implements IComputer{
    
    public void printComputer()
    {
    
        System.out.println("This  is  a  MacbookPro");
    }
}
class SurfaceBookComputerImpl implements IComputer{
    
    public void printComputer()
    {
    
        System.out.println("This  is  a  SurfaceBook");
    }
}
class Client{
    
	 public void buyComputer(IComputer computer)
    {
    
        computer.printComputer();
    }
}
public class Client{
    
    public static void main(String[] args)
    {
      
        Client client = new Client();
        client.buyComputer(new MacbookProComputerImpl());
        client.buyComputer(new SurfaceBookComputerImpl());
    }
}

  但是这个时候，如果这位同学又看上了一台外星人(Alienware)笔记本，我们就不得不返回客户端（主方法）去修改代码，让客户端支持Alienware笔记本。那么，如何将实例化具体类的代码从客户端中提出，或者封装起来，使它们不会干扰其他部分呢？

1.1 简单工厂模式

  简单工厂模式：专门定义一个类用来创建其它类的实例，被创建的实例通常都具有相同的父类。
  就相当于创建生产电脑的工厂，客户需要购买什么样的电脑，只需要输入类型编号就可以获取该电脑。将类型的实例化交给工厂，易于解耦（将客户端创建对象的操作解耦到外部第三方类）。

import java.util.Scanner;
interface IComputer{
    
    //省略方法前的 public abstract
    void printComputer();
}
class MacbookProComputerImpl implements IComputer{
    
    public void printComputer()
    {
    
        System.out.println("This  is  a  MacbookPro");
    }
}
class SurfaceBookComputerImpl implements IComputer{
    
    public void printComputer()
    {
    
        System.out.println("This  is  a  SurfaceBook");
    }
}
class Client{
    
	public void buyComputer(IComputer computer)
    {
    
        computer.printComputer();
    }
}
//定义一个类创建其它类实例
class ComputerFactory{
    
    //静态方法通过类名直接调用
    public static IComputer getInstance(String type)
    {
    
        IComputer computer = null;
        if("macbook".equals(type))
        {
    
            computer = new MacbookProComputerImpl();
        }else if("surface".equals(type))
        {
    
            computer = new SurfaceBookComputerImpl();
        }
        return computer;
    }
}
public class Test{
    
    public static void main(String[] args)
    {
      
        Client client = new Client();
        //输入电脑型号
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入你想要的电脑类型:");
        String type = scanner.nextLine();

        IComputer computer = ComputerFactory.getInstance(type);
        client.buyComputer(computer);
    }
}

  以上就是简单工厂模式！
简单工厂：

• 一个抽象产品类
• n个具体产品类
• 一个工厂

优点:

• 简单，易于实现
• 把类的实例化交给工厂，利于解耦。

缺点：

• 添加具体产品需要修改工厂，违反了java的开放封闭原则

什么是java开放封闭原则？

  对扩展开放，对修改关闭，遇到增加功能的需求时，几乎不用修改源代码，只是增加几个类，然后调用就好。

1.2 工厂方法模式

  工厂方法模式：定义一个用来创建对象的接口，让子类决定实例化哪一个类。
  工厂方法模式是针对每个产品提供一个工厂类，在客户端中判断使用哪个工厂去创建对象。我们将之前的ComputerFactory抽象成一个接口，那么创建相应具体的工厂类去实现该接口的方法。

interface IComputer{
    
    //省略方法前的 public abstract
    void printComputer();
}
class MacbookProComputerImpl implements IComputer{
    
    public void printComputer()
    {
    
        System.out.println("This  is  a  MacbookPro");
    }
}
class SurfaceBookComputerImpl implements IComputer{
    
    public void printComputer()
    {
    
        System.out.println("This  is  a  SurfaceBook");
    }
}
//定义一个用来创建对象的接口
interface IComputerFactory{
    
    IComputer creatComputer();
}
//针对每个产品提供一个工厂类
class MsFactoryImpl implements IComputerFactory{
    
    public IComputer creatComputer()
    {
    
        return new MacbookProComputerImpl();
    }
}
class SurfaceFactory implements IComputerFactory{
    
    public IComputer creatComputer()
    {
    
        return new SurfaceBookComputerImpl();
    }
}
class Client{
    
	public void buyComputer(IComputer computer)
    {
    
        computer.printComputer();
    }
}
public class Test{
    
    public static void main(String[] args)
    {
      
        Client client =  new Client();
        //在客户端中判断使用哪个工厂创建对象
        IComputerFactory factory = new SurfaceFactory();
        client.buyComputer(factory.creatComputer());
    }
}

  工厂方法模式是针对每个产品提供一个工厂类，在客户端中判断使用哪个工厂去创建对象。
工厂模式：

• 一个抽象的产品类
• 多个具体产品类
• 一个抽象工厂
• 多个具体工厂----工厂数与产品数相对应

优点：

• 降低了代码的耦合度，对象的生成交给子类去完成
• 实现了开放封闭原则（每次添加子类，不需要原有的代码）

缺点：

• 增加了代码量，每个具体产品都需要一个具体工厂
• 当增加抽象产品，也就是添加一个其他产品族，需要修改工厂

1.3 简单工厂模式&工厂方法模式

  对于简单工厂模式而言，创建对象的逻辑判断放在了工厂类中，客户不感知具体的类，但是违背了开闭原则，如果要增加新的具体的类，就必须修改工厂类。
  对于工厂方法模式而言，是通过扩展来新增具体的类的，符合开闭原则，但是在客户端就必须要感知到具体的工厂类，也就是将判断逻辑由简单工厂的工厂类挪到客户端。
  工厂模式横向扩展很方便，假如该工厂又有新产品Macbook Air要生产，那么只需要创建相应的工厂类和产品类去实现抽象的工厂接口和抽象的产品接口即可，而不用去修改原有已经存在的代码。

1.4 抽象工厂模式

  买电脑时肯定要安装操作系统，我们想要即买电脑又装操作系统，这时候该工厂就需要生产操作系统
  抽象工厂模式： 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类
  工厂方法模式和抽象工厂模式基本类似，可以这么理解：当工厂只生产一个产品（电脑）的时候即为工厂方法模式，而工厂如果生产两个或以上的产品即变为抽象工厂模式。

//电脑
interface IComputer{
    
    //省略方法前的 public abstract
    void printComputer();
}
class MacbookProComputerImpl implements IComputer{
    
    public void printComputer()
    {
    
        System.out.println("This  is  a  MacbookPro");
    }
}
class SurfaceBookComputerImpl implements IComputer{
    
    public void printComputer()
    {
    
        System.out.println("This  is  a  SurfaceBook");
    }
}

//操作系统
interface IOperatingSystem {
    
    void printSystem();
}
class MacSystemImpl implements IOperatingSystem{
    
    public void printSystem()
    {
    
        System.out.println("This is a mac os");
    }   
}
class Windows8System implements IOperatingSystem{
    
    public void printSystem()
    {
    
        System.out.println("This is a Windows 8");
    }
}

//定义一个用来创建对象的接口
interface IComputerFactory{
    
    IComputer creatComputer();
    IOperatingSystem creatSystem();
}
//针对每个产品提供一个工厂类
class MsFactoryImpl implements IComputerFactory{
    
    public IComputer creatComputer()
    {
    
        return new MacbookProComputerImpl();
    }
     public IOperatingSystem creatSystem()
    {
    
        return new MacSystemImpl();
    }
}
class SurfaceFactory implements IComputerFactory{
    
    public IComputer creatComputer()
    {
    
        return new SurfaceBookComputerImpl();
    }
     public IOperatingSystem creatSystem()
    {
    
        return new Windows8System();
    }
}
class Client{
    
	public void buyComputer(IComputer computer)
    {
    
        computer.printComputer();
    }
    public void buySystem(IOperatingSystem system)
    {
    
        system.printSystem();
    }
}
public class Test{
    
    public static void main(String[] args)
    {
      
        Client client =  new Client();
        //在客户端中判断使用哪个工厂创建对象
        IComputerFactory factory = new SurfaceFactory();
        client.buyComputer(factory.creatComputer());
        client.buySystem(factory.creatSystem());
    }
}

抽象模式:

• 多个抽象产品类
• n个具体产品类
• 抽象工厂类（一组返回抽象产品的方法）
• 多个具体工厂（生成具体产品）

优点：

• 代码解耦
• 实现多个产品族（相关联产品组成的家族），可以满足更多的生产需求
• 很好的实现了开放封闭原则
• 抽象工厂模式中我们可以定义实现不止一个借口，一个工厂也可以生产不止一个产品类，对于复杂对象的生产相当灵活易扩展

缺点：

• 扩展产品族相当麻烦，而且扩展产品族会违反开放封闭原则，因为要修改所有的工厂
• 由于抽象工厂模式是工厂方法模式的扩展，总体来说比较笨重

1.5 总结

  简单工厂模式最大的优点就是工厂内有具体的逻辑去判断生成什么产品，将类的实例化交给了工厂，这样当我们需要什么产品只需要修改工厂的调用而不需要去修改客户端，对于客户端来说降低了与具体产品的依赖。
  工厂方法模式是简单工厂的扩展，工厂方法模式把原先简单工厂中的实现那个类的逻辑判断交给了客户端，如果添加功能只需要修改客户和添加具体的功能，不用去修改原来的类。
  抽象工厂模式进一步扩展了工厂方法模式，它把原先的工厂模式中只能有一个抽象产品不能添加产品族的缺点克服了，抽象模式不仅仅遵循开放封闭原则，而且可以添加更多的抽象产品，具体工厂也不仅仅可以生成单一产品，而是生成一组产品，抽象工厂也是声明一组产品，对应扩展更加灵活，但是要扩展族系就会很笨重。