设计模式学习笔记(2) --简单工厂

最新推荐文章于 2024-05-02 17:01:34 发布

无悔_一叶扁舟

最新推荐文章于 2024-05-02 17:01:34 发布

阅读量135

点赞数

文章标签：设计模式简单工厂

本文链接：https://blog.csdn.net/u011662320/article/details/83549500

版权

设计模式专栏收录该内容

16 篇文章 0 订阅

订阅专栏

1.定义:

简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

2.UML图：

3.代码:

package com.skiff.www.factory.simplefactory.fruit;

/**
 * @author 一叶扁舟(skiff)
 * @ClassName: AbstractFruit
 * @Description:
 * @create 2018-08-03 14:13
 **/
//Product：抽象产品角色
public abstract class AbstractFruit {

    public abstract  void eat();
}

package com.skiff.www.factory.simplefactory.fruit;

/**
 * @author 一叶扁舟(skiff)
 * @ClassName: Apple
 * @Description:
 * @create 2018-08-03 14:14
 **/
//ConcreteProduct：具体产品角色
public class Apple extends AbstractFruit {
    @Override
    public void eat() {
        System.out.println("正在吃苹果。。。。。");
    }
}

package com.skiff.www.factory.simplefactory.fruit;

/**
 * @author 一叶扁舟(skiff)
 * @ClassName: Orange
 * @Description:
 * @create 2018-08-03 14:17
 **/
//ConcreteProduct：具体产品角色
public class Orange extends AbstractFruit {
    @Override
    public void eat() {
        System.out.println("正在吃橘子。。。。。");
    }
}

package com.skiff.www.factory.simplefactory.fruit;

/**
 * @author 一叶扁舟(skiff)
 * @ClassName: SimpleFactory
 * @Description:
 * 模式结构
        简单工厂模式包含如下角色：
        Factory：工厂角色
        Product：抽象产品角色
        ConcreteProduct：具体产品角色

 * @create 2018-08-03 14:18
 **/
//Factory：工厂角色
public class SimpleFactory {

    /**
     * 根据传入的参数，创建出具体的对象
     * @param fruitName
     * @return
     */
    public static AbstractFruit getFruit1(String fruitName) throws Exception{
        if(fruitName.equalsIgnoreCase("apple")){
            return new Apple();
        }else if(fruitName.equalsIgnoreCase("orange")){
            return new Orange();
        }else {
            System.out.println("没有这个水果");
            return null;
        }
    }

    /**
     * 利用反射获取对应的对象，特别要注意：这个传入的参数，一定是一个真实的类名
     * @param fruitName
     * @return
     * @throws Exception
     */
    public static AbstractFruit getFruit2(String fruitName) throws Exception{
        Class fruit = Class.forName("com.skiff.www.factory.simplefactory.fruit." + fruitName);
        return (AbstractFruit) fruit.newInstance();
    }
}

package com.skiff.www.factory.simplefactory.fruit;

import org.junit.Test;

/**
 * @author 一叶扁舟(skiff)
 * @ClassName: TestSimpleFactory
 * @Description:
 * @create 2018-08-03 14:29
 **/
public class TestSimpleFactory {
    @Test
    public void eatFruit1(){
        try {
            AbstractFruit apple = SimpleFactory.getFruit1("Apple");
            apple.eat();

            AbstractFruit orange = SimpleFactory.getFruit1("Orange");
            orange.eat();

            AbstractFruit branner = SimpleFactory.getFruit1("Branner");
            branner.eat();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    @Test
    public void eatFruit2() throws Exception{
        AbstractFruit apple = SimpleFactory.getFruit2("Apple");
        apple.eat();

        AbstractFruit orange = SimpleFactory.getFruit2("Orange");
        orange.eat();
    }

}

4.简单工厂优缺点：

（1）、简单工厂模式的优点

工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品；简单工厂模式通过这种做法实现了对责任的分割，它提供了专门的工厂类用于创建对象。

（2）、简单工厂模式的缺点

由于工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。使用简单工厂模式将会增加系统中类的个数，在一定程序上增加了系统的复杂度和理解难度。

系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。

5.简单工厂的应用：

模式适用环境：

在以下情况下可以使用简单工厂模式：工厂类负责创建的对象比较少：由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂。

客户端只知道传入工厂类的参数，对于如何创建对象不关心：客户端既不需要关心创建细节，甚至连类名都不需要记住，只需要知道类型所对应的参数。

（1）、模式应用1

在JDK类库中广泛使用了简单工厂模式，如工具类java.text.DateFormat，它用于格式化一个本地日期或者时间

public final static DateFormat getDateInstance();

public final static DateFormat getDateInstance(int style);

public final static DateFormat getDateInstance(int style,Locale locale);

（2）、模式应用2

Java加密技术

//获取不同加密算法的密钥生成器 KeyGenerator keyGen=KeyGenerator.getInstance("DESede");

//创建密码器 Cipher cp=Cipher.getInstance("DESede");

例子:

package com.skiff.www.factory.simplefactory;

import org.junit.Test;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

/**
 * @Auther: 一叶扁舟
 * @Date: 2018/10/30 22:11
 * @Description:
 */
public class JDKDate {

    //    public final static DateFormat getDateInstance();
//    public final static DateFormat getDateInstance(int style);
//    public final static DateFormat getDateInstance(int style, Locale locale);
//
    @Test
    public void testDate() {

        DateFormat dateFormat = DateFormat.getDateInstance();
//        格式化日期:2018-10-30
        String format = dateFormat.format(new Date());
        System.out.println("格式化日期:" + format);
        String format1 = DateFormat.getTimeInstance().format(new Date());
//        格式化日期时间:22:20:46
        System.out.println("格式化时间:" + format1);
        String format2 = new SimpleDateFormat().format(new Date());
        System.out.println("使用simpleDateFormat:"+format2);

        String format3 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date());
        System.out.println("使用simpleDateFormat:"+format3);
    }
}

例子：

package com.skiff.www.factory.simplefactory.encode;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;

/**
 * @Auther: 一叶扁舟
 * @Date: 2018/10/30 21:58
 * @Description:
 */
public class DESEncrypt {


