JAVA简单工厂创立性模式介绍

合集下载

简单工厂模式的使用场景与示例

简单工厂模式的使用场景与示例简单工厂模式是一种常见的设计模式，它是一种创建型模式，可以帮助我们根据客户端的需求动态地生成不同的对象。

本文将介绍简单工厂模式的使用场景与示例，以便读者更好地理解和应用该模式。

一、简单工厂模式的基本原理在介绍简单工厂模式的使用场景之前，我们先来了解一下它的基本原理。

简单工厂模式由三个角色组成：工厂类、抽象产品类和具体产品类。

工厂类根据客户端的需求，决定创建哪一种具体产品类的对象，并返回给客户端使用。

二、简单工厂模式的使用场景1. 创建对象时只需要知道其类别，而不需要知道具体的实现。

简单工厂模式可以隐藏具体产品类的创建细节，客户端只需要调用工厂类的方法即可获取所需的对象。

2. 客户端不关心对象的创建过程。

通过简单工厂模式，我们可以将对象的创建逻辑封装在工厂类中，使得客户端完全不需要关心对象的创建过程，只需要关心获取到所需对象即可。

3. 需要一组相关的对象被统一创建。

在某些场景下，我们可能需要一组相关的对象被统一创建，简单工厂模式可以灵活地满足这种需求。

三、简单工厂模式的示例下面通过一个示例来具体介绍简单工厂模式的应用。

假设我们有一个游戏场景中的角色类，包括玩家角色和敌人角色。

我们需要根据不同的角色类型创建对应的角色对象。

首先，我们定义一个抽象角色类（Role），用于表示玩家角色和敌人角色的共有属性和方法，包括姓名（name）和攻击力（attack）。

```javapublic abstract class Role {protected String name;protected int attack;public Role(String name, int attack) { = name;this.attack = attack;}public abstract void display();public abstract void attack();}```接下来，我们定义具体的玩家角色类（PlayerRole）和敌人角色类（EnemyRole），它们分别继承自抽象角色类（Role）。

软件开发几种设计模式

产。
抽象工厂：
用来生产不同产品族的全部固定产品；可以增加新产品族（不同产品的组合），但不能增加新产品；不同产品族通过不同的工厂类生成，一个类中有多个成员函数去
生成不同具体产品。
简单工厂
特点：
简单工厂模式的工厂类一般使用静态方法生成产品对象，通过输入参数的不同来返回不同对象实例。
个工厂就生产一个品牌的所有轿车、货车和客车。增加新的产品线（已有产品的组合）很容易，但是无法增加新的产品。
工厂模式
工厂模式中，重要的是工厂类，而不是产品类。
产品类可以是多种形式。但要明确，工厂模式的接口只会返回一种类型的实
例。所以在设计产品类时要注意，一般是返回父类或者
共同实现的接口。
单例模式
特点：
通过静态函数来生成唯一实例。构造函数是私有的。
其主要功能都是帮助我们把对象的实例化部分抽取出来，优化系统架构，增强系统扩展性。
工厂模式
主要作用
抽象了对象的构造过程，即生成对象的过程。
使得具有
可以具有一个共同的
或者统一的生成方法。避免了总是写几乎完全
重复的构造函数，生成功能差不多的对象。
注意：
类似功能的对象并不是完全相同的对象。它们虽然大体类似，但是确有具体差别。
使用工厂模式，返回的实例一定是工厂创建的，而不是从其它对象中获取的。
工厂模式返回的实例可以不是新创建的，返回由工厂创建好的实例也可以。
单例模式（Singleton Pattern）
单例模式
主要作用
保证一个类仅有一个实例，并提供一个访问它的全局访问点。
简单地说，就是代替全局对象。
几种设计模式

java工厂设计模式原理

java工厂设计模式原理
工厂设计模式是一种创建型设计模式，它提供了一种创建对象的方法，而无需在代码中直接使用new关键字来实例化对象。

该模式封装了对象的实例化逻辑，使得客户端可以通过工厂类来创建所需的对象实例。

工厂设计模式包含一个工厂类和具体产品类。

客户端只需要调用工厂类的方法，传入相应的参数，工厂类就会根据这些参数来实例化对象并返回给客户端。

客户端无需关心对象的具体创建过程，只需知道如何使用该对象即可。

工厂设计模式有三种常见的实现方式：简单工厂模式、工厂方法模式和抽象工厂模式。

1. 简单工厂模式：
简单工厂模式也称为静态工厂模式，它通过一个工厂类来创建产品对象。

客户端只需要传入相应的参数，工厂类就会使用这个参数来判断并创建相应的产品实例。

简单工厂模式主要由工厂类和产品类组成。

2. 工厂方法模式：
工厂方法模式通过抽象工厂和具体工厂来创建产品对象。

抽象工厂定义了一个创建产品的抽象方法，具体工厂则实现了这个抽象方法来创建产品对象。

工厂方法模式主要由抽象工厂、具体工厂和产品类组成。

3. 抽象工厂模式：
抽象工厂模式通过一组相关的工厂来创建产品对象。

每个具体工厂都对应着一组产品对象，而每个产品类都有对应的抽象产品。

抽象工厂模式主要由抽象工厂、具体工厂和抽象产品、具体产品类组成。

工厂设计模式的优点包括封装了对象的创建过程，降低了客户端与具体产品类的耦合度，提高了代码的可维护性和可扩展性。

同时，工厂设计模式还可以通过配置文件或者反射来动态创建对象，增加了程序的灵活性。

Java工厂模式详解

工厂模式1. 简单工厂模式(Simple Factory)从设计模式的类型上来说，简单工厂模式是属于创建型模式，又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。

简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

该模式中包含的角色及其职责：（1）工厂（Creator）角色：简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。

工厂类可以被外界直接调用，创建所需的产品对象。

（2）抽象产品（Product）角色：简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

（3）具体产品（Concrete Product）角色：是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

使用场景：工厂类负责创建的对象比较少；客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心；由于简单工厂很容易违反高内聚责任分配原则，因此一般只在很简单的情况下应用。

应用举例：对于一个典型的Java应用而言，应用之中各实例之间存在复杂的调用关系（Spring把这种调用关系成为依赖关系，例如A实例调用B实例来的方法，则成为A依赖与B）。

当A对象需要调用B对象的方法是，许多初学者会选择使用new关键字来创建一个B实例，然后调用B实例的方法。

从语法角度来看，这种做法没有任何问题，这种做法的坏处在于：A类的方法实现直接调用了B类的类名（这种方式也被称为硬编码耦合），一旦系统需要重构；需要使用C类来代替B类时，程序不得不写A类代码。

