抽象工厂模式
策略模式简单工厂模式抽象工厂模式
策略模式简单工厂模式抽象工厂模式策略模式、简单工厂模式和抽象工厂模式是常见的设计模式，用于解决不同的问题和满足不同的设计需求。
下面将分别介绍这三种模式，并进行详细的比较。
策略模式策略模式是一种行为型模式，它将一组特定的算法封装成一个独立的类，使得它们可以相互替换。
应用策略模式的主要目的是让算法的变化独立于使用算法的客户端。
策略模式将算法的定义与算法的使用分离开来，这样可以让算法的定义更加灵活，能够根据需要动态地改变。
简单工厂模式简单工厂模式是一种创建型模式，它由一个工厂类负责创建不同类型的对象。
简单工厂模式的核心思想是将对象的创建过程封装起来，客户端只需要通过一个工厂类的方法来获取所需的对象，而不需要了解创建对象的细节。
简单工厂模式常常使用静态方法来创建对象，这样客户端可以直接通过类名来调用工厂方法。
抽象工厂模式也是一种创建型模式，它提供了一种创建一族相关或相互依赖对象的接口，而不需要指定具体的类。
抽象工厂模式的核心思想是将对象的创建过程封装到一个工厂接口中，具体的工厂类实现这个接口来创建不同的对象。
抽象工厂模式可以用于创建一系列的产品对象，这些产品对象有一定的关联关系。
比较1.目的不同：-策略模式的目的是将一组算法封装起来，使得它们可以相互替换。
-简单工厂模式的目的是封装对象的创建过程，使得客户端只需要通过一个工厂类的方法来获取所需的对象。
-抽象工厂模式的目的是提供一种创建一族相关或相互依赖对象的接口。
2.使用场景不同：-策略模式适用于一组特定的算法需要进行动态切换或扩展的场景。
-简单工厂模式适用于需要根据输入参数来决定创建具体对象的场景。
-抽象工厂模式适用于需要创建一系列相关或相互依赖的对象的场景。
3.灵活性不同：-策略模式的算法可以灵活地添加、删除或替换，客户端可以根据需要动态地选择所需的算法。
-简单工厂模式的创建过程在工厂类中，所以客户端只能通过修改工厂类代码来实现创建对象的变化，不够灵活。
面向对象23种设计模式
面向对象23种设计模式面向对象23种设计模式在面向对象的编程中，设计模式是一种解决问题的通用方案。
设计模式可以帮助开发人员在开发过程中减少代码的冗余和复杂性，并提高代码的可维护性和可重用性。
本文将介绍23种面向对象的设计模式。
1. 工厂方法模式工厂方法模式是一种创建型设计模式，它定义了一个用于创建对象的接口，但是让子类决定实例化哪个类。
在工厂方法模式中，客户端不需要知道具体的创建逻辑，只需要知道工厂类中定义的接口即可。
2. 抽象工厂模式抽象工厂模式是一种创建型设计模式，它提供了一个接口，用于创建相关或依赖对象的家族，而不需要指定它们的具体类。
在抽象工厂模式中，客户端不需要知道具体的创建逻辑，只需要知道工厂类中定义的接口即可。
3. 单例模式单例模式是一种创建型设计模式，它保证一个类只有一个实例，并提供一个访问该实例的全局点。
4. 原型模式原型模式是一种创建型设计模式，它允许复制或克隆一个现有的对象，而不必知道其具体实现。
5. 建造者模式建造者模式是一种创建型设计模式，它允许逐步创建复杂的对象，而不必知道其内部实现细节。
6. 适配器模式适配器模式是一种结构型设计模式，它将一个或多个不兼容的类或接口转换为客户端所需的接口。
7. 桥接模式桥接模式是一种结构型设计模式，它将抽象部分与其实现部分分离开来，以便独立地进行修改。
8. 组合模式组合模式是一种结构型设计模式，它将一组对象作为单个对象处理，以便客户端可以以相同的方式处理单个对象和组合对象。
9. 装饰器模式装饰器模式是一种结构型设计模式，它允许向现有对象添加额外的功能，同时不改变其现有的结构。
10. 外观模式外观模式是一种结构型设计模式，它为一组复杂的子系统提供了一个统一的接口，以便于客户端使用。
11. 享元模式享元模式是一种结构型设计模式，它利用共享技术来最小化内存使用，以及提高应用程序的性能。
12. 代理模式代理模式是一种结构型设计模式，它提供了一个代理对象，使得客户端可以通过代理对象间接地访问实际对象。
工厂方法和抽象工厂的区别
工厂方法和抽象工厂的区别首先，让我们来看看工厂方法模式。
工厂方法模式是一种创建型模式，它定义了一个用于创建对象的接口，但将具体的创建过程延迟到子类中。
换句话说，工厂方法模式将对象的实例化推迟到子类中进行，从而实现了对象的创建和使用分离。
这样一来，当需要添加新的产品时，只需要添加一个新的具体工厂类即可，而不需要修改现有的代码，符合了开闭原则。
而抽象工厂模式则更进一步，它提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
抽象工厂模式可以看作是工厂方法模式的升级版，它不仅仅是创建单一对象，而是创建一组相关的对象。
通过抽象工厂模式，可以实现不同产品族的创建，而不需要关心具体的产品是什么。
接下来，我们来看看工厂方法和抽象工厂之间的区别。
首先，工厂方法模式只关注于创建单一对象，它将对象的创建延迟到子类中进行，从而实现了对象的使用和创建分离。
而抽象工厂模式则更加抽象，它不仅可以创建单一对象，还可以创建一组相关的对象，这些对象之间通常存在一定的关联性。
其次，工厂方法模式只有一个抽象产品类和一个抽象工厂类，而抽象工厂模式则有多个抽象产品类和多个抽象工厂类，它们之间存在着一定的层次结构。
这也是为什么抽象工厂模式可以创建一组相关的对象，而工厂方法模式只能创建单一对象的原因。
最后，工厂方法模式只需要定义一个抽象工厂和一组具体工厂，而抽象工厂模式需要定义多个抽象工厂和一组具体工厂，因此抽象工厂模式的扩展性更好，可以应对更复杂的场景。
总的来说，工厂方法模式和抽象工厂模式都是非常重要的设计模式，它们在软件开发中有着广泛的应用。
工厂方法模式更加注重于对象的创建，而抽象工厂模式则更加注重于创建一组相关的对象。
在实际的项目中，我们可以根据具体的需求选择合适的模式来进行设计，从而更好地满足项目的需求。
希望本文对读者能够有所帮助，谢谢阅读！。
策略模式简单工厂模式抽象工厂模式
策略模式简单⼯⼚模式抽象⼯⼚模式⽆论⼯⼚还是策略模式，每个具体⼯具类（⼯⼚模式）/具体策略类（策略模式）中执⾏⽅法名都是⼀样的，都和抽象⼯具（⼯⼚模式）/抽象策略（策略模式）中⽅法名⼀样的1、简单⼯⼚类 思想：将创建何种⼯具交由⼯⼚。
将原本逻辑if...else...中“变”的部分抽离为具体⼯具类，调⽤⽅通过在⼯⼚中传⼊标志符来确定创建何种⼯具 结构图： 代码实现： 抽象⼯具类： public abstract class FAbsStep {public abstract void run();} 具体⼯具类： public class FBanmaStep extends FAbsStep{public void run() {System.out.println("斑马编译步骤开始执⾏");System.out.println("斑马编译步骤...");System.out.println("斑马编译步骤执⾏结束");}}public class FshangqiStep extends FAbsStep{public void run() {System.out.println("上汽编译步骤开始执⾏");System.out.println("上汽编译步骤...");System.out.println("上汽编译步骤执⾏结束");}} ⼯⼚类：⽤于创建具体⼯具（通过传⼊string类型标志位来判断创建何种⼯具）public class Ffactory {public FAbsStep getStep(String name) { //①通过name来判断创建何种具体⼯具②返回抽象产品结果if(name.equals("banma")) {return new FBanmaStep();}else {return new FshangqiStep();}}} main⽅法public class Fmain {public static void main(String[] args) {Ffactory tfactory=new Ffactory();FAbsStep step=tfactory.getStep("shangqi"); //创建出具体⼯具实例step.run(); //执⾏具体实例⽅法}}2、策略模式 思想：根据传⼊何种策略具体执⾏对应⾏为 结构图： 代码实现： 抽象策略：public abstract class TAbsStep {public abstract void run();} 具体策略： public class TBanmaStep extends FAbsStep{public void run() {System.out.println("斑马编译步骤开始执⾏");System.out.println("斑马编译步骤...");System.out.println("斑马编译步骤执⾏结束");}}public class TshangqiStep extends FAbsStep{public void run() {System.out.println("上汽编译步骤开始执⾏");System.out.println("上汽编译步骤...");System.out.println("上汽编译步骤执⾏结束");}} 环境类：抽象策略类作为成员变量，接收具体策略//TEnvironment环境类，⽤户传⼊具体策略类名进⽽执⾏具体策略public class TEnvironment {private FAbsStep fAbsStep; //抽象策略策略类作为环境类的成员变量public TEnvironment(FAbsStep fAbsStep) { //环境类构造⽅法，抽象策略作为形参this.fAbsStep=fAbsStep;}public void exec() {fAbsStep.run();}} main类：public class Tmain {public static void main(String[] args) {TEnvironment tEnvironment = new TEnvironment(new TshangqiStep()); //环境类传⼊具体策略⽅法，⽤来执⾏对应策略⽅法tEnvironment.exec();}}简单⼯⼚VS策略1.⾸先看⼀下接收的参数：简单⼯⼚类中的Ffactory.getStep() ⽅法接收的是字符串，返回的是⼀个 FAbsStep(抽象⼯⼚类)对象；⽽策略模式Environment 类初始化时需要接收⼀个 new TshangqiStep()(具体策略类)对象。
简单工厂工厂方法抽象工厂策略模式策略与工厂的区别
简单工厂工厂方法抽象工厂策略模式策略与工厂的区别简单工厂、工厂方法、抽象工厂以及策略模式在软件开发中都是常用的设计模式，它们都是为了解决不同对象的创建和使用问题。
下面将对它们进行详细的介绍，并比较它们之间的区别。
1. 简单工厂模式（Simple Factory Pattern）：简单工厂模式是由一个工厂类根据传入的参数决定创建哪种产品的设计模式。
它包含三个角色：工厂类负责创建产品，产品类定义产品的具体实现，客户端通过工厂类获取产品对象。
简单工厂模式将对象的创建与使用进行了分离，增加了灵活性，但是违反了开闭原则，因为每次新增产品都需要修改工厂类。
2. 工厂方法模式（Factory Method Pattern）：工厂方法模式是指定义一个创建产品对象的接口，但是由子类决定实例化哪个类。
这样可以将产品的实例化延迟到子类中进行，满足了开闭原则。
工厂方法模式由抽象工厂类、具体工厂类和抽象产品类、具体产品类组成。
具体工厂类负责创建具体产品类的实例，抽象产品类定义了产品的接口。
客户端通过抽象工厂类获取产品对象。
工厂方法模式解决了简单工厂模式的缺点，但是增加了类的个数。
3. 抽象工厂模式（Abstract Factory Pattern）：抽象工厂模式是指提供一个创建一系列相关或互相依赖对象的接口，而无需指定具体的类。
抽象工厂模式由抽象工厂类、具体工厂类和抽象产品类、具体产品类组成。
抽象工厂类定义了创建产品的接口，具体工厂类负责创建具体产品。
抽象产品类定义了产品的接口，具体产品类实现了产品的具体实现。
客户端通过抽象工厂类获取产品对象。
抽象工厂模式提供了一种创建一系列产品对象的方法，但是增加新产品时需要修改所有的工厂类。
4. 策略模式（Strategy Pattern）：策略模式是指定义了一系列的算法，并将每个算法封装起来，使得它们可以互相替换，使得算法的选择和使用可以独立于客户端。
策略模式由抽象策略类、具体策略类和环境类组成。
java 面向对象的常用设计模式
java 面向对象的常用设计模式java 面向对象的常用设计模式有：1、观察者模式观察者模式又称为发布-订阅模式，定义了对象之间一对多依赖关系，当目标对象(被观察者)的状态发生改变时，它的所有依赖者(观察者)都会收到通知。
2、抽象工厂模式抽象工厂模式主要用于创建相关对象的家族。
当一个产品族中需要被设计在一起工作时，通过抽象工厂模式，能够保证客户端始终只使用同一个产品族中的对象；并且通过隔离具体类的生成，使得客户端不需要明确指定具体生成类；所有的具体工厂都实现了抽象工厂中定义的公共接口，因此只需要改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。
3、单例设计模式单例设计模式可以确保系统中某个类只有一个实例，该类自行实例化并向整个系统提供这个实例的公共访问点，除了该公共访问点，不能通过其他途径访问该实例。
4、策略模式将类中经常改变或者可能改变的部分提取为作为一个抽象策略接口类，然后在类中包含这个对象的实例，这样类实例在运行时就可以随意调用实现了这个接口的类的行为。
比如定义一系列的算法，把每一个算法封装起来，并且使它们可相互替换，使得算法可独立于使用它的客户而变化，这就是策略模式。
5、适配器模式适配器模式主要用于将一个类或者接口转化成客户端希望的格式，使得原本不兼容的类可以在一起工作，将目标类和适配者类解耦；同时也符合“开闭原则”，可以在不修改原代码的基础上增加新的适配器类；将具体的实现封装在适配者类中，对于客户端类来说是透明的，而且提高了适配者的复用性，但是缺点在于更换适配器的实现过程比较复杂。
6、命令模式命令模式的本质是将请求封装成对象，将发出命令与执行命令的责任分开，命令的发送者和接收者完全解耦，发送者只需知道如何发送命令，不需要关心命令是如何实现的，甚至是否执行成功都不需要理会。
命令模式的关键在于引入了抽象命令接口，发送者针对抽象命令接口编程，只有实现了抽象命令接口的具体命令才能与接收者相关联。
设计模式(简单工厂,工厂方法,抽象工厂)区别
第一种表述简单工厂，工厂方法，抽象工厂都属于设计模式中的创建型模式。
其主要功能都是帮助我们把对象的实例化部分抽取了出来，优化了系统的架构，并且增强了系统的扩展性。
本文是本人对这三种模式学习后的一个小结以及对他们之间的区别的理解。
简单工厂简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。
不修改代码的话，是无法扩展的。
工厂方法工厂方法是针对每一种产品提供一个工厂类。
通过不同的工厂实例来创建不同的产品实例。
在同一等级结构中，支持增加任意产品。
抽象工厂抽象工厂是应对产品族概念的。
比如说，每个汽车公司可能要同时生产轿车，货车，客车，那么每一个工厂都要有创建轿车，货车和客车的方法。
应对产品族概念而生，增加新的产品线很容易，但是无法增加新的产品。
小结★工厂模式中，重要的是工厂类，而不是产品类。
产品类可以是多种形式，多层继承或者是单个类都是可以的。
但要明确的，工厂模式的接口只会返回一种类型的实例，这是在设计产品类的时候需要注意的，最好是有父类或者共同实现的接口。
★使用工厂模式，返回的实例一定是工厂创建的，而不是从其他对象中获取的。
★工厂模式返回的实例可以不是新创建的，返回由工厂创建好的实例也是可以的。
区别简单工厂：用来生产同一等级结构中的任意产品。
（对于增加新的产品，无能为力）工厂模式：用来生产同一等级结构中的固定产品。
（支持增加任意产品）抽象工厂：用来生产不同产品族的全部产品。
（对于增加新的产品，无能为力；支持增加产品族）以上三种工厂方法在等级结构和产品族这两个方向上的支持程度不同。
所以要根据情况考虑应该使用哪种方法。
第二种表述简单工厂、工厂方法和抽象工厂都是创建型的设计模式。
三者的共同点是：1、都有两种作用不同的类：产品类和工厂类。
其中，工厂类在自己的方法中实例化产品类（即使用new命令生成产品类的对象），并将生成的产品类的对象提供给外部使用。
2、创建的过程，都是类似的：工厂类得到一个标志（可以由程序输入，也可以读取配置文件中的内容），返回一个产品对象。
实验3 抽象工厂模式
interfaceView {
voidcreate();
}
classAndroidimplementsContral {
publicvoidcreate() {
System.out.println("contral");
}
}
classAndroid2implementsView
{
publicvoidcreate() {
publicvoidcreate() {
System.out.println("mac'RAM");
}
}
interfaceComputerFactory {
CPU produceCPU();
RAM produceRAM();
}
classPcFactoryimplementsComputerFactory {
RAM ram;
Factory = new ComputerFactory();
cpu =factory.produceCPU();
cpu.create();
ram =factory.produceRAM();
ram.create();
}
}
2.类图及代码：
interfaceContral {
voidcreate();
Factory factory =newSymbinFactory();
Contral c;
View v;
c = factory.produce1();
c.create();
v = factory.produce2();
v.create();
}
}
五．实验总结
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品具体类型的情况下，创建多个产品族中的产品对象。
这就是抽象工厂模式的用意。
每个模式都是针对一定问题的解决方案。
抽象工厂模式面对的问题是多产品等级结构的系统设计。
在学习抽象工厂具体实例之前，应该明白两个重要的概念：产品族和产品等级。
产品族：是指位于不同产品等级结构中，功能相关联的产品组成的家族。
比如AMD的CPU和ADM芯片的主板，组成一个家族。
Intel的CPU和Intel芯片的主板，又组成一个家族。
而这两个家族都来自于两个产品等级：CPU，主板。
一个等级结构是由相同的结构的产品组成，示意图如下：理解这个产品结构是理解抽象工厂模式的关键所在，所以我不惜花费时间来画此图。
如果领悟不到此图的含义，就无法区分工厂方法模式和抽象工厂模式的区别。
从上图可以看出，抽象工厂模式的每个工厂创造出来的都是一族产品，而不是一个或者一组。
组是可以随意组合的！其实两个就这点点差别，呵呵，估计现在你已经差不多明白了抽象工厂模式的含义。
不废话了，看个例子，真相将大白于天下！1.3.1 抽象工厂模式在农场中的实现1.3.1.1 背景聪明的农场主总是让自己的庄园越来越有价值，“农场”在经历了简单工厂模式和工厂模式后，不断的扩大生产。
如今，再次面临新的大发展，一项重要的工作就是引进塑料大棚技术，在大棚里种植热带（Trop ical）和亚热带（Northern）的水果和蔬菜，用以满足市场需求，获取更大的利益。
1.3.1.2 产品角色图经过分析，对产品角色进行分析得出下图1.3.1.3 系统设计经过分析，所谓的各个园丁其实就是工厂角色，而蔬菜和水果则是产品角色。
将抽象工厂模式用于农场中，系统设计图如下：1.3.1.4 实现源码1.3.1.4.1 抽象工厂：Gardener.javapackage vasoft.patterns.abstractfactory.ybms; /*** Created by IntelliJ IDEA.* FileName:Gardener.java* User: LavaSoft* Date: 2006-12-5* Time: 22:55:23* 《Java与模式》（--阎宏博士著）读书笔记* 工厂模式--抽象工厂模式--一般性模式（农场应用）* ReadMe: 抽象工厂角色：工厂接口*/public interface Gardener {public Fruit createFruit(String name);public Veggie createVeggie(String name);}1.3.1.4.2 抽象水果产品：Fruit.javapackage vasoft.patterns.abstractfactory.ybms; /*** Created by IntelliJ IDEA.* FileName:Fruit.java* User: LavaSoft* Date: 2006-12-5* Time: 22:54:15* 《Java与模式》（--阎宏博士著）读书笔记* 工厂模式--抽象工厂模式--一般性模式（农场应用）* ReadMe: 抽象产品角色：水果接口*/public interface Fruit {}1.3.1.4.3 抽象蔬菜产品：Veggie.javapackage vasoft.patterns.abstractfactory.ybms; /*** Created by IntelliJ IDEA.* FileName:Veggie.java* User: LavaSoft* Date: 2006-12-5* Time: 22:56:22* 《Java与模式》（--阎宏博士著）读书笔记* 工厂模式--抽象工厂模式--一般性模式（农场应用）* ReadMe: 抽象产品角色：蔬菜接口public interface Veggie {}1.3.1.4.4 热带水果：TropicalFruit.javapackage vasoft.patterns.abstractfactory.ybms;/*** Created by IntelliJ IDEA.* FileName:TropicalFruit.java* User: LavaSoft* Date: 2006-12-5* Time: 22:57:08* 《Java与模式》（--阎宏博士著）读书笔记* 工厂模式--抽象工厂模式--一般性模式（农场应用）* ReadMe: 具体产品角色：热带水果*/public class TropicalFruit implem ents Fruit {private String name;public TropicalFruit(String name) {System.out.println("热带工厂为您创建了：热带水果－"+name);}public String getName() {return name;}public void setNam e(String name) {this.nam e = name;}}1.3.1.4.5 热带蔬菜：TropicalVeggie.javapackage vasoft.patterns.abstractfactory.ybms;/*** Created by IntelliJ IDEA.* FileName:TropicalVeggie.java* User: LavaSoft* Date: 2006-12-5* Time: 22:58:03* 《Java与模式》（--阎宏博士著）读书笔记* 工厂模式--抽象工厂模式--一般性模式（农场应用）* ReadMe: 具体产品角色：热带蔬菜*/public class TropicalVeggie implements Veggie {private String name;public TropicalVeggie(String name) {System.out.println("热带工厂为您创建了：热带水果－"+name);}public String getName() {return name;}public void setNam e(String name) {this.nam e = name;}}1.3.1.4.6 亚热带水果：NorthernFruit.javapackage vasoft.patterns.abstractfactory.ybms;/*** Created by IntelliJ IDEA.* FileName:NorthernFruit.java* User: LavaSoft* Date: 2006-12-5* Time: 22:58:55* 《Java与模式》（--阎宏博士著）读书笔记* 工厂模式--抽象工厂模式--一般性模式（农场应用）* ReadMe: 具体产品角色：亚热带水果*/public class NorthernFruit implements Fruit {private String name;public NorthernFruit(String name) {System.out.println("亚热带工厂为您创建了：亚热带水果－"+name);}public String getName() {return name;}public void setNam e(String name) {this.nam e = name;}}1.3.1.4.7 亚热带蔬菜：NorthernVeggie.javapackage vasoft.patterns.abstractfactory.ybms;/*** Created by IntelliJ IDEA.* FileName:NorthernVeggie.java* User: LavaSoft* Date: 2006-12-5* Time: 22:59:36* 《Java与模式》（--阎宏博士著）读书笔记* 工厂模式--抽象工厂模式--一般性模式（农场应用）* ReadMe: 具体产品角色：亚热带蔬菜*/public class NorthernVeggie implements Veggie {private String name;public NorthernVeggie(String name) {System.out.println("亚热带工厂为您创建了：亚热带蔬菜－"+name);}public String getName() {return name;}public void setNam e(String name) {this.nam e = name;}}1.3.1.4.8 热带工厂：TropicalGardener.java/*** Created by IntelliJ IDEA.* FileName:TropicalGardener.java* User: LavaSoft* Date: 2006-12-5* Time: 23:01:49* 《Java与模式》（--阎宏博士著）读书笔记* 工厂模式--抽象工厂模式--一般性模式（农场应用）* ReadMe: 具体工厂角色：热带工厂*/public class TropicalGardener implements Gardener {public Fruit createFruit(String name) {return new TropicalFruit(name);}public Veggie createVeggie(String name) {return new TropicalVeggie(name);}}1.3.1.4.9 亚热带工厂：NorthernGardener.j avapackage vasoft.patterns.abstractfactory.ybms;/*** Created by IntelliJ IDEA.* FileName:NorthernGardener.java* User: LavaSoft* Date: 2006-12-5* Time: 23:00:31* 《Java与模式》（--阎宏博士著）读书笔记* 工厂模式--抽象工厂模式--一般性模式（农场应用）* ReadMe: 具体工厂角色：亚热带工厂*/public class NorthernGardener implements Gardener { public Fruit createFruit(String name) {return new NorthernFruit(name);}public Veggie createVeggie(String name) {return new NorthernVeggie(name);}}1.3.1.4.10 测试类（客户端）：TestApp.javapackage vasoft.patterns.abstractfactory.ybms; /*** Created by IntelliJ IDEA.* FileName:TestApp.java* User: LavaSoft* Date: 2006-12-5* Time: 23:03:22* 《Java与模式》（--阎宏博士著）读书笔记* 工厂模式--抽象工厂模式--一般性模式（农场应用）* ReadMe: 测试类（客户端）*/public class TestApp {private void test(){Veggie tv,nv;Fruit tf,nf;TropicalGardener tg=new TropicalGardener();NorthernGardener ng=new NorthernGardener();tv=tg.createVeggie("热带菜叶");nv=ng.createVeggie("东北甜菜");tf=tg.createFruit("海南椰子");nf=ng.createFruit("雪梨");}public static void main(String args[]){TestApp test=new TestApp();test.test();}}1.3.1.4.11 测试运行结果热带工厂为您创建了：热带水果－热带菜叶亚热带工厂为您创建了：亚热带蔬菜－东北甜菜热带工厂为您创建了：热带水果－海南椰子亚热带工厂为您创建了：亚热带水果－雪梨Process finished with exit code 0看完设计图和源码，原理已经很清楚了，这个模式应用很灵活，猴交给你了，看你怎么玩它！哈哈哈哈。