设计模式之工厂模式

最新推荐文章于 2024-09-15 16:31:23 发布

原创最新推荐文章于 2024-09-15 16:31:23 发布 · 置顶 · 199 阅读

0 ·

CC 4.0 BY-SA版权

java 专栏收录该内容

44 篇文章

订阅专栏

部署运行你感兴趣的模型镜像

本文仅是个人学习中的理解，如有问题欢迎大家批评指正

设计模式中的工厂模式有3种:简单工厂模式（Simple Factory Pattern）、工厂方法模式（Factory Method Pattern）和抽象工厂模式(Abstract Factory Pattern),这三种模式没有好坏之分，只看是否适合自己的业务需要。个人理解工厂模式就是把变化的部分抽象成接口或抽象类，利用OOP中的多态性，设计更容易扩展的程序。

简单工厂模式（Simple Factory Pattern）

简单工厂模式通俗的理解是对外部提供了一个新建实例的工具类。此模式有3种角色构成:

1、具体工厂角色：是简单工厂模式的核心，一般内部会有业务逻辑。根据逻辑生产不同的产品

2、抽象产品角色：是某一类产品的父类或者接口，父类的继承或者方法的实现是由子类去完成的。

3、具体产品角色：是该类产品下某一款具体的产品

代码实例如下：

a、具体工厂角色

package factory.simpleFactory;

/**
 * 食用油的工厂类
 */
public class SimpleFactory {
    public static Object create(Class<?> clazz){
        if(LuHuaOil.class.getName().equals(clazz.getName())){
            return initLuHua();
        }else if(JinLongYuOil.class.getName().equals(clazz.getName())){
            return initJinLongYu();
        }else{
            System.out.println("没有此对象");
            return null;
        }
    }
    /*
     实例化鲁花花生油
     */
    private static LuHuaOil initLuHua(){
        return new LuHuaOil();
    }
    /*
     实例化金龙鱼花生油
     */
    private static JinLongYuOil initJinLongYu(){
        return new JinLongYuOil();
    }
}

b、抽象产品角色

package factory.simpleFactory;

/**
 *食用油
 *@author jerry
 * @date 2018-02-18
 *
 */
public abstract class PeanutOil {
    /*
    描述食用油
     */
    public abstract void description();
}

c、具体产品角色

package factory.simpleFactory;

/**
 * 金龙鱼花生油
 */
public class JinLongYuOil extends PeanutOil{

    @Override
    public void description() {
        System.out.println("金龙鱼花生油好吃!!!");
    }
}

package factory.simpleFactory;

/**
 * 鲁花花生油
 */
public class LuHuaOil extends PeanutOil {
    @Override
    public void description() {
        System.out.println("鲁花花生油好吃!!!");
    }
}

测试类

package factory.simpleFactory;

public class SimpleFactoryTest {
    public static void main(String args[]){
        SimpleFactory sf=new SimpleFactory();
        LuHuaOil luHuaOil=(LuHuaOil)sf.create(LuHuaOil.class);
        luHuaOil.description();

        JinLongYuOil jinLongYuOil=(JinLongYuOil)sf.create(JinLongYuOil.class);
        jinLongYuOil.description();
    }
}

测试结果如下：

通过以上代码可以发现，简单工厂模式是对象实例化集中管理，不需要用户显示的实例化。当然缺点也是很明显的，扩展不灵活，每增加一个具体的产品都需要修改工厂类，不符合闭环原则（Open Closed princple）

工厂方法模式（Factory Method Pattern）

工厂方法模式是在简单工厂模式的基础上做了优化和调整，简单理解是把工厂类也进行了抽象。工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化哪一个，工厂方法把类的实例化推迟到了子类。

此模式下有4种角色
1、抽象产品角色 2、具体产品角色 3、抽象工厂角色 4、具体工厂角色

代码示例如下：

a、抽象产品角色

package factory.factoryMethod;

/**
 * 食用油
 * @author jerry
 *
 */
public interface IEdibleOil {
    /*
      美味的
     */
    public void delicious();
}

b、具体产品角色

package factory.factoryMethod;


/**
 * 花生油
 */
public class PeanutOil implements IEdibleOil {

    @Override
    public void delicious() {
        System.out.println("PeanutOil is delicious!");
    }
}

package factory.factoryMethod;

/**
 * 大豆油
 */
public class SoybeanOil implements IEdibleOil {
    @Override
    public void delicious() {
        System.out.println("SoybeanOil is delicious!");
    }
}

