创建类模式总结-简单工厂、工厂、抽象工厂、建造、原型

最新推荐文章于 2022-07-29 08:51:55 发布
最新推荐文章于 2022-07-29 08:51:55 发布
阅读量553 收藏
点赞数
分类专栏： C++设计模式代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wsgxiaomianao/article/details/38679481
版权 
#pragma once
#include <Windows.h>
#include <iostream>
using namespace  std;

#define SAMPLE_FACTORY				0
#define FACTORY_MODE				0
#define ABSTRACT_FACTORY			0
#define ABSTRACT_FACTORY_OPTIMAL	0
#define BUILDER_MODE				0
#define PROTO_MODE					1

#define _INIT(x)	 x = NULL;
#define _RELEASE(x)  if (x!=NULL){delete x;x = NULL;}
//
//简单工厂模式
//在扩展时破坏了开闭原则
#if SAMPLE_FACTORY

enum{
	PRO_A= 1,
	PRO_B
};
class IProduct{
public:
	virtual void ShowPro() = 0;
};

class ProductA : public IProduct
{
public:
	virtual void ShowPro(){
		cout<<"Create ProductA"<<endl;
	}
};

class ProductB : public IProduct
{
public:
	virtual void ShowPro(){
		cout<<"Create ProductB"<<endl;
	}
};

class Factory{

public:
	IProduct * ShowProduct(UINT nType){
		
		IProduct *pPro = NULL;

		switch (nType)
		{
		case PRO_A:
			{
				pPro = new ProductA();
			}
			break;
		case PRO_B:
			{
				pPro = new ProductB();
			}
			break;
		default:
			break;
		}

		return pPro;
	}
};


void main()
{
	Factory *pFactory = new Factory();
	pFactory->ShowProduct(PRO_A)->ShowPro();
	pFactory->ShowProduct(PRO_B)->ShowPro();
	delete pFactory;
	pFactory = NULL;

}
#endif // _DEBUG

//
//工厂模式
//需要调用端知道调用哪一个具体的工厂类
#if FACTORY_MODE

class IProduct{
public:
	virtual void ShowPro() = 0;
};

class ProductA : public IProduct
{
public:
	virtual void ShowPro(){
		cout<<"Create ProductA"<<endl;
	}
};

class ProductB : public IProduct
{
public:
	virtual void ShowPro(){
		cout<<"Create ProductB"<<endl;
	}
};

class IFactory{

public:
	IFactory(){_INIT(m_pPro)}
	~IFactory(){_RELEASE(m_pPro)}
protected:
	IProduct *m_pPro;
public:
	virtual IProduct * ShowProduct() = 0;
};

class FactoryProA : public IFactory
{
public:
	FactoryProA(){m_pPro = NULL;}
	~FactoryProA(){_RELEASE(m_pPro);}
public:
	IProduct * ShowProduct()
	{
		m_pPro  = new ProductA;
		return m_pPro;
	}
};

class FactoryProB : public IFactory
{
public:
	FactoryProB(){m_pPro = NULL;}
	~FactoryProB(){_RELEASE(m_pPro);}
public:
	IProduct * ShowProduct()
	{
		m_pPro  = new ProductB;
		return m_pPro;
	}
};

void main()
{
	
	IFactory *pIFactory = new FactoryProA;
	pIFactory->ShowProduct()->ShowPro();
	delete pIFactory;
	pIFactory = new FactoryProB;
	pIFactory->ShowProduct()->ShowPro();
	delete pIFactory;
	pIFactory = NULL;
}
#endif // .
//
//抽象工厂模式
//需要调用端知道调用哪一个具体的工厂类并实现多产品的生产

#if ABSTRACT_FACTORY

class IProductMeal{
public:
	virtual void ShowPro() = 0;
};

class ProductMealA : public IProductMeal
{
public:
	virtual void ShowPro(){
		cout<<"Create ProductMealA"<<endl;
	}
};

class ProductMealB : public IProductMeal
{
public:
	virtual void ShowPro(){
		cout<<"Create ProductMealB"<<endl;
	}
};


class IProductFruit
{
public:
	virtual void ShowPro() = 0;
};

class ProductFruitA : public IProductFruit
{
public:
	virtual void ShowPro(){
		cout<<"Create ProductFruitA"<<endl;
	}
};

