工厂模式（FactoryMethod）

一般实现

• 创建实体类

   public class WithOutEntityA {
        public WithOutEntityA(){
            System.out.println("create WithOutEntityA ...");
        }
    }
    
    public class WithOutEntityB {
        public WithOutEntityB(){
            System.out.println("create WithOutEntityB ...");
        }
    }

• 调用方法

    public static void main(String[] args) {
        new WithOutEntityA();
        new WithOutEntityB();
    }

• 输出

    create WithOutEntityA ...
    create WithOutEntityB ...

• 问题
  new操作符是创建对象最常用的方法，但是在一些情况下，new方法会产生一些问题，或者并不能满足需求，也就是说，对象的创建是一个过程，而不是一个操作。

简单/静态工厂方法

• 创建接口或抽象类

    public interface IEntity {
    }

• 具体实现类

    public class EntityA implements IEntity {
        public EntityA(){
            System.out.println("create EntityA ...");
        }
    }
    
    public class EntityB implements IEntity {
        public EntityB(){
            System.out.println("create EntityB ...");
        }
    }

• 创建工厂

    public class SimpleFactory {
        public IEntity create(String type){
            IEntity entity = null;
            if(type.equals("A")){
                entity = new EntityA();
            }else if(type.equals("B")){
                entity = new EntityB();
            }
            return entity;
        }
    }

• 调用

    public static void main(String[] args) {
        SimpleFactory simpleFactory = new SimpleFactory();
        simpleFactory.create("A");
        simpleFactory.create("B");
    }

• 输出

    create EntityA ...
    create EntityB ...

• 缺点
  如果要加入新的类，不仅要修改调用代码，还要修改工厂类代码，违反了开闭原则。

工厂方法模式

• 组成
  1.一个抽象工厂类
  2.多个具体工厂类
  3.一个抽象产品类或产品接口
  4.多个具体产品类，每个具体产品类，对应一个具体工厂类
• 具体实现
  定义产品接口

    public interface IEntity {
    }

定义具体产品类

    public class EntityA implements IEntity {
        public EntityA(){
            System.out.println("create EntityA ...");
        }
    }
    
    public class EntityB implements IEntity {
        public EntityB(){
            System.out.println("create EntityB ...");
        }
    }

定义抽象工厂

    public abstract class Factory {
        public abstract IEntity create();
    }

定义具体工厂

    public class FactoryA extends Factory{
        @Override
        public IEntity create() {
            return new EntityA();
        }
    }
    
    public class FactoryB extends Factory{
        @Override
        public IEntity create() {
            return new EntityB();
        }
    }

调用方法

    public static void main(String[] args) {
        Factory factory = new FactoryA();
        factory.create();
        factory = new FactoryB();
        factory.create();
    }

输出

    create EntityA ...
    create EntityB ...

• 优点
  能够轻松构建对象实例，而不必关心对象实例创建的发杂过程，对对象的创建进行了包装，将对象的具体创建过程隔离起来，提高灵活度。

源码

https://github.com/Seasons20/DisignPattern.git

END