抽象工厂模式(设计模式_17)

抽象工厂模式：的简单理解是，用来生成不同的产品族(就像一个家族一样)，例如：总工厂，分工厂，每个工厂都可以制造，其他很多不同的产品；

以下举例两个案例，来体现抽象工厂模式：

---

案例一：（造汽车）
制造各种名牌汽车，有总工厂，分工厂来制造，各种不同品牌的汽车；

package com.oop.demo4.car1;

/**
 * 抽象出奔驰车制作标准规范接口
 * @author Liudeli
 *
 */
public interface BenzCar {

    /**
     * 制造轮胎
     */
    public void doTyre();

    /**
     * 制造发动机
     */
    public void doEngine();

    /**
     * 制造底盘
     */
    public void doChassis();

}

package com.oop.demo4.car1;

/**
 * 分公司制造中心
 * @author Liudeli
 *
 */
public class FBenzCar implements BenzCar{

    public void doTyre() {
        System.out.println("分公司把奔驰的轮胎已经生产好了...");
    }

    public void doEngine() {
        System.out.println("分公司把奔驰的发动机已经研制成功了...");
    }

    public void doChassis() {
        System.out.println("分公司把奔驰的底盘已经制作好了...");
    }

}

package com.oop.demo4.car1;

/**
 * 总公司制造中心
 * @author Liudeli
 *
 */
public class ZBenzCar implements BenzCar{

    public void doTyre() {
        System.out.println("总公司把奔驰的轮胎已经生产好了...");
    }

    public void doEngine() {
        System.out.println("总公司把奔驰的发动机已经研制成功了...");
    }

    public void doChassis() {
        System.out.println("总公司把奔驰的底盘已经制作好了...");
    }

}

package com.oop.demo4.car2;

/**
 * 抽象出宝马车制作标准接口规范
 * @author Liudeli
 *
 */
public interface BMWCar {

    /**
     * 制造宝马车轮胎
     */
    public void doDoor();

}

package com.oop.demo4.car2;

/**
 * 分公司制造宝马车对象
 * @author Liudeli
 *
 */
public class FBMWCar implements BMWCar {

    public void doDoor() {
        System.out.println("分公司把宝马车的门制造成功了...");
    }

}

package com.oop.demo4.car2;

/**
 * 总公司制造宝马车对象
 * @author Liudeli
 *
 */
public class ZBMWCar implements BMWCar{

    public void doDoor() {
        System.out.println("总公司把宝马车的门制造好了...");
    }

}

package com.oop.demo4.factory;

import com.oop.demo4.car1.BenzCar;
import com.oop.demo4.car2.BMWCar;

/**
 * 抽象出工厂接口
 * @author Liudeli
 *
 */
public interface Factory {

    /**
     * 创建奔驰车
     * @return
     */
    public BenzCar createBeanz();

    /**
     * 创建宝马车
     * @return
     */
    public BMWCar createBMW();

}

package com.oop.demo4.factory;

import com.oop.demo4.car1.BenzCar;
import com.oop.demo4.car1.FBenzCar;
import com.oop.demo4.car2.BMWCar;
import com.oop.demo4.car2.FBMWCar;

/**
 * 分工厂 制造厂
 * @author Liudeli
 *
 */
public class FFactory implements Factory{

    public BenzCar createBeanz() {
        return new FBenzCar();
    }

    public BMWCar createBMW() {
        return new FBMWCar();
    }

}

package com.oop.demo4.factory;

import com.oop.demo4.car1.BenzCar;
import com.oop.demo4.car1.ZBenzCar;
import com.oop.demo4.car2.BMWCar;
import com.oop.demo4.car2.ZBMWCar;

/**
 * 总工厂 制作厂
 * @author Liudeli
 *
 */
public class ZFactory implements Factory{

    public BenzCar createBeanz() {
        return new ZBenzCar();
    }

    public BMWCar createBMW() {
        return new ZBMWCar();
    }

}

package com.oop.demo4.main;

import com.oop.demo4.car1.BenzCar;
import com.oop.demo4.car2.BMWCar;
import com.oop.demo4.factory.FFactory;
import com.oop.demo4.factory.Factory;
import com.oop.demo4.factory.ZFactory;

/**
 * 测试程序
 * @author Liudeli
 *
 */
public class Test {

