JAVA之工厂模式(静态工厂模式（简单工厂模式）、工厂方法模式、抽象工厂模式)

最新推荐文章于 2023-02-25 15:46:18 发布

iBaoxing

最新推荐文章于 2023-02-25 15:46:18 发布

阅读量626

点赞数

分类专栏： java 文章标签： java

java 专栏收录该内容

78 篇文章 0 订阅

订阅专栏

一、引子
话说十年前,有一个暴发户,他家有三辆汽车——Benz 奔驰、Bmw 宝马、Audi 奥迪,

还雇了司机为他开车。不过,暴发户坐车时总是怪怪的:上 Benz 车后跟司机说“开奔驰车!”, 坐上 Bmw 后他说“开宝马车!”,坐上 Audi 说“开奥迪车!”。你一定说:这人有病!直接说开车不就行了?!

而当把这个暴发户的行为放到我们程序设计中来时,会发现这是一个普遍存在的现象。幸运的是,这种有病的现象在 OO(面向对象)语言中可以避免了。下面就以 Java 语言为基础来引入我们本文的主题:工厂模式。
二、分类
工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到提高灵活性的目的。

工厂模式在《Java 与模式》中分为三类:
1)简单工厂模式(Simple Factory)
2)工厂方法模式(Factory Method)
3)抽象工厂模式(Abstract Factory)
这三种模式从上到下逐步抽象,并且更具一般性。
GOF 在《设计模式》一书中将工厂模式分为两类:工厂方法模式(Factory Method)与抽象工厂模式(Abstract Factory)。将简单工厂模式(Simple Factory)看为工厂方法模式的一种特例,两者归为一类。

两者皆可,在本文使用《Java 与模式》的分类方法。下面来看看这些工厂模式是怎么来“治病”的。

三、简单工厂模式简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单:定义一个用于创建对象的接口。
先来看看它的组成:
1.1) 工厂类角色:这是本模式的核心,含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。
2.2) 抽象产品角色:它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。
3.3) 具体产品角色:工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。来用类图来清晰的表示下的它们之间的关系。

那么简单工厂模式怎么来使用呢?我们就以简单工厂模式来改造暴发户坐车的方式 ——现在暴发户只需要坐在车里对司机说句:“开车”就可以了。

①、简单工厂模式实例！

package demo05;
/**
 * //抽象产品角色
 * */
public interface Car {
    public void drive();
}

package demo05;
/**
 * 具体产品角色
 * */
public class Benz implements Car {

    @Override
    public void drive() {
        System.out.println("Driving Benz "); 
    }
}

package demo05;
/**
 * 具体产品角色
 * */
public class Bmw implements Car {

    @Override
    public void drive() {
        System.out.println("Driving Bmw "); 
    }
}

package demo05;
/**
 * 具体产品角色
 * */
public class Audi implements Car {

    @Override
    public void drive() {
        System.out.println("Driving Audi "); 
    }
}

package demo05;
/**
 * 工厂类角色
 * */
public class FactoryDriver {
    //工厂方法.注意 返回类型为抽象产品角色
    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 if(s.equalsIgnoreCase("Audi"))
            return new Audi();
        else throw new Exception();
    }
}

下面欢迎暴发户出场……

package demo05;
/**
 * 暴发户出场
 * */
public class Magnate {
    public static void main(String[] args) {
        try{
             //告诉司机我今天坐奔驰
            Car car = FactoryDriver.driverCar("benz"); 
            //下命令:开车
            car.drive(); 
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

这便是简单工厂模式了！
首先,使用了简单工厂模式后,我们的程序不在“有病”,更加符合现实中的情况;而且客户端免除了直接创建产品对象的责任,而仅仅负责“消费”产品(正如暴发户所为)。

下面我们从开闭原则(对扩展开放;对修改封闭)上来分析下简单工厂模式。当暴发户增加了一辆车的时候,只要符合抽象产品制定的合同,那么只要通知工厂类知道就可以被客户使用了。所以对产品部分来说,它是符合开闭原则的;但是工厂部分好像不太理想,因为每增加一辆车,都要在工厂类中增加相应的业务逻辑或者判断逻辑,这显然是违背开闭原则的。可想而知对于新产品的加入,工厂类是很被动的。对于这样的工厂类(在我们的例子中是为司机师傅),我们称它为全能类或者上帝类。

我们举的例子是最简单的情况,而在实际应用中,很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品,所以这可能会把我们的上帝累坏了, 也累坏了我们这些程序员
于是工厂方法模式作为救世主出现了。

四、工厂方法模式工厂方法模式去掉了简单工厂模式中工厂方法的静态属性,使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。你应该大致猜出了工厂方法模式的结构,来看下它的组成:
1.1) 抽象工厂角色: 这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在 java 中它由抽象类或者接口来实现。
2.2) 具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
3.3) 抽象产品角色:它是具体产品继承的父类或者是实现的接口。在 java 中一般有抽象类或者接口来实现。
4.4) 具体产品角色:具体工厂角色所创建的对象就是此角色的实例。在 java 中由具体的类来实现。
用类图来清晰的表示下的它们之间的关系:
工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。

