工厂模式（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