Java设计模式——工厂方法和抽象工厂方法

工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂 角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

例如：

 1 //交通工具必须实现的接口
 2 public interface Moveable {
 3     public void run();
 4 }
 5
 6 //交通工具1.car
 7 public class Car implements Moveable{
 8
 9     @Override
10     public void run() {
11         // TODO Auto-generated method stub
12         System.out.println("Car----------------");
13
14     }
15
16 }
17
18 //交通工具2.plane
19 public class Plane implements Moveable{
20
21     @Override
22     public void run() {
23         // TODO Auto-generated method stub
24         System.out.println("Plane----------------");
25     }
26
27 }
28
29 //作为工厂必须实现的接口
30 public interface Factory {
31     public Moveable create();
32 }
33
34 //具体的交通工具工厂CarFactory
35 public class CarFactory implements Factory{
36
37     @Override
38     public Moveable create() {
39         // TODO Auto-generated method stub
40
41         return new Car();
42     }
43
44 }
45
46 //具体的交通工具工厂PlaneFactory
47 public class PlaneFactory implements Factory{
48
49     @Override
50     public Moveable create() {
51         // TODO Auto-generated method stub
52         return new Plane();
53     }
54
55 }

测试1：

1 public class Test {
2     public static void main(String args[]){
3         Factory fac = new PlaneFactory();
4         Moveable mov = fac.create();
5         mov.run();
6     }
7 }

输出1：

Plane----------------

测试2:

1 public class Test {
2     public static void main(String args[]){
3         Factory fac = new CarFactory();
4         Moveable mov = fac.create();
5         mov.run();
6     }
7 }

输出2：

Car----------------

在上述例子中，工厂方法使我们能够定制任意交通工具的类型和生产过程，假设我们有了新的交通工具vihicle

//交通工具3.vihicle
public class Vihicle implements Moveable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("Vihicle----------------");
    }
}

实现VihicleFactory类：

1 public class VihicleFactory implements Factory{
2
3     @Override
4     public Moveable create() {
5         // TODO Auto-generated method stub
6         return new Vihicle();
7     }
8
9 }

在生产过程中，我们只需new一个VihicleFactory并调用create()方法即可：

1 public class Test {
2     public static void main(String args[]){
3         Factory fac = new VihicleFactory();
4         Moveable mov = fac.create();
5         mov.run();
6     }
7 }

输出：

Vihicle----------------

在工厂方法中，每当我们有了新的Product需要生产时，我们就必须实现对应的ProductFactory，这样一来，随着Product数量的增多，往往容易造成ProductFactory泛滥，若我们想要生产十几种产品就要相应的实现十几个具体的工厂，这显然是不科学的，而抽象工厂方法正好解决了这个问题

例：

  1 //食物接口
  2 public interface Food {
  3     public void printName();
  4 }
  5
  6 //食物产品1.apple
  7 public class Apple implements Food{
  8
  9     @Override
 10     public void printName() {
 11         // TODO Auto-generated method stub
 12         System.out.println("this is apple");
 13     }
 14
 15 }
 16
 17 //食物产品2.banana
 18 public class Banana implements Food{
 19
 20     @Override
 21     public void printName() {
 22         // TODO Auto-generated method stub
 23         System.out.println("this is banana");
 24     }
 25
 26 }
 27
 28 //汽车接口
 29 public interface Vehicle {
 30     public void run();
 31 }
 32
 33 //汽车产品1.benz
 34 public class Benz implements Vehicle{
 35
 36     @Override
 37     public void run() {
 38         // TODO Auto-generated method stub
 39         System.out.println("Benz--------------");
 40     }
 41
 42 }
 43
 44
 45 //汽车产品2.bwm
 46 public class BWM implements Vehicle{
 47
 48     @Override
 49     public void run() {
 50         // TODO Auto-generated method stub
 51         System.out.println("BWM--------------");
 52     }
 53
 54 }
 55
 56 //武器接口
 57 public interface Weapon {
 58     public void shot();
 59 }
 60
 61
 62 //武器产品1.AK47
 63 public class AK47 implements Weapon{
 64     @Override
 65     public void shot(){
 66         System.out.println("AK47-------------");
 67     }
 68 }
 69
 70 //武器产品2.M4
 71 public class M4 implements Weapon{
 72
 73     @Override
 74     public void shot() {
 75         // TODO Auto-generated method stub
 76         System.out.println("M4--------------");
 77     }
 78
 79 }
 80
 81 //工厂接口
 82 public interface AbstractFactory {
 83     public Vehicle createVehicle();
 84     public Weapon  createWeapon();
 85     public Food     createFood();
 86 }
 87
 88 //工厂1：能够生产BWM、AK47、Apple
 89 public class Factory1 implements AbstractFactory{
 90
 91     @Override
 92     public Vehicle createVehicle() {
 93         // TODO Auto-generated method stub
 94         return new BWM();
 95     }
 96
 97     @Override
 98     public Weapon createWeapon() {
 99         // TODO Auto-generated method stub
100         return new AK47();
101     }
102
103     @Override
104     public Food createFood() {
105         // TODO Auto-generated method stub
106         return new Apple();
107     }
108
109 }
110
111 //工厂2：Benz、M4、Banana
112 public class Factory2 implements AbstractFactory{
113
114     @Override
115     public Vehicle createVehicle() {
116         // TODO Auto-generated method stub
117         return new Benz();
118     }
119
120     @Override
121     public Weapon createWeapon() {
122         // TODO Auto-generated method stub
123         return new M4();
124     }
125
126     @Override
127     public Food createFood() {
128         // TODO Auto-generated method stub
129         return new Banana();
130     }
131
132 }

