设计模式-工厂方法模式

最新推荐文章于 2024-07-28 11:55:02 发布
原创 最新推荐文章于 2024-07-28 11:55:02 发布 · 189 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

例子：女娲造人
类图：
这里写图片描述
这个过程我们就用程序来实现，首先定义一个人类的总称：

/**
 * Created by xpeng on 2018/5/1.
 * 定义一个人类的统称
 */

public interface Human {
    //首先定义什么是人类

    //人是会笑的
    public void laugh();

    //人类还会哭
    public void cry();

    //人类会说话
    public void talk();
}

然后定义具体的人类：

/**
 * Created by xpeng on 2018/5/1.
 * 黄色人类
 */

public class YellowHuman implements Human {
    @Override
    public void cry() {
        Log.e("xyz","黄色人类会哭");
    }

    @Override
    public void laugh() {
        Log.e("xyz","黄色人类会笑");
    }

    @Override
    public void talk() {
        Log.e("xyz","黄色人类会说话");
    }
}
/**
 * Created by xpeng on 2018/5/1.
 * 白色人类
 */

public class WhiteHuman implements Human {
    @Override
    public void cry() {
        Log.e("xyz","白色人类会哭");
    }

    @Override
    public void laugh() {
        Log.e("xyz","白色人类会笑");
    }

    @Override
    public void talk() {
        Log.e("xyz","白色人类会说话");
    }
}
/**
 * Created by xpeng on 2018/5/1.
 * 黑色人类
 */

public class BlackHuman implements Human {
    @Override
    public void cry() {
        Log.e("xyz","黑色人类会哭");
    }

    @Override
    public void laugh() {
        Log.e("xyz","黑色人类会笑");
    }

    @Override
    public void talk() {
        Log.e("xyz","黑色人类会说话");
    }
}

定义八卦炉（工厂）

/**
 * Created by xpeng on 2018/5/1.
 * 女娲八卦炉造人
 */

public class HumanFactory {

    //定一个烤箱，泥巴塞进去，人就出来，这个老厉害了
    public static Human createHuman(Class c) {
        Human human = null;

        try {
                human = (Human) Class.forName(c.getName()).newInstance();
        } catch (InstantiationException e) {
            Log.e("xyz", " 必须指定人类的颜色 ");
        } catch (IllegalAccessException e) {//定义的人类有问题
            Log.e("xyz", " 人类定义错误！ ");
        } catch (ClassNotFoundException e) {
            Log.e("xyz", " 混蛋，你指定的人类找不着 ");
        }
        return human;
    }

}

女娲大神造人了

    Log.e("xyz"," 造出的第一批人是这样的：白人 ");

       Human whiteHuman = HumanFactory.createHuman(WhiteHuman.class);
       whiteHuman.cry();
       whiteHuman.laugh();
       whiteHuman.talk();

       Log.e("xyz"," 造出的第二批人是这样的：黑人 ");
        Human blackHuman = HumanFactory.createHuman(BlackHuman.class);
        blackHuman.cry();
        blackHuman.laugh();
        blackHuman.talk();

        Log.e("xyz"," 造出的第二批人是这样的：黄色人类 ");
        Human yellowHuman = HumanFactory.createHuman(YellowHuman.class);
        yellowHuman.cry();
        yellowHuman.laugh();
        yellowHuman.talk();

人有了，但是这样创建太累了，神仙也会累的，那怎么办？我塞进去一团泥巴，随机出来一群人，管他什么颜色呢，只要是人就行。
类图：
这里写图片描述

/**
 * Created by xpeng on 2018/5/1.
 * 女娲八卦炉造人
 */

public class HumanFactory {

    //定一个烤箱，泥巴塞进去，人就出来，这个老厉害了
    public static Human createHuman(Class c) {
        Human human = null;

        try {
                human = (Human) Class.forName(c.getName()).newInstance();

        } catch (InstantiationException e) {
            Log.e("xyz", " 必须指定人类的颜色 ");
        } catch (IllegalAccessException e) {//定义的人类有问题
            Log.e("xyz", " 人类定义错误！ ");
        } catch (ClassNotFoundException e) {
            Log.e("xyz", " 混蛋，你指定的人类找不着 ");
        }
        return human;
    }

