设计模式之工厂模式

工厂模式:

　　工厂模式,也是最常见的模式之一,属于创建型模式,列如Spring的bean就是被BeanFactory管理的

工厂模式又细分为三种工厂:

　　简单工厂模式

　　工厂方法模式

　　抽象工厂模式

简单工厂模式:

　　简单工厂是,通过对Bean的创建,分离由统一的工厂生产对象,通过参数辨别

创建基础Bean类:

package jms.create.factory.simple.interfaces;

/**
 * 字母接口
 * @author ZYGisComputer
 */
public interface Zm {

    /**
     * 输出方法
     */
    void print();

}

创建子类:

package jms.create.factory.simple.entity;

import jms.create.factory.simple.interfaces.Zm;

/**
 * A类
 * @author ZYGisComputer
 */
public class A implements Zm {

    @Override
    public void print() {
        System.out.println("I am A!");
    }

}

package jms.create.factory.simple.entity;

import jms.create.factory.simple.interfaces.Zm;

/**
 * B类
 * @author ZYGisComputer
 */
public class B implements Zm {

    @Override
    public void print() {
        System.out.println("I am B!");
    }

}

创建工厂接口类:

package jms.create.factory.simple.factory;

import jms.create.factory.simple.interfaces.Zm;

/**
 * 工厂接口
 * @author ZYGisComputer
 */
public interface AbstractZmFactory {

    /**
     * 创建字母工厂
     * @param tClass 类型
     * @param <T> 泛型必须继承字母接口
     * @return 字母类
     */
    <T extends Zm> T createZm(Class<T> tClass);

}

创建工厂实现类

package jms.create.factory.simple.factory;

import jms.create.factory.simple.interfaces.Zm;

/**
 * 字母工厂
 * @author ZYGisComputer
 */
public class ZmFactory implements AbstractZmFactory{


    @Override
    public <T extends Zm> T createZm(Class<T> tClass) {
        Zm zm = null;
        try {
            zm = (T)Class.forName(tClass.getName()).newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return (T)zm;
    }
}

创建客户端调用类:

package jms.create.factory.simple;

import jms.create.factory.simple.entity.A;
import jms.create.factory.simple.entity.B;
import jms.create.factory.simple.factory.AbstractZmFactory;
import jms.create.factory.simple.factory.ZmFactory;

/**
 * 调用客户端
 * @author ZYGisComputer
 */
public class Client {

    public static void main(String[] args) {

        // 创建工厂
        AbstractZmFactory abstractZmFactory = new ZmFactory();

        // 通过类型进行创建
        A zm = abstractZmFactory.createZm(A.class);
        zm.print();
        B zm1 = abstractZmFactory.createZm(B.class);
        zm1.print();

    }

}

执行结果:

I am A!
I am B!

以上就是简单工厂模式的实现了,就是实现了,使用者和具体创建对象之间的隔离,简单工厂采用统一工厂创建了所有的统一类型的类

工厂方法模式:

　　和简单工厂模式中工厂负责生产所有产品相比，工厂方法模式将生成具体产品的任务分发给具体的产品工厂

工厂接口类:

package jms.create.factory.factory;

import jms.create.factory.simple.interfaces.Zm;

/**
 * 字母工厂
 * @author ZYGisComputer
 */
public interface AbsZmFactory {

    Zm createZm();

}

工厂实现类,多个具体实现类

package jms.create.factory.factory;

import jms.create.factory.simple.entity.A;
import jms.create.factory.simple.interfaces.Zm;

public class AFactory implements AbsZmFactory {

    @Override
    public Zm createZm() {
        return new A();
    }
}

package jms.create.factory.factory;

import jms.create.factory.simple.entity.B;
import jms.create.factory.simple.interfaces.Zm;

public class BFactory implements AbsZmFactory {

    @Override
    public Zm createZm() {
        return new B();
    }

}

实体类采用上面创建的Zm,A,B

调用类

package jms.create.factory.factory;

import jms.create.factory.simple.interfaces.Zm;

public class Client {
    public static void main(String[] args) {

        // 创建工厂类
        AbsZmFactory a = new AFactory();
        Zm zm = a.createZm();
        zm.print();
        a = new BFactory();
        Zm zm1 = a.createZm();
        zm1.print();

    }
}

执行结果:

I am A!
I am B!

以上是工厂方法的代码,通过代码可以看出来,工厂方法是将各个种类不同的工厂,分开

抽象工厂模式:

　　其实抽象工厂模式,在我看来,就是将同一种业务类型的,接口放入统一的工厂中,比如上面的工厂能生产大写的A,那么小写的a自然也能,生产,属于同一种类型,所以可以放在一起,感觉这么说有些牵强,换一种说法,就像是我们生产水果,比如苹果,同时还能生产苹果的包装这就是抽象工厂

总结:

　　其实三种工厂是不区分高不高级的,实际应用时能解决问题满足需求即可，可灵活变通，无所谓高级与低级。

作者：彼岸舞

时间：2020112

内容关于：设计模式

本文来源于网络，只做技术分享，一概不负任何责任