测试1：

public class Test {
    public static void main(String args[]){
        AbstractFactory abs=new Factory1();
        Food fo = abs.createFood();
        Vehicle ve = abs.createVehicle();
        Weapon we = abs.createWeapon();
        fo.printName();
        ve.run();
        we.shot();
    }
}

输出1：

this is apple
BWM--------------
AK47-------------

测试2:

public class Test {
    public static void main(String args[]){
        AbstractFactory abs=new Factory2();
        Food fo = abs.createFood();
        Vehicle ve = abs.createVehicle();
        Weapon we = abs.createWeapon();
        fo.printName();
        ve.run();
        we.shot();
    }
}

输出2:

1 this is banana
2 Benz--------------
3 M4--------------

抽象工厂的优点在于能够生产一系列可能存在关联的产品，但是，当我们需要在抽象工厂中添加新的产品时，几乎所有的工厂类都要修改

图片来自http://www.cnblogs.com/devinzhang/archive/2011/12/19/2293160.html

图片来自http://www.cnblogs.com/devinzhang/archive/2011/12/19/2293160.html

这样看来：

工厂模式生产一类产品（一个产品等级结构），来自同一个接口或抽象类

抽象工厂生产多类可能存在关联的产品（多个产品等级结构），来自多个接口或抽象类

时间： 2024-10-06 00:10:39

Java设计模式——工厂方法和抽象工厂方法的相关文章

java设计模式 -------- 创建模式 之 抽象工厂模式

本文是自己学习所做笔记,欢迎转载,但请注明出处:http://blog.csdn.net/jesson20121020 工厂方法模式和抽象工厂模式不好区分清楚: 工厂方法模式特点: 1. 一个抽象产品类,可以派生出多个具体产品类. 2. 一个抽象工厂类,可以派生出多个具体工厂类. 3. 每个具体工厂类只能创建一个具体产品类的实例. 抽象工厂模式特点: 1. 多个抽象产品类,每个抽象产品类可以派生出多个具体产品类. 2. 一个抽象工厂类,可以派生出多个具体工厂类. 3. 每个具体工厂类可以创建多个

Java设计模式：Abstract Factory(抽象工厂)模式

概念定义 抽象工厂(Abstract Factory)模式提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. 抽象工厂模式中,系统的产品有多于一个的产品族(一个产品族里定义多个产品),而系统只消费其中某一族的产品.换句话说,抽象工厂创建一整套具有相互依赖或作用关系的产品(至少两个产品),而工厂方法中的工厂只能创建单一系列的产品. 应用场景 客户端不需要知道它所创建的对象的类. 需要一组对象共同完成某种功能时,并且可能存在多组对象完成不同功能的情况. 系统结构稳定,不会频繁地增加

Java设计模式菜鸟系列(五)抽象工厂模式建模与实现

转载请注明出处:http://blog.csdn.net/lhy_ycu/article/details/39784403 抽象工厂模式(Abstract Factory):抽象工厂--顾名思义,就是把工厂抽象出来,不同的工厂生产不同的产品.这样做有个好处:一旦需要增加新的功能,直接增加新的工厂类就可以了,不需要修改之前的代码. 一.uml建模图: 二.代码实现 /** * 示例:抽象工厂--顾名思义,就是把工厂抽象出来,不同的工厂生产不同的产品 * * 优点:一旦需要增加新的功能,直接增加新的