    //女娲生气了，把一团泥巴塞到八卦炉，爱产生啥人类就啥人类
    public static Human createHuman() {
        Human human = null;//定义一个类型的人类
        try {
            //定义了多少人类
            List<Class> concreateHumanList = ClassUtils.getAllClassByInterface(Human.class);
            //八卦炉自己开始想烧出什么人就什么人
            Random random = new Random();
            int rand = random.nextInt(concreateHumanList.size());
            human = createHuman(concreateHumanList.get(rand));
        }catch (Exception e){
            Log.e("xyz","这里需要好好思考研究");
        }

        return human;
    }

}

女娲生气了，把一团泥巴塞进去，爱出来什么颜色的人类随意

 //女娲生气了，把一团泥巴塞到八卦炉，爱产生啥人类就啥人类
    public static Human createHuman() {
        Human human = null;//定义一个类型的人类
        try {
            //定义了多少人类
            List<Class> concreateHumanList = ClassUtils.getAllClassByInterface(Human.class);
            //八卦炉自己开始想烧出什么人就什么人
            Random random = new Random();
            int rand = random.nextInt(concreateHumanList.size());
            human = createHuman(concreateHumanList.get(rand));
        }catch (Exception e){
            Log.e("xyz","这里需要好好思考研究");
        }

        return human;
    }

这里还需要一个类，ClassUtils

/**
 * Created by xpeng on 2018/5/2.
 */

