简单工厂模式与工厂模式和抽象工厂模式
简单工厂模式、工厂模式和抽象工厂模式区别及优缺点
简单⼯⼚模式、⼯⼚模式和抽象⼯⼚模式区别及优缺点各位⼩伙伴好，今天给⼤家主要介绍⼀下简单⼯⼚模式、⼯⼚模式和抽象⼯⼚模式的区别及各⾃的优缺点。
（本⽂实现语⾔为Python3）【前⾔】众所周知今天所讲的内容是设计模式的⼀类；对于设计模式这个概念，我想⾸先请⼤家问问⾃⼰：1、什么是设计模式 2、我们为什么要了解并学习设计模式？从我上学的时候我相信⼤家跟我⼀样也接触过设计模式的课程，当时可能懵懵懂懂只是知其然，当时还会想明明可以直接写出来为什么要搞成这样的形式，我就算学会了它到底什么时候能⽤呢？⼀系列的问题...Emm算了到时候再想想（lazy）。
随着实践的不断增多，现在我想可以对这些问题有个初步的回答了： 1、在我看来，设计模式外在看是经过前⼈不断实践总结出的针对某些指定场景极其好⽤的⼀种代码结构设计模板；内在看其实是⼀种设计思想(即为什么他们会这么想，这样想较之其他⽅法有什么好处)。
当我们真正的理解设计思想的时候，就可能会在⾯对问题和场景时⾃然⽽然的灵活运⽤到多种设计模式，⽽不是单⼀的刻板结构。
2、在⼯程化的开发中，需求往往是会不断变化的，这也是让很多开发⼈员及其烦躁的地⽅，所以才会有开发与产品的亲密关系。
设计模式就是为了抵御外部需求变化产⽣的。
设计模式应符合开闭原则(类、模块和函数等应该对扩展开放，对修改关闭。
)⼀个好的设计在之后的开发中，包括发⽣重⼤需求变化的时候，往往代码只需要进⾏简单重构去进⾏适配，⽽不是通过打补丁的⽅式去堆砌，也很容易避免破窗效应，充分的发挥了灵活的扩展和适配，⼤⼤增强了维护性。
综上所述，我们了解并学习设计模式，可以使我们的代码变得更加健壮、结构清晰，可以从容、灵活的适配需求变更(可复⽤、可扩展、可维护、够灵活)【正⽂】⾸先，这三种模式解决的问题是实例化对象的问题；那么为什么不直接实例化⽽⽤这样的⼯⼚形式去实例化对象呢？因为【待实例化对象太多(⼦类多且变动、调⽤频繁)或者实例化对象的过程、准备⽐较复杂】，直接实例化意味着每次都⽤重复的去执⾏实例化这个操作，如果有很多待实例化的操作，那么就要重复执⾏很多次，更不要说万⼀在实例化之前还要执⾏⼀堆配置项的初始化。
策略模式简单工厂模式抽象工厂模式
策略模式简单工厂模式抽象工厂模式策略模式、简单工厂模式和抽象工厂模式是常见的设计模式，用于解决不同的问题和满足不同的设计需求。
下面将分别介绍这三种模式，并进行详细的比较。
策略模式策略模式是一种行为型模式，它将一组特定的算法封装成一个独立的类，使得它们可以相互替换。
应用策略模式的主要目的是让算法的变化独立于使用算法的客户端。
策略模式将算法的定义与算法的使用分离开来，这样可以让算法的定义更加灵活，能够根据需要动态地改变。
简单工厂模式简单工厂模式是一种创建型模式，它由一个工厂类负责创建不同类型的对象。
简单工厂模式的核心思想是将对象的创建过程封装起来，客户端只需要通过一个工厂类的方法来获取所需的对象，而不需要了解创建对象的细节。
简单工厂模式常常使用静态方法来创建对象，这样客户端可以直接通过类名来调用工厂方法。
抽象工厂模式也是一种创建型模式，它提供了一种创建一族相关或相互依赖对象的接口，而不需要指定具体的类。
抽象工厂模式的核心思想是将对象的创建过程封装到一个工厂接口中，具体的工厂类实现这个接口来创建不同的对象。
抽象工厂模式可以用于创建一系列的产品对象，这些产品对象有一定的关联关系。
比较1.目的不同：-策略模式的目的是将一组算法封装起来，使得它们可以相互替换。
-简单工厂模式的目的是封装对象的创建过程，使得客户端只需要通过一个工厂类的方法来获取所需的对象。
-抽象工厂模式的目的是提供一种创建一族相关或相互依赖对象的接口。
2.使用场景不同：-策略模式适用于一组特定的算法需要进行动态切换或扩展的场景。
-简单工厂模式适用于需要根据输入参数来决定创建具体对象的场景。
-抽象工厂模式适用于需要创建一系列相关或相互依赖的对象的场景。
3.灵活性不同：-策略模式的算法可以灵活地添加、删除或替换，客户端可以根据需要动态地选择所需的算法。
-简单工厂模式的创建过程在工厂类中，所以客户端只能通过修改工厂类代码来实现创建对象的变化，不够灵活。
工厂模式的实现方式
工厂模式的实现方式
工厂模式有以下几种实现方式：
1. 简单工厂模式：由一个工厂类负责创建对象，根据传入的参数不同，工厂类可以创建不同的对象。
这种方式对于创建简单的对象较为适用，但是如果需要创建复杂的对象或者对象之间存在复杂的依赖关系，则不太适用。
2. 工厂方法模式：定义一个创建对象的工厂接口，由具体的工厂类来实现这个接口，每个具体工厂类负责创建一种具体的对象。
这种方式可以避免简单工厂模式中的一个类负责创建所有对象的问题，而且可以方便地扩展创建新的对象。
3. 抽象工厂模式：定义一个抽象工厂接口，具体的工厂类实现这个接口并负责创建一组相关的对象。
这种方式可以创建一组相关的对象，而不仅仅是单个对象。
这三种实现方式都可以用来创建对象，具体选择哪一种方式取决于具体的需求和设计。
软件开发几种设计模式
抽象工厂 ：
用来生产不同产品族的全部固定产品； 可以增加新产品族（不同产品的组合），但不能增加新产品； 不同产品族通过不同的工厂类生成，一个类中有多个成员函数去
生成不同具体产品。
简单工厂
特点：
简单工厂模式的工厂类一般使用静态方法生成产品对象，通过输 入参数的不同来返回不同对象实例。
个工厂就生产一个品牌的所有轿车、货车和客车。 增加新的产品线（已有产品的组合）很容易，但是无法增加新的产品。
工厂模式
工厂模式中，重要的是工厂类，而不是产品类。
产品类可以是多种形式。 但要明确，工厂模式的接口只会返回一种类型的实
例。 所以在设计产品类时要注意，一般是返回父类或者
共同实现的接口。
单例模式
特点：
通过静态函数来生成唯一实例。 构造函数是私有的。
其主要功能都是帮助我们把对象的实例化部分 抽取出来，优化系统架构，增强系统扩展性。
工厂模式
主要作用
抽象了对象的构造过程，即生成对象的过程。
使得具有
可以具有一个共同的
或者统一的生成方法。避免了总是写几乎完全
重复的构造函数，生成功能差不多的对象。
注意：
类似功能的对象并不是完全相同的对象。它们 虽然大体类似，但是确有具体差别。
使用工厂模式，返回的实例一定是工厂创建的， 而不是从其它对象中获取的。
工厂模式返回的实例可以不是新创建的，返回 由工厂创建好的实例也可以。
单例模式 （Singleton Pattern）
单例模式
主要作用
保证一个类仅有一个实例，并提供一个访问它 的全局访问点。
简单地说，就是代替全局对象。
几种设计模式
策略模式简单工厂模式抽象工厂模式
策略模式简单⼯⼚模式抽象⼯⼚模式⽆论⼯⼚还是策略模式，每个具体⼯具类（⼯⼚模式）/具体策略类（策略模式）中执⾏⽅法名都是⼀样的，都和抽象⼯具（⼯⼚模式）/抽象策略（策略模式）中⽅法名⼀样的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. 简单工厂模式：
- 定义一个工厂类，提供一个静态方法（或实例方法），接收参数并根据参数返回不同的产品实例。
- 例如，有一个`AnimalFactory`，通过传入字符串类型参数如"dog"或"cat"，返回对应的`Dog`或`Cat`对象实例。
2. 工厂方法模式：
- 定义一个抽象工厂类，其中声明一个创建产品的抽象方法，由其子类来实现具体的创建逻辑。
- 如有`AnimalFactory`抽象类，其中包含`createAnimal()`抽象方法，然后分别创建`DogFactory`和`CatFactory`子类，它们各自重写`createAnimal()`方法，返回相应的`Dog`或`Cat`对象实例。
3. 抽象工厂模式：
- 提供一个接口用于创建相关或依赖对象家族的多个对象，而无需指定具体的产品类。
- 假设存在不同类型的动物及其对应的食物，可以创建一个`PetFactory`抽象工厂，它能生产出某一特定种类的宠物及其专属食物。
工厂模式的业务逻辑就是围绕如何根据需求动态选择和创建合适对象来进行组织和设计，从而降低耦合度，提高代码的灵活性和可扩展性。
简单工厂工厂方法抽象工厂策略模式策略与工厂的区别
简单工厂工厂方法抽象工厂策略模式策略与工厂的区别简单工厂、工厂方法、抽象工厂以及策略模式在软件开发中都是常用的设计模式，它们都是为了解决不同对象的创建和使用问题。
下面将对它们进行详细的介绍，并比较它们之间的区别。
1. 简单工厂模式（Simple Factory Pattern）：简单工厂模式是由一个工厂类根据传入的参数决定创建哪种产品的设计模式。
它包含三个角色：工厂类负责创建产品，产品类定义产品的具体实现，客户端通过工厂类获取产品对象。
简单工厂模式将对象的创建与使用进行了分离，增加了灵活性，但是违反了开闭原则，因为每次新增产品都需要修改工厂类。
2. 工厂方法模式（Factory Method Pattern）：工厂方法模式是指定义一个创建产品对象的接口，但是由子类决定实例化哪个类。
这样可以将产品的实例化延迟到子类中进行，满足了开闭原则。
工厂方法模式由抽象工厂类、具体工厂类和抽象产品类、具体产品类组成。
具体工厂类负责创建具体产品类的实例，抽象产品类定义了产品的接口。
客户端通过抽象工厂类获取产品对象。
工厂方法模式解决了简单工厂模式的缺点，但是增加了类的个数。
3. 抽象工厂模式（Abstract Factory Pattern）：抽象工厂模式是指提供一个创建一系列相关或互相依赖对象的接口，而无需指定具体的类。
抽象工厂模式由抽象工厂类、具体工厂类和抽象产品类、具体产品类组成。
抽象工厂类定义了创建产品的接口，具体工厂类负责创建具体产品。
抽象产品类定义了产品的接口，具体产品类实现了产品的具体实现。
客户端通过抽象工厂类获取产品对象。
抽象工厂模式提供了一种创建一系列产品对象的方法，但是增加新产品时需要修改所有的工厂类。
4. 策略模式（Strategy Pattern）：策略模式是指定义了一系列的算法，并将每个算法封装起来，使得它们可以互相替换，使得算法的选择和使用可以独立于客户端。
策略模式由抽象策略类、具体策略类和环境类组成。
三种工厂模式区别
工厂方法模式：一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别：工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
看了网络上很多关于设计模式的方法,有的模式看起来相似,但本质还是区别很大的.像简单工厂,工厂方法和抽象工厂就有很明显的区别.有一个比较好理解的例子,在这跟大家介绍下:1.如果一个后花园只种蔬菜类,那么就用简单工厂就可以了.2.如果后花园蔬菜品种繁多.得用工厂方法才可以,把共有的东西抽象出来.3.如果要扩大后花园的规模,比如一个在北方,一个在南方,这样工厂方法就无法实现了,就应当用抽象工厂,把各种各样的植物,又组成一个后花园.所以我个人认为,简单工厂是一个工厂只生产一类的产品,面对的是具体的类,工厂方法是可以生产不同的产品,把公共的方法抽象出来,然后进行创建各种各样的产品.抽象工厂把几种产品划出共同的东西,把相互依赖的对象抽象出来,只要实现这些接口就可以得到不同的产品.具体例子:1.简单工厂:using System;public interface ICar{void run();}public class BMWCar : ICar{public void run(){Console.WriteLine("BMWCar run");}}public class BenzCar : ICar{public void run(){Console.WriteLine("BenzCar run");}}public class Driver{public static ICar DriverCar(string carType){switch (carType){case "BMWCar": return new BMWCar();case "BenzCar": return new BenzCar();default: throw new Exception();}}}public class Client{public static void Main(){ICar m yCar =Driver.DriverCar("BenzCar");m yCar.run();Console.Read();}}心得:优点是只要实现共有的接口就可以实现不同车跑的方式.但缺点就是要判断哪一种车,造成要修改Driver 类2.工厂方法:using System;public interface ICar{void run();public class BMWCar : ICar{public void run(){Console.WriteLine("BMWCar run"); }}public class BenzCar : ICar{public void run(){Console.WriteLine("BenzCar run"); }}public abstract class Driver{public abstract ICar DriverCar();}public class BMWDriver : Driver{public override ICar DriverCar(){return new BMWCar();}}public class BenzDriver : Driver{public override ICar DriverCar(){return new BenzCar();}}class Client{public static void Main(){Driver m yDriver = new BenzDriver();ICar m yCar =myDriver.DriverCar();m yCar.run();Console.Read();}}心得:优点是符合了开放-封闭原则(OCP),从整体上还看不出什么缺点.3.抽象工厂:using System;public interface IBusinessCar{void run();}public interface ISportCar{void run();}public class BMWBusinessCar : IBusinessCar{public void run(){Console.WriteLine("BMWCar run");}}public class BenzBusinessCar : IBusinessCar{public void run(){Console.WriteLine("BenzBusinessCar run");}public class BMWSportCar:ISportCar {public void run(){Console.WriteLine("BMWSportCar run"); }}public class BenzSportCar:ISportCar {public void run(){Console.WriteLine("BenzSportCar run"); }}public interface IDriver{IBusinessCar BusinessCarDriver(); ISportCar SportCarDriver();}public class BMWDriver:IDriver{public IBusinessCar BusinessCarDriver() {return new BMWBusinessCar();}public ISportCar SportCarDriver(){return new BMWSportCar();}}public class BenzDriver:IDriverpublic IBusinessCar BusinessCarDriver(){return new BenzBusinessCar();}public ISportCar SportCarDriver(){return new BenzSportCar();}}class Client{public static void Main(){IDriver myDriver =new BenzDriver();ISportCar m yCar =myDriver.SportCarDriver();m yCar.run();Console.Read();}}心得:抽象方法似乎达到了完美境界.把开奔驰的司机和开宝马的司机的公共方法抽象出来,并对不同的司机创建不同的类,到时候不管是开什么车的司机随你添加.它们唯一的共同点都是开车. 教你如何用WORD文档(2012-06-27 192246)转载▼标签：杂谈1. 问：WORD 里边怎样设置每页不同的页眉？如何使不同的章节显示的页眉不同？答：分节，每节可以设置不同的页眉。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Java1.1 简单工厂（Simple Factory）模式简单工厂模式是类的创建，又叫静态工厂方法（Static Factory Methord）模式。
简单工厂模式是由一个工厂对象决定创造哪一种产品类的实例。
1.1.1 工厂模式的几种形态工厂模式专门负责将大量有共同接口的类实例化。
工厂模式可以动态的决定将哪一个类实例化，工厂模式有以下几种形态：λ简单工厂（Simple Factory）模式：又称静态工厂方法（Static Factory Methord）模式。
λ工厂方法（Factory Method）模式：又称多态性工厂（Polymorphic Factory）模式或虚拟构造子（Virtual Constructor）模式。
λ抽象工厂（Abstract Factory）模式：又称工具箱（Kit或Toolkit）模式。
下图所示的就是简单工厂模式的简略类图。
简单工厂模式，或称静态工厂方法模式，是不同工厂方法模式的一个特殊实现。
在Java语言中，通常的工厂方法模式不能通过设计功能的退化给出静态工厂方法模式。
1.1.2 简单工厂模式的引进（一般模式）比如有一个农场，生产各种水果，有苹果（Apple）、草莓（Strawberry）、葡萄（Grape）；农场的园丁（FruitGardener）要根据客户的需求，提供相应的水果。
下面看看是如何用简单工厂模式实现这个过程的，如下图：此模式的实现源码如下：1.1.2.1 产品接口－水果接口：Fruit.javapackage vasoft.patterns.simplefactory.ybgc;/*** Created by IntelliJ IDEA.* FileName:Fruit.java* User: LavaSoft* Date: 2006-12-1* Time: 0:26:51* 《Java与模式》（--阎宏博士著）读书笔记* 工厂模式模式--简单工厂模式--一般模式* ReadMe: 抽象产品角色:工厂的水果产品接口--水果*/public interface Fruit {/*** 种植*/void plant();/*** 生长*/void grow();/*** 收获*/void harvest();}1.1.2.2 产品－平果类：Apple.java package vasoft.patterns.simplefactory.ybgc;* Created by IntelliJ IDEA.* FileName:Apple.java* User: LavaSoft* Date: 2006-12-1* Time: 0:47:25* 《Java与模式》（--阎宏博士著）读书笔记* 工厂模式模式--简单工厂模式--一般模式* ReadMe: 水果工厂的产品:苹果*/public class Apple implements Fruit {private int treeAge;/*** 种植*/public void plant() {System.out.println("Apple has been planted.");}/*** 生长*/public void grow() {System.out.println("Apple is growing...");}/*** 收获*/public void harvest() {System.out.println("Apple has been harvested.");}/*** @return 返回树龄*/public int getTreeAge() {return treeAge;}/*** 设置树龄*/public void setTreeAge(int treeAge) {this.treeAge = treeAge;}}1.1.2.3 产品－草莓类：Strawberry.ja vapackage vasoft.patterns.simplefactory.ybgc;/*** Created by IntelliJ IDEA.* FileName:Strawberry.java* User: LavaSoft* Date: 2006-12-1* Time: 0:45:09* 《Java与模式》（--阎宏博士著）读书笔记* 工厂模式模式--简单工厂模式--一般模式* ReadMe: 水果工厂的产品:草莓*/public class Strawberry implements Fruit {/*** 生长*/public void grow() {System.out.println("Strawberry is growing...");}/*** 收获*/public void harvest() {System.out.println("Strawberry has been harvested.");}/*** 种植*/public void plant() {System.out.println("Strawberry has been planted.");}/*** 辅助方法*/public static void log(String msg) {System.out.println(msg);}}1.1.2.4 产品－葡萄类：Grape.javapackage vasoft.patterns.simplefactory.ybgc;/*** Created by IntelliJ IDEA.* FileName:Grape.java* User: LavaSoft* Date: 2006-12-1* Time: 0:36:56* 《Java与模式》（--阎宏博士著）读书笔记* 工厂模式模式--简单工厂模式--一般模式* ReadMe: 水果工厂的产品:葡萄*/public class Grape implements Fruit {private boolean seedless; //是否有籽/*** 种植*/public void plant() {System.out.println("Grape has been planted.");}/*** 生长*/public void grow() {System.out.println("Grape is growing...");}/*** 收获*/public void harvest() {System.out.println("Grape has been harvested.");}/*** @return 是否有籽*/public boolean getSeedless() {return seedless;}/*** 有无籽的赋值方法*/public void setSeedless(boolean seedless) {this.seedless = seedless;}/*** 辅助方法*/public static void log(String msg) {System.out.println(msg);}}1.1.2.5 工厂－园丁类：FruitGardener.javapackage vasoft.patterns.simplefactory.ybgc;/*** Created by IntelliJ IDEA.* FileName:FruitGardener.java* User: LavaSoft* Date: 2006-12-1* Time: 1:03:27* 《Java与模式》（--阎宏博士著）读书笔记* 工厂模式模式--简单工厂模式--一般模式* ReadMe: 工厂类角色: 水果园丁,生产水果产品*/public class FruitGardener {/*** 静态工厂方法* @param which :具体的产品名称* @return 一个水果对象* @throws BadFruitException*/public static Fruit factory(String which) throws BadFruitException { if (which.equalsIgnoreCase("apple")) {return new Apple();} else if (which.equalsIgnoreCase("strawberry")) {return new Strawberry();} else if (which.equalsIgnoreCase("grape")) {return new Grape();} else {throw new BadFruitException("Bad fruit request");}}}1.1.2.6 工厂异常定义类：BadFruitException.javapackage vasoft.patterns.simplefactory.ybgc;/*** Created by IntelliJ IDEA.* FileName:BadFruitException.java* User: LavaSoft* Date: 2006-12-1* Time: 1:04:56* 《Java与模式》（--阎宏博士著）读书笔记* 工厂模式模式--简单工厂模式--一般模式* ReadMe: 工厂的异常处理类*/public class BadFruitException extends Exception {public BadFruitException(String msg) {super(msg); //调用父类的构造方法}}1.1.2.7 一般工厂模式的测试类package vasoft.patterns.simplefactory.ybgc;/*** Created by IntelliJ IDEA.* FileName:TestApp.java* User: LavaSoft* Date: 2006-12-1* Time: 1:12:08* 《Java与模式》（--阎宏博士著）读书笔记* 工厂模式模式--简单工厂模式--一般模式* ReadMe: 一般工厂模式的测试类*/public class TestApp {/*** 测试方法*/private void test(String fruitName) {try {Fruit f = FruitGardener.factory(fruitName);System.out.println("恭喜!生产了一个水果对象:" + fruitName);} catch (BadFruitException e) {System.out.println("对不起!工厂目前不能生产你所要的产品:" + fruitName);System.out.println(e.getMessage()); //输出异常信息e.printStackTrace(); //输出异常堆栈信息}}/*** 应用入口方法*/public static void main(String args[]) {TestApp t = new TestApp();t.test("apple");t.test("grape");t.test("strawberry");t.test("car"); //此处会抛异常,水果工厂能生产car(轿车)吗!哈哈哈哈...}}1.1.2.8 测试运行结果恭喜!生产了一个水果对象:apple恭喜!生产了一个水果对象:grape恭喜!生产了一个水果对象:strawberry对不起!工厂目前不能生产你所要的产品:carBad fruit requestvasoft.patterns.simplefactory.ybgc.BadFruitException: Bad fruit requestatvasoft.patterns.simplefactory.ybgc.FruitGardener.factory(FruitGardener.java:28) at vasoft.patterns.simplefactory.ybgc.TestApp.test(TestApp.java:19)at vasoft.patterns.simplefactory.ybgc.TestApp.main(TestApp.java:37)at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)atsun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:2 5)at ng.reflect.Method.invoke(Method.java:585)at com.intellij.rt.execution.application.AppMain.main(AppMain.java:90)Process finished with exit code 0从结果看来，有异常，是因为输入了工厂不能生产的类型car（小汽车），哈哈哈哈，果园能生产汽车吗？让幼儿园的小朋友告诉你吧！1.1.3 简单工厂模式的一般性结构总结一下，从上面的简单工厂模式的实现可以看到，简单工厂模式需要实现工厂角色：园丁λ抽象产品：水果接口λ具体产品：苹果、葡萄、草莓λ另外还一般还需要实现工厂异常类λ客户类λ简单工厂模式的一般性结构图如下：1.1.4 简单工厂模式的实现1.1.4.1 使用接口或者抽象类实现多层次的产品结构工厂类可以有多个静态的工厂方法，分别用来生产不同的产品对象。