class ProductFruitB : public IProductFruit
{
public:
	virtual void ShowPro(){
		cout<<"Create ProductFruitB"<<endl;
	}
};

class IFactoryMealFruit{

public:
	IFactoryMealFruit(){_INIT(m_pProMeal); _INIT(m_pProFruit);}
	~IFactoryMealFruit(){_RELEASE(m_pProFruit);_RELEASE(m_pProFruit);}
protected:
	IProductMeal *m_pProMeal;
	IProductFruit *m_pProFruit;
public:
	virtual IProductMeal * ShowProductMeal() = 0;
	virtual IProductFruit * ShowProductFruit() = 0;
};

class FactoryMealAFruitB : public IFactoryMealFruit
{
public:
	FactoryMealAFruitB(){_INIT(m_pProMeal);_INIT(m_pProFruit);}
	~FactoryMealAFruitB(){_RELEASE(m_pProMeal);_RELEASE(m_pProFruit);}
public:
	IProductMeal * ShowProductMeal()
	{
		m_pProMeal  = new ProductMealA;
		return m_pProMeal;
	}

	IProductFruit * ShowProductFruit()
	{
		m_pProFruit  = new ProductFruitB;
		return m_pProFruit;
	}
};

class FactoryMealBFruitA : public IFactoryMealFruit
{
public:
	FactoryMealBFruitA(){_INIT(m_pProMeal);_INIT(m_pProFruit);}
	~FactoryMealBFruitA(){_RELEASE(m_pProMeal);_RELEASE(m_pProFruit);}
public:
	IProductMeal * ShowProductMeal()
	{
		m_pProMeal  = new ProductMealB;
		return m_pProMeal;
	}

	IProductFruit * ShowProductFruit()
	{
		m_pProFruit  = new ProductFruitA;
		return m_pProFruit;
	}
};

void main()
{

	cout<<"订单1:"<<endl;
	IFactoryMealFruit *pIFactoryMF = new FactoryMealAFruitB();
	pIFactoryMF->ShowProductMeal()->ShowPro();
	pIFactoryMF->ShowProductFruit()->ShowPro();
	delete pIFactoryMF;

	cout<<"订单2:"<<endl;
	pIFactoryMF = new FactoryMealBFruitA();
	pIFactoryMF->ShowProductMeal()->ShowPro();
	pIFactoryMF->ShowProductFruit()->ShowPro();
	delete pIFactoryMF;
	pIFactoryMF = NULL;

}

#endif // _DEBUG

//
//抽象工厂模式优化
//创建meal和fruit都使用共同的showPro的接口，现实中生成食物和生产水果都有很多共同的特性，
//因此将这两个接口类合并，从一个接口类派生

#if ABSTRACT_FACTORY_OPTIMAL

class IProduct
{
public:
	virtual void ShowPro() = 0;
};

class IProductMeal : public IProduct{
	//添加特有属性和方法
};

class ProductMealA : public IProductMeal
{
public:
	virtual void ShowPro(){
		cout<<"Create ProductMealA"<<endl;
	}
};

class ProductMealB : public IProductMeal
{
public:
	virtual void ShowPro(){
		cout<<"Create ProductMealB"<<endl;
	}
};


class IProductFruit : public IProduct
{
	//添加特有属性和方法

};

class ProductFruitA : public IProductFruit
{
public:
	virtual void ShowPro(){
		cout<<"Create ProductFruitA"<<endl;
	}
};

class ProductFruitB : public IProductFruit
{
public:
	virtual void ShowPro(){
		cout<<"Create ProductFruitB"<<endl;
	}
};

class IFactoryMealFruit{

public:
	IFactoryMealFruit(){_INIT(m_pProMeal); _INIT(m_pProFruit);}
	~IFactoryMealFruit(){_RELEASE(m_pProFruit);_RELEASE(m_pProFruit);}
protected:
	IProductMeal *m_pProMeal;
	IProductFruit *m_pProFruit;
public:
	virtual IProductMeal * ShowProductMeal() = 0;
	virtual IProductFruit * ShowProductFruit() = 0;
};