java设计模式--创建型模式--抽象工厂

什么是抽象工厂,再次学习. 1 抽象工厂 2 概述 3 提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. 4 5 适用性 6 1.一个系统要独立于它的产品的创建.组合和表示时. 7 8 2.一个系统要由多个产品系列中的一个来配置时. 9 10 3.当你要强调一系列相关的产品对象的设计以便进行联合使用时. 11 12 4.当你提供一个产品类库,而只想显示它们的接口而不是实现时. 13 参与者 14 1.AbstractFactory 15 声明一个创建抽象产品对象的操作接口.

Java工厂模式（简单工厂、工厂方法、抽象工厂）

工厂模式:主要用来实例化有共同接口的类,工厂模式可以动态决定应该实例化那一个类.工厂模式的形态工厂模式主要用一下几种形态:1:简单工厂(Simple Factory).2:工厂方法(Factory Method).3:抽象工厂(Abstract Factory). 简单工厂(Simple Factory)又叫静态工厂,是工厂模式三中状态中结构最为简单的.主要有一个静态方法,用来接受参数,并根据参数来决定返回实现同一接口的不同类的实例.我们来看一个具体的例子:假设一家工厂,几生产洗衣机,有生产冰箱

Java设计模式（一） 简单工厂模式不简单

原创文章,转载请务必将下面这段话置于文章开头处. 本文转发自Jason's Blog,原文链接 http://www.jasongj.com/design_pattern/simple_factory 简单工厂模式使用案例 有一种抽象产品--汽车(Car),同时有多种具体的子类产品,如BenzCar,BMWCar,LandRoverCar.类图如下 作为司机,如果要开其中一种车,比如BenzCar,最直接的做法是直接创建BenzCar的实例,并执行其drive方法,如下 package com.

Java设计模式—工厂方法模式&抽象工厂模式

工厂方法模式与抽象工厂模式都是设计模式中重要而且常见的模式.       工厂方法模式:定义一个用于创建对象的接口,让子类决定实例化哪一个类.工厂方法使一个类的实例化延迟到其子类. 通用类图如下: 在工厂方法模式中,抽象产品类Product负责定义产品的共性,实现对事物最抽象的定义:Creator为抽象创建 类,也就是抽象工厂,具体如何创建产品类是由具体的实现工厂ConcreteCreator完成的. 工厂方法模式的扩展方式有很多种,下边是工厂方法模式一个比较实用的源代码: 抽象产品类: pub

Java设计模式（创建型：工厂方法模式+抽象工厂模式)

设计模式根据目的准则可以分为三类: 创建型:creational 创建型的设计模式与对象的创建有关. 结构型:Structural 处理类和对象之间的组合. 行为型:behavioral 描述类和对象如何交互及如何分配职责. 工厂方法模式 站在使用者的角度,工厂方法模式是指使用者提出想要实现的具体功能或者说是想要生产的具体的东西的要求,在通过工厂制造之后就将该东西或功能交付给使用者.使用者并不知道实现的具体过程,只是做了要求提出以及实现的结果的使用. 严谨来说工厂方法模式(Factory Met

Java设计模式之简单工厂、工厂方法和抽象工厂

在前面的学习中(参见前面的博客),我们学到了很多OO原则: 封装变化 多用组合,少用继承 针对接口/超类编程,不针对实现编程 松耦合 开闭原则 让我们从一个简单的类开始,看看如何将之改造成符合OO原则的类以及工厂模式在解耦中的威力. class FoodStore { public Food orderFood() //通过此方法顾客从食物商店中得到食物 { Food food=new Food(); food.prepare(); // 准备食物 food.cut(); // 将食物切好 fo

设计模式系列---简单工厂、工厂方法、抽象工厂

前言,最近看spring的源代码.发现之前没有完全弄懂(工厂方法.抽象工厂)的区别. spring中代理对象的产生,是通过代理工厂(工厂模式),首先spring中的代理是使用jdk或者cglib的代理,只要看目标类是否实现接口. public class ProxyFactory extends ProxyCreatorSupport { //createAopProxy()方法是通过AopProxyFactory获取AopProxy(JDK,CGLIB) public Object getPr