简单工厂,工厂方法和抽象工厂模式
对于简单工厂来说,它的工厂只能是这个样子的
public class SimplyFactory {
/**
* 静态工厂方法
*/
public static Prouct factory(String which) throw NoSuchProductExcption
{
if(which.equalIgnoreCase("product1"))
{
return new Product1();
}
else if(which.equalsIgnoreCase("product2"))
{
return new Product2();
}
else if(which.equalsIgnoreCase("product3"))
{
return new Product3();
}
else throw NoSuchProductExcption("NoSuchProduct");
}
}
}
而对产品Product1,Product2,Product3,可以执行接口Product,也可以不执行接口Product(当然这样不好),这个Product接口只是用来抽象具体product用的
public interface Product
{
void productMethod1(); //这些只是
void productMethod2();
void productMethod3();
}
对工厂来说,只要有这么一种产品,一般来说就要在工厂里有它的生产的方法, 否则抛出异常,而要工厂生产的话,也必须下达生产什么产品的命令,至少要向工厂发出信号,让工厂足以区分是要生产什么产品,否则工厂是不知道生产哪一种产品,
对于简单工厂来说,就是需要在工厂中枚举所有的产品,所以说简单工厂还是非常笨的。
if(which.equalIgnoreCase("product1")) 只是用来区分生产什么产品的标记值,(也可以根据产品其它属性来判断,比如产品类型,产品大小,总之能够区分是什么产品的属性,或者是与产品属性相关的变量) 或者说标记值是A,生产A产品,或者工厂里定义不是这样的,我偏偏要生产B产品,或者再特殊一些,我偏偏要生产A产品+B产品,那么就要return new ProductA()+new ProductB()了。
这样,我们就可以看出一个问题来,如果要能够被简单工厂生产出来,就必须在简单工厂中有能够生产出的它的方法定义,当然还需要有这个具体产品类的定义,就是有class对应,这样确保在简单工厂中new 它的时候不会抛出 NoSuchProduct的Exception.
对于工厂方法来说
实质上它是让工厂实现了抽象的工厂接口,它把具体怎么生产一种东西,放在具体的工厂去实现了,所谓”延迟到子类中实现“
public interface Creator
{
public Prouct factory();
}
public SubCreator1 implent Creator
{
public Prouct factory()
{
return new ConcreteProduct1();
}
}
public SubCreator2 implent Creator
{
public Prouct factory()
{
return new ConcreteProduct2();
}
}
请注意:返回类型是Product型的!!
这样客户端调用是直接new 一个具体工厂的实例,然后命令它去生产,而对于具体工厂的父类(既工厂接口,接口完全可以改成子类继承父类来实现,只是这样不好,不符合OO的原则),它完全不知道什么产品被生产了,甚至它连那个具体工厂被实例化它都不知道
抽象工厂模式
抽象工厂模式主要是用来解决具体产品是有几类产品簇的问题
public interface Creator
{
public ProuctA factoryA();
public ProuctB factoryB();
}
public interface ProductA //ProductA 接口
{
}
public interface ProductB //ProductB 接口
{
}
public class ConCreator1 implent Creator
{
public ProuctA factoryA()
{
return new ConcreteProductA1();
}
public ProuctB factoryB()
{
return new ConcreteProductB1();
}
}
public class ConCreator2 implent Creator
{
public ProuctA factoryA()
{
return new ProductA2();
}
public ProuctB factoryB()
{
return new ProductB2();
}
}
public class ProductA1 implements ProductA
{
public ProductA1()
{
}
}
public class ProductA2 implements ProductA
{
public ProductA2()
{
}
}
public class ProductB1 implements ProductB
{
public ProductB1()
{
}
}
public class ProductB2 implements ProductB
{
public ProductB2()
{
}
}
实际上是这样的
1,两个工厂类ConCreator1,ConCreator2都实现了Creator接口
2,ProuctA1,ProductA2都实现了ProductA接口
3,ProuctB1,ProductB2都实现了ProductB接口
4,ConCreator1负责生产ProductA类型的产品(包括ProductA1,ProductB1)
5,ConCreator2负责生产ProductB类型的产品(包括ProductA2,ProductB2)
6,工厂方法也有这样的特征,也就是说Creator不知道什么被生产出来,甚至不知道ConCreator1还是ConCreator2被实例化了,因为client高兴调那一个工厂,就调那一个工厂,就是说工厂能生产什么,对客户端是可见的。甚至还有一种情况,客户端高兴起来就生产了ProductA1,我就不生产ProductA2,因为上面的例子中它们还都是松散的,没有绑定在一起
于是提出另外一个例子,也是老提起的电脑类型的例子
1,电脑生产商是接口,
2,CUP是接口,
3,硬盘是接口,
4,IBM工厂是制造IBM品牌的电脑的工厂
5,DELL工厂是制造DEll品牌的电脑的工厂
为讨论方便,就认为电脑=CUP+硬盘;
6,所以呀CUP有IBM的CPU和DELL的CPU
7,同样硬盘也是有IBM的硬盘和DELL的硬盘
8,IBM工厂生产IBM的CPU和IBM的硬盘,绝对不生产DELL的CPU,也不生产DELL的硬盘
9,同样DELL工厂也是一样
public interface 电脑生产商
{
public CPU 制造CPU();
public 硬盘 制造硬盘();
}
public interface CPU
{
}
public interface 硬盘
{
}
public class IBM的CPU implements CPU
{
public IBM的CPU();
}
public class IBM的硬盘 implements 硬盘
{
public IBM的硬盘();
}
public class DELL的CPU implements CPU
{
public DELL的CPU();
}
public class DELL的硬盘 implements 硬盘
{
public DELL的硬盘();
}
//下面是IBM工厂
public class IBM工厂
{
private CPU IBM的CPU私有变量=null;
private 硬盘 IBM的硬盘私有变量=null;
private CPU 制造IBMCPU()
{
return new IBM的CPU();
}
private 硬盘 制造IBM硬盘()
{
return new IBM的CPU();
}
public 电脑 制造IBM电脑()
{
try{
IBM的CPU私有变量=制造IBMCPU();
IBM的硬盘私有变量=制造IBM硬盘();
if(IBM的CPU私有变量!=null&&IBM的硬盘私有变量!=null)
retrun (IBM的CPU私有变量+IBM的硬盘私有变量);
//组装成IBM电脑
}
catch(Exception e)
{
System.out.println("制造IBM电脑失败!");
}
}
}
}
这样,客户端无法通过命令单生产出一个CPU来,这样抽象才真正成为一个完整产品的工厂,只要向工厂发出生产的命令,一台完整的电脑就生产出来了,而工厂怎么生产的,生产了哪些部件,外界就看不见了,外界就知道这个工厂是生产IBM电脑整机的工厂!
DELL电脑工厂一样
分享到:
相关推荐
工厂模式分为三种主要类型:简单工厂模式、工厂方法模式和抽象工厂模式。 1. **简单工厂模式** 简单工厂模式是最简单的工厂模式实现,它提供一个静态方法或者类来创建对象,这个类通常被称为“工厂”。用户只需要...
在软件设计模式中,工厂模式是一组非常基础且实用的设计模式,主要分为简单工厂模式、工厂方法模式和抽象工厂模式。这些模式都是为了解决对象创建的问题,通过封装对象的创建过程,使得代码更加灵活,易于扩展和维护...
工厂方法模式和抽象工厂模式是两种常见的设计模式,它们都属于创建型模式,用于解决对象的创建问题。在软件设计中,这两种模式都是用来隔离对象的创建和使用,以提高系统的灵活性和可扩展性。 首先,工厂方法模式的...
简单工厂模式适用于快速原型开发或小型项目,而工厂方法和抽象工厂模式则更适合大型项目或需要高度灵活性的系统。理解并熟练运用这些设计模式,能够提高代码的可维护性和可扩展性,也是成为一名专业IT从业者必备的...
在软件设计模式中,工厂方法模式(Factory Method Pattern)和抽象工厂模式(Abstract Factory Pattern)是两种常用的创建型设计模式,它们都属于“工厂”家族,但有着不同的应用场景和目标。 工厂方法模式的核心...
本文将探讨三个重要的设计模式:抽象工厂模式、工厂方法模式以及策略模式,并结合一个实际的场景——手机加工厂,来具体阐述它们的应用。 首先,我们来看**抽象工厂模式**。这个模式主要用于创建相关或依赖对象的...
在这个压缩包中,包含了三种工厂模式的C++实现:简单工厂模式、工厂方法模式以及抽象工厂模式。让我们一一探讨这些模式。 1. 简单工厂模式: 简单工厂模式是一种静态工厂方法,它提供一个公共的工厂类来创建对象。...
工厂模式分为三种主要类型:简单工厂模式、普通工厂模式(也称为工厂方法模式)和抽象工厂模式。 1. **简单工厂模式**: - 简单工厂模式中,有一个中心工厂类,它负责根据输入条件(通常是一个参数)来创建具体的...
在Java中,工厂模式分为三种:简单工厂、工厂方法模式和抽象工厂模式。 **简单工厂模式** 是最基本的工厂模式,它由一个工厂类根据传入的参数决定创建哪一种产品类的实例。简单工厂容易实现,但违反开闭原则,即...
在某些情况下,我们可以将简单工厂作为抽象工厂的一个实现,或者在系统初期使用简单工厂,随着系统复杂性的增加逐步过渡到抽象工厂模式。 至于“仅仅是抽象工厂模式”,这意味着设计完全围绕着抽象工厂模式进行,...
抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口,而无需指定它们的具体类。它允许客户端创建一个产品族,其中每个产品都是同一类别中的一个实例,如创建GUI组件,可以同时为Windows和Mac OS提供对应的...
抽象工厂模式则更进一步,它提供了一个创建一系列相关或相互依赖对象的接口,而无需指定它们的具体类。在多线程或者跨平台的C#应用中,抽象工厂可以帮助我们隔离产品族,使得更换产品族变得容易。例如,我们可以有...
本文将深入探讨三种工厂模式:简单工厂模式、工厂方法模式以及抽象工厂模式,并结合源码分析其应用场景和优缺点。 1. 简单工厂模式 简单工厂模式(Simple Factory Pattern)是一种静态工厂方法,它通过一个公共的...
从简单工厂,到工厂方法到抽象工厂,这几种都带有“工厂”的模式,总是容易叫人迷糊,我仔细研究了下,然后用简单的例子做类比,列出了自己的通俗理解和比较,大部分是自己的体会,感觉理的比较清楚,末尾提了下...
本文将深入探讨Java中的工厂模式,包括基本的工厂模式、抽象工厂模式以及工厂方法模式。 **工厂模式**:工厂模式的核心思想是提供一个创建对象的接口,但让实现这个接口的类来决定实例化哪一个类。这样,客户端无需...
抽象工厂模式是最为复杂的一种工厂模式,它提供了创建相关或依赖对象的家族,而无需指定它们的具体类。这种模式主要用于当产品族中的对象需要一起使用时,确保它们都属于同一产品等级结构。抽象工厂可以确保客户端...
根据描述,我们将深入探讨Java中的两种工厂模式:工厂方法模式和抽象工厂模式,并通过实例来理解它们的工作原理。 首先,我们来看**工厂方法模式**。这种模式定义了一个用于创建对象的接口,但让子类决定实例化哪一...
工厂模式分为三种主要形态:简单工厂模式、工厂方法模式和抽象工厂模式。 1. 简单工厂模式:也称为静态工厂方法模式,它通过一个静态方法来创建对象。在这个例子中,`FruitGardener` 类就是简单工厂,它根据输入的...
java设计模式 抽象工厂模式详解 一张图让你彻底明白抽象工厂模式
抽象工厂模式通过定义多个工厂接口,每个接口对应一类产品,然后由具体的工厂类实现这些接口,以创建对应的实例。这样,客户端可以通过选择不同的工厂来获取不同系列的产品,而不需要知道具体的产品实现细节。这种...