工厂模式和抽象工厂模式之间的基本区别是什么?
当前回答
基本的区别:
工厂:创建对象时不向客户端公开实例化逻辑。
工厂方法:定义用于创建对象的接口，但让子类决定实例化哪个类。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的抽象工厂设计模式
其他回答
基本的区别:
工厂:创建对象时不向客户端公开实例化逻辑。
工厂方法:定义用于创建对象的接口，但让子类决定实例化哪个类。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的抽象工厂设计模式
点击这里查看:http://www.allapplabs.com/java_design_patterns/abstract_factory_pattern.htm 似乎Factory方法使用一个特定的类(不是抽象类)作为基类，而抽象工厂则使用一个抽象类。此外，如果使用接口而不是抽象类，结果将是抽象工厂模式的不同实现。
:D
根据定义，我们可以拖出两者的差异:
工厂:接口用于创建对象，但子类决定实例化哪个类。对象的创建是在需要时完成的。
抽象工厂:抽象工厂模式充当一个超级工厂，它可以创建其他工厂。在抽象工厂模式中，接口负责创建一组相关对象或依赖对象，而不指定它们的具体类。
所以，在上面的定义中，我们可以强调一个特定的区别。也就是说，工厂模式负责创建对象，抽象工厂负责创建一组相关的对象;显然都是通过一个接口。
工厂模式:
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();
}
}
//Abstract factory - Provides interface to create factory of related products
interface PizzaIngredientsFactory{
public Dough createDough(); //Will return you family of Dough
public Clam createClam(); //Will return you family of Clam
public Sauce createSauce(); //Will return you family of Sauce
}
class NYPizzaIngredientsFactory implements PizzaIngredientsFactory{
@Override
public Dough createDough(){
//create the concrete dough instance that NY uses
return doughInstance;
}
//override other methods
}
课本上的定义已经由其他答案提供了。我想我也会提供一个例子。
因此这里pizzaingredient factory是一个抽象工厂，因为它提供了创建一系列相关产品的方法。
注意，抽象工厂中的每个方法本身都是一个工厂方法。就像createDough()本身是一个工厂方法，其具体实现将由nypizzafactorentsfactory等子类提供。因此，使用这个方法，每个不同的位置都可以创建属于其位置的具体成分实例。
工厂方法
提供具体实现的实例
在这个例子中: - createDough() -提供面团的具体实现。这是一个工厂方法
抽象工厂
提供创建相关对象族的接口
在这个例子中: pizzafactorentsfactory是一个抽象工厂，因为它允许创建一组相关的对象，如面团，蛤蜊，酱汁。为了创建每个对象族，它提供了一个工厂方法。
来自Head First设计模式的示例
我认为我们可以通过查看Java8示例代码来理解这两者之间的区别:
interface Something{}
interface OneWhoCanProvideSomething {
Something getSomething();
}
interface OneWhoCanProvideCreatorsOfSomething{
OneWhoCanProvideSomething getCreator();
}
public class AbstractFactoryExample {
public static void main(String[] args) {
//I need something
//Let's create one
Something something = new Something() {};
//Or ask someone (FACTORY pattern)
OneWhoCanProvideSomething oneWhoCanProvideSomethingOfTypeA = () -> null;
OneWhoCanProvideSomething oneWhoCanProvideSomethingOfTypeB = () -> null;
//Or ask someone who knows soemone who can create something (ABSTRACT FACTORY pattern)
OneWhoCanProvideCreatorsOfSomething oneWhoCanProvideCreatorsOfSomething = () -> null;
//Same thing, but you don't need to write you own interfaces
Supplier<Something> supplierOfSomething = () -> null;
Supplier<Supplier<Something>> supplierOfSupplier = () -> null;
}
}
现在的问题是你应该使用哪种创造方式以及为什么: 第一种方式(没有模式，只是普通的构造函数):自己创建不是一个好主意，你必须做所有的工作，你的客户端代码绑定到特定的实现。
第二种方式(使用Factory模式):为您提供了可以传递任何类型的实现的好处，这些实现可以基于某些条件(可能是传递给创建方法的参数)提供不同类型的东西。
第三种方法(使用抽象工厂模式):这为您提供了更多的灵活性。您可以根据某些条件(可能是传递的参数)找到不同类型的创建者。
请注意，您总是可以通过将两个条件组合在一起来摆脱工厂模式(这稍微增加了代码的复杂性和耦合)，我想这就是为什么我们很少看到抽象工厂模式的实际用例。