class FactoryMealAFruitB : public IFactoryMealFruit
{
public:
	FactoryMealAFruitB(){_INIT(m_pProMeal);_INIT(m_pProFruit);}
	~FactoryMealAFruitB(){_RELEASE(m_pProMeal);_RELEASE(m_pProFruit);}
public:
	IProductMeal * ShowProductMeal()
	{
		m_pProMeal  = new ProductMealA;
		return m_pProMeal;
	}

	IProductFruit * ShowProductFruit()
	{
		m_pProFruit  = new ProductFruitB;
		return m_pProFruit;
	}
};

class FactoryMealBFruitA : public IFactoryMealFruit
{
public:
	FactoryMealBFruitA(){_INIT(m_pProMeal);_INIT(m_pProFruit);}
	~FactoryMealBFruitA(){_RELEASE(m_pProMeal);_RELEASE(m_pProFruit);}
public:
	IProductMeal * ShowProductMeal()
	{
		m_pProMeal  = new ProductMealB;
		return m_pProMeal;
	}

	IProductFruit * ShowProductFruit()
	{
		m_pProFruit  = new ProductFruitA;
		return m_pProFruit;
	}
};

void main()
{

	cout<<"订单1:"<<endl;
	IFactoryMealFruit *pIFactoryMF = new FactoryMealAFruitB();
	pIFactoryMF->ShowProductMeal()->ShowPro();
	pIFactoryMF->ShowProductFruit()->ShowPro();
	delete pIFactoryMF;

	cout<<"订单2:"<<endl;
	pIFactoryMF = new FactoryMealBFruitA();
	pIFactoryMF->ShowProductMeal()->ShowPro();
	pIFactoryMF->ShowProductFruit()->ShowPro();
	delete pIFactoryMF;
	pIFactoryMF = NULL;

}
#endif // _DEBUG

//
//建造者模式---创建复杂对象时使用
//将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
//在抽象工厂模式中，要创建MealA和FruitB，但是万一忘记其一那不就没的吃了。
//因此使用建造者模式来解决

#if BUILDER_MODE

class IProduct
{
public:
	virtual void ShowPro() = 0;
};

class IProductMeal : public IProduct{
	//添加特有属性和方法
};

class ProductMealA : public IProductMeal
{
public:
	virtual void ShowPro(){
		cout<<"Create ProductMealA"<<endl;
	}
};

class ProductMealB : public IProductMeal
{
public:
	virtual void ShowPro(){
		cout<<"Create ProductMealB"<<endl;
	}
};


class IProductFruit : public IProduct
{
	//添加特有属性和方法

};

class ProductFruitA : public IProductFruit
{
public:
	virtual void ShowPro(){
		cout<<"Create ProductFruitA"<<endl;
	}
};

class ProductFruitB : public IProductFruit
{
public:
	virtual void ShowPro(){
		cout<<"Create ProductFruitB"<<endl;
	}
};

class IFactoryMealFruit{

public:
	IFactoryMealFruit(){_INIT(m_pProMeal); _INIT(m_pProFruit);}
	~IFactoryMealFruit(){_RELEASE(m_pProFruit);_RELEASE(m_pProFruit);}
protected:
	IProductMeal *m_pProMeal;
	IProductFruit *m_pProFruit;
public:
	virtual IProductMeal * ShowProductMeal() = 0;
	virtual IProductFruit * ShowProductFruit() = 0;
};

class FactoryMealAFruitB : public IFactoryMealFruit
{
public:
	FactoryMealAFruitB(){_INIT(m_pProMeal);_INIT(m_pProFruit);}
	~FactoryMealAFruitB(){_RELEASE(m_pProMeal);_RELEASE(m_pProFruit);}
public:
	IProductMeal * ShowProductMeal()
	{
		m_pProMeal  = new ProductMealA;
		return m_pProMeal;
	}

	IProductFruit * ShowProductFruit()
	{
		m_pProFruit  = new ProductFruitB;
		return m_pProFruit;
	}
};

class FactoryMealBFruitA : public IFactoryMealFruit
{
public:
	FactoryMealBFruitA(){_INIT(m_pProMeal);_INIT(m_pProFruit);}
	~FactoryMealBFruitA(){_RELEASE(m_pProMeal);_RELEASE(m_pProFruit);}
public:
	IProductMeal * ShowProductMeal()
	{
		m_pProMeal  = new ProductMealB;
		return m_pProMeal;
	}

	IProductFruit * ShowProductFruit()
	{
		m_pProFruit  = new ProductFruitA;
		return m_pProFruit;
	}
};

