java设计模式--工厂模式

前言

工厂模式是一种常见的创建模式，android源码中很多地方都用到了这种模式，比如：

• BitmapFactory就是一种简单的工厂模式

• ArrayList中的迭代器Iterator也是用的工厂模式

工厂模式的核心思想：提供创建对象的功能，不需要使用者了解产品生产的具体过程

好处：降低使用者与产品之间的耦合度，有利于产品的拓展

分类

工厂模式可以分为三类：

• 简单工厂模式（Simple Factor）
• 工厂方法模式（Factory Method）
• 抽象工厂模式（Abstract Factory）

GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。

将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。

一简单工厂模式（Simple Factor）

简单工厂模式就是去创建一个创建对象的工具类。在这个工具类里面，我们就可以进行一些其他操作，比如对象的初始化。它的组成部分有：

• 抽象产品类 ：一般是一个接口，有具体产品类实现
• 具体产品类：实现抽象产品类，他的实例由工厂类创建
• 工厂类：用来创建产品的实例

例子：有一个客户需要猫和狗两种玩具但又不会做，客户只好委派给一家能制作两种玩具的工厂来制作玩具

• 产品类

interface Toys {

}

public class Cat implements Toys{

    public Cat(){
        System.out.println("生产了玩具猫");
    }
}

public class Dog implements Toys{

    public Dog(){
        System.out.println("生产了玩具狗")


    }
}

• 工厂类

public class ToysFactory {

    //写法一
    public static Toys createToys(int type){
        switch (type){
            case 1:
                return new Cat();
            case 2:
                return new Dog();
        }
        return null;
    }

    //写法二
    public static <T extends Toys> Toys createToys(Class<T> clz){
        Toys toys = null;
        try {
            toys = (Toys) Class.forName(clz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();

        return toys;
    }
}

• 客户类

    private void buyToys() {
        Toys toys1 = ToysFactory.createToys(1);
        Toys toys2 = ToysFactory.createToys(2);

        Toys toys3 = ToysFactory.createToys(Cat.class);
        Toys toys4 = ToysFactory.createToys(Dog.class);
    }

一工厂方法模式（Factory Method）

工厂方法模式，将简单工厂模式中的静态方法抽象，由它的子工厂类来实现，它的组成部分有：

• 抽象产品类 ：一般是一个接口，由具体产品类实现
• 具体产品类：实现抽象产品类，它的实例由工厂类创建
• 抽象工厂类：是一个抽象类，抽象产品的创建的方法，由子类实现
• 具体工厂类：用来创建产品的实例

例子：有一个客户需要猫和狗两种玩具但又不会做，客户只好委派给一家工厂来制作玩具，工厂接到任务后，又把任务分别指派给专门制作玩具猫和专门制作玩具狗的两家子工厂生产

• 产品类

public interface Toys {
    void call();
}
public class Cat implements Toys {

    public Cat(){
        System.out.println("生产了玩具猫");
    }

    @Override
    public void call() {
        System.out.println("喵喵喵");
    }
}
public class Dog implements Toys {

    public Dog(){
        System.out.println("生产了玩具狗");
    }

    @Override
    public void call() {
        System.out.println("汪汪汪");
    }
}

• 工厂类

public abstract class IFactory {

    /**
     * 创建产品的方法，由子类实现
     */
    protected abstract Toys createToys();

    /**
     * 示意，会使用产品的某些功能
     */
    public void someOperation(){
        Toys toys =  createToys();
        //使用产品
        toys.call();
    }
}
public class CatFactory extends IFactory {

    @Override
    protected Toys createToys() {
        return new Cat();
    }
}
public class DogFactory extends IFactory {
    @Override
    protected Toys createToys() {
        return new Dog();
    }
}

• 客户类

private void buyToys() {
        new CatFactory().someOperation();
        new DogFactory().someOperation();
}

–抽象工厂模式（Abstract Factory）

抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。它的组成部分有：

• 抽象产品类 ：一般是多个接口，多种抽象产品，由具体产品类实现
• 具体产品类：实现抽象产品类，它的实例由工厂类创建
• 抽象工厂类：是一个抽象类，抽象产品的创建的方法，里面有多个生产产品的抽象方法，由子类实现
• 具体工厂类：用来创建产品的实例

例子：有一个客户需要猫和狗两种玩具但又不会做，客户只好委派给一家工厂来制作玩具，工厂接到任务后，又把任务分别分派两家子工厂生产，一家制作玩具猫一家制作玩具狗，两家厂商又分别制作对应的玩具模型和声音发生器来组装指定的玩具

• 产品类

  //玩具外形
  public interface Toys {
  
  }
  public class Cat implements Toys {
      public Cat(){
          System.out.println("生产了玩具猫外形");
      }
  }
  public class Dog implements Toys {
  
      public Dog(){
          System.out.println("生产了玩具狗外形");
      }
  }
  //发声器
  public interface ISound {
      void call();
  }
  public class CatSound implements ISound {
      @Override
      public void call() {
          System.out.println("喵喵喵");
      }
  }
  public class DogSound implements ISound {
      @Override
      public void call() {
          System.out.println("汪汪汪");
      }
  }

• 工厂类

public abstract class IFactory {

    //创建外形
    protected abstract Toys createToys();
    //创建发声器
    protected abstract ISound createSound();

    /**
     * 示意，会使用产品的某些功能
     */
    public void someOperation(){
        Toys toys = createToys();
        ISound sound =  createSound();
        //使用产品
        sound.call();
    }
}
public class CatFactory extends IFactory {

    @Override
    protected Toys createToys() {
        return new Cat();
    }

    @Override
    protected ISound createSound() {
        return new CatSound();
    }
}
public class DogFactory extends IFactory {
    @Override
    protected Toys createToys() {
        return new Dog();
    }

    @Override
    protected ISound createSound() {
        return new DogSound();
    }
}

• 客户类

private void buyToys() {
        new CatFactory().someOperation();
        new DogFactory().someOperation();
}

总结

无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦，提高代码的扩展性，方便项目的维护

以上就是本人对三种工厂模式的理解，如有分析不正确的地方，欢迎大家来指出并改正