设计模式——工厂模式

最新推荐文章于 2022-11-23 22:31:48 发布
最新推荐文章于 2022-11-23 22:31:48 发布
阅读量75 收藏
点赞数
文章标签： 设计模式 java
原文链接：http://www.cnblogs.com/lcqBlogs/archive/2012/03/21/2409519.html
版权

工厂模式：工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

1）简单工厂模式（Simple Factory）：不利于产生系列产品；

2）工厂方法模式：

（生产同一种类型的产品，不同风味） 将生产产品的类做成抽象类，抽象方法中创建产品。由子类处理对象的实例化。

3）抽象工厂模式（Abstract Factory）：又称为工具箱，产生产品族，但不利于产生新的产品；

一·首先我们实现简单工厂模式：

我们的需求是建立交通工具类，该类有移动的功能，因为交通工具有很多种具体的产品，所以我们抽象出Moveable接口：

1 package com.lcq.factory;
2 
3 public interface Moveable {
4     public void run();
5 }

然后我们创建具体的实现类：

 1 package com.lcq.factory;
 2 
 3 public class Plane implements Moveable{
 4 
 5     @Override
 6     public void run() {
 7         System.out.println("扇着翅膀飞奔而来。。。");
 8     }
 9 
10 }

接下来我们将Plane类创建对象的过程进行封装，实现工厂。在实现工厂类之前，我们可以对工厂类进行抽象，创建抽象工厂类：

1 package com.lcq.factory;
2 
3 public abstract class VehicleFactory {
4     public abstract Moveable create();
5 }

在具体的工厂类中继承抽象的工厂类：

1 package com.lcq.factory;
2 
3 public class PlaneFactory extends VehicleFactory{
4 
5     @Override
6     public Moveable create() {
7         return new Plane();
8     }
9 }

这样客户就可以使用工厂进行对象的创建和使用了：

 1 package com.lcq.factory;
 2 
 3 public class Test2 {
 4     public static void main(String[] args) {
 5         
 6         VehicleFactory factory = new PlaneFactory();
 7 //        VehicleFactory factory = new BroomFactory();
 8         
 9         Moveable m = factory.create();
10         m.run();
11     }
12 
13 }

假如我们想提供另外的交通工具类就会非常灵活。比如我们想将交通工具换成扫帚，则可以创建Broom对象：

 1 package com.lcq.factory;
 2 
 3 public class Broom implements Moveable{
 4 
 5     @Override
 6     public void run() {
 7         System.out.println("刮着沙尘暴呼啸而来。。。");
 8     }
 9 
10 }

实现它的工厂生产类：

 1 package com.lcq.factory;
 2 
 3 public class BroomFactory extends VehicleFactory{
 4 
 5     @Override
 6     public Moveable create() {
 7         return new Broom();
 8     }
 9 
10 }

在客户类中替换掉工厂就可以了：

1 VehicleFactory factory = new BroomFactory();

所以简单工厂模式对于创建新的产品是比较方便灵活的。

简单工厂类图：

二.工厂方法

简单的模拟一下工厂方法：

interface IProduct {  
    public void productMethod();  
}  
  
class Product implements IProduct {  
    public void productMethod() {  
        System.out.println("产品");  
    }  
}  
  
interface IFactory {  
    public IProduct createProduct();  
}  
  
class Factory implements IFactory {  
    public IProduct createProduct() {  
        return new Product();  
    }  
}  
  
public class Client {  
    public static void main(String[] args) {  
        IFactory factory = new Factory();  
        IProduct prodect = factory.createProduct();  
        prodect.productMethod();  
    }  
}

　　

工厂方法类图

三·抽象工厂实现

我们的需求是客户需要一系列的产品，比如这些产品包括：交通工具，武器，食物。

我们首先创建这些产品：

交通工具：

1 package com.lcq.factory.abstractfactory;
2 
3 public abstract class Vehicle {
4     public abstract void run();
5 }

具体的交通工具Car：

 1 package com.lcq.factory.abstractfactory;
 2 /**
 3  * 单例模式和工厂方法模式
 4  * @author lcq
 5  *
 6  */
 7 
 8 public class Car extends Vehicle{
 9 
10     @Override
11     public void run() {
12         System.out.println("开车去东北。。。");
13         
14     }
15     
16 }

武器：

