工厂模式（FactoryMethod）

2024年1月30日 90次阅读 来源: Knowing

一般实现

  • 创建实体类
   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

    原文作者：Knowing
    原文地址: https://segmentfault.com/a/1190000014698332
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