class FactoryMealBFruitB : public IFactoryMealFruit
{
public:
	FactoryMealBFruitB(){_INIT(m_pProMeal);_INIT(m_pProFruit);}
	~FactoryMealBFruitB(){_RELEASE(m_pProMeal);_RELEASE(m_pProFruit);}
public:
	IProductMeal * ShowProductMeal()
	{
		m_pProMeal  = new ProductMealB;
		return m_pProMeal;
	}

	IProductFruit * ShowProductFruit()
	{
		m_pProFruit  = new ProductFruitB;
		return m_pProFruit;
	}
};

//抽象建造者指挥者类
class IBuilderDirector{
public:
	IBuilderDirector(){}
	IBuilderDirector(IFactoryMealFruit *pFactoryMealFruit){this->m_pFactoryMealFruit = pFactoryMealFruit;}
	~IBuilderDirector(){}

protected:

	IFactoryMealFruit *m_pFactoryMealFruit;
public:
	virtual void showProuct()=0;
};

//具体建造者指挥者类
class BuildDirector : public IBuilderDirector{
public:
	BuildDirector(IFactoryMealFruit *pFactoryMealFruit){this->m_pFactoryMealFruit = pFactoryMealFruit;}
	~BuildDirector(){}

public:
	virtual void showProuct(){
		m_pFactoryMealFruit->ShowProductFruit()->ShowPro();
		m_pFactoryMealFruit->ShowProductMeal()->ShowPro();
	}

};

void main()
{

	cout<<"订单1:"<<endl;
	IFactoryMealFruit *pIFactoryMF = new FactoryMealAFruitB();
	IBuilderDirector *pIBuilder = new BuildDirector(pIFactoryMF);
	pIBuilder->showProuct();
	delete pIFactoryMF;
	delete pIBuilder;	

	cout<<"订单2:"<<endl;
	pIFactoryMF = new FactoryMealBFruitA();
	pIBuilder = new BuildDirector(pIFactoryMF);
	pIBuilder->showProuct();
	delete pIFactoryMF;
	pIFactoryMF = NULL;

	cout<<"订单3:"<<endl;
	pIFactoryMF = new FactoryMealBFruitB();
	pIBuilder = new BuildDirector(pIFactoryMF);
	pIBuilder->showProuct();
	delete pIFactoryMF;
	pIFactoryMF = NULL;

}
#endif // _DEBUG
//
//原型模式
//原型抽象类定义clone接口
//从抽象类派生具体类，实现深拷贝构造和clone方法

#if PROTO_MODE

class IMachine{
public:
		
	IMachine(){cout<<"IMachine"<<endl;}
	~IMachine(){cout<<"~IMachine"<<endl;}
public:
	virtual IMachine* clone() = 0;
	virtual void ShowName() = 0;
	virtual void SetName(char *NewName) = 0 ;
protected:
	char *m_pMachineName;	
};

class MachineComputer : public IMachine
{
public:
	MachineComputer(char *name){

		if (name == NULL)
		{
			m_pMachineName = new char[1];
			m_pMachineName[0] = '\0';
		}else
		{
			m_pMachineName = new char[strlen(name)+1];
			ZeroMemory(m_pMachineName,sizeof(char)*(strlen(name)+1));
			strcpy_s(m_pMachineName,sizeof(char)*(strlen(name)+1),name);
		}

	}
	~MachineComputer(){
		cout<<"~MachineComputer"<<endl;
	}
	MachineComputer(const MachineComputer & mc){
		this->m_pMachineName = new char[strlen(mc.m_pMachineName)+1];
		strcpy_s(this->m_pMachineName,strlen(mc.m_pMachineName)+1,mc.m_pMachineName);

	}
public:
	virtual IMachine* clone(){

		return new MachineComputer(*this);
	}
	virtual void ShowName() {
		cout<<"m_pMachineName : "<<m_pMachineName<<endl;
	}

	virtual void SetName(char *NewName){
		if (NewName== NULL)
		{
			delete []m_pMachineName;
			m_pMachineName = NULL;

			m_pMachineName = new char[1];
			m_pMachineName[0] = '\0';
		}else
		{
			delete []m_pMachineName;
			m_pMachineName = NULL;

			m_pMachineName = new char[strlen(NewName)+1];
			strcpy_s(m_pMachineName,strlen(NewName)+1,NewName);
		}

	}

};