正如上面所说,这样便分担了对象承受的压力;而且这样使得结构变得灵活起来——当有新的产品(即暴发户的汽车)产生时,只要按照抽象产品角色、抽象工厂角色提供的合同来生成,那么就可以被客户使用,而不必去修改任何已有的代码。可以看出工厂角色的结构也是符合开闭原则的!
我们还是老规矩,使用一个完整的例子来看看工厂模式各个角色之间是如何来协调的。话说暴发户生意越做越大,自己的爱车也越来越多。这可苦了那位司机师傅了,什么车它都要记得,维护,都要经过他来使用!于是暴发户同情他说:看你跟我这么多年的份上,以后你不用这么辛苦了,我给你分配几个人手,你只管管好他们就行了!于是,工厂方法模式的管理出现了。代码如下:

②工厂方法模式

package demo06;
/**
 * //抽象产品角色
 * */
public interface Car {
    public void drive();
}

package demo06;
/**
 * 具体产品角色
 * */
public class Audi implements Car {

    @Override
    public void drive() {
        System.out.println("Driving Audi "); 
    }
}

package demo06;
/**
 * 抽象产品角色
 * */
public class AudiDriver implements FactoryDriver {

    @Override
    public Car driverCar() {
        return new Audi();
    }

}

package demo06;
/**
 * 抽象产品角色
 * */
public class BmwDriver implements FactoryDriver {

    @Override
    public Car driverCar() {
        return new Bmw();
    }

}

package demo06;
/**
 * 抽象工厂角色
 * */
public interface FactoryDriver {
    public abstract Car driverCar();
}

package demo06;
/**
 * 具体工厂角色
 * */
public class BenzDriver implements FactoryDriver {

    @Override
    public Car driverCar() {
        return new Benz();
    }

}

有请暴发户先生

package demo06;


/**
 * 暴发户出场
 * */
public class Magnate {
    public static void main(String[] args) {
        try{
            FactoryDriver driver = new BenzDriver();
            Car car = driver.driverCar();
            car.drive();

        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

可以看出工厂方法的加入,使得对象的数量成倍增长。当产品种类非常多时,会出现大量的与之对应的工厂对象,这不是我们所希望的。因为如果不能避免这种情况,可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类:即对于产品树上类似的种类 (一般是树的叶子中互为兄弟的)使用简单工厂模式来实现。
五、小结工厂方法模式仿佛已经很完美的对对象的创建进行了包装,使得客户程序中仅仅处理抽
象产品角色提供的接口。那我们是否一定要在代码中遍布工厂呢?大可不必。也许在下面情况下你可以考虑使用工厂方法模式:
1) 当客户程序不需要知道要使用对象的创建过程。
2) 客户程序使用的对象存在变动的可能,或者根本就不知道使用哪一个具体的对象。简单工厂模式与工厂方法模式真正的避免了代码的改动了?没有。在简单工厂模式中, 新产品的加入要修改工厂角色中的判断语句;而在工厂方法模式中,要么将判断逻辑留在抽象工厂角色中,要么在客户程序中将具体工厂角色写死(就象上面的例子一样)。而且产品对象创建条件的改变必然会引起工厂角色的修改。

面对这种情况,Java 的反射机制与配置文件的巧妙结合突破了限制——这在 Spring 中完美的体现了出来。

六、抽象工厂模式
先来认识下什么是产品族: 位于不同产品等级结构中,功能相关联的产品组成的家族。
还是让我们用一个例子来形象地说明一下吧。
BmwCar 和 BenzCar 就是两个产品树(产品层次结构);而BenzSportsCar 和 BmwSportsCar 就是一个产品族。他们都可以放到跑车家族中,因此功能有所关联。同理 BmwBussinessCar 和 BenzSportsCar 也是一个产品族。
回到抽象工厂模式的话题上。
可以说,抽象工厂模式和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。
抽象工厂模式的用意为:给客户端提供一个接口,可以创建多个产品族中的产品对象
而且使用抽象工厂模式还要满足以下条件:
1.1) 系统中有多个产品族,而系统一次只可能消费其中一族产品。
2.2) 同属于同一个产品族的产品以其使用。
来看看抽象工厂模式的各个角色(和工厂方法的如出一辙):
1.1) 抽象工厂角色: 这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在 java 中它由抽象类或者接口来实现。
2.2) 具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在 java 中它由具体的类来实现。
3.3) 抽象产品角色:它是具体产品继承的父类或者是实现的接口。在 java 中一般有抽象类或者接口来实现。
4.4) 具体产品角色:具体工厂角色所创建的对象就是此角色的实例。在 java 中由具体的类来实现。
③抽象工厂模式