如果应用中有100个或10000个类以硬编码耦合了B类，则需要重新改写100个，10000个地方…..换一个角度来看这个问题：对于A对象而言，它只需要调用B对象的方法，并不关心B对象的实现、创建过程。

简单工厂模式的介绍、优缺点分析和解决方案

简单⼯⼚模式的介绍、优缺点分析和解决⽅案所有的模式都是利⽤java中的封装、继承、多态这三个特性张开的，就像由这三个秘籍组成的各种变幻万千的招式，⽽所有的⽬的都是为了打败坏模式带来的代码垃圾这个敌⼈，所有的招式都是要求“可维护”、“可扩展”、“可复⽤”，当然如果达到这三个标准后，基本上“灵活性好”同时也就拥有了。

所以下⾯介绍最常⽤的⼯⼚模式，分为三类：简单⼯⼚模式、⼯⼚模式和抽象⼯⼚模式。

⼀、简单⼯⼚模式1.介绍⼯⼚模式，顾名思义，最少有⼀个⽣产产品的机器存在的⼯⼚Factory，与此同时，也要有⼀个构建好的产品模块Product。

所以，我们要⽤到Factory来创造Product。

在简单⼯⼚模式中，有⼏种⾓⾊存在。

⼀个是所有产品的⽗类P，即所有产品的模板；另外⼀个是继承了⽗类P 的产品⼦类p1，p2...;当然，最重要的是Factory，在Factory中可以将这些的产品实例化，根据需求来将Factory和Product产⽣联系。

2.例⼦我们先来做⼀个例⼦吧，以做⼀个简单的计算器来开始。

a. Product的⽗类： Operationpublic class Operation {private double _numberA = 0 ;private double _numberB = 0;private double result = 0;public double get_numberA() {return _numberA;}public void set_numberA(double _numberA) {this._numberA = _numberA;}public double get_numberB() {return _numberB;}public void set_numberB(double _numberB) {this._numberB = _numberB;}public double getResult() {return result;}public void setResult(double result) {this.result = result;}}b.继承了Product的⼦类：加法产品（OperationAdd），乘法产品（OperationMul），减法产品（OperationSub），除法产品（OperationDiv）public class OperationAdd extends Operation{@Overridepublic double getResult(){double result = 0;result = get_numberA() + get_numberB();return result;}}public class OperationSub extends Operation{@Overridepublic double getResult(){double result = 0 ;result = get_numberA() - get_numberB();return result;}}public class OperationMul extends Operation {@Overridepublic double getResult(){double result = 0;result = get_numberA()*get_numberB();return result;}}public class OperationDiv extends Operation{@Overridepublic double getResult(){double result = 0 ;if(get_numberB() == 0){throw new RuntimeException("除数不能为0.");}else{result = get_numberA()/get_numberB();return result;}}}c.⽣产产品的⼯⼚Factory（OperationFactory）package SimpleFactory;public class OperationFactory {public static Operation createOperation(String operate){Operation oper = null;switch(operate){case "+" :oper = new OperationAdd() ;break;case "-" :oper = new OperationSub() ;break;case "*" :oper = new OperationMul() ;break;case "/" :oper = new OperationDiv() ;break;}return oper;}}最后我们把⼯⼚和产品做好以后就可以，将产品买给客户啦。

深入理解Java的三种工厂模式

深入理解Java的三种工厂模式一、简单工厂模式简单工厂的定义：提供一个创建对象实例的功能，而无须关心其具体实现。

被创建实例的类型可以是接口、抽象类，也可以是具体的类实现汽车接口public interface Car {String getName();}奔驰类public class Benz implements Car {@Overridepublic String getName() {return "Benz";}}宝马类public class BMW implements Car {@Overridepublic String getName() {return "BMW";}}简单工厂，既能生产宝马又能生产奔驰public class SimpleFactory {public Car getCar(String name){if (name.equals("BMW")){return new BMW();}else if (name.equals("benz")){return new Benz();}else {System.out.println("不好意思，这个品牌的汽车生产不了");return null;}}}测试类public class SimpleFactoryTest {public static void main(String[] args){SimpleFactory simpleFactory = new SimpleFactory();Car car = simpleFactory.getCar("BMW");System.out.println(car.getName());}}测试结果BMW根据简单工厂的定义，用户只要产品而不在乎产品如何生产，看起来好像很完美的样子。

深入理解java三种工厂模式

在使用了简单工厂模式后，现在暴发户只需要坐在车里对司机说句："开车"就可以了。来看看怎么实现的：
//抽象产品角色 public interface Car{ public void drive(); } //具体产品角色 public class Benz implements Car{ public void drive() { System.out.println("Driving Benz "); } } public class Bmw implements Car{ public void drive() { System.out.println("Driving Bmw "); } } 。。。（奥迪我就不写了:P） //工厂类角色 public class Driver{ //工厂方法 //注意返回类型为抽象产品角色 public static Car driverCar(String s)throws Exception { //判断逻辑，返回具体的产品角色给Client if(s.equalsIgnoreCase("Benz")) return new Benz(); else if(s.equalsIgnoreCase("Bmw")) return new Bmw(); ...... else throw new Exception(); 。。。 //欢迎暴发户出场...... public class Magnate{ public static void main(String[] args){ try{ //告诉司机我今天坐奔驰 Car car = Driver.driverCar("benz"); //下命令：开车 car.drive(); 。。。

Java代码实现设计模式之工厂模式

Java代码实现设计模式之工厂模式工厂设计模式：为了解耦合，把对象的创建者与对象的使用者分开。

生活中：批量生产产品Java中：批量生产对象分工：把生产（创建）对象与使用对象分开了，解耦合1、简单工厂模式优点：代码比较简洁缺点：如果增加新的产品类型，需要修改工厂类违反了面向对象的一个开发原则：对扩展开放，对修改关闭2、工厂方法模式（1）为了生产对象与使用对象分开（2）如果增加新产品，就不需要修改原来的工厂类优点：遵循了增加新产品，不修改原来的类的原则，缺点：类太多了示例：简单工厂模式class SimpleFactory2{public static Car getCar(String type){if("BMW".equals(type)){return new BMW();}else if("BZ".equals(type)){return new Benz();}return null;}}示例：工厂方法模式interface Factory{VehiCle getVehiCle ();}class BMWFactory implements Factory{@Overridepublic Che getChe() {return new BaoMa();}}class BZFactory implements Factory{@Overridepublic Che getChe() {return new BZ();}}......示例：使用反射，结合工厂方法模式与简单工厂模式class SimpleFactory{public static Vehicle getVehicle(String className)throws Exception{Class clazz = Class.forName(className);Object obj = clazz.newInstance();if(obj instance of Vehicle){return (Vehicle) obj;}return null;}}。