void main()
{

	IMachine *pMachine = new MachineComputer("world");
	pMachine->ShowName();
	

	IMachine *pMachine2 = pMachine->clone();
	pMachine2->ShowName();
	
	pMachine->SetName("pMachine set world to hello");
	pMachine->ShowName();

	delete pMachine;
	delete pMachine2;
	pMachine2 = pMachine = NULL;
}

#endif // _DEBUG



                

        

        

    

  


    

      

        

            

              
                
                  wsgxiaomianao
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
【23种设计模式】创建型模式（工厂、抽象工厂、建造者、原型、单例）

				
			

			

				

					随心所欲的博客
				

				

					08-17
					
					544
					
				

			

		

		

			
				
这23种设计模式中，属于创建型模式的有5种分别为工厂模式、抽象工厂模式、建造者模式、原型模式、搭理模式。下面分别介绍：
1.工厂模式【Factory Method】
延迟实例化，接口+方法返回抽象类对象（顶层），然后将实现放到底层，工厂返回的对象均实现共同接口，因此调用工厂方法固定使用接口接收。
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类...

			
		

	



                

            
              



	

		

			

				
					
创建型模式--抽象工厂模式

					
最新发布

				
			

			

				

					-
				

				

					06-17
					
					1178
					
				

			

		

		

			
				
抽象工厂模式为创建一组对象提供了一种解决方案。与工厂方法模式相比，抽象工厂模式中的具体工厂不只是创建一种产品，它负责创建一族产品。抽象工厂模式定义如下：抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，它是一种对象创建型模式。在抽象工厂模式中，每个具体工厂都提供了多个工厂方法用于产生多种不同类型的产品，这些产品构成了一个产品族。抽象工厂模式结构如图所示。

			
		

	



              


  
              

                


	

		

			

				
					
java设计模式之工厂模式（工厂方法、抽象工厂）

				
			

			

				

					以博促学
				

				

					06-29
					
					531
					
				

			

		

		

			
				
java设置模式之工厂模式，包括简单工厂模式，工厂方法模式，抽象工厂模式

			
		

	





	

		

			

				
					
设计模式之创建类模式——抽象工厂模式

				
			

			

				

					weixin_30532759的博客
				

				

					08-19
					
					115
					
				

			

		

		

			
				