1 package com.lcq.factory.abstractfactory;
2 
3 public abstract class Weapon {
4     public abstract void shoot();
5 
6 }

具体的武器实现：

 1 package com.lcq.factory.abstractfactory;
 2 
 3 public class AK47 extends Weapon {
 4 
 5     @Override
 6     public void shoot() {
 7         System.out.println("da da da...");
 8     }
 9 
10 }

食物：

1 package com.lcq.factory.abstractfactory;
2 
3 public abstract class Food {
4     public abstract void print();
5 }

具体的食物：

 1 package com.lcq.factory.abstractfactory;
 2 
 3 public class Apple extends Food {
 4 
 5     @Override
 6     public void print() {
 7         System.out.println("eat apple");
 8     }
 9 
10 }

接下来定义我们的抽象工厂类，在该类中我们定义抽象的创建交通工具和武器以及食品的抽象方法：

1 package com.lcq.factory.abstractfactory;
2 
3 public abstract class AbstractFactory {
4     public abstract Vehicle createVehicle();
5     public abstract Weapon createWeapon();
6     public abstract Food createFood();
7     
8 }

定义具体生产产品的工厂类：

 1 package com.lcq.factory.abstractfactory;
 2 
 3 public class DefaultFactory extends AbstractFactory {
 4 
 5     @Override
 6     public Vehicle createVehicle() {
 7         return new Car();
 8     }
 9 
10     @Override
11     public Weapon createWeapon() {
12         return new AK47();
13     }
14 
15     @Override
16     public Food createFood() {
17         return new Apple();
18     }
19 
20 }

这样客户就可以利用工厂类去使用系列产品了：

 1 package com.lcq.factory.abstractfactory;
 2 /**
 3  * 测试抽象工厂
 4  * @author lcq
 5  *
 6  */
 7 public class test {
 8     public static void main(String[] args) {
 9         
10         AbstractFactory factory = new DefaultFactory();
11         
12         Vehicle vehicle = factory.createVehicle();
13         vehicle.run();
14         Weapon weapon = factory.createWeapon();
15         weapon.shoot();
16         Food food = factory.createFood();
17         food.print();
18         
19         
20         
21         
22     }
23 
24 }

以上是实现了一个系列的产品，如果想改成其他系列的产品，可以比较方便的实现：

创建另外系列的产品：

交通工具：

 1 package com.lcq.factory.abstractfactory;
 2 
 3 public class Broom extends Vehicle {
 4 
 5     @Override
 6     public void run() {
 7         System.out.println("冒着沙尘暴一路飞奔而来。。。");
 8     }
 9 
10 }

武器：

 1 package com.lcq.factory.abstractfactory;
 2 
 3 public class MagicStick extends Weapon {
 4 
 5     @Override
 6     public void shoot() {
 7         System.out.println("fire hu hu hu...");
 8     }
 9 
10 }

食品：

 1 package com.lcq.factory.abstractfactory;
 2 
 3 public class MushRoom extends Food {
 4 
 5     @Override
 6     public void print() {
 7         System.out.println("mushroom");
 8     }
 9 
10 }

创建好对应的工厂类：

 1 package com.lcq.factory.abstractfactory;
 2 
 3 public class MagicFactory extends AbstractFactory{
 4 
 5     @Override
 6     public Vehicle createVehicle() {
 7         return new Broom();
 8     }
 9 
10     @Override
11     public Weapon createWeapon() {
12         return new MagicStick();
13     }
14 
15     @Override
16     public Food createFood() {
17         return new MushRoom();
18     }
19 
20 }

在客户类中修改即可更换产品系列：

1 AbstractFactory factory = new MagicFactory();

抽象工厂类图：

三·模拟spring实现工厂模式

基本思路是结合配置文件实现工厂模式。

和先前的流程相似，创建Moveable接口和其实现类Car：

1 package com.spring.factory;
2 
3 public interface Moveable {
4     public void run();
5 }
 1 package com.spring.factory;
 2 /**
 3  * 单例模式和工厂方法模式
 4  * @author lcq
 5  *
 6  */
 7 
 8 public class Car implements Moveable{
 9 
10     @Override
11     public void run() {
12         System.out.println("开车去东北。。。");
13     }
14 }

再添加一个实现类Train；

 1 package com.spring.factory;
 2 
 3 public class Train implements Moveable {
 4 
 5     @Override
 6     public void run() {
 7         System.out.println("开着火车冒着烟。。。");
 8     }
 9 
10 }