    public static void main(String args[])
    {
        String codeStringBegin="一叶扁舟(skiff)";  //要加密的明文
        String codeStringEnd=null;             //加密后的密文
        String decodeString=null;              //密文解密后得到的明文
        String cipherType = "DESede"; //加密算法类型，可设置为DES、DESede、AES等字符串
        try
        {
            //获取密钥生成器
            KeyGenerator keyGen=KeyGenerator.getInstance(cipherType);
            //初始化密钥生成器，不同的加密算法其密钥长度可能不同
            keyGen.init(112);
            //生成密钥
            SecretKey key=keyGen.generateKey();

            //得到密钥字节码
            byte[] keyByte=key.getEncoded();
            //输出密钥的字节码
            System.out.println("密钥是：");
            for(int i=0;i<keyByte.length;i++)
            {
                System.out.print(keyByte[i]+",");
            }
            System.out.println("");
            //创建密码器
            Cipher cp=Cipher.getInstance(cipherType);
            //初始化密码器
            cp.init(Cipher.ENCRYPT_MODE,key);
            System.out.println("要加密的字符串是："+ codeStringBegin);
            byte[] codeStringByte=codeStringBegin.getBytes("UTF8");
            System.out.println("要加密的字符串对应的字节码是：");
            for(int i=0;i<codeStringByte.length;i++)
            {
                System.out.print(codeStringByte[i]+",");
            }
            System.out.println("");
            //开始加密
            byte[] codeStringByteEnd=cp.doFinal(codeStringByte);
            System.out.println("加密后的字符串对应的字节码是：");
            for(int i=0;i<codeStringByteEnd.length;i++)
            {
                System.out.print(codeStringByteEnd[i]+",");
            }
            System.out.println("");
            codeStringEnd=new String(codeStringByteEnd);
            System.out.println("加密后的字符串是：" + codeStringEnd);
            System.out.println("");
            //重新初始化密码器
            cp.init(Cipher.DECRYPT_MODE,key);
            //开始解密
            byte[] decodeStringByteEnd=cp.doFinal(codeStringByteEnd);
            System.out.println("解密后的字符串对应的字节码是：");
            for(int i=0;i<decodeStringByteEnd.length;i++)
            {
                System.out.print(decodeStringByteEnd[i]+",");
            }
            System.out.println("");
            decodeString=new String(decodeStringByteEnd);
            System.out.println("解密后的字符串是：" + decodeString);
            System.out.println("");
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
}

6.总结：

（1）、创建型模式对类的实例化过程进行了抽象，能够将对象的创建与对象的使用过程分离。简单工厂模式又称为静态工厂方法模式，它属于类创建型模式。

（2）、在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

（3）、简单工厂模式包含三个角色：

工厂角色负责实现创建所有实例的内部逻辑；

抽象产品角色是所创建的所有对象的父类，负责描述所有实例所共有的公共接口；

具体产品角色是创建目标，所有创建的对象都充当这个角色的某个具体类的实例。

（4）、简单工厂模式的要点在于：

当你需要什么，只需要传入一个正确的参数，就可以获取你所需要的对象，而无须知道其创建细节。

简单工厂模式最大的优点在于实现对象的创建和对象的使用分离，将对象的创建交给专门的工厂类负责，但是其最大的缺点在于

工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑代码，而且产品较多时，工厂方法代码将会非常复杂。

简单工厂模式适用情况包括：工厂类负责创建的对象比较少；客户端只知道传入工厂类的参数，对于如何创建对象不关心。

无悔_一叶扁舟

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式学习笔记(2) --简单工厂

1.定义:简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。2.UML图：3.代码:package com.skiff.www.facto...
复制链接

扫一扫