c、抽象工厂角色

package factory.factoryMethod;
/**
 * 油的抽象工厂类
 * @author jerry
 *
 */
public abstract class OilFactory {
    /*
        实例化对象
     */
    public abstract IEdibleOil initOil();
}

d、具体工厂角色

package factory.factoryMethod;
/**
 *
 * 花生油工厂
 */
public class PeanutOilFactory extends OilFactory{


    @Override
    public IEdibleOil initOil() {
        return new PeanutOil();
    }
}

package factory.factoryMethod;

/**
 * 大豆油工厂
 */
public class SoybeanOilFactory extends OilFactory {

    @Override
    public IEdibleOil initOil() {
        return new SoybeanOil();
    }
}

测试类：

package factory.factoryMethod;

/**
 * 测试类
 */
public class FactoryMethodTest {
    public static void main(String args[]){
        //大豆油
    OilFactory soilFactory=new SoybeanOilFactory();
    IEdibleOil iEdibleOil= soilFactory.initOil();
    iEdibleOil.delicious();
        //花生油
    OilFactory poilFactory=new PeanutOilFactory();
    IEdibleOil piEdibleOil= poilFactory.initOil();
    piEdibleOil.delicious();
    }
}

测试结果：


抽象工厂模式(Abstract Factory Pattern)
抽象工厂模式是在方法工厂模式基础上，产品变的更复杂了，有了产品族的概念。
此模式的角色有a、抽象工厂 b、具体工厂（多个）c、抽象产品（多个） d、具体产品（多个）
具体代码如下：
a、抽象工厂

package factory.abstractFactory;

/**
 * 油的抽象工厂类
 * @author jerry
 *
 */
public abstract class OilFactory {
    /*
        实例化对象
     */
    public abstract IEdibleOil initOil();
    public abstract ITransgene transgene();
}

b、具体工厂

package factory.abstractFactory;

/**
 *
 * 花生油工厂
 */
public class PeanutOilFactory extends OilFactory {


    @Override
    public IEdibleOil initOil() {

        return new PeanutOil();
    }

    @Override
    public ITransgene transgene() {
        return new TransgenePeanut();
    }
}

package factory.abstractFactory;

/**
 * 大豆油工厂
 */
public class SoybeanOilFactory extends OilFactory {

    @Override
    public IEdibleOil initOil() {
        return new SoybeanOil();
    }

    @Override
    public ITransgene transgene() {
        return new TransgeneSoybean();
    }
}

c、抽象产品

package factory.abstractFactory;

/**
 * 食用油
 * @author jerry
 *
 */
public interface IEdibleOil {
    /*
      美味的
     */
    public void delicious();
}

package factory.abstractFactory;

/**
 * 转基因接口
 */
public interface ITransgene {
    /*
      是否是转基因产品
     */
    public void isTransgene();
}

d、具体产品

package factory.abstractFactory;


/**
 * 花生油
 */
public class PeanutOil implements IEdibleOil {

    @Override
    public void delicious() {
        System.out.println("PeanutOil is delicious!");
    }
}

package factory.abstractFactory;

/**
 * 大豆油
 */
public class SoybeanOil implements IEdibleOil {
    @Override
    public void delicious() {
        System.out.println("SoybeanOil is delicious!");
    }

}

package factory.abstractFactory;

public class TransgenePeanut implements ITransgene {

    @Override
    public void isTransgene() {
        System.out.println("This is TransgenePeanut,Not natural oil");
    }
}

package factory.abstractFactory;

public class TransgeneSoybean implements ITransgene {
    @Override
    public void isTransgene() {
        System.out.println("This is TransgeneSoybean,Not natural oil");
    }
}

测试类

package factory.abstractFactory;

/**
 * 测试类
 */
public class FactoryMethodTest {
    public static void main(String args[]){
        //大豆油
    OilFactory soilFactory=new SoybeanOilFactory();
    IEdibleOil iEdibleOil= soilFactory.initOil();
    iEdibleOil.delicious();
    ITransgene iTransgene=soilFactory.transgene();
    iTransgene.isTransgene();

        //花生油
    OilFactory poilFactory=new PeanutOilFactory();
    IEdibleOil piEdibleOil= poilFactory.initOil();
    piEdibleOil.delicious();
    ITransgene piTransgene=poilFactory.transgene();
    piTransgene.isTransgene();
    }

}