创建配置文件spring.properties：

vehicleType=com.spring.factory.Train

在客户类中使用工厂：

 1 package com.spring.factory;
 2 
 3 import java.util.Properties;
 4 
 5 public class Test {
 6     public static void main(String[] args) throws Exception {
 7         Properties properties = new Properties();
 8         properties.load(Test.class.getClassLoader().getResourceAsStream(
 9                 "com/spring/factory/spring.properties"));
10         String vehicleTypeName = properties.getProperty("vehicleType");
11         Object o = Class.forName(vehicleTypeName).newInstance();
12 
13         Moveable m = (Moveable) o;
14         m.run();
15     }
16 }

这样在更改产品时可以直接修改配置文件，比如：

vehicleType=com.spring.factory.Car

即可。










 







 







 

 



 

转载于:https://www.cnblogs.com/lcqBlogs/archive/2012/03/21/2409519.html

awp51086
关注
【设计模式】工厂模式
HoldonWithYourGoal的博客
12-08 392
工厂模式是一种创建型设计模式。 开闭原则 开闭原则是设计模式原则之一，倡导实体应当对扩展开发，对修改关闭。 意思是说，你想要扩展或者修改已写好代码的功能，可以往里面加入新的代码，但不允许修改修改以前已经写好的代码。 高耦合将会导致，拓展功能时，不得不修改以前的代码。 比如 public class Service { Dao dao = new JpaDao(); void se...
PHP 常见设计模式——工厂模式
程序员小晨|blog
12-19 3580
今天这篇文章主要是描述一下PHP常见设计模式之工厂模式。工厂模式其实可以划分为：简单工厂模式、工厂方法模式、抽象工厂模式等。
工厂模式
Little_Oranges的博客
07-27 313
工厂模式 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。 介绍 意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。 主要解决：主要解...
设计模式-工厂模式
盲流子的博客
05-18 234
工厂模式介绍 它提供了了⼀种创建对象的最佳方式，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象 工厂模式的好处： 解耦：分离职责，把复杂的对象的创建和使用的过程分开 复用代码降低维护成本：如果对象创建复杂且多处需用到，如果每处都进行编写，则很多重复代码，如果业务逻辑发生了改变，需要四处修改；使用工厂模式统一创建，则只需要修改工厂类即可，降低维护成本 工厂模式三种不同实现方式 简单工厂模式：通过传入相关的类型来返回相应的类，这种方式比较单一，可扩展性相对较差 工
C++之工厂(factory)模式
热门推荐
lovely_yoshino的博客
03-07 1万+
0. 简介 继单例模式写完后，我觉得对于C++的高级用法可以来开一个专栏来专门整理与阐述，这里，我将以我们最常用的工厂模式开始，来逐步的共同学习。 https://www.cnblogs.com/hebaichuanyeah/category/824625.html ......
Java设计模式——工厂设计模式详解
08-28
Java设计模式——工厂设计模式详解 在软件设计中，工厂设计模式是一种常用的设计模式，主要用于实例化有共同接口的类。Java设计模式——工厂设计模式是Java中的一种常用的设计模式，主要用于实例化有共同接口的类。...
Java设计模式——工厂设计模式
12-22
工厂模式： – 实现了创建者和调用者的分离。 – 详细分类： 简单工厂模式 工厂方法模式 抽象工厂模式 面向对象设计的基本原则： OCP（开闭原则，Open-Closed Principle）：一个软件的实体应当对扩展开放，对修改...
（创建模式 上）设计模式——工厂、抽象工厂 C++/Python3实现
01-20
简介 设计模式是为了解决一些出现的问题设计的解决方案。是长时间经验的总结，是根据...工厂模式 在类中实现一个接口创建指定对象，使一个类的实例化延迟到了子类。简单来说把类的创建都封装起来，只需要调用一个子类
设计模式——工厂模式在开发中的应用（简单计算器）
08-11
这个是http://blog.csdn.net/dawanganban/article/details/9884681博客中java设计模式的源代码。下载前请先看《设计模式——工厂模式在开发中的应用》一文。
设计模式之工厂模式
最新发布
m0_51050554的博客
11-23 502
工厂模式有三种，分别是简单工厂模式、工厂模式以及抽象工厂模式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值