public class ClassUtils {
    //给一个接口，返回这个接口的所有实现类
    public static List<Class> getAllClassByInterface(Class c) {
        List<Class> returnClassList = new ArrayList<Class>();//返回结果

        //如果不是一个接口，则不做处理
        if (c.isInterface()) {
            String packageName = c.getPackage().getName(); //获得当前包名
            try {
                //获得当前包下以及子包下的所有类
                List<Class> allClass = getClasses(packageName);
                //判断是否是同一个接口
                for (int i = 0; i < allClass.size(); i++) {
                    if (c.isAssignableFrom(allClass.get(i))) {//判断是不是同一个接口
                        if (!c.equals(allClass.get(i))) {//本身不加进去
                            returnClassList.add(allClass.get(i));
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }


        }
        return returnClassList;

    }

    //从一个包中查找所有的类，在jar包中不能查找
    private static List<Class> getClasses(String packageName) throws ClassNotFoundException, IOException {
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        String path = packageName.replace('.', '/');
        Enumeration<URL> resources = classLoader.getResources(path);
        List<File> dirs = new ArrayList<File>();
        while (resources.hasMoreElements()) {
            URL resource = resources.nextElement();
            dirs.add(new File(resource.getFile()));
        }
        ArrayList<Class> classes = new ArrayList<Class>();
        for (File directory : dirs) {
            classes.addAll(findClasses(directory, packageName));
        }
        return classes;
    }


    private static List<Class> findClasses(File directory, String packageName) throws ClassNotFoundException {
        List<Class> classes = new ArrayList<Class>();
        if (!directory.exists()) {
            return classes;
        }
        File[] files = directory.listFiles();
        for (File file : files) {
            if (file.isDirectory()) {
                assert !file.getName().contains(".");
                classes.addAll(findClasses(file, packageName + "." + file.getName()));
            } else if (file.getName().endsWith(".class")) {
                classes.add(Class.forName(packageName + "." + file.getName().substring(0, file.getName().length() - 6)));
            }
        }
        return classes;
    }

}

这个ClassUtils可是个宝，用处可大了去了，可以由一个接口查找所有实现的类，也可以由父类查找到所有的子类，这个要自己修改一下，需要思考一下
完整类图：
这里写图片描述

总结一下，特别是增加了createHuman()后，是不是这个工厂vhangde扩展性更好了？只要你继续集成Human接口就成了，然后啥也不用修改就可以生产了，具体产多少，八卦炉说了算，简单工厂模式就是这么简单。

工厂方法模式还有一个非常重要的应用，就是延迟始化，直接从内存中拿就行了，怎么实现呢，很简单：

/**
 * Created by xpeng on 2018/5/1.
 * 女娲八卦炉造人
 */

public class HumanFactory {

    //定义一个MAP，初始化过的Human对象都放在这里
    private static HashMap<String,Human> humans = new HashMap<String,Human>();

    //定一个烤箱，泥巴塞进去，人就出来，这个老厉害了
    public static Human createHuman(Class c) {
        Human human = null;

        try {
            //如果MAP中有，则直接从中取出，不用初始化
            if (humans.containsKey(c.getSimpleName())){
                //产生一个人类
                human = humans.get(c.getSimpleName());
            }else {
                human = (Human) Class.forName(c.getName()).newInstance();
                //放到MAP中
                humans.put(c.getSimpleName(),human);
            }

        } catch (InstantiationException e) {
            Log.e("xyz", " 必须指定人类的颜色 ");
        } catch (IllegalAccessException e) {//定义的人类有问题
            Log.e("xyz", " 人类定义错误！ ");
        } catch (ClassNotFoundException e) {
            Log.e("xyz", " 混蛋，你指定的人类找不着 ");
        }
        return human;
    }

    //女娲生气了，把一团泥巴塞到八卦炉，爱产生啥人类就啥人类
    public static Human createHuman() {
        Human human = null;//定义一个类型的人类
        try {
            //定义了多少人类
            List<Class> concreateHumanList = ClassUtils.getAllClassByInterface(Human.class);
            //八卦炉自己开始想烧出什么人就什么人
            Random random = new Random();
            int rand = random.nextInt(concreateHumanList.size());
            human = createHuman(concreateHumanList.get(rand));
        }catch (Exception e){
            Log.e("xyz","这里需要好好思考研究");
        }

        return human;
    }

}

就是定义一个MAP，这个类初始化很消耗资源的情况下比较实用，比如你要连接硬件，或者初始化一个类需要准备比较多的条件（参数），通过这种方式可以减少项目的复杂度。
最后引入一个问题：人是有性别的啊，有男有女，你这怎么没区别，这个需要下一个讲的模式：抽象工厂模式

23种设计模式-工厂方法(Factory Method)设计模式
片言可决讼，半纸能缚龙
11-28 1902
软考中级-软件设计师 工厂方法模式
获得指定接口的所有实现类(实现类需位于接口所在的包或其子包中)
Justin的专栏
10-23 984
1 关键代码位于“ClassUtils.java”中，如下所示 package com.cbf4life; import java.io.File; import java.io.IOException; import java.net.URL; import java.util.ArrayList; import java.util.Enumeration; import java
反射的一些使用方式
weixin_34174422的博客
07-27 172
2019独角兽企业重金招聘Python工程师标准>>> ...
c++：继承（超详解）
热门推荐
qq_62718027的博客
07-22 8万+
目录一：什么是继承二：继承的格式继承的总结：二：子类和父类（基类和派生类）1.子类和父类的相互赋值：2.同名的成员变量3.同名成员函数三：子类中默认的成员函数1.构造函数2.析构函数3.拷贝构造4.赋值运算符重载 四：单继承和多继承单继承： 多继承：菱形继承解决方法一：解决方法二：单继承和多继承的总结：定义：继承(inheritance)机制是面向对象程序设计中使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能。这样产生的新类，称派生类（或子类），被继承的类称基类（或父类）
Java设计模式——工厂模式（Factory Pattern）
http://itzones.cn
09-11 515
情景一 描述：女娲补天的故事大家都听说过吧，今天不说这个，说女娲创造人的故事，可不是“造人”的工作，这个词被现代人滥用了。这个故事是说，女娲在补了天后，下到凡间一看，哇塞，风景太优美了，天空是湛蓝的，水是清澈的，空气是清新的，太美丽了，然后就待时间长了就有点寂寞了，没有动物，这些看的到 都是静态的东西呀，怎么办？         别忘了是神仙呀，没有办不到的事情，于是女娲就架起了八卦炉（技术
Python的类
sinat_33731745的博客
02-12 571
类的定义 class Human(object): def eat(self): print('I can eat') DoctorLiu = Human() DoctorLiu.eat() I can eat class Human(object)定义一个类叫做Human，Human类继承了object这个类，object类是python内的一个基础类，所...
《您的设计模式》（CBF4LIFE）之“工厂方法模式”【整理】
遥远征程的专栏
10-27 447
故事背景：女娲造人，女娲架起八卦炉（技术术语：建立工厂）开始创建人，具体过程是这样的：先是捏泥巴，然后放八卦炉里烤，再扔到地上成长，但是意外总是会产生的： 第一次烤泥人，一个白人诞生了；第二次烤泥人，一个黑人；第三次烤泥人，黄种人。 首先定义一个人类总称： package com.teng.pattern.impl; /** * 人类接口 * 创建日期：2016年6月22日
c++设计模式-工厂方法模式
06-04
在标题“c++设计模式-工厂方法模式”中，我们关注的是如何在C++中实现工厂方法这一设计模式。工厂方法模式的核心思想是定义一个创建对象的接口，但让子类决定实例化哪一个类。这样，工厂方法可以使类的实例化过程...
设计模式-工厂方法模式(C#)
11-20
设计一个程序来读取多种不同存储格式的图片，针对每一种图片格式都设计一个图片读取器（ImageReader），如GIF格式图片读取器（GifReader）用于读取...请使用工厂方法模式实现该程序的设计，并使用UML画出该模式的类图。
Python设计模式 - 工厂方法模式
最新发布
mofei
07-28 827
工厂方法模式是一种创建型设计模式，它定义一个创建对象的接口，让其子类来处理对象的创建，而不是直接实例化对象。
每日一题（四七）class Human{static str = aaa sayStr = ()={throw new Error(need to implconst leo = new Stud
MFWSCQ的博客
06-05 270
class Human{ static str = 'aaa'; sayStr = ()=>{ throw new Error('need to implement'); } } class Student extends Human{ constructor(){ super(); } sayStr(){ console.log(Student.str) } } const leo = n.
android 定期调用接口,Android 自动实例化实现某接口的所有类，并调用接口方法...
weixin_39910043的博客
05-31 381
接口 InitializerInterface.javaimport android.content.Context;public interface InitializerInterface {void init(Context context);}实现类 LoggerInitializer.javaimport android.content.Context;import com.hbz.co...
【java设计模式】之 工厂（Factory）模式
武哥聊编程
04-23 3万+
1.工厂模式的定义         工厂模式使用的频率非常高，我们在开发中总能见到它们的身影。其定义为：Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation t...
设计模式之工厂模式
weixin_36838693的博客
09-09 338
工厂模式实现简介： 1.工厂模式定义了统一的接口和众多实现类，工厂模式生成实现类对象的方式是通过定义的ClassUtils中静态方法getAllClassByInterface(Class c)实现的， 1.首先获传入的接口全路径包名  // c.getPackage().getName(); 2.通过类加载机制获取列表文件信息 3.通过文件信息反射创建类对象 代码示例如下： 1.接口...
Java 定义类Human，具有若干属性和功能；定义其子类Man、Woman；在主类TestHuman中测试其特性
SummerSoul的博客
05-04 4273
题目： 【问题描述】 定义类Human，具有若干属性和功能；定义其子类Man、Woman；在主类TestHuman中测试其特性。 【输入形式】 无 【输出形式】 my name is:Dave my age is:28 my sex is:man I am a man. I am a strong man. my name is:Jude my age is:58 my sex is:woman I am a woman. I am a beautiful woman. 【样例输入】 无 【样例输出】 my
class 构造与析构
knight
02-01 619
#include class human { public: human(){ human_num++;}; //默认构造函数 static int human_num;     //静态成员 ~human() { human_num--; print(); } void print()             // { cout } protected: pri
python Class 类的交互随笔
qq_25846269的博客
07-03 195
class human: '''人类''' def __init__(self, name, age, happyVal=0, moneyVal=0, owned=[], woman=True, Belover=[], Annoying=[]) -> None: '''人类初始化''' if woman: self.gender = 'woman' else: self.gender =.
设计模式——简单工厂模式之女娲造人
huang498的博客
04-28 7302
设计模式——简单工厂模式之女娲造人
理解Java设计模式：工厂方法模式详解
"Java设计模式中的工厂方法模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。在工厂方法模式中，一个工厂接口用于创建一个对象，但让子类决定实例化哪一个类。工厂方法让类的实例化推迟到子类。这种模式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值