工厂模式和抽象工厂模式之间的基本区别是什么?
当前回答
我的资源是:StackOverflow, tutorialspoint.com, programmers.stackexchange.com和CodeProject.com。
工厂方法(也称为工厂)用于解耦接口实现的客户端。例如，我们有一个具有圆和方两个实现的Shape接口。我们已经定义了一个工厂类，它带有一个工厂方法和一个确定参数，如Type和Shape接口的新的相关实现。
抽象工厂包含多个工厂方法或多个工厂实现的工厂接口。 对于上面的下一个示例，我们有一个带有两个红色和黄色实现的颜色接口。 我们已经用两个RedCircleFactory和YellowSquareFactory定义了一个ShapeColorFactory接口。下面的代码解释这个概念:
interface ShapeColorFactory
{
public Shape getShape();
public Color getColor();
}
class RedCircleFactory implements ShapeColorFactory
{
@Override
public Shape getShape() {
return new Circle();
}
@Override
public Color getColor() {
return new Red();
}
}
class YellowSquareFactory implements ShapeColorFactory
{
@Override
public Shape getShape() {
return new Square();
}
@Override
public Color getColor() {
return new Yellow();
}
}
这里是FactoryMethod和AbstractFactory的区别。工厂方法返回接口的具体类，而抽象工厂返回工厂的工厂。换句话说，抽象工厂返回不同组合的一系列界面。
我希望我的解释有用。
其他回答
此信息的来源:http://java.dzone.com/news/intro-design-patterns-abstract
抽象工厂与工厂方法
抽象工厂的方法被实现为工厂方法。抽象工厂模式和工厂方法模式都通过抽象类型和工厂将客户端系统与实际实现类解耦。 工厂方法通过继承创建对象，而抽象工厂通过组合创建对象。
抽象工厂模式由AbstractFactory、ConcreteFactory、AbstractProduct、ConcreteProduct和客户端组成。
如何实现
抽象工厂模式可以使用工厂方法模式、原型模式或单例模式来实现。ConcreteFactory对象可以作为一个单例对象实现，因为只需要一个ConcreteFactory对象实例。
工厂方法模式是抽象工厂模式的简化版本。工厂方法模式负责创建属于一个家族的产品，而抽象工厂模式处理多个产品家族。
工厂方法使用接口和抽象类将客户端与生成器类和生成的产品解耦。摘要工厂有一个生成器，它是几个工厂方法的容器，以及将客户端与生成器和产品分离的接口。
何时使用工厂方法模式
当需要将客户端与其使用的特定产品解耦时，请使用工厂方法模式。使用Factory方法可以减轻客户端创建和配置产品实例的责任。
何时使用抽象工厂模式
当客户端必须从产品类中解耦时，使用抽象工厂模式。 特别适用于程序配置和修改。抽象工厂模式还可以强制约束哪些类必须与其他类一起使用。建造新的混凝土工厂可能需要做很多工作。
例子:
抽象工厂实例1
本规范适用于制备不同类型面食的圆盘 在面食机中有一个抽象工厂，每个特定的圆盘都是一个工厂。 所有的工厂(意大利面食机磁盘)从抽象工厂继承他们的属性。 每个单独的磁盘都包含如何制作意大利面，而意大利面机没有。
例子2:
冲压设备对应于抽象工厂，因为它是一个 用于创建抽象产品对象的操作接口。 模具对应混凝土工厂，因为他们创造一个混凝土产品。 每个部件类别(罩、门等)都对应于抽象产品。 具体部件(即99凯美瑞的司机侧门)对应 混凝土制品。
工厂方法示例:
玩具公司对应于创造者，因为它可以使用工厂来创建产品对象。制造特定类型玩具(马或汽车)的玩具公司的部门对应于ConcreteCreator。
基本的区别:
工厂:创建对象时不向客户端公开实例化逻辑。
工厂方法:定义用于创建对象的接口，但让子类决定实例化哪个类。Factory方法允许类延迟实例化到子类
抽象工厂:提供一个接口，用于创建一系列相关或依赖的对象，而无需指定它们的具体类。
AbstractFactory模式使用组合将创建对象的责任委托给另一个类，而Factory方法模式使用继承并依赖于派生类或子类来创建对象
来自oodesign的文章:
工厂类图:
例如:StaticFactory
public class ShapeFactory {
//use getShape method to get object of type shape
public static Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("CIRCLE")){
return new Circle();
} else if(shapeType.equalsIgnoreCase("RECTANGLE")){
return new Rectangle();
} else if(shapeType.equalsIgnoreCase("SQUARE")){
return new Square();
}
return null;
}
}
非静态工厂实现FactoryMethod的例子在这篇文章中可用:
设计模式:工厂vs工厂方法vs抽象工厂
何时使用:客户端只需要一个类，并不关心它得到的是哪个具体实现。
工厂方法类digaram:
何时使用:客户端不知道在运行时需要创建什么具体的类，而只是想获得一个可以完成这项工作的类。
来自dzone的抽象工厂类图
何时使用:当您的系统必须创建多个产品系列，或者您希望提供一个产品库而不公开实现细节时。
以上文章中的源代码示例非常有助于清楚地理解这些概念。
相关SE问题与代码示例:
工厂模式。什么时候使用工厂方法?
差异:
抽象工厂类通常使用工厂方法来实现，但它们也可以使用原型来实现 设计开始使用工厂方法(不太复杂，更可定制，子类激增)，然后向其他需要更多灵活性的创建模式(更灵活，更复杂)发展。 工厂方法通常在模板方法中调用。
其他有用的文章:
来自sourcemmaking的Factory_method
摘要工厂从sourcemmaking
来自journaldev的抽象工厂设计模式
根据定义，我们可以拖出两者的差异:
工厂:接口用于创建对象，但子类决定实例化哪个类。对象的创建是在需要时完成的。
抽象工厂:抽象工厂模式充当一个超级工厂，它可以创建其他工厂。在抽象工厂模式中，接口负责创建一组相关对象或依赖对象，而不指定它们的具体类。
所以，在上面的定义中，我们可以强调一个特定的区别。也就是说，工厂模式负责创建对象，抽象工厂负责创建一组相关的对象;显然都是通过一个接口。
工厂模式:
public interface IFactory{
void VehicleType(string n);
}
public class Scooter : IFactory{
public void VehicleType(string n){
Console.WriteLine("Vehicle type: " + n);
}
}
public class Bike : IFactory{
public void VehicleType(string n) {
Console.WriteLine("Vehicle type: " + n);
}
}
public interface IVehicleFactory{
IFactory GetVehicleType(string Vehicle);
}
public class ConcreteVehicleFactory : IVehicleFactory{
public IFactory GetVehicleType(string Vehicle){
switch (Vehicle){
case "Scooter":
return new Scooter();
case "Bike":
return new Bike();
default:
return new Scooter();
}
}
class Program{
static void Main(string[] args){
IVehicleFactory factory = new ConcreteVehicleFactory();
IFactory scooter = factory.GetVehicleType("Scooter");
scooter.VehicleType("Scooter");
IFactory bike = factory.GetVehicleType("Bike");
bike.VehicleType("Bike");
Console.ReadKey();
}
}
工厂模式:
interface IVehicleFactory{
IBike GetBike();
IScooter GetScooter();
}
class HondaFactory : IVehicleFactory{
public IBike GetBike(){
return new FZS();
}
public IScooter GetScooter(){
return new FZscooter();
}
}
class HeroFactory: IVehicleFactory{
public IBike GetBike(){
return new Pulsur();
}
public IScooter GetScooter(){
return new PulsurScooter();
}
}
interface IBike
{
string Name();
}
interface IScooter
{
string Name();
}
class FZS:IBike{
public string Name(){
return "FZS";
}
}
class Pulsur:IBike{
public string Name(){
return "Pulsur";
}
}
class FZscooter:IScooter {
public string Name(){
return "FZscooter";
}
}
class PulsurScooter:IScooter{
public string Name(){
return "PulsurScooter";
}
}
enum MANUFACTURERS
{
HONDA,
HERO
}
class VehicleTypeCheck{
IBike bike;
IScooter scooter;
IVehicleFactory factory;
MANUFACTURERS manu;
public VehicleTypeCheck(MANUFACTURERS m){
manu = m;
}
public void CheckProducts()
{
switch (manu){
case MANUFACTURERS.HONDA:
factory = new HondaFactory();
break;
case MANUFACTURERS.HERO:
factory = new HeroFactory();
break;
}
Console.WriteLine("Bike: " + factory.GetBike().Name() + "\nScooter: " + factory.GetScooter().Name());
}
}
class Program
{
static void Main(string[] args)
{
VehicleTypeCheck chk = new VehicleTypeCheck(MANUFACTURERS.HONDA);
chk.CheckProducts();
chk= new VehicleTypeCheck(MANUFACTURERS.HERO);
chk.CheckProducts();
Console.Read();
}
}
很多人可能会感到惊讶，但这个问题是不正确的。如果你在面试中听到这个问题，你需要帮助面试官理解你的困惑在哪里。
让我们从一个事实开始，即没有具体的模式被称为“工厂”。有一种模式叫做“抽象工厂”，也有一种模式叫做“工厂方法”。
那么，“工厂”是什么意思呢?以下之一(根据引用的范围，都可以认为是正确的):
有些人用它作为“抽象工厂”的别名(快捷方式)。 有些人使用它作为“工厂方法”的别名(快捷方式)。 有些人将其用作所有工厂/创建模式的通用名称。例如，“抽象工厂”和“工厂方法”都是工厂。
不幸的是，许多人使用“Factory”来表示另一种类型的工厂，它创建了一个或多个工厂(或它们的接口)。根据他们的理论:
Product实现了IProduct，它是由Factory创建的 实现了由AbstractFactory创建的IFactory。
为了理解这有多愚蠢，让我们继续我们的方程:
AbstractFactory实现了IAbstractFactory，它由… AbstractAbstractFactory ? ?
我希望你能明白我的意思。不要困惑，请不要发明那些无缘无故存在的东西。
-
附注:产品的工厂是AbstractFactory，而抽象工厂的工厂也是AbstractFactory的另一个例子。
抽象工厂是创建相关对象的接口，而工厂方法是一种方法。抽象工厂采用工厂方法实现。
