工厂顾名思义就是创建产品，根据产品是具体产品还是具体工厂可分为简单工厂模式和工厂方法模式。

简单工厂

Phone类：手机标准规范类(AbstractProduct)

  1. public interface Phone {
  2.     void make();
  3. }

MiPhone类：制造小米手机（Product1）

  1. public class MiPhone implements Phone {
  2.     public MiPhone() {
  3.         this.make();
  4.     }
  5.     @Override
  6.     public void make() {
  7.         // TODO Auto-generated method stub
  8.         System.out.println("make xiaomi phone!");
  9.     }
  10. }

IPhone类：制造苹果手机（Product2）

  1. public class IPhone implements Phone {
  2.     public IPhone() {
  3.         this.make();
  4.     }
  5.     @Override
  6.     public void make() {
  7.         // TODO Auto-generated method stub
  8.         System.out.println("make iphone!");
  9.     }
  10. }

PhoneFactory类：手机代工厂（Factory）

  1. public class PhoneFactory {
  2.     public Phone makePhone(String phoneType) {
  3.         if(phoneType.equalsIgnoreCase("MiPhone")){
  4.             return new MiPhone();
  5.         }
  6.         else if(phoneType.equalsIgnoreCase("iPhone")) {
  7.             return new IPhone();
  8.         }
  9.         return null;
  10.     }
  11. }

测试

  1. public class Demo {
  2.     public static void main(String[] arg) {
  3.         PhoneFactory factory = new PhoneFactory();
  4.         Phone miPhone = factory.makePhone("MiPhone");            // make xiaomi phone!
  5.         IPhone iPhone = (IPhone)factory.makePhone("iPhone");    // make iphone!
  6.     }
  7. }

缺点：

  • 由于工厂类集中了所有实例的创建逻辑，违反了高内聚低耦合原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。
  • 当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求。这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；

    工厂方法

    我们要创建一个对象，首先要创建该对象的工厂，用这个对象的工厂去创建这个对象
    (说实话，等后面看到具体的例子，我可能才会理解为啥我创建一个对象，前提要去创建这个对象工厂)
    AbstractFactory类：生产不同产品的工厂的抽象类
    1. public interface AbstractFactory {
    2.   Phone makePhone();
    3. }
    XiaoMiFactory类：生产小米手机的工厂（ConcreteFactory1）
    1. public class XiaoMiFactory implements AbstractFactory{
    2.   @Override
    3.   public Phone makePhone() {
    4.       return new MiPhone();
    5.   }
    6. }
    AppleFactory类：生产苹果手机的工厂（ConcreteFactory2）
    1. public class AppleFactory implements AbstractFactory {
    2.   @Override
    3.   public Phone makePhone() {
    4.       return new IPhone();
    5.   }
    6. }
    测试
    1. public class Demo {
    2.   public static void main(String[] arg) {
    3.       AbstractFactory miFactory = new XiaoMiFactory();
    4.       AbstractFactory appleFactory = new AppleFactory();
    5.       Phone miPhone = miFactory.makePhone();            // make xiaomi phone!
    6.       Phone iPhone = appleFactory.makePhone();        // make iphone!
    7.   }
    8. }