    public static void main(String[] args) {
        // 总公司 生产制造厂
        Factory factory = new ZFactory();
        // 修改成分公司制作厂去制造
        // factory = new FFactory();

        // 制作奔驰车零件
        BenzCar beanz = factory.createBeanz();
        beanz.doChassis();
        beanz.doEngine();
        beanz.doTyre();

        // 制作宝马车零件
        BMWCar bmw = factory.createBMW();
        bmw.doDoor();
    }

}

运行结果：

修改工厂：

Factory factory = new FFactory();

运行结果：

---

---

案例二：（数据库DB,切换）
软件工程师在维护一个项目，这个项目最初是用Oracle数据库来做的，现在要更换成Sqlserver数据库，有可能以后还会切换到Oracle数据库，所以他想到了一招，就是用抽象工厂模式来切换数据库即可：

package com.oop.demo3;

/**
 * 模拟用户对象数据
 * @author Liudeli
 *
 */
public class User {

    // 模拟ID 和 NAME 其他很多值 省略...

    private int id;
    private String name;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public String toString() {
        return "User [id=" + id + ", name=" + name + "]";
    }

}

package com.oop.demo3;

/**
 * 定义数据模版接口标准
 * @author Liudeli
 *
 */
public interface IUser {

    /**
     * 模拟插入一条用户数据
     * @param user
     */
    public void insert(User user);

    /**
     * 模拟删除一条数据
     * @param id
     */
    public void detele(int id);
}

package com.oop.demo3;

/**
 * 模拟使用SQLServer数据库操作User数据
 * @author Liudeli
 *
 */
public class SQLServerUser implements IUser{

    public void insert(User user) {
        System.out.println("用户数据 id:1, name:liudeli");
    }

    public void detele(int id) {
        System.out.println("用户数据 id:" + id + "已被删除成功...");
    }

}

package com.oop.demo3;

/**
 * 模拟使用Oracle数据库操作User数据
 * @author Liudeli
 *
 */
public class OracleUser implements IUser {

    public void insert(User user) {
        System.out.println("用户数据 id:2, name:lnderly");
    }

    public void detele(int id) {
        System.out.println("用户数据 id:" + id + "已被删除成功...");
    }

}

package com.oop.demo3;

/**
 * 模拟人的对象数据
 * @author Liudeli
 *
 */
public class Person {

    // 模拟name 和 sex 其他很多值 省略...

    private String name;
    private String sex;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }

    public String toString() {
        return "Person [name=" + name + ", sex=" + sex + "]";
    }
}

package com.oop.demo3;

public interface IPerson {

    public void update(Person person);

}

package com.oop.demo3;

public class SQLServerPerson implements IPerson{

    public void update(Person person) {
        System.out.println("Person 更新了一条数据信息...");
    }

}

package com.oop.demo3;

public class OraclePerson implements IPerson{

    public void update(Person person) {
        System.out.println("Person 更新了一条数据...");
    }

}

package com.oop.demo3;

/**
 * 定义规范标准工厂，实例化那个对象
 * @author Liudeli
 *
 */
public interface IFactory {

    /**
     * 创建使用哪种数据库模式来操作
     * @return
     */
    public IUser createUserFactory();

    public IPerson createPersonFactory();

}

package com.oop.demo3;

public class OracleFactory implements IFactory{

    public IUser createUserFactory() {
        return new OracleUser();
    }

    public IPerson createPersonFactory() {
        return new OraclePerson();
    }

}

package com.oop.demo3;

public class SQLServerFactory implements IFactory{

    public IUser createUserFactory() {
        return new SQLServerUser();
    }

    public IPerson createPersonFactory() {
        return new SQLServerPerson();
    }

}

package com.oop.demo3;

/*
 * 
 */

/**
 * 测试程序
 * @author Liudeli
 *
 */
public class Main {

    public static void main(String[] args) {

        // 获取到数据
        User user = new User();
        Person person = new Person();

        // 得到工厂
        IFactory factory = new OracleFactory();
        // factory = new SQLServerFactory(); // 切换SQLServer数据库

        IUser createUserFactory = factory.createUserFactory();
        createUserFactory.insert(user);
        createUserFactory.detele(9);

        IPerson createPersonFactory = factory.createPersonFactory();
        createPersonFactory.update(person);

    }

}

运行结果：

---

谢谢大家的观看，更多精彩技术博客，会不断的更新，请大家访问，
刘德利CSDN博客， http://blog.csdn.net/u011967006