精华内容
下载资源
问答
  • 工厂方法模式实例

    千次阅读 2016-12-25 13:16:27
    题目: 现需要设计一个程序来读取多种不同类型的图片格式,针对每一种图片格式都设计一个图片读取...图片读取器对象通过图片读取器工厂ImageReaderFactory来创建,ImageReaderFactory是一个抽象类,用于定义创建图片读

    题目:

    /*
     * 现需要设计一个程序来读取多种不同类型的图片格式,针对每一种图片格式
     *   都设计一个图片读取器(ImageReader),
     *   如GIF图片读取器(GifReader)用于  读取GIF格式的图片、
     *   JPG图片读取器(JpgReader)用于读取JPG格式的图片。
     *   图片读取器对象通过图片读取器工厂ImageReaderFactory来创建,
     *   ImageReaderFactory是一个抽象类,用于定义创建图片读取器的工厂方法,
     *   其子类GifReaderFactory和JpgReaderFactory用于创建具体的图片读取器对象。
     *   试使用工厂方法模式设计该程序,绘制类图并编程模拟实现。需充分考虑系统的灵活性和可扩展性。 
     * */
    

    类图

    这里写图片描述

    java 程序实现

    ImageReader.java

    package com.yuzhyun.test3.Interface;
    
    public interface ImageReader {
    
    	void read();
    }
    
    

    ImageReaderFactory.java

    package com.yuzhyun.test3.Interface;
    
    public interface ImageReaderFactory {
    
    	ImageReader getImgReader();
    }
    
    

    GifReader.java

    package com.yuzhyun.test3.Concrete;
    
    import com.yuzhyun.test3.Interface.ImageReader;
    
    public class GifReader implements ImageReader {
    
    	@Override
    	public void read() {
    		System.out.println("GifReader is reading ");
    		
    	}
    
    }
    
    

    GifReaderFactory.java

    package com.yuzhyun.test3.Concrete;
    
    import com.yuzhyun.test3.Interface.ImageReader;
    import com.yuzhyun.test3.Interface.ImageReaderFactory;
    
    public class GifReaderFactory implements ImageReaderFactory {
    
    	@Override
    	public ImageReader getImgReader() {
    		
    		return new GifReader();
    	}
    
    }
    
    

    JpgReader.java

    package com.yuzhyun.test3.Concrete;
    
    import com.yuzhyun.test3.Interface.ImageReader;
    
    public class JpgReader implements ImageReader {
    
    	@Override
    	public void read() {
    		System.out.println("JpgReader is reading ");
    		
    	}
    
    }
    
    

    JpgReaderFactory.java

    package com.yuzhyun.test3.Concrete;
    
    import com.yuzhyun.test3.Interface.ImageReader;
    import com.yuzhyun.test3.Interface.ImageReaderFactory;
    
    public class JpgReaderFactory implements ImageReaderFactory {
    
    	@Override
    	public ImageReader getImgReader() {
    		// TODO Auto-generated method stub
    		return new JpgReader();
    	}
    
    }
    
    

    配置文件读取类XMLUtil.java

    package com.yuzhyun.util;
    
    
    
    import java.io.File;
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import org.w3c.dom.Document;
    import org.w3c.dom.Node;
    import org.w3c.dom.NodeList;
    
    public class XMLUtil {
    
    	public static Object getBean(String configFileName,String packageName) {
    
    		try {
    			DocumentBuilderFactory dFactory = DocumentBuilderFactory
    					.newInstance();
    			DocumentBuilder builder = dFactory.newDocumentBuilder();
    			Document document;
    			//配置文件放在项目的根目录下,不是放在src目录下
    			document=builder.parse(new File(configFileName));
    			//获取包含类名的节点 
    			NodeList nodeList=document.getElementsByTagName("className");
    			Node node= nodeList.item(0).getFirstChild();
    			String cName=node.getNodeValue().trim();
    			
    			//通过类名生成实例对象并将其返回
    			//如果没有包名,会报错java.lang.ClassNotFoundException: 
    			Class class1=Class.forName(packageName+cName);
    			Object object=class1.newInstance();
    			return object;
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace(); 
    			return null;
    		} 
    
    	}
    
    }
    
    
    

    客户类Client.java

    package com.yuzhyun.test3;
    
    
    import com.yuzhyun.test3.Interface.ImageReader;
    import com.yuzhyun.test3.Interface.ImageReaderFactory;
    import com.yuzhyun.util.XMLUtil;
    
    public class Client {
    	public static void main(String[] args) {
    		ImageReaderFactory imageReaderFactory;
    		ImageReader imageReader;
    		imageReaderFactory=(ImageReaderFactory) XMLUtil.getBean("config.xml","com.yuzhyun.test3.Concrete.");	
    		imageReader= imageReaderFactory.getImgReader();
    		imageReader.read();
    	}
    }
    
    

    配置文件config.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <config>
    	<className>GifReaderFactory</className>
    </config>
    
    个人小程序推广
    

    在这里插入图片描述

    展开全文
  • 当系统准备为用户提供某个类的子类的实例,又不想让用户代码和该子类形成耦合时,就可以使用...工厂方法模式的关键是在一个接口或抽象类中定义一个抽象方法,下面我们会具体介绍Java使用设计模式中的工厂方法模式实例解析.
  • 本文实例讲述了Python设计模式之工厂方法模式。分享给大家供大家参考,具体如下: 工厂方法模式(Factory Method Pattern):定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使一个类的实例化延时到其...
  • 主要介绍了Android编程设计模式之工厂方法模式,结合实例形式详细分析了Android工厂方法模式的概念、原理、使用方法及相关注意事项,需要的朋友可以参考下
  • 工厂方法模式实例之电视机工厂: 电视机工厂类图: 此节翻译有个难点,实例当中使用了java中的反射机制,而c++原生不支持,需要自己实现,所以参考了其他博客讲解的反射机制,实现了一个简单的反射头文件,相关...

    工厂方法模式实例之电视机工厂:

    电视机工厂类图:

    此节翻译有个难点,实例当中使用了java中的反射机制,而c++原生不支持,需要自己实现,所以参考了其他博客讲解的反射机制,实现了一个简单的反射头文件,相关反射知识将会在最后面讲解。

    抽象产品类TV(电视机类):

    //抽象产品类TV(电视机类) 
    class TV{
    public:
    	virtual void play() = 0;
    };

    具体产品类HaierTV(海尔电视机类):

    //具体产品类HaierTV(海尔电视机类)
    class HaierTV : public TV{
    public:
    	void play(){
    		cout << "海尔电视机播放中。。。" << endl;
    	}
    }; 

    具体产品类HisenseTV(海信电视机类):

    //具体产品类HisenseTV(海信电视机类)
    class HisenseTV : public TV{
    public:
    	void play(){
    		cout << "海信电视机播放中。。。" << endl;
    	}
    }; 

    抽象工厂类TVFactory(电视机工厂类) :

    //抽象工厂类TVFactory(电视机工厂类)
    class TVFactory{
    public:
    	virtual TV* produceTV() = 0;
    }; 

    具体工厂类HaierTVFactory(海尔电视机工厂类): 

    //具体工厂类HaierTVFactory(海尔电视机工厂类)
    class HaierTVFactory : public TVFactory{
    public:
    	TV* produceTV(){
    		cout << "海尔电视机工厂生产海尔电视机。" << endl;
    		return new HaierTV();
    	}
    };
    //*注册反射
    REGISTER(HaierTVFactory);

    具体工厂类HisenseTVFactory(海信电视机工厂类) : 

    //具体工厂类HisenseTVFactory(海信电视机工厂类) 
    class HisenseTVFactory : public TVFactory{
    public:
    	TV* produceTV(){
    		cout << "海信电视机工厂生产海信电视机。" << endl;
    		return new HisenseTV();
    	}
    }; 
    //*注册反射
    REGISTER(HisenseTVFactory);

     客户端测试类Clinet:

    //Client
    int main(void){
    	try{
    		string factoryName = "HaierTVFactory";    //这里假装从xml中读取
    		TV *tv = nullptr;
    		TVFactory *factory = (TVFactory*)ClassFactory::getInstance().getClassByName(factoryName);
    		tv = factory->produceTV();
    		tv->play();
    	}catch(const string *e){
    		cout << e << endl;
    	}
    	return 0;
    } 

     主要讲解一下REGISTER(className)ClassFactory::getInstance().getClassByName(className)的作用。

    REGISTER()是个宏,通过宏替换,作用是生成这个类的创建函数指针(不是指针函数,注意区分),然后把函数指针通过ClassFactory类用map<className,类创建函数指针>来保存。

    通过ClassFactory::getInstance().getClassByName()来根据类名,在上面提及到的map中做映射,获取到这个类的创建函数指针,然后调用此函数指针来生成这个类的实例,并返回(className*)指针,此指针指向刚才生成的类实例。

    具体的可以参考https://blog.csdn.net/k346k346/article/details/51698184,这个博客讲的很清晰,比较好理解。

    最后附上面所用到的库(reflection.h)。

    //reflection.h
    //c++实现反射 
    #include<map>
    using namespace std;
    
    //定义函数指针,用于指向创建类实例的回调函数. 
    typedef void* (*PTRCreateObject)(void);
    
    //工厂类的定义(单例模式) 
    class ClassFactory{
    private:
    	ClassFactory(){};										//构造函数私有化
    	~ClassFactory(){}; 
    	map<string,PTRCreateObject> m_classMap;					//储存反射类 
    public:
    	void* getClassByName(string className);					//反射class 
    	void registClass(string name,PTRCreateObject method);	//注册需要反射的类 
    	static ClassFactory& getInstance(); 					//返回工厂类实例 
    }; 
    
    //@brief:获取工厂类的单个实例对象  
    ClassFactory& ClassFactory::getInstance(){
    	static ClassFactory sLo_factory;
    	return sLo_factory;
    } 
    
    //@brief:通过类名称字符串获取类的实例
    void* ClassFactory::getClassByName(string className){
    	auto iter = m_classMap.find(className);
    	if(iter != m_classMap.end()){
    		return iter->second();
    	}else{
    		throw new string("无此类名");
    		return nullptr;
    	}
    }
    
    //@brief:将给定的类名称字符串和对应的创建类对象的函数保存到map中   
    void ClassFactory::registClass(string name,PTRCreateObject method){
    	m_classMap.insert(pair<string,PTRCreateObject>(name,method));
    }
    
    //注册方法类,因为全局域不能直接调用函数,只能间接通过类来实现调用注册方法
    class RegisterAction {
    public:
        RegisterAction(string className, PTRCreateObject ptrCreateFn) {
            ClassFactory::getInstance().registClass(className, ptrCreateFn);
        }
    };
    
    #define REGISTER(className)\
    	className* objectCreator_##className(){	\
    		return new className;\
    	} \
    	RegisterAction register_##className(#className,(PTRCreateObject)objectCreator_##className);
    
    
    

    End,如有错误或疑问,请指出。


    设计模式实例目录

    展开全文
  • 场景 例题:一座现代化兵工厂能根据...(2)具体产品类(ConcreteProduct)抽象产品的子类,工厂方法模式中工厂方法所创建的对象是某个具体产品类的实例。具体产品与具体工厂之间需要一一对应,即具体产品由对应的具体

    场景

    例题:一座现代化兵工厂能根据国防需要生产各种兵器,例如机关枪,手枪和狙击枪等等,但不能生产子弹。
    根据国防需求变化,需要生产狙击步枪,在残酷的反恐作战中狙杀恐怖分子。

    传统解决方法
    在这里插入图片描述
    缺陷
    在这里插入图片描述

    工厂方法模式

    概念
    在这里插入图片描述
    在这里插入图片描述
    模式结构
    工厂方法模式结构包括4个角色:
    (1)抽象产品类(Product)负责定义所有具体产品的公共接口
    (2)具体产品类(ConcreteProduct)抽象产品的子类,工厂方法模式中工厂方法所创建的对象是某个具体产品类的实例。具体产品与具体工厂之间需要一一对应,即具体产品由对应的具体工厂所创建。
    (3)抽象工厂类(AbstractFactory)一个接口(或者抽象类),声明的工厂方法(Factory Method)返回一个抽象产品,抽象工厂是工厂方法模式的核心,所有创建具体产品的具体工厂类都需要实现接口。
    (4)具体工厂类(ConcreteFactory)抽象工厂类(接口)的子类,实现了抽象工厂中定义的工厂方法,返回一个具体产品类的实例

    模式优点
    在这里插入图片描述
    在这里插入图片描述
    模式缺点
    在这里插入图片描述
    应用场景
    在这里插入图片描述
    解决方法
    在这里插入图片描述
    实现代码:

    //抽象产品类
    abstract class Weapon{
        abstract void display();//显示兵器名称
    }
    //具体产品类
    class MachineGun extends Weapon{
        @Override
        void display(){
            System.out.println("机光枪");
        }
    }
    class Pistol extends Weapon{
        @Override
        void display(){
            System.out.println("手枪");
        }
    }
    //武器工厂接口
    interface WeaponFactory{
        weapon createWeapon();
    }
    //创建手枪工厂
    class PistolFactory implements WeaponFactory{
        @Override
        public Weapon createWeapon(){
            return new Pistol(); //返回手枪
        }
    }
    //创建机关枪工厂
    class MachineGunFactory implements WeaponFactory{
        @Override
        public Weapon createWeapon(){
            return new MachineGun(); //返回机关枪
        }
    }
    //客户端
    public class DemoP{
        public static void main(String[] args){
                //兵器工厂生产机关枪
                WeaponFactory wf1=new MachineGunFactory();
                Weapon w1 = wf1.createWeapon();//制造机关枪
                w1.display();      
                //兵器工厂生产手枪
                WeaponFactory wf2=new PistolFactory();
                Weapon w2 = wf2.createWeapon();//制造手枪
                w2.display();
        }
    }
    

    运行截图:
    在这里插入图片描述

    展开全文
  • 工厂方法模式是类的创建模式,又叫做虚拟构造子(Virtual Constructor)模式或者多态性工厂(Polymorphic Factory)模式。 工厂方法模式的用意是定义一个创建产品对象的工厂接口,将实际创建工作推迟到子类中。 或者...

    一、基本概念

    工厂方法模式是类的创建模式,又叫做虚拟构造子(Virtual Constructor)模式或者多态性工厂(Polymorphic Factory)模式。 工厂方法模式的用意是定义一个创建产品对象的工厂接口,将实际创建工作推迟到子类中

    或者说引入工厂模式的目的就是我们需要多个工厂,但是每个工厂内部又要划分情况,如果只用一个工厂的话,会产生多种复合的情况。

    比如说我们有两个工厂,每个工厂有3种情况,如果用简单工厂模式,要分为 3 * 2 = 6种情况,所以可以用工厂方法模式解决。

    二、结构

    在简单工厂中,创建对象的是另一个类,而在工厂方法中,是由大工厂的子类(或者实现类)来创建对象。

    即上面有一个大工厂,下面是分类的工厂。

     

    三、案例

    案例,模拟需要生成中国食物A,中国食物B,美国食物A,美国食物B。

    代码逻辑结构图:

     

    基本结构图:

     

    先给出这些食物(Product):

    public interface Food {
    }
    
    public class AmericanFoodA implements Food {
    }
    
    public class AmericanFoodB implements Food {
    }
    
    public class ChineseFoodA implements Food {
    }
    
    public class ChineseFoodB implements Food {
    }

    然后是抽象工厂:

    public interface FoodFactory {
        Food makeFood(String name);
    }

    然后就是两个子工厂:

    public class ChineseFoodFactory implements FoodFactory {
        @Override
        public Food makeFood(String name) {
            if (name.equals("A")) {
                return new ChineseFoodA();
            } else if (name.equals("B")) {
                return new ChineseFoodB();
            } else {
                return null;
            }
        }
    }
    public class AmericanFoodFactory implements FoodFactory {
        @Override
        public Food makeFood(String name) {
            if (name.equals("A")) {
                return new AmericanFoodA();
            } else if (name.equals("B")) {
                return new AmericanFoodB();
            } else {
                return null;
            }
        }
    }

    最后测试:

    public class MyTest {
        public static void main(String[] args) {
            // 先选择一个具体的工厂
            FoodFactory factory = new ChineseFoodFactory();
    
            // 由第一步的工厂产生具体的对象,不同的工厂造出不一样的对象
            Food food = factory.makeFood("A"); //  chineseFood * A
        }
    }

    四、总结

    工厂方法模式和简单工厂模式在结构上的不同很明显。

    工厂方法模式的核心是一个抽象工厂类,而简单工厂模式把核心放在一个具体类上

    工厂方法模式退化后可以变得很像简单工厂模式。设想如果非常确定一个系统只需要一个具体工厂类,那么不妨把抽象工厂类合并到具体工厂类中去。由于只有一个具体工厂类,所以不妨将工厂方法改为静态方法,这时候就得到了简单工厂模式。

     

    免费Java高级资料需要自己领取,涵盖了Java、Redis、MongoDB、MySQL、Zookeeper、Spring Cloud、Dubbo高并发分布式等教程,一共30G。
    传送门:https://mp.weixin.qq.com/s/JzddfH-7yNudmkjT0IRL8Q
    展开全文
  • 如果实例化对象的子类可能改变,就要使用工厂方法模式。 三、一般工厂方法模式 使用一般工厂方法模式时,客户只包含工厂的引用,一个工厂生产一种产品。增加一种产品的同时需要增加一个新工厂类和一个
  • 工厂方法模式java实例demo,来自刘伟老师的《设计模式》一书.rar
  • 转自:java 工厂方法模式简单实例 介绍 在简单工厂模式中,我们提到,工厂方法模式是简单工厂模式的一个延伸,它属于Gof23中设计模式的创建型设计模式。它解决的仍然是软件设计中与创建对象有关的问题。它可以更好...
  • 一、题目分析 (1)、简单工厂模式 使用简单工厂模式模拟女娲(Nvwa)造人(Person),如果传入参数M,则返回一个Man对象,如果传入...(2)、工厂方法模式 海尔工厂(Haier)生产海尔空调(HaierAirCondition),美的工厂...
  • 工厂方法模式
  • 工厂方法模式

    2021-03-18 10:53:57
    工厂模式一、工厂方法模式二、工厂方法模式实例之日志记录器1.实例说明2.实例类图3.实例代码参考文献 一、工厂方法模式 工厂方法模式(Factory Method Pattern)也称为工厂模式,又称为虚拟构造器(Virtual ...
  • 上一篇博文我们说到了工厂模式:https://blog.csdn.net/duan_2018/article/details/79880643一、与工厂方法模式的区别工厂方法模式:一个抽象产品类,可以派生出多个具体产品类。 一个抽象工厂类,可以派生出多个...
  • 工厂方法模式是简单工厂模式的进一步抽象和推广,它不仅保持了简单工厂模式能够向客户隐藏类的实例化过程这一优点,而且还通过多态性克服了工厂类过于复杂且不易于扩展的缺点。在工厂方法模式中,处于核心地位的工厂...
  • 目录一、简单工厂1、模式结构2、模式实例2.1 首先创建抽象产品接口类2.2 创建具体的产品类2.3 创建工厂类2.4 客户端调用工厂类2.5 XMLUtil.java2.6 XML配置文件3、模式分析3.1 优点3.2 缺点3.3 适用场景二、工厂方法...
  • 工厂方法模式(Factory Method Pattern),定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使一个类的实例化延迟到其子类中。 二、解决的问题(What To Solve)  工厂方法模式较简单工厂模式,...
  • 前言 大家都知道java最大的优点是它的完全OO化和...由于笔者能力限制,在实践中也没参与过什么大的项目,笔者参与过的项目用到的工厂模式主要是简单工厂模式(Simple Factory)和工厂方法模式(Factory Method),所以
  • 工厂方法模式实例分析
  • 23种设计模式C++实例工厂方法模式

    千次阅读 2015-12-11 19:23:40
    工厂模式有三种:简单工厂模式,工厂方法模式,抽象工厂模式,其中简单工厂模式属于23种设计模式,实例如下: #include using namespace std; /* * 不符合开闭原则,不是23种标准的设计模式 * */ class Fruit ...
  • 之前写过一篇关于工厂模式(Factory Pattern)的随笔,里面分析了简单工厂模式,但对于工厂方法和抽象工厂的分析较为简略...工厂模式在一些设计模式的书中分为简单工厂模式,工厂方法模式和抽象工厂模式三类。也有把工
  • 工厂方法模式(Factory Method Pattern),定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使一个类的实例化延迟到其子类中。 二、解决的问题(What To Solve)  工厂方法模式较简单工厂模式,...
  • 2.工厂方法模式 产品抽象类 public interface Product { public void create(); } 之后三个产品实类 public class Serverproduct implements Product{ public void create(){ System.out...
  • 工厂方法模式 1、工厂方法模式是类的创建模式,又叫虚拟构造子模式或者多态性工厂模式。 工厂方法模式的用意是定义一个创建产品对象的工厂接口,将实际的创建工作推迟到子类中。 2、工厂方法模式是对简单工厂...
  • 一、工厂方法模式简介(Brief Introduction) 工厂方法模式(Factory Method Pattern),定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使一个类的实例化延迟到其子类中。二、解决的问题...
  • 三、工厂方法模式实例 简单工厂模式的算法,在增加新的算法时,除了新增加算法类,同时还需要修改工厂类。 继续完善,在增加新的算法时,不修改工厂类,而是单独修改客户端。   四、简单工厂模式与工厂方法模式...
  • 工厂方法模式---实例

    2019-05-24 02:01:46
    NULL 博文链接:https://xizhenyin.iteye.com/blog/371321
  • 设计模式(二): 工厂方法模式

    千次阅读 2019-09-03 23:34:15
    目录一、介绍二、适用场景三、工厂方法模式角色分配四、工厂方法模式实例 一、介绍 工厂方法模式应该是工厂模式家族中用的最多的模式,一般项目中存在的最多的就是这个模式。 工厂方法模式是简单工厂的进一步深化,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,038
精华内容 5,615
关键字:

工厂方法模式实例