设计模式之禅学习——工厂方法模式
工厂方法模式——定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。
一、工厂方法模式的通用代码：
首先要定义产品族，也就是一个产品的接口
package com.wang.factoryPattern.method;
/**
* 产品类接口
* @author HeJW
*
*/
public interface Product {
public void method1();
public String method2(String args);
}
然后，让我们定义两个实现该接口的类，也就是具体的产品：
第一个产品：
package com.wang.factoryPattern.method;
/**
* 具体产品类1
* @author HeJW
*
*/
public class ConcreteProduct1 implements Product {
public ConcreteProduct1(){
System.out.println("ConcreteProduct1 被创建");
}
@Override
public void method1() {
System.out.println("xx");
}
@Override
public String method2(String args) {
return args;
}
}
第二个产品，代码与第一个产品基本相同：
package com.wang.factoryPattern.method;
/**
* 具体产品类2
* @author HeJW
*
*/
public class ConcreteProduct2 implements Product {
public ConcreteProduct2(){
System.out.println("ConcreteProduct2 被创建");
}
@Override
public void method1() {
System.out.println("yy");
}
@Override
public String method2(String args) {
return args;
}
}
现在该定义工厂方法的工厂接口了：
package com.wang.factoryPattern.method;
/**
* 工厂方法的接口
* @author HeJW
*
*/
public interface Factory {
/*
* 创建一个产品对象，其输入参数类型可以自行设置
* 通常为String、Enum、Class等，当然也可以为空
*/
//输入类型为Class
public <T extends Product> T productFactory1(Class<T> c);
//输入类型为String
public Product productFactory2(String product);
}
之后，实现该工厂接口：
package com.wang.factoryPattern.method;
/**
* 具体工厂类
* @author HeJW
*
*/
public class ConcreteFactory implements Factory {
@Override
public <T extends Product> T productFactory1(Class<T> c) {
Product product1 = null;
try {
product1 = (Product)Class.forName(c.getName()).newInstance();
} catch (Exception e) {
//异常处理
}
return (T)product1;
}
@Override
public Product productFactory2(String product) {
Product product2 = null;
if( product.equals("ConcreteProduct1") ){
product2 = new ConcreteProduct1();
} else {
product2 = new ConcreteProduct2();
}
return product2;
}
}
现在工厂方法模式已经实现了，下面编写一个测试类，看看工厂方法模式的使用：
package com.wang.factoryPattern.method;
/**
* 测试类
* @author HeJW
*
*/
public class App {
public static void main(String[] args) {
Factory factory = new ConcreteFactory();
ConcreteProduct1 product1 = factory.productFactory1(ConcreteProduct1.class);
product1.method1();
ConcreteProduct2 product2 = (ConcreteProduct2) factory.productFactory2("ConcreteProduct2");
product2.method1();
}
}
运行结果如下：
二、工厂方法模式的扩展
1、工厂方法模式向下缩小为简单工厂模式，
简单工厂模式的工厂类代码如下：
package com.wang.factoryPattern.simple;
import com.wang.factoryPattern.method.Product;
/**
* 简单工厂类
* 就是加了个static
* @author HeJW
*
*/
public class SimpleFactory {
public static <T extends Product> T productFactory( Class<T> c ){
Product product = null;
try {
product = (Product)Class.forName(c.getName()).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return (T)product;
}
}
非常简单，下面编写一个测试类，看看简单工厂模式的使用：
package com.wang.factoryPattern.simple;
import com.wang.factoryPattern.method.ConcreteProduct1;
/**
* 简单工厂测试类
* @author HeJW
*
*/
public class App {
public static void main(String[] args) {
ConcreteProduct1 product1 = SimpleFactory.productFactory(ConcreteProduct1.class);
product1.method1();
}
}
2、工厂方法模式向上扩展为多工厂模式，所谓多工厂模式，就是为具体的每一个产品类，都有专门的工厂方法，该工厂方法，只能生产指定的某一产品。
多工厂模式的工厂接口：
package com.wang.factoryPattern.many;
import com.wang.factoryPattern.method.Product;
/**
* 多工厂模型的工厂接口
* @author HeJW
*
*/
public interface ProductFacory {
public Product productFactory();
}
产品1的工厂方法：
package com.wang.factoryPattern.many;
import com.wang.factoryPattern.method.ConcreteProduct1;
import com.wang.factoryPattern.method.Product;
/**
* ConcreteProduct1工厂的实现类
* @author HeJW
*
*/
public class ConcreteProduct1Factory implements ProductFacory {
@Override
public Product productFactory() {
return new ConcreteProduct1();
}
}
产品2的工厂方法：
package com.wang.factoryPattern.many;
import com.wang.factoryPattern.method.ConcreteProduct2;
import com.wang.factoryPattern.method.Product;
/**
* ConcreteProduct2工厂的实现类
* @author HeJW
*
*/
public class ConcreteProduct2Factory implements ProductFacory {
@Override
public Product productFactory() {
return new ConcreteProduct2();
}
}
现在已经为产品1和产品2定制了专门的工厂，现在我们看看多工厂模式的使用：
package com.wang.factoryPattern.many;
import com.wang.factoryPattern.method.ConcreteProduct1;
public class App {
public static void main(String[] args) {
ProductFacory factory = new ConcreteProduct1Factory();
ConcreteProduct1 product1 = (ConcreteProduct1) factory.productFactory();
product1.method1();
}
}
3、使用工厂方法模式替代单例模式，使用的是一些反射的知识。
首先先建立一个符合单例模式的单例类：
package com.wang.factoryPattern.singleton;
/**
* 单例类
* @author HeJW
*
*/
public class Singleton {
private Singleton(){
//不允许通过New，产生一个对象
System.out.println("singleton 创建");
};
public void method(){
System.out.println("singleton 输出");
}
}
然后为这个单例类创建它的工厂方法：
package com.wang.factoryPattern.singleton;
import java.lang.reflect.Constructor;
/**
* 替代单例模式的工厂类
* @author HeJW
*
*/
public class SingletonFactory {
private static Singleton singleton;
static{
try{
Class c1 = Class.forName(Singleton.class.getName());
//获得无参构造函数
Constructor constructor = c1.getDeclaredConstructor();
//设置无参构造函数是可访问的
constructor.setAccessible(true);
//产生一个实例对象
singleton = (Singleton) constructor.newInstance();
} catch( Exception e ){
//异常处理
}
}
public static Singleton getSingleton(){
return singleton;
}
}
编写一个测试类，来看看单例类是不是只被创建的一次：
package com.wang.factoryPattern.singleton;
public class App {
public static void main(String[] args) {
Singleton singleton1 = SingletonFactory.getSingleton();
singleton1.method();
Singleton singleton2 = SingletonFactory.getSingleton();
singleton2.method();
}
}
运行结果如下：
4、使用工厂方法模式实现类的延时初始化
意思就是如果这个产品没有被创建或者已经被销毁，那么就创建一个；如果在程序运行中，已经有了实例对象，那么就直接用这个实例对象，代码如下：
package com.wang.factoryPattern.lazy;
import java.util.HashMap;
import java.util.Map;
import com.wang.factoryPattern.method.ConcreteProduct1;
import com.wang.factoryPattern.method.ConcreteProduct2;
import com.wang.factoryPattern.method.Product;
/**
* 延时初始化的工厂类
* @author HeJW
*
*/
public class LazyProductFactory {
private static final Map<String, Product> prMap = new HashMap<String, Product>();
public static synchronized Product ProductFactory(String type){
Product product = null;
//如果Map中已经有这个对象
if ( prMap.containsKey(type) ) {
product = prMap.get(type);
} else {
if( type.equals("ConcreteProduct1") ){
product = new ConcreteProduct1();
} else if (type.equals("ConcreteProduct2")) {
product = new ConcreteProduct2();
}
//同时把对象放到缓存容器中
prMap.put(type, product);
}
return product;
}
}
测试类代码如下：
package com.wang.factoryPattern.lazy;
import com.wang.factoryPattern.method.ConcreteProduct1;
public class App {
public static void main(String[] args) {
ConcreteProduct1 product1 = (ConcreteProduct1) LazyProductFactory.ProductFactory("ConcreteProduct1");
product1.method1();
//当此次创建ConcreteProduct1时，是从map中取出的。
ConcreteProduct1 product2 = (ConcreteProduct1) LazyProductFactory.ProductFactory("ConcreteProduct1");
product2.method1();
}
}
运行结果如下：
相关推荐
### 工厂模式及其核心实现 #### 一、工厂模式定义与概述 工厂模式是一种常用的创建型设计模式，它提供了一种创建对象的最佳方式。在工厂模式中，当我们需要创建一个对象时，无需通过new关键字指定其具体类型，而是...
在软件设计模式中，工厂模式是一种非常常用的行为型模式，它的主要目的是为了隔离对象的创建过程，使得客户端代码不直接创建对象，而是通过一个...阅读并理解这些代码有助于深入理解工厂模式及其在Java编程中的应用。
这样，工厂方法模式使得一个类的实例化延迟到了其子类进行，增强了系统的可扩展性。 在Java或类似的面向对象编程语言中，工厂方法模式通常通过以下四个关键角色来实现： 1. **产品接口（Product）**：这是所有由...
本文将深入探讨PHP中的工厂方法模式（Factory Method Pattern），并通过具体的例子来解释这一模式的应用场景及其优势。 #### 二、工厂方法模式定义 工厂方法模式是一种创建型设计模式，它提供了一个创建对象的最佳...
通过运行这些示例代码，你可以更深入地理解工厂方法模式的工作原理及其在实际项目中的应用。 设计模式的学习不仅仅是理论上的了解，更重要的是将这些模式运用到实际的项目中去。工厂方法模式在软件设计中扮演着重要...
最后，"工厂方法模式"是另一种创建型设计模式，它是简单工厂模式的扩展。在工厂方法模式中，抽象工厂类定义了创建对象的接口，但由其子类决定实例化哪个类。这种模式允许延迟对象的实例化，同时也引入了多态性，使得...
抽象工厂模式是设计模式中的一种创建型模式，它...总的来说，抽象工厂模式是一种强大的设计工具，可以帮助我们构建更加灵活、可扩展的系统。理解并合理运用抽象工厂模式，可以提升软件架构的质量，降低系统维护的成本。
设计模式是软件开发中的一种最佳实践，它们...了解并掌握工厂模式及其变体，有助于编写出更加健壮、灵活的代码。在实际编码过程中，结合其他设计模式，如单例模式、建造者模式等，可以构建出更高效、可扩展的系统架构。
实验的核心在于理解和实践**抽象工厂模式**，这是一种常用的面向对象设计模式，旨在解决软件设计中的灵活性和扩展性问题。实验的目标包括： 1. **深入理解抽象工厂模式的基本概念和原理**：通过理论学习和实际操作...
工厂模式通常分为简单工厂模式、工厂方法模式和抽象工厂模式三种类型。在实际项目中，例如数据库连接的创建，我们可以使用工厂模式来创建不同类型的连接对象，如MySQL连接、Oracle连接等，而无需关心具体的实现细节...
结合工厂模式，可以进一步优化单例的创建过程，提高代码的可读性和可维护性。 单例模式的核心在于控制类的实例化过程，常见的实现方式有懒汉式、饿汉式和双重检查锁定（DCL）等。懒汉式是在类被加载时并不创建实例...
- 在实际应用中，工厂方法模式常常作为抽象工厂模式的一个子集出现，即抽象工厂模式可以包含多个工厂方法，分别对应工厂方法模式。 通过了解这两种模式，开发者可以在设计系统时根据需求选择合适的模式，提高代码的...
简单工厂模式把创建对象的过程进行了封装，客户端无需知道具体的创建细节，只需要知道调用哪个方法即可得到所需对象。 ### 主要角色 1. **产品接口/抽象类**：定义了所有创建对象的共同接口或抽象类，例如`Product`...
下面将详细介绍这三种工厂模式及其代码示例。 1. 简单工厂模式： 简单工厂模式通常用于创建一系列相关或相互依赖的对象。它包含一个工厂类，负责根据输入参数或条件来决定创建哪种类型的实例。在代码中，这个工厂...
本篇文章将深入探讨三种常见的创建型模式：简单工厂模式、工厂方法模式以及抽象工厂模式。这三种模式都是为了在不指定具体类的情况下创建对象，从而提高代码的复用性和隔离性。 1. **简单工厂模式**： 简单工厂...
工厂方法模式通过封装对象的创建过程，降低了客户端与具体实现之间的耦合度，使得系统更易于维护和扩展。在实际开发中，合理运用工厂方法模式，能够提高代码的可读性，降低维护成本，提升软件的灵活性和可扩展性。...
标题"我讲设计模式--工厂方法"暗示我们将深入探讨工厂方法的设计模式及其应用。这篇博文可能涉及了该模式的基本概念、工作原理以及实际场景下的使用示例。遗憾的是，由于没有直接提供博客的具体内容，我将基于工厂...
这些源代码可以是不同工厂模式类型的实现，通过阅读和理解这些代码，读者可以更直观地了解工厂模式的运作方式及其应用场景。 总之，这篇博客“闲谈工厂模式”可能涵盖了工厂模式的基本概念、分类、优缺点，以及在...
工厂方法模式是面向对象设计模式中的行为模式之一，它提供了一种创建对象的最佳方式。在工厂方法模式中，我们创建一个...通过阅读和分析这个文件，你可以更深入地理解工厂方法模式的实现方式及其在实际编程中的运用。