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）。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

工厂模式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的三种工厂模式一、简单工厂模式简单工厂的定义：提供一个创建对象实例的功能，而无须关心其具体实现。

被创建实例的类型可以是接口、抽象类，也可以是具体的类实现汽车接口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代码实现设计模式之工厂模式工厂设计模式：为了解耦合，把对象的创建者与对象的使用者分开。

生活中：批量生产产品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;}}。

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设计模式-简单⼯⼚模式简单⼯⼚模式详解⼀，概述 简单⼯⼚模式属于创建型模式⼜叫做静态⼯⼚⽅法模式，它属于类创建型模式。

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

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

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

简单⼯⼚模式中⽤于被创建实例的⽅法通常为因此简单⼯⼚模式⼜被成为静态⼯⼚⽅法(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的特性继承和多态，简单说：⼦类对象⽗类型。