工厂方法模式使用继承而抽象工厂模式使用组合如何

这是经过深思熟虑后修改的回复。

Factory方法：通常，createObject((是Creator对象的一个方法。

抽象工厂：通常工厂对象是Creator对象的一个属性。

现在假设createObject((和Factory对象属于它们各自的Creator。

Factory方法：createObject((可能会在Creator的子类中发生更改。通过继承更改creatObject((的实现，就会发生这种情况。

抽象工厂：工厂对象也可能在创建者的子类中发生更改。但是，这种更改是通过用不同的Factory对象替换一个Factory对象来实现的，即Creator对象由组合更改。

在您的演示中，creatObject((和Factory Object是Creator的外部对象，因此混淆了组合/继承之间的区别！

Christopher Okhravi有很棒的youTube模式视频。

工厂方法https://www.youtube.com/watch?v=EcFVTgRHJLM&index＝4&list=PLrhzvIcii6GNjpARdnO4ueTUAVR9eMBpc

抽象工厂https://www.youtube.com/watch?v=v-GiuMmsXj4&索引=5&list=PLrhzvIcii6GNjpARdnO4ueTUAVR9eMBpc

根据要求，这里有一个工厂方法的版本(这次是C++！(。如果你需要任何口译帮助，请告诉我。

class IRose
{
public:
virtual const char * Color(void) = 0;
};
class RedRose : public IRose
{
public:
const char * Color(void)
{
return "I am a Red rose";
}
};
class YellowRose : public IRose
{
public:
const char * Color(void)
{
return "I am a Yellow rose";
}
};
class RoseGarden
{
protected: class IRose* rose;   // a pointer to the garden's rose
public:
virtual void createRose() { }  // abstract Factory Method
public: void sayColor() {
cout << rose->Color() << 'n';
}
};
class RedRoseGarden : public RoseGarden
{
public:
void createRose()
{
this->rose = new RedRose();   // concrete factory method
}
};
class YellowRoseGarden : public RoseGarden
{
public:
void createRose()
{
this->rose = new YellowRose();  // concrete factory method
}
};
int main()
{
RoseGarden * garden = NULL;
garden = new YellowRoseGarden;
garden->createRose();      // correct factory method is chosen via inheritance
garden->sayColor();
delete garden;
garden = new RedRoseGarden;
garden->createRose();      // correct factory method is chosen via inheritance
garden->sayColor();
delete garden;
return 1;
}

这里还有一个稍微修改过的抽象工厂版本，以更好地展示它是如何使用的。刚刚添加了一个房子对象。注意，对于我的编译器，我将所有的"字符串"对象都更改为constchar*。

// make different types of fridges
class IFridge
{
public:
virtual const char* Run(void) = 0;
};
class FridgeSamsung : public IFridge
{
public:
const char* Run(void)
{
return "This house has a Samsung Fridgen";
}
};
class FridgeWhirlpool : public IFridge
{
public:
const char* Run(void)
{
return "This house has a Whirlpool Fridgen";
}
};
// make different types of washing machine 
class IWashingMachine
{
public:
virtual const char*  Run(void) = 0;
};
class WashingMachineSamsung : public IWashingMachine
{
public:
const char* Run(void)
{
return "This house has a Samsung Washing Machinen";
}
};
class WashingMachineWhirlpool : public IWashingMachine
{
public:
const char* Run(void)
{
return "This house has a Whirlpool Washing Machinen";
}
};
// make different type of factory
class IFactory
{
public:
virtual IFridge* GetFridge(void) = 0;
virtual IWashingMachine* GetWashingMachine(void) = 0;
};
class FactorySamsung : public IFactory
{
IFridge* GetFridge(void)
{
return new FridgeSamsung();
}
IWashingMachine* GetWashingMachine(void)
{
return new WashingMachineSamsung();
}
};
class FactoryWhirlpool : public IFactory
{
IFridge* GetFridge(void)
{
return new FridgeWhirlpool();
}
IWashingMachine* GetWashingMachine(void)
{
return new WashingMachineWhirlpool();
}
};
// Make a house object that has a fridge and a washing machine
class House
{
private:
class  IWashingMachine * washingMachine;
class  IFridge * fridge;
public:
House(IFactory * houseFactory) {
washingMachine = houseFactory->GetWashingMachine();
fridge = houseFactory->GetFridge();
}
void showAppliances() {
cout << washingMachine->Run();
cout << fridge->Run();
}
};
int main()
{
class IFactory * factory;  
class House * house;       
// make a samsung house
factory = new FactorySamsung;
house = new House(factory);     // passing the factory by injection
house->showAppliances();        // now we have a Samsung house
cout << 'n';
// clean up
delete house;
delete factory;
// make a whirlpool house
factory = new FactoryWhirlpool;
house = new House(factory);    // passing the factory by injection
house->showAppliances();       // now we have a WHilepool house
cout << 'n';
// clean up
delete house;
delete factory;
return 1;
}