package com.factory;  

import com.bean.Animal;  

/** 
 * 母亲接口 
 * 
 */  
public interface AnimalMother {  
    /** 
     * 生育动物 
     * @return 
     */  
    public  Animal giveBirth();  
}

package com.factory;  

import com.bean.Milk;  

/** 
 * 能产奶的 动物母亲 
 * 这里继承 AnimalMother 实现 生育小动物  产奶在此接口声明 构成抽象工厂总接口 
 * 
 */  
public interface MilkAnimalMother extends AnimalMother {  
    /** 
     * 产奶 
     * @return 
     */  
    public Milk produceMilk();  
}

package com.factory.impl;  

import com.bean.Animal;  
import com.bean.Cattle;  
import com.bean.CattleMile;  
import com.bean.Milk;  
import com.factory.MilkAnimalMother;  

/** 
 * 奶牛
 * 
 */  
public class CattleMilkMother implements MilkAnimalMother {  

    @Override  
    public Animal giveBirth() {  
        // TODO Auto-generated method stub  
        Animal cattle=new Cattle();  
        System.out.println("奶牛生了一只小牛");  
        return cattle;  
    }  

    @Override  
    public Milk produceMilk() {  
        // TODO Auto-generated method stub  
        Milk milk=new CattleMile();  
        System.out.println("奶牛生产了牛奶");  
        return milk;  
    }  

}

package com.factory.impl;  

import com.bean.Animal;  
import com.bean.Milk;  
import com.bean.Sheep;  
import com.bean.SheepMilk;  
import com.factory.MilkAnimalMother;  

/** 
 * 奶羊 
 * 
 */  
public class SheepMilkMother implements MilkAnimalMother{  

    @Override  
    public Animal giveBirth() {  
        // TODO Auto-generated method stub  
        Animal sheep=new Sheep();  
        System.out.println("奶羊生了一只小羊");  
        return sheep;  
    }  

    @Override  
    public Milk produceMilk() {  
        // TODO Auto-generated method stub  
        Milk milk=new SheepMilk();  
        System.out.println("奶羊生产了羊奶");  
        return milk;  
    }  

}

package com.bean;  

/** 
 * 动物类 
 * 
 */  
public abstract class Animal {  

    private String name;  

    public Animal() {  
        super();  
        // TODO Auto-generated constructor stub  
    }  
    public Animal(String name) {  
        super();  
        this.name = name;  
    }  
    public abstract void eat();  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  

}

package com.bean;

public class Milk {

}

package com.bean;

public class CattleMile extends Milk{

}

package com.bean;

public class SheepMilk extends Milk{

}

package com.bean;

public class Cattle extends Animal{

    @Override
    public void eat() {
        // TODO Auto-generated method stub

    }

}

package com.bean;

public class Sheep extends Animal{

    @Override
    public void eat() {
        // TODO Auto-generated method stub

    }

}

package com.test;

import org.junit.Test;

import com.bean.Animal;
import com.bean.Cat;
import com.bean.Dog;
import com.factory.AnimalMother;
import com.factory.MilkAnimalMother;
import com.factory.impl.CatMother;
import com.factory.impl.CattleMilkMother;
import com.factory.impl.DogMother;
import com.factory.impl.SheepMilkMother;
import com.factory.sta.StaticFactory;

/**
 * 测试类
 * */
public class TestCase {
    /** 
     * 抽象工厂模式测试 
     */  
    @Test  
    public void abstrFactoryTest(){  
        MilkAnimalMother mother=new SheepMilkMother();  
        mother.giveBirth();  
        mother.produceMilk();  
        mother=new CattleMilkMother();  
        mother.giveBirth();  
        mother.produceMilk();  
    }  
}

iBaoxing

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
JAVA之工厂模式(静态工厂模式（简单工厂模式）、工厂方法模式、抽象工厂模式)

一、引子话说十年前,有一个暴发户,他家有三辆汽车——Benz 奔驰、Bmw 宝马、Audi 奥迪, 还雇了司机为他开车。不过,暴发户坐车时总是怪怪的:上 Benz 车后跟司机说“开奔驰车!”, 坐上 Bmw 后他说“开宝马车!”,坐上 Audi 说“开奥迪车!”。你一定说:这人有病!直接说开车不就行了?! 而当把这个暴发户的行为放到我们程序设计中来时,会发现这是一个普遍存在的现象。幸运的是
复制链接

扫一扫

专栏目录