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

最新推荐文章于 2017-01-05 10:19:47 发布
最新推荐文章于 2017-01-05 10:19:47 发布
阅读量339 收藏
点赞数 1
分类专栏： 面向对象思想 设计模式 文章标签： 设计模式 面向对象思想 OOP Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011967006/article/details/53931644
版权

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

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

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

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

刘德利_Android
关注
专栏目录
设计模式_抽象工厂模式.zip
07-30
抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在抽象工厂模式中，接口是负责...
设计模式之抽象工厂模式-c++
最新发布
09-18
抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，提供一个接口用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。这种模式常用于需要跨多个产品系列进行实例化的场景。 抽象工厂模式的...
java常用设计模式-抽象工厂模式
08-26
java常用设计模式-抽象工厂模式 抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它通过定义一个创建对象的接口来创建对象，但将具体实现的决定留给子类来决定。在抽象工厂模式中，接口是负责创建...
Java设计模式之抽象工厂模式实例详解
08-29
Java设计模式之抽象工厂模式实例详解 Java设计模式之抽象工厂模式实例详解是指在软件设计中，通过提供一个创建一系列相关或相互依赖对象的接口，且无需指定它们具体的类别的方式来生成这些对象的模式。抽象工厂模式...
Java设计模式之抽象工厂模式.docx
10-25
抽象工厂模式是设计模式中的一种，属于创建型模式，它为创建一组相关或相互依赖的对象提供了一个统一的接口，使得客户端无需关注这些对象的具体实现细节，仅需与抽象工厂交互即可。这种模式遵循开放封闭原则（OCP）...
面向对象思想设计_计算器小程序(设计模式入门篇_01)
刘德利CSDN博客
12-14 7944
名称：简单计算器程序面向对象思想的由来：面向对象编程思想的由来是从面向过程演变而来，所以我们用一个简单的计算器程序用面向过程的方式去实现以下是面向过程方式实现计算器程序：public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in);
面向对象在生活中世界
刘德利CSDN博客
12-15 2477
面向对象是怎么来的，是由面向过程演变而来，所以我们要对面向过程有一个简单的了解，最常见的面向过程理解就是想用有什么就创建一个什么来用，没有太多的全面思考，而面向对象的出现就是为了修复面向过程的种种不足，面向对象的出现后，相比面向过程有了更多的思考，考虑了如何复用，如何扩展起来好维护，如何降低代码的耦合度，如何提高一个对象该做的事情单一职责，所以说面向对象体现出来的思想，主要包含了，高内聚，低耦合，可
方法模版模式(设计模式_11)【精品博客】
刘德利CSDN博客
12-19 2366
今天给大家介绍的是：模版方法模式，这个模式非常的常见，很多开发者，无意中其实就已经用到了，也非常简单，只是还不知道，这属于一种设计模式而已，而关于这个设计模式，在网上有很多专业性词语来说明，看的人审美疲劳。其实这个设计模式，通俗易懂的来讲，就是把子类重复的东西，定义到父类中模块化起来，父类只需要去管理好算法流程框架，把经常变化的点，让子类去继承完成。我们看下面几道案例来理解就OK了：案例一： 在很久
简单工厂模式，工厂方法模式，抽象工厂模式 三大案例 (设计模式_16)
刘德利CSDN博客
12-29 1033
工厂模式，细分下来为（简单工厂模式，工厂方法模式，抽象工厂模式 ），每一种模式的使用都是在应用场景的不同来决定；案例一：（简单工厂模式） 简单工厂模式，根据工厂接收的类型来决定，返回的对象的具体实例，简单工厂模式在扩展性方面表现不足，（增加对象需要修改工厂代码，才能完成）简单工厂模式，实际上就是一个工厂非常简单的运用，工厂根据接收不同的类型，返回不同 的实例对象，（想要扩展必须要修改工厂代码才行
开放封闭原则(设计模式_04)
刘德利CSDN博客
12-14 674
由来：开放封闭式原则是遵循面向对象思想开发扩展性的体现，简单明了的理解就是，对修改关闭，对扩展开放，以下写一个例子来体现：// 加法类 public class AddCount { public double countMethod(double count1, double count2) { return count1 + count2; }}// 客户端调用计算
单一职责原则(设计模式_03)
刘德利CSDN博客
12-14 576
由来：单一职责原则的由来，是面向对象核心思想，高内聚 低耦合，中的高内聚体现，一个类只负责一个类改做的事情，职责分清楚，写一个案例来体现：以下案例是违反了单一职责原则的模拟代码：public class Main { // 模拟：这是没有体现出单一职责原则，因为写在了一起，造成了高耦合度 // 算法： 是一个单一职责原则 // 界面： 是一个单一职责原则 public s
合成聚合复用原则(设计模式_23)
刘德利CSDN博客
01-05 574
在面向对象思想编程中的继承体系中，关于继承，子类继承父类，父类一旦改变会影响到子类，这其实是不灵活的表现，而且继承的越频繁越不好维护，子类与父类有依赖关系存在，而（合成聚合复用原则）的出现，很好的 去改善了继承中这种不灵活性合成聚合复用原则：的定义就是为了改善继承体现中的，依赖性，不灵活性；关于合成聚合复用原则： 聚合指的是弱包含关系：例如（人属于人群的一部分，而人不包
迪米特法则(设计模式_13)
刘德利CSDN博客
12-20 497
迪米特法则简单易懂的话语来描述就是：知道的越少越好，什么知道越少越好呢，两个类之间交互的越少越好，从而可以减低耦合度，当两个类之间的交互很少，耦合度就会降低，耦合度一旦降低，修改其中一个类就不会对另外一个类造成影响：我们直接看案例来说明分析：以下是违反了迪米特法则案例： 煮菜类与买菜类，洗菜类，交互的比较多，耦合度增高：/** * 定义一个买菜类 * @author Liudeli */ c
依赖倒置原则(设计模式_05)
刘德利CSDN博客
12-14 481
依赖倒转原则就是高层模块不能依赖底层模块，他们两个应该依赖抽象，而抽象就是接口或者抽象类，是管理他们两个的父类，由于这种关系，所以抽象不能依赖细节，而细节要依赖抽象。我们直接用案例来分析就明白了：// 定义一个语言接口 public interface ILanguage { // 定义一个输出语言的方法 public String getLanguage();}// Java语言类
外观模式(设计模式_12)
刘德利CSDN博客
12-19 469
由来：外观模式的由来，举一个例子：研发人员做了一个系统给客户用户使用，客户用户不需要知道那么多的具体细节，客户用户访问这些，具体的细节，耦合度也比较高，所以就定义了 一个外观对象，外观对象去处理这些具体的细节，客户用户只需要去访问外观对象，的行为即可外观模式在设计中非常的常见，这种模式可以减低耦合度，区域划分的比较灵活，不需要增加客户用户的复杂度；我们来看几个案例来说明分析：常规的写法：/** *
策略模式(设计模式_02)
刘德利CSDN博客
12-14 442
策略模式，其实就是封装变化，为了更加好理解，直接写一个简单案例来说明：首先抽象一个打印的类，这个类里面有打印方法，就是简单的打印一句话// 定义一个抽象打印的类 public abstract class Print { // 定义打印一句话的方法 public abstract void printMethod(); }// 写一个子类A，继承父类 Print public cla
装饰模式(设计模式_06)
刘德利CSDN博客
12-14 406
装饰模式，可以动态给对象增加一些额外的职责，比子类更加灵活，通常使用继承来实现扩展性，继承的子类越来越多，会增加复杂性，装饰模式的特点是：装饰者与被装饰者拥有共同的超类，继承的目的是继承类型。以下用一个案例来实现装饰模式：// 定义装饰接口 public interface IDecoration { // 定义显示show装饰的方法 public void show();}// 定义
代理模式(设计模式_07)
刘德利CSDN博客
12-14 374
代理模式，说得很通俗的话就是，客户要去办证，找代理办证，代理会自己去找办证公司去办证，最后客户端只知道代理办证成功，不会让客户知道办证是那一家公司，办证的流程等等…, 以下就用一个简单的案例来说明：// 定义一个办证的抽象类 public class Proxy extends Permit{ private Permit permit = null; public Proxy() {
工厂方法模式(设计模式_08)
刘德利CSDN博客
12-15 361
工厂方法模式遵循了，开放封闭式原则，我们直接用案例来体现：// 定义一个电脑接口 public interface IComputer { // 获取电脑组件的方法 public void myStyle();}// 电脑适配器实现电脑接口 public class Adapter implements IComputer{ public void myStyle() {
C#设计模式解析：抽象工厂模式实战
“详解C#的设计模式编程之抽象工厂模式的应用，通过生活中的例子和UML图，介绍如何在C#中应用抽象工厂模式，强调在处理多个抽象类及其具体子类时，抽象工厂模式的优势。” 在软件设计模式中，抽象工厂模式是一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值