JAVA设计模式之创造型模式介绍

JA V A设计模式之创造型模式创造型模式包括工厂方法、抽象工厂、创造者模式、单态模式、原型模式共5类1、工厂方法定义一个用于创建对象的接口，让子类决定实例化哪一个类。

FactoryMethod使一个类的实例化延迟到其子类。

适用条件：1）当一个类不知道它所必须创建的对象的类的时候。

2）当一个类希望由它的子类来指定它所创建的对象的时候。

3）当类将创建对象的职责委托给多个帮助子类中的某一个，并且类希望将哪一个帮助子类是代理者这一信息局部化的时候。

参与者：1）Product：定义工厂方法所创建的对象的接口。

2）ConcreteProduct：实现Product接口。

3）Creator：声明工厂方法，该方法返回一个Product类型的对象。

Creator也可以定义一个工厂方法的缺省实现，它返回一个缺省的ConcreteProduct对象。

可以调用工厂方法以创建一个Product对象。

4）ConcreteCreator：重定义工厂方法以返回一个ConcreteProduct实例。

示例：package zantip.modules;public class FactoryMethodTest {public static void main(String[] args) {IWorkFactory studentWorkFactory = new StudentWorkFactory();studentWorkFactory.getWork().doWork();IWorkFactory teacherWorkFactory = new TeacherWorkFactory();teacherWorkFactory.getWork().doWork();}}// Productinterface Work {void doWork();}// ConcreteProductclass StudentWork implements Work {@Overridepublic void doWork() {System.out.println("学生做作业");}}class TeacherWork implements Work {@Overridepublic void doWork() {System.out.println("老师审批作业");}}// Creatorinterface IWorkFactory {Work getWork();}// ConcreteCreatorclass StudentWorkFactory implements IWorkFactory {@Overridepublic Work getWork() {return new StudentWork();}}class TeacherWorkFactory implements IWorkFactory {@Overridepublic Work getWork() {return new TeacherWork();}}输出结果：学生做作业老师审批作业2 抽象工厂提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

java设计模式-简单工厂模式

java设计模式-简单⼯⼚模式简单⼯⼚模式详解⼀，概述简单⼯⼚模式属于创建型模式⼜叫做静态⼯⼚⽅法模式，它属于类创建型模式。

在简单⼯⼚模式中，可以根据参数的不同返回不同类的实例。

简单⼯⼚模式专门定义⼀个类来负责创建其他类的实例，被创建的实例通常都具有共同的⽗类。

简单⼯⼚只需要传⼊⼀个正确的参数，就可以获取所需要的对象，⽽⽆需知道其实现过程。

简单⼯⼚模式中⽤于被创建实例的⽅法通常为因此简单⼯⼚模式⼜被成为静态⼯⼚⽅法(Static Factory Method)。

下⾯由我深⼊浅出的给⼤家讲解下简单⼯⼚模式，不⾜之处还望批评指正。

⼆，结构图Factory：⼯⼚类，简单⼯⼚模式的核⼼，它负责实现创建所有实例的内部逻辑。

⼯⼚类的创建产品类的⽅法可以被外界直接调⽤，创建所需的产品对象。

IProduct：抽象产品类，简单⼯⼚模式所创建的所有对象的⽗类，它负责描述所有实例所共有的公共接⼝。

Product：具体产品类，是简单⼯⼚模式的创建⽬标三，简单⼯⼚举例说明　这⾥我们以⾷品加⼯⼚来举例，假设有⼀个⾷品加⼯⼚，主要加⼯啤酒饮料矿泉⽔，根据需求，我们就需要⽤⼀个单独的类来专门⽣产啤酒饮料矿泉⽔，这就⽤到了简单⼯⼚模式，下⾯我们来实现简单⼯⼚模式。

四，具体代码实现第⼀步：我们⾸先创建我们的⾷品基类，也就是⾷品⽗类，也就是我们结构图中抽象产品类，这是个抽象类。