抽象工厂模式（Abstract Factory Pattern）是一种比较常用的模式。  定义： 为创建一组相关或相互依赖的对象提供一个接口，而且无需指定它们的具体类。  抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。  通用类图：    通用代码：/**
 * A抽象产品类
 * @author Admini...

			
		

	



		

			
		



	

		

			

				
					
Java设计模式之工厂模式（简单工厂、工厂方法、抽象工厂）

				
			

			

				

					学习印记  Learning imprint
				

				

					05-14
					
					1436
					
				

			

		

		

			
				
/**
* 简单工厂模式：不直接产生对象，而由一个具体的工厂类统一产生对象。这样不利于增加新的产品。
*
* 工厂方法模式：一个抽象的工厂类可以派生出多个具体的工厂类来负责产生各个产品的对象。（大话设计模式中是用一个具体工厂类，把负责生成某一产品对象封装为具体工厂类的一个函数）
*     这样在产生对象时相互独立，更符合开放闭合原则。
* 抽象工厂模式：有多个抽象

			
		

	





	

		

			

				
					
java设计模式之——工厂模式

				
			

			

				

					hughjin
				

				

					09-26
					
					330
					
				

			

		

		

			
				
下面例子中鼠标，键盘，耳麦为产品，惠普，戴尔为工厂。

简单工厂模式

简单工厂模式不是 23 种里的一种，简而言之，就是有一个专门生产某个产品的类。

比如下图中的鼠标工厂，专业生产鼠标，给参数 0，生产戴尔鼠标，给参数 1，生产惠普鼠标。



工厂模式

工厂模式也就是鼠标工厂是个父类，有生产鼠标这个接口。

戴尔鼠标工厂，惠普鼠标工厂继承它，可以分别生产戴尔鼠标，惠普鼠标。

生产哪种鼠标...

			
		

	





	

		

			

				
					
设计模式 笔记1 | 五个创建型模式 | Java 语言实现 | 工厂方法设计模式 | 抽象工厂模式 |建造者模式 | 单例模式 | 原型模式

				
			

			

				

					希望每天都能进步一点点
				

				

					07-29
					
					365
					
				

			

		

		

			
				
设计模式 笔记1 | 五个创建型模式 | Java 语言实现 | 工厂方法设计模式 | 抽象工厂模式 |建造者模式 | 单例模式 | 原型模式

			
		

	





	

		

			

				
					
day02 工厂模式+原型模式+建造者模式

				
			

			

				

					10-18
				

			

		

		

			
				
工厂方法模式包含四个角色：抽象工厂、具体工厂、抽象产品和具体产品。  优点：  * 完全遵循开闭原则 * 可以通过工厂方法来创建对象 * 客户端代码不需要关心对象的创建细节  原型模式  原型模式是一种创建型模式，...

			
		

	





	

		

			

				
					
设计模式---创建型模式（工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式）

				
			

			

				

					一个游戏前端的成长现场
				

				

					04-12
					
					576
					
				

			

		

		

			
				
对设计模式出于学习阶段没有啥高深的见解，本文主要讲的是自己的感悟与在自己实践中可能用到的地方，后续会有自己项目中的总结，全面学习还是进链接里，我就不赘述啦
工厂模式
文章链接：工厂模式.
个人理解：
1.买小汽车，去奥迪4S店（统一接口），你只需要做的就是告诉他型号（不同实现），交钱即可。车是怎么造出来的事，归工厂管。（体现了接口，也就是面向对象封装的好处）
实操：
1.飞机大战里的飞机、子弹。
2.养成游戏：不同食物、不同衣服
抽象工厂模式
文章链接：抽象工厂模式.
个人理解：
1.上面提到了工厂模式，那

			
		

	





	

		

			

				
					
创建型设计模式之--简单工厂、工厂方法、抽象工厂模式

				
			

			

				

					王温暖的博客
				

				

					07-05
					
					643
					
				

			

		

		

			
				
我们举一个摘水果的例子，果园中种着苹果树、香蕉树、桔子树等等果树，当有三个小伙伴想要吃苹果时，他们就需要各自去拿各自想要吃的水果，我们最原始朴素的写法如下，谁需要谁就自己去拿就好了：




/**
 * 不使用设计模式：最原始的想法，哪里用就直接在哪里new出来相应的对象
 */
public class PeterClient {
    //Peter自己吃水果
    public static void main(String[] args) {
        peterdo();
      

			
		

	





	

		

			

				
					
java+抽象工厂方法模式_java设计模式——抽象工厂方法

				
			

			

				

					weixin_29007135的博客
				

				

					03-05
					
					99
					
				

			

		

		

			
				
说明：什么使用我们可以使用抽象工厂方法？怎么使用抽象工厂方法应用场景：当我们建立的两个类之间有组合关系的时候，比如说学校、老师、学生。这那个之间的关系是：学校可以使一中、二中、三中。老师可以是一中老师、二中老师。同样，学生也可以使一中学生，二中学生。如果以后多一个三中的话，还有三中老师，三中学生。定义：老师类：学生类：一中一中老师一中学生二中二中老师二中学生学校工厂类(可以生产一中、二中)具体实现...

			
		

	





	

		

			

				
					
创建型模式：简单工厂、工厂方法、抽象工厂

				
			

			

				

					NoMoreCode的博客
				

				

					08-25
					
					271
					
				

			

		

		

			
				
一、在没有使用设计模式之前，我相信很多Coder都是这样创建对象的：



在项目中这样直接使用类去New一个对象，它会有哪些缺点呢？作为上端（调用方）过于依赖下端（细节部分），是紧密耦合在一起的，如果我们的细节部门发生了改变，那么我们的上端代码也是需要做改变的，怎么解决这个问题，那么我们可以使用一种抽象思维：把对象的创建放到一个工厂里去做，这个工厂只负责对象的创建，然后返回一个接口类型：

二、...

			
		

	





	

		

			

				
					
创建型模式——简单工厂、工厂方法、抽象工厂详解

				
			

			

				

					weixin_38357164的博客
				

				

					11-07
					
					267
					
				

			

		

		

			
				
工厂模式分为简单工厂（工厂方法）、抽象工厂三种。目的无非就两种情况：一是为了把创建对象公共的部抽取整合（有点类似面向切面的意思），降低代码耦合度，二是为了增强扩展性。

大白话翻译一下：创建对象大多数都是new 来操作，工厂模式是用工厂方法代替new操作的一种模式。为什么要用工厂模式呢？首先从解耦的角度来说，初学者可能还没有这种感觉，平时创建对象直接就new了，但是如果随着业务的复杂度增加，我...

			
		

	





	

		

			

				
					
Java创建型设计模式之简单工厂，工厂方法，抽象工厂

				
			

			

				

					我神级欧文的博客
				

				

					07-01
					
					449
					
				

			

		

		

			
				
在Java的23中设计模式中，其中有创建型的一类创建模式，通常用来抽象封装创建对象来使用的，这一类创建模式是使得客户端调用者不用关心对象是如何创建，统统交给一个叫做“工厂”的对象来创建对应的对象。这样就能做到客户端不与想要创建的对象紧密地耦合，降低耦合度。


1.简单工厂


简单工厂具体来并不属于Java中的23种设计模式中之一，它只是一种对创建对象的简单的封装，只需要传入一个正确的参数，就...

			
		

	





	

		

			

				
					
设计模式之工厂模式（简单工厂，工厂方法，抽象方法）

				
			

			

				

					蒟蒻达的博客
				

				

					05-22
					
					306
					
				

			

		

		

			
				
工厂模式
1、简单工厂模式：
​	首先我们有一个Car类，这个Car可以go：
public class Car {
    public void go() {
        System.out.println("car go ...");
    }
}

还有一个调用者，这样就可以造出车来跑：
public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        c

			
		

	





	

		

			

				
					
设计模式-创建型模式-工厂模式（简单工厂、工厂方法、抽象工厂）

				
			

			

				

					CodingAnHour
				

				

					03-10
					
					280
					
				

			

		

		

			
				
无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了; 而对于抽象工厂模式，当减少一个 方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。

			
		

	





	

		

			

				
					
MTK 增加Factory模式命令

				
			

			

				

					zhoukok的专栏
				

				

					07-28
					
					2476
					
				

			

		

		

			
				
因为客户需要增加factory mode，而且只能用命令进入，而不让用户感知这个模式的存在，所以决定在系统中增加命令: reboot factory，从而进入factory mode

先看一下reboot命令是如何实现的。

我们在串口输入或者在cmd命令行输入 reboot后，系统会重启，如果后面跟的参数是 bootloader，机器会进入fastboot模式，而如果后面跟的参数是 recov...

			
		

	





	

		

			

				
					
[Factory mode] 怎么配置工厂模式测试项

				
			

			

				

					sandform的博客
				

				

					07-11
					
					6008
					
				

			

		

		

			
				
[Factory mode] 怎么配置工厂模式测试项
[DESCRIPTION]

修改alps/mediatek/custom/$proj/factory/factory.ini配置工厂模式测项

[KEYWORD]

Factory mode test

[SOLUTION]

alps/mediatek/custom/$proj/factory/factory.ini 

			
		

	





	

		

			

				
					
2022-15-Java 设计模式-抽象工厂模式

				
			

			

				

					zzhangwa的博客
				

				

					05-11
					
					3459
					
				

			

		

		

			
				
在工厂方法模式中，我们使用一个工厂创建一个产品，一个具体工厂对应一个具体产品，但有时候我们需要一个工厂能够提供多个产品对象，而不是单一的对象，这个时候我们就需要使用抽象工厂模式。
    在介绍抽象工厂模式前，我们先厘清两个概念：

产品等级结构：产品等级结构指的是产品的继承结构，例如一个空调抽象类，它有海尔空调、格力空调、美的空调等一系列的子类，那么这个空调抽象类和他的子类就构成了一个产品等级结构。
产品族：产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。比如，海尔工厂生产海尔空调、海尔冰

			
		

	





	

		

			

				
					
理解Java设计模式：简单工厂、工厂方法、抽象工厂

				
			

			

				

					
				

			

		

		

			
				
3. 抽象工厂模式：在抽象工厂模式中，提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。这种模式适用于当产品族中的对象需要一起使用时，确保它们都来自同一工厂，以保持一致性。  在Java OOP...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值