package pattern.simplenessfactory;/***产品抽象类* @author ningbeibei**/public abstract class Product {//获取产品⽅法public abstract void getFood();} 第⼆步：具体的啤酒饮料矿泉⽔⾷品类都需要继承⾷品抽象类 Productpackage pattern.simplenessfactory;/*** 具体啤酒类继承⾃Product类* @author ningbeibei**/public class Berr extends Product {@Overridepublic void getFood() {System.out.println("啤酒");};}package pattern.simplenessfactory;/*** 具体饮料类继承⾃Product* @author ningbeibei**/public class Drinks extends Product {@Overridepublic void getFood() {System.out.println("饮料");}}package pattern.simplenessfactory;/*** 具体矿泉⽔类继承⾃Product* @author ningbeibei**/public class Water extends Product {@Overridepublic void getFood() {System.out.println("矿泉⽔");}} 第三步：上⾯我们已经把产品类设计好了，现在开始创建⾷品加⼯⼚Factory ⾷品加⼯⼯⼚专门负责创建具体的⾷品对象并返回，⼤家看下⾯getCommodity(String type) ⽅法，这个⽅法是静态⽅法，并且根据参数决定创建⾷品对象，⽅法内部通过逻辑判断决定返回啤酒还是饮料或者是矿泉⽔，要注意的是：Product product = null; 这个变量⽤到的是java的特性继承和多态，简单说：⼦类对象⽗类型。

java factory写法

java factory写法Java工厂模式的写法工厂模式是一种常用的设计模式，用于创建对象。

在Java中，工厂模式有多种实现方式，包括简单工厂模式、工厂方法模式和抽象工厂模式。

在本文中，我们将聚焦于Java工厂模式的写法，并一步一步回答你关于这一主题的问题。

1. 什么是Java工厂模式？Java工厂模式是一种创建型设计模式，通过使用工厂类从具体实现类中解耦对象的创建。

它将对象的创建委托给一个工厂类，从而使得客户端不需要关心对象的具体创建过程。

2. 简单工厂模式的写法简单工厂模式是工厂模式的一种简单形式，其核心思想是由一个工厂类根据传入的参数来决定创建哪个具体对象。

下面是简单工厂模式的写法：首先，我们创建一个接口或抽象类，定义了需要创建的对象的方法。

public interface Product {void operation();接下来，创建多个实现接口或抽象类的具体产品类。

public class ConcreteProductA implements Product { Overridepublic void operation() {System.out.println("ConcreteProductA operation");}}public class ConcreteProductB implements Product { Overridepublic void operation() {System.out.println("ConcreteProductB operation");}}然后，创建一个简单工厂类，用来根据传入的参数来生成具体的产品对象。

public class SimpleFactory {public static Product createProduct(String type) {if (type.equalsIgnoreCase("A")) {return new ConcreteProductA();} else if (type.equalsIgnoreCase("B")) {return new ConcreteProductB();}return null;}}最后，我们可以在客户端调用简单工厂类来创建具体的产品对象。

java设计模式三种工厂模式简单介绍

java设计模式三种⼯⼚模式简单介绍⼀．简单⼯⼚模式概述：简单⼯⼚模式的创建意图就是，把对类的创建初始化全都交给⼀个⼯⼚来执⾏，⽽⽤户不需要去关⼼创建的过程是什么样的，只⽤告诉⼯⼚我想要什么就⾏了。

⽽这种⽅法的缺点也很明显，违背了设计模式的开闭原则，因为如果你要增加⼯⼚可以初始化的类的时候，你必须对⼯⼚进⾏改建。

客户端通过简单⼯⼚可以⽣产出具体产品A，具体产品B，具体产品C。

⼆. ⼯⼚⽅法模式为了解决简单⼯⼚的问题，程序员们⼜想出来⼀个新的办法，就是设计⼀个⼯⼚的接⼝，你想要什么东西，就写个类继承于这个⼯⼚，这样就不⽤修改什么，直接添加就⾏了。

就相当于，我这个⼯⼚是⽤来⽣产鞋⼦的，⽽要什么品牌的鞋⼦具体分到了每个车间，如果新多了⼀种品牌的鞋⼦，直接新增⼀个车间就⾏了。

那么问题⼜来了，如果想要⽣产⾐服怎么办？三. 抽象⼯⼚模式定义：为创建⼀组相关或相互依赖的对象提供⼀个接⼝，⽽且⽆需指定他们的具体类。

抽象⼯⼚与⼯⼚⽅法的区别，就在于产品簇的问题，多了⼀种产品，这时候怎么办呢，就是在接⼝类⾥⾯加上创建⾐服的⽅法，然后每个车间就可以有两个⼦车间分别来⽣产⾐服和鞋⼦。

这样的话缺点也很显然的冒了出来，如果我⼜想⽣产帽⼦，那么我要需要更改所有的⼯⼚车间以及⼯⼚接⼝。

如何改善这个现象，我们可以这样找到不常变的类写进接⼝⾥，⽐如，如果这个⼯⼚长期决定只做鞋和帽⼦，但是品牌变化⼤，那么我们在接⼝⾥写创建⾐服和创建帽⼦类，后续品牌变化的时候，我们只需新建⼀个车间就⾏了。

抽象⼯⼚模式是⼯⼚⽅法模式的升级版本，他⽤来创建⼀组相关或者相互依赖的对象。

他与⼯⼚⽅法模式的区别就在于，⼯⼚⽅法模式针对的是⼀个产品等级结构；⽽抽象⼯⼚模式则是针对的多个产品等级结构。

在编程中，通常⼀个产品结构，表现为⼀个接⼝或者抽象类，也就是说，⼯⼚⽅法模式提供的所有产品都是衍⽣⾃同⼀个接⼝或抽象类，⽽抽象⼯⼚模式所提供的产品则是衍⽣⾃不同的接⼝或抽象类。

JAVA设计模式——简单工厂

JAVA设计模式——简单⼯⼚⼯⼚模式分为三种：简单⼯⼚模式，⼯⼚⽅法模式，抽象⼯⼚模式。

我看有的书上和有的⽂章⾥是分为两种，没有简单⼯⼚。

⼯⼚模式主要的作⽤是：⼀个对象在实例化的时候可以选择多个类，在实例化的时候根据⼀些业务规则来选择实例化哪个类。

1.先定义⼀个图形接⼝，有⼀个画⽅法public interface Shape {void draw();}2.再创建两个实现接⼝的实体类public class Rectangle implements Shape {@Overridepublic void draw() {System.out.println("画长⽅形。

");}}public class Square implements Shape {@Overridepublic void draw() {System.out.println("画正⽅形。

");}}3.创建⼀个⼯⼚，⽣成基于给定信息的实体类的对象public class ShapeFactory {//使⽤ createShape ⽅法获取形状类型的对象public Shape createShape(String shapeType) {if (shapeType == null) {return null;}if (shapeType.equalsIgnoreCase("RECTANGLE")) {return new Rectangle();} else if (shapeType.equalsIgnoreCase("SQUARE")) {return new Square();}return null;}}4.使⽤该⼯⼚，通过传递类型信息来获取实体类的对象。

public class SimpleFactoryPatternDemo {public static void main(String[] args) {ShapeFactory shapeFactory = new ShapeFactory();//获取 Rectangle 的对象，并调⽤它的 draw ⽅法Shape shape1 = shapeFactory.createShape("RECTANGLE");//调⽤ Rectangle 的 draw ⽅法shape1.draw();//获取 Square 的对象，并调⽤它的 draw ⽅法Shape shape2 = shapeFactory.createShape("SQUARE");//调⽤ Square 的 draw ⽅法shape2.draw();}}输出：画长⽅形。

java简单工厂设计模式

java简单⼯⼚设计模式⼀、基本定义/**简单⼯⼚设计模式：*⽂字描述理解：* 简单⼯⼚模式属于类的创建型模式，⼜叫做静态⼯⼚⽅法模式。

* 通过专门定义⼀个类来负责创建其它类的实例，被创建的实例通常* 都具有共同的⽗类。

* */⼆、⾸先创建Apple、Banana实体类public class Apple {public void eat(){System.out.println("吃苹果");}}public class Banana {public void eat(){System.out.println("吃⾹蕉");}}编写测试类：public class MainClass {public static void main(String[] args) {//实例AppleApple apple = new Apple();//实例BananaBanana banana = new Banana();apple.eat();banana.eat();//可以发现Apple、Banana可以共同抽象出⼀个接⼝eat}}在运⾏中，我们发现Apple、Banana类都有共同的⽅法。

那么我们就可以抽象出来⼀个接⼝来实现。

修改代码如下：public interface Fruit {void eat();}public class Apple implements Fruit {@Overridepublic void eat() {System.out.println("吃苹果");}}public class Banana implements Fruit{@Overridepublic void eat() {System.out.println("吃⾹蕉");}}public class MainClass {public static void main(String[] args) {/*//实例AppleApple apple = new Apple();//实例BananaBanana banana = new Banana();apple.eat();banana.eat();**///可以发现Apple、Banana可以共同抽象出⼀个接⼝eat,多态实例化Fruit apple = new Apple();Fruit banana = new Banana();apple.eat();banana.eat();//按照定义：通过专门定义⼀个类来负责创建其他类的实例，那么我们就需要创建FruitFactory实例，具体代码如下。

java设计模式-----1、简单工厂模式

java设计模式-----1、简单⼯⼚模式简单⼯⼚模式是属于创建型模式，⼜叫做静态⼯⼚⽅法（Static Factory Method）模式，但不属于23种GOF设计模式之⼀。

简单⼯⼚模式是由⼀个⼯⼚对象决定创建出哪⼀种产品类的实例，简单来说就是，通过专门定义⼀个类来负责创建其他类的实例，被创建的实例通常都具有共同的⽗类。

简单⼯⼚模式是⼯⼚模式家族中最简单实⽤的模式，可以理解为是不同⼯⼚模式的⼀个特殊实现。

⾸先举个例⼦：创建两个类，⼀个Apple，⼀个Banana，都有个⼀⽅法1public class Apple{2public void get(){3 System.out.println("采集苹果");4 }5 }1public class Banana{2public void get(){3 System.out.println("采集⾹蕉");4 }5 } 在创建⼀个主⽅法来调⽤这两个类中的⽅法1public class MainClass {2public static void main(String[] args) {3//实例化Apple4 Apple apple = new Apple();5//实例化Banana6 Banana banana = new Banana();78 apple.get();9 banana.get();10 }11 } 执⾏后，输出结果为：采集苹果采集⾹蕉但是代码还可以改进，可以看出Apple与Banana的功能类似，所以可以抽取出⼀个接⼝，并让Apple与Banana实现此接⼝1public interface Fruit {2public void get();3 }1public class Apple implements Fruit{2public void get(){3 System.out.println("采集苹果");4 }5 }1public class Banana implements Fruit{2public void get(){3 System.out.println("采集⾹蕉");4 }5 } 这时，主⽅法调⽤形式就变成了这样1public class MainClass {2public static void main(String[] args) {3//实例化⼀个Apple，⽤到了多态4 Fruit apple = new Apple();5//实例化⼀个Banana，⽤到了多态6 Fruit banana= new Banana();78 apple.get();9 banana.get();10 }11 } 这样还是刚才的结果，不同的代码达到了相同的⽬的。

创建型模式——简单工厂模式

创建型模式——简单⼯⼚模式⼯⼚模式（Factory Pattern）是 Java 中最常⽤的设计模式之⼀。

这种类型的设计模式属于创建型模式，它提供了⼀种创建对象的最佳⽅式。

在⼯⼚模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使⽤⼀个共同的接⼝来指向新创建的对象。

⼀、介绍意图：定义⼀个创建对象的接⼝，让其⼦类⾃⼰决定实例化哪⼀个⼯⼚类，⼯⼚模式使其创建过程延迟到⼦类进⾏。

主要解决：主要解决接⼝选择的问题。

何时使⽤：我们明确地计划不同条件下创建不同实例时。

如何解决：让其⼦类实现⼯⼚接⼝，返回的也是⼀个抽象的产品。

关键代码：创建过程在其⼦类执⾏。

应⽤实例： 1、您需要⼀辆汽车，可以直接从⼯⼚⾥⾯提货，⽽不⽤去管这辆汽车是怎么做出来的，以及这个汽车⾥⾯的具体实现。

2、Hibernate 换数据库只需换⽅⾔和驱动就可以。

优点： 1、⼀个调⽤者想创建⼀个对象，只要知道其名称就可以了。

2、扩展性⾼，如果想增加⼀个产品，只要扩展⼀个⼯⼚类就可以。

3、屏蔽产品的具体实现，调⽤者只关⼼产品的接⼝。

缺点：每次增加⼀个产品时，都需要增加⼀个具体类和对象实现⼯⼚，使得系统中类的个数成倍增加，在⼀定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

这并不是什么好事。

使⽤场景： 1、⽇志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，⽤户可以选择记录⽇志到什么地⽅。

2、数据库访问，当⽤户不知道最后系统采⽤哪⼀类数据库，以及数据库可能有变化时。

3、设计⼀个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现⼀个接⼝。

注意事项：作为⼀种创建类模式，在任何需要⽣成复杂对象的地⽅，都可以使⽤⼯⼚⽅法模式。

有⼀点需要注意的地⽅就是复杂对象适合使⽤⼯⼚模式，⽽简单对象，特别是只需要通过 new 就可以完成创建的对象，⽆需使⽤⼯⼚模式。

Java简单工厂模式详细解释

Java简单⼯⼚模式详细解释⽬录简单⼯⼚模式概述简单⼯⼚模式的结构与实现结构：实现简单⼯⼚模式的简化简单⼯⼚模式的优缺点和适⽤环境简单⼯⼚模式的优点简单⼯⼚模式的缺点简单⼯⼚模式的适⽤环境简单案例题⽬：UML：运⾏结果：总结简单⼯⼚模式概述1.定义：定义⼀个⼯⼚类，他可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的⽗类2.在简单⼯⼚模式中⽤于被创建实例的⽅法通常为静态(static)⽅法,因此简单⼯⼚模式⼜被成为静态⼯⼚⽅法(Static Factory Method)3.需要什么，只需要传⼊⼀个正确的参数，就可以获取所需要的对象，⽽⽆需知道其实现过程4.例如，我开⼀家披萨店，当客户需要某种披萨并且我这家店⾥也能做的时候，我就会为其提供所需要的披萨(当然是要钱的哈哈),如果其所需的我这没有，则是另外的情况，后⾯会谈。

这时候，我这家披萨店就可以看做⼯⼚(Factory),⽽⽣产出来的披萨被成为产品(Product),披萨的名称则被称为参数，⼯⼚可以根据参数的不同返回不同的产品，这就是简单⼯⼚模式简单⼯⼚模式的结构与实现结构：2.Product(抽象类产品)：⼯⼚类所创建的所有对象的⽗类，封装了产品对象的公共⽅法，所有的具体产品为其⼦类对象3.ConcreteProduct(具体产品)：简单⼯⼚模式的创建⽬标，所有被创建的对象都是某个具体类的实例。

它要实现抽象产品中声明的抽象⽅法(有关抽象类)实现abstract class Product{public void MethName(){//公共⽅法的实现}public abstract void MethodDiff();//声明抽象业务⽅法}class ConcreteProductA : Product{public override void MethodDiff(){//业务⽅法的实现}}class Factory{public static Product GetProduct(string arg){Product product = null;if(arg.Equals("A"){product = new ConcreteProductA();//init}else if(arg.Equals("B")){product = new ConcreteProductB();//init}else{....//其他情况}return product;}}class Program{static void Main(string[] args){Product product;product = Factory.GetProduct("A");//⼯⼚类创建对象Product.MethName();product.MethodDiff();}}简单⼯⼚模式的简化1.为了简化简单⼯⼚模式，将抽象产品类和⼯⼚类合并，将静态⼯⼚⽅法移到抽象产品类中客户端可以调⽤产品⽗类的静态⼯⼚⽅法，根据不同的参数创建不同类型的产品⼦类对象。

第5讲简单工厂模式

工厂方法模式 (Factory Method Pattern)
定义定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。
定义一个用于创建对象的接口，但是让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。
使用频率
★★★☆☆
★★★★★
抽象工厂模式 (Abstract Factory Pattern)
Factory + FactoryMethod (string arg) : Product ...
简单工厂模式的结构
简单工厂模式包含以下3个角色
Factory（工厂角色） Product（抽象产品角色） ConcreteProduct（具体产品角色）
简单工厂模式的实现
典型的抽象产品类代码
简单工厂模式的应用实例
某软件公司要基于Java语言开发一套图表库，该图表库可以为应用系统提供多种不同外观的图表，例如柱状图 (HistogramChart)、饼状图 (PieChart)、折线图(LineChart)等。该软件公司图表库设计人员希望为应用系统开发人员提供一套灵活易用的图表库，通过设置不同的参数即可得到不同类型的图表，而且可以较为方便地对图表库进行扩展，以便能够在将来增加一些新类型的图表。
练习
使用简单工厂模式设计一个可以创建不同几何形状(Shape)，如圆形(Circle) 、矩形(Rectangle)和三角形(Circle) 等的绘图工具类，每个几何图形有绘制 Draw()和擦除Erase()两个方法。
简单工厂模式的优点
实现了对象创建和使用的分离
客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

　从１９９２年到现在，在美国从事软件研究开发工作。

曾任职于汤臣金融（Ｔｈｏｍｓｏｎ　Ｆｉｎａｎｃｉａｌ），参于设计开发投资关系网站ｗｗｗ．ＩＲＣｈａｎｎｅｌ．ｃｏｍ（原来叫ｗｗｗ．ＩＲＵｎｉｖｅｒｓｅ．ｃｏｍ），第一声（ｗｗｗ．ＦｉｒｓｔＣａｌｌ．ｃｏｍ），曾在奥本海默基金（Ｏｐｐｅｎｈｅｉｍｅｒ）开发股票实时交易系统，曾在美国阿贡国家实验室从事专家系统的研究。

　现在美国花旗银行（Ｃｉｔｉｂａｎｋ）工作，副总裁级系统工程师。

参与公司的网上银行设计与开发工作（ｗｗｗ．ｃｉｔｉｄｉｒｅｃｔ－ｏｎｌｉｎｅ．ｃｏｍ）。

　ＰＤＦ文档制作　Ｊａｖａ研究组织　ｗｗｗ．ｊａｖａｒｅｓｅａｒｃｈ．ｏｒｇ　疾风摩郎　ｄｅｎｇｋｅ＠ｊａｖａｒｅｓｅａｒｃｈ．ｏｒｇ２００２年７月１６日研究和使用创立性模式的必要性　面向对象的设计的目的之一，就是把责任进行划分，以分派给不同的对象。

我们推荐这种划分责任的作法，　是因为它和封装（Ｅｎｃａｐｓｕｌａｔｉｏｎ）和分派（Ｄｅｌｅｇａｔｉｏｎ）的精神是相符合的。

创立性模式把对象的创立过程封装起来，使得创立实例的责任与使用实例的责任分割开，　并由专门的模块分管实例的创立，而系统在宏观上不再依赖于对象创立过程的细节。

所有面向对象的语言都有固定的创立对象的办法。

爪哇语的办法就是使用ｎｅｗ操作符。

比如：　ＳｔｒｉｎｇＢｕｆｆｅｒ　ｓ　＝　ｎｅｗ　ＳｔｒｉｎｇＢｕｆｆｅｒ（１０００）；　就创立了一个对象ｓ，其类型是ＳｔｒｉｎｇＢｕｆｆｅｒ。

使用ｎｅｗ操作符的短处是事先必须明确知道要实例化的类是什么，　而且实例化的责任往往与使用实例的责任不加区分。

使用创立性模式将类实例化，首先不必事先知道每次是要实例化哪一个类，　其次把实例化的责任与使用实例的责任分割开来，可以弥补直接使用ｎｅｗ操作符的短处。

而工厂模式就是专门负责将大量有共同接口的类实例化，而且不必事先知道每次是要实例化哪一个类的模式。

工厂模式有几种形态　工厂模式有以下几种形态：简单工厂（Ｓｉｍｐｌｅ　Ｆａｃｔｏｒｙ）模式工厂方法（Ｆａｃｔｏｒｙ　Ｍｅｔｈｏｄ）模式，又称多形性工厂（Ｐｏｌｙｍｏｒｐｈｉｃ　Ｆａｃｔｏｒｙ）模式抽象工厂（Ａｂｓｔｒａｃｔ　Ｆａｃｔｏｒｙ）模式，又称工具箱（Ｋｉｔ或Ｔｏｏｌｋｉｔ）模式介绍简单工厂模式　比如说，你有一个描述你的后花园的系统，在你的后花园里有各种的花，但还没有水果。

你现在要往你的系统里引进一些新的类，用来描述下列的水果：葡萄　Ｇｒａｐｅｓ草莓　Ｓｔｒａｗｂｅｒｒｙ苹果　Ａｐｐｌｅ花和水果最大的不同，就是水果最终是可以采摘食用的。

那么，很自然的作法就是建立一个各种水果都适用的接口，这样一来这些水果类作为相似的数据类型就可以和你的系统的其余部分，如各种的花有所不同，易于区分。

图１．　Ｇｒａｐｅ，　Ｓｔｒａｗｂｅｒｒｙ和Ａｐｐｌｅ是拥有共同接口ＦｒｕｉｔＩＦ的类。

　代码清单１．　接口ＦｒｕｉｔＩＦ的源代码。

这个接口确定了水果类必备的方法：种植ｐｌａｎｔ（），生长ｇｒｏｗ（），　以及收获ｈａｒｖｅｓｔ（）。

　ｐａｃｋａｇｅ　ｃｏｍ．ｊａｖａｐａｔｔｅｒｎｓ．ｓｉｍｐｌｅｆａｃｔｏｒｙ；　ｐｕｂｌｉｃ　ｉｎｔｅｒｆａｃｅ　ＦｒｕｉｔＩＦ｛　　ｖｏｉｄ　ｇｒｏｗ（）；　　ｖｏｉｄ　ｈａｒｖｅｓｔ（）；　　ｖｏｉｄ　ｐｌａｎｔ（）；　　Ｓｔｒｉｎｇ　ｃｏｌｏｒ　＝　ｎｕｌｌ；　　Ｓｔｒｉｎｇ　ｎａｍｅ　＝　ｎｕｌｌ；　｝　代码清单２．　类Ａｐｐｌｅ的源代码。

苹果是多年生木本植物，因此具备树龄ｔｒｅｅＡｇｅ性质。

　ｐａｃｋａｇｅ　ｃｏｍ．ｊａｖａｐａｔｔｅｒｎｓ．ｓｉｍｐｌｅｆａｃｔｏｒｙ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　Ａｐｐｌｅ　ｉｍｐｌｅｍｅｎｔｓ　ＦｒｕｉｔＩＦ　｛　　ｐｕｂｌｉｃ　ｖｏｉｄ　ｇｒｏｗ（）　　｛　ｌｏｇ（＂Ａｐｐｌｅ　ｉｓ　ｇｒｏｗｉｎｇ．．．＂）；　　｝　　ｐｕｂｌｉｃ　ｖｏｉｄ　ｈａｒｖｅｓｔ（）　　｛　ｌｏｇ（＂Ａｐｐｌｅ　ｈａｓ　ｂｅｅｎ　ｈａｒｖｅｓｔｅｄ．＂）；　　｝　　ｐｕｂｌｉｃ　ｖｏｉｄ　ｐｌａｎｔ（）　　｛　ｌｏｇ（＂Ａｐｐｌｅ　ｈａｓ　ｂｅｅｎ　ｐｌａｎｔｅｄ．＂）；　　｝　　ｐｕｂｌｉｃ　ｓｔａｔｉｃ　ｖｏｉｄ　ｌｏｇ（Ｓｔｒｉｎｇ　ｍｓｇ）　　｛　Ｓｙｓｔｅｍ．ｏｕｔ．ｐｒｉｎｔｌｎ（ｍｓｇ）；　　｝　　ｐｕｂｌｉｃ　ｉｎｔ　ｇｅｔＴｒｅｅＡｇｅ（）　ｒｅｔｕｒｎ　ｔｒｅｅＡｇｅ；　｝　　ｐｕｂｌｉｃ　ｖｏｉｄ　ｓｅｔＴｒｅｅＡｇｅ（ｉｎｔ　ｔｒｅｅＡｇｅ）　｛　ｔｈｉｓ．ｔｒｅｅＡｇｅ　＝　ｔｒｅｅＡｇｅ；　｝　　ｐｒｉｖａｔｅ　ｉｎｔ　ｔｒｅｅＡｇｅ；　｝　代码清单３．　类Ｇｒａｐｅ的源代码。

葡萄分为有籽与无籽两种，因此具有ｓｅｅｄｆｕｌ性质。

　ｐａｃｋａｇｅ　ｃｏｍ．ｊａｖａｐａｔｔｅｒｎｓ．ｓｉｍｐｌｅｆａｃｔｏｒｙ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　Ｇｒａｐｅ　ｉｍｐｌｅｍｅｎｔｓ　ＦｒｕｉｔＩＦ　｛　　ｐｕｂｌｉｃ　ｖｏｉｄ　ｇｒｏｗ（）　　｛　ｌｏｇ（＂Ｇｒａｐｅ　ｉｓ　ｇｒｏｗｉｎｇ．．．＂）；　　｝　　ｐｕｂｌｉｃ　ｖｏｉｄ　ｈａｒｖｅｓｔ（）　　｛　ｌｏｇ（＂Ｇｒａｐｅ　ｈａｓ　ｂｅｅｎ　ｈａｒｖｅｓｔｅｄ．＂）；　　｝　　ｐｕｂｌｉｃ　ｖｏｉｄ　ｐｌａｎｔ（）　　｛　ｌｏｇ（＂Ｇｒａｐｅ　ｈａｓ　ｂｅｅｎ　ｐｌａｎｔｅｄ．＂）；　　｝　　ｐｕｂｌｉｃ　ｓｔａｔｉｃ　ｖｏｉｄ　ｌｏｇ（Ｓｔｒｉｎｇ　ｍｓｇ）　　｛　Ｓｙｓｔｅｍ．ｏｕｔ．ｐｒｉｎｔｌｎ（ｍｓｇ）；　　｝　　ｐｕｂｌｉｃ　ｂｏｏｌｅａｎ　ｇｅｔＳｅｅｄｆｕｌ（）　　｛　ｒｅｔｕｒｎ　ｓｅｅｄｆｕｌ；　　｝　　ｐｕｂｌｉｃ　ｖｏｉｄ　ｓｅｔＳｅｅｄｆｕｌ（ｂｏｏｌｅａｎ　ｓｅｅｄｆｕｌ）　ｔｈｉｓ．ｓｅｅｄｆｕｌ　＝　ｓｅｅｄｆｕｌ；　　｝　　ｐｒｉｖａｔｅ　ｂｏｏｌｅａｎ　ｓｅｅｄｆｕｌ；　｝　代码清单４．　类Ｓｔｒａｗｂｅｒｒｙ的源代码。

　ｐａｃｋａｇｅ　ｃｏｍ．ｊａｖａｐａｔｔｅｒｎｓ．ｓｉｍｐｌｅｆａｃｔｏｒｙ；　　ｐｕｂｌｉｃ　ｃｌａｓｓ　Ｓｔｒａｗｂｅｒｒｙ　ｉｍｐｌｅｍｅｎｔｓ　ＦｒｕｉｔＩＦ　　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｇｒｏｗ（）　｛　ｌｏｇ（＂Ｓｔｒａｗｂｅｒｒｙ　ｉｓ　ｇｒｏｗｉｎｇ．．．＂）；　｝　ｐｕｂｌｉｃ　ｖｏｉｄ　ｈａｒｖｅｓｔ（）　｛　ｌｏｇ（＂Ｓｔｒａｗｂｅｒｒｙ　ｈａｓ　ｂｅｅｎ　ｈａｒｖｅｓｔｅｄ．＂）；　｝　ｐｕｂｌｉｃ　ｖｏｉｄ　ｐｌａｎｔ（）　｛　ｌｏｇ（＂Ｓｔｒａｗｂｅｒｒｙ　ｈａｓ　ｂｅｅｎ　ｐｌａｎｔｅｄ．＂）；　｝　ｐｕｂｌｉｃ　ｓｔａｔｉｃ　ｖｏｉｄ　ｌｏｇ（Ｓｔｒｉｎｇ　ｍｓｇ）　｛　Ｓｙｓｔｅｍ．ｏｕｔ．ｐｒｉｎｔｌｎ（ｍｓｇ）；　｝　｝　你作为小花果园的主人兼园丁，也是系统的一部分，自然要由一个合适的类来代表，这个类就是　ＦｒｕｉｔＧａｒｄｅｎｅｒ类。

这个类的结构请见下面的ＵＭＬ类图。

图２．　ＦｒｕｉｔＧａｒｄｅｎｅｒ类图。

　ＦｒｕｉｔＧａｒｄｅｎｅｒ类会根据要求，创立出不同的水果类，比如萍果Ａｐｐｌｅ，葡萄Ｇｒａｐｅ或草莓Ｓｔｒａｗｂｅｒｒｙ的实例。

而如果接到不合法的要求，ＦｒｕｉｔＧａｒｄｅｎｅｒ类会给出例外ＢａｄＦｒｕｉｔＥｘｃｅｐｔｉｏｎ。

图３．　ＢａｄＦｒｕｉｔＥｘｃｅｐｔｉｏｎ类图。

代码清单５．　ＦｒｕｉｔＧａｒｄｅｎｅｒ类的源代码。

　ｐａｃｋａｇｅ　ｃｏｍ．ｊａｖａｐａｔｔｅｒｎｓ．ｓｉｍｐｌｅｆａｃｔｏｒｙ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＦｒｕｉｔＧａｒｄｅｎｅｒ　｛　　ｐｕｂｌｉｃ　ＦｒｕｉｔＩＦ　ｆａｃｔｏｒｙ（Ｓｔｒｉｎｇ　ｗｈｉｃｈ）　ｔｈｒｏｗｓ　ＢａｄＦｒｕｉｔＥｘｃｅｐｔｉｏｎ｛　ｉｆ　（ｗｈｉｃｈ．ｅｑｕａｌｓＩｇｎｏｒｅＣａｓｅ（＂ａｐｐｌｅ＂））　｛　ｒｅｔｕｒｎ　ｎｅｗ　Ａｐｐｌｅ（）；　｝　ｅｌｓｅ　ｉｆ　（ｗｈｉｃｈ．ｅｑｕａｌｓＩｇｎｏｒｅＣａｓｅ（＂ｓｔｒａｗｂｅｒｒｙ＂））　｛　ｒｅｔｕｒｎ　ｎｅｗ　Ｓｔｒａｗｂｅｒｒｙ（）；　｝　ｅｌｓｅ　ｉｆ　（ｗｈｉｃｈ．ｅｑｕａｌｓＩｇｎｏｒｅＣａｓｅ（＂ｇｒａｐｅ＂））　｛　ｒｅｔｕｒｎ　ｎｅｗ　Ｇｒａｐｅ（）；　｝　ｅｌｓｅ　｛　ｔｈｒｏｗ　ｎｅｗ　ＢａｄＦｒｕｉｔＥｘｃｅｐｔｉｏｎ（＂Ｂａｄ　ｆｒｕｉｔ　ｒｅｑｕｅｓｔ＂）；　｝　　｝　｝　代码清单６．　ＢａｄＦｒｕｉｔＥｘｃｅｐｔｉｏｎ类的源代码。

　ｐａｃｋａｇｅ　ｃｏｍ．ｊａｖａｐａｔｔｅｒｎｓ．ｓｉｍｐｌｅｆａｃｔｏｒｙ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＢａｄＦｒｕｉｔＥｘｃｅｐｔｉｏｎ　ｅｘｔｅｎｄｓ　Ｅｘｃｅｐｔｉｏｎ　｛　　ｐｕｂｌｉｃ　ＢａｄＦｒｕｉｔＥｘｃｅｐｔｉｏｎ（Ｓｔｒｉｎｇ　ｍｓｇ）　　｛　ｓｕｐｅｒ（ｍｓｇ）；　　｝　｝　在使用时，只须呼叫ＦｒｕｉｔＧａｒｄｅｎｅｒ的ｆａｃｔｏｒｙ（）方法即可ｔｒｙ　｛　　ＦｒｕｉｔＧａｒｄｅｎｅｒ　ｇａｒｄｅｎｅｒ　＝　ｎｅｗ　ＦｒｕｉｔＧａｒｄｅｎｅｒ（）；　　ｇａｒｄｅｎｅｒ．ｆａｃｔｏｒｙ（＂ｇｒａｐｅ＂）；　　ｇａｒｄｅｎｅｒ．ｆａｃｔｏｒｙ（＂ａｐｐｌｅ＂）；　　ｇａｒｄｅｎｅｒ．ｆａｃｔｏｒｙ（＂ｓｔｒａｗｂｅｒｒｙ＂）；　　．．．　　｝　　ｃａｔｃｈ（ＢａｄＦｒｕｉｔＥｘｃｅｐｔｉｏｎ　ｅ）　　｛　．．．　｝　就这样你的小果园一定会有百果丰收啦！　简单工厂模式的定义　总而言之，简单工厂模式就是由一个工厂类根据参数来决定创立出那一种产品类的实例。

下面的ＵＭＬ类图就精确定义了简单工厂模式的结构。

图４．　简单工厂模式定义的类图。

　ｐｕｂｌｉｃ　ｃｌａｓｓ　Ｃｒｅａｔｏｒ　｛　　ｐｕｂｌｉｃ　Ｐｒｏｄｕｃｔ　ｆａｃｔｏｒｙ（）　　｛　ｒｅｔｕｒｎ　ｎｅｗ　ＣｏｎｃｒｅｔｅＰｒｏｄｕｃｔ（）；　　｝　｝　ｐｕｂｌｉｃ　ｉｎｔｅｒｆａｃｅ　Ｐｒｏｄｕｃｔ　｛　｝　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＣｏｎｃｒｅｔｅＰｒｏｄｕｃｔ　ｉｍｐｌｅｍｅｎｔｓ　Ｐｒｏｄｕｃｔ　｛　　ｐｕｂｌｉｃ　ＣｏｎｃｒｅｔｅＰｒｏｄｕｃｔ（）｛｝　｝　代码清单７．　简单工厂模式框架的源代码。

简单工厂模式实际上就是我们要在后面介绍的，工厂方法模式的一个简化了的情形。