精华内容
下载资源
问答
  • 抽象工厂模式结构视图
    2020-03-27 21:27:56

    介绍:

    抽象工厂模式是一种创建型模式。它为创建一组相关或者是相互依赖的对象提供一个接口,而不是指定它们的具体类。

    类图:

    在这里插入图片描述

    AbstractProduct(抽象产品类):需要创建的产品的抽象类。
    ConcreteProduct(具体产品类):为实现抽象产品的某个具体产品类。
    AbstractFactory(抽象工厂类):工厂模式方法核心,创建一系列产品对象。
    ConcreteFactory(具体工厂类):实现抽象工厂中定义的创建产品的方。

    用法:

    • 一个对象组有相同的约束时可以使用抽象工厂模式

    个人理解:
    在生产多个产品组合的对象时使用抽象工厂模式,也就是需要在一个工厂中生成一系列特定的产品对象时使用这模式,本质还是创建对象。

    例子:

    在这里引用《大话设计模式》中此篇幅的例子:数据库MySQL和Oracle虽然都是用数SQL语句写,但操作语法上也会存在区别。假如一个公司更换数据库,对于业务层的代码来说需要把所有地方的语法都换一下,会改到崩溃。

    需求:用抽象工厂模式实现数据库表操作

    1、实现数据库表操作

    1.1、实现User表操作(第一个产品类)

    public interface IUser {
        public void setUser(int id,String name);
        public String getUserName(int id);
    }
    
    public class MySQLUser implements IUser{
        @Override
        public void setUser(int id, String name) {
            //将id、name插入数据库表
            System.out.println("在MySql中增加一条记录:");
        }
    
        @Override
        public String getUserName(int id) {
            //获取id位置的name值
            System.out.println("在MySql中获得一条记录:");
            return null;
        }
    }
    
    public class OracleUser implements IUser{
        @Override
        public void setUser(int id, String name) {
            //将id、name插入数据库表
            System.out.println("在Oracle中增加一条记录:");
        }
    
        @Override
        public String getUserName(int id) {
            //获取id位置的name值
            System.out.println("在Oracle中获得一条记录:");
            return null;
        }
    }
    
    

    这部分内容是属于操作User表的过程,IUser接口直接对接业务层,也就是我们需要调用的方法。而MySQLUser、和OracleUser属于具体产品的角色,实现各自的数据库操作。如果这部分阅读有困难请先参考简单工厂模式工厂方法模式理解一下产品类。

    1.2、实现Department表操作(第二个产品类)

    public interface IDepartment {
        public void setDepartment(int id,String name);
        public String getDepartmentName(int id);
    }
    
    public class MySQLDepartment implements IDepartment {
        @Override
        public void setDepartment(int id, String name) {
            //将id、name插入Department表
            System.out.println("在MySql中增加一条记录:");
        }
    
        @Override
        public String getDepartmentName(int id) {
            //获取id位置的name值
            System.out.println("在MySql中获得一条记录:");
            return null;
        }
    }
    
    public class OracleDepartment implements IDepartment {
        @Override
        public void setDepartment(int id, String name) {
            //将id、name插入Department表
            System.out.println("在Oracle中增加一条记录:");
        }
    
        @Override
        public String getDepartmentName(int id) {
            //获取id位置的name值
            System.out.println("在Oracle中获得一条记录:");
            return null;
        }
    }
    

    同理,IDepartment也是对接业务层代码的。然后数据库中的N个表的交互都是按这样的结构去写了,每个表对应一个操作类。

    1.3、实现数据库工厂类

    public interface IDBFactory {
        public IUser createUser();
        public IDepartment createDepartment();
    }
    
    public class MySQLFactory implements IDBFactory {
        @Override
        public IUser createUser() {
            return new MySQLUser();
        }
    
        @Override
        public IDepartment createDepartment() {
            return new MySQLDepartment();
        }
    }
    
    public class OracleFactory implements IDBFactory {
        @Override
        public IUser createUser() {
            return new OracleUser();
        }
    
        @Override
        public IDepartment createDepartment() {
            return new OracleDepartment();
        }
    }
    

    我们可以看出,在抽象工厂IDBFactory分别创建出两个产品了。与工厂方法模式相比较,抽象工厂模式仅仅是用于创建多个产品,而工厂方法模式是一个工厂创建一个产品。

    1.4、实现

    public class Test {
        public static void main(String[] args) {
            IDBFactory factory = new MySQLFactory();
    
            IUser user = factory.createUser();
            user.setUser(1,"晓明");
            user.getUserName(1);
    
            IDepartment department = factory.createDepartment();
            department.setDepartment(1,"技术部");
            department.getDepartmentName(1);
    
        }
    }
    
    

    在这里此模式的用法已经介绍完啦,需要换数据库就直接改动IDBFactory factory = new OracleFactory();这行代码就行了。

    2、简单工厂模式 VS 工厂方法模式 VS 抽象工厂模式

    三种工厂方法,第一次学习的时候可能会混乱,下面来总结一下:

    类型简单工厂工厂方法抽象工厂
    定义一个用于创建对象的接口,让子类决定实例化那个类一个用于创建对象的接口,让子类决定实例化那个类它为创建一组相关或者是相互依赖的对象提供一个接口
    用法生成一个复杂对象生成一个复杂对象生成一组复杂对象
    使用IProduct p = EasyFactory.create("a");IProduct p = new Facotry().getProduct();IFactory f = new Factory();
    ProductA a = f.getProductA();
    PrdocutB b = f.getProductB();

    2.1、相同点
    • 用法一样,本质是创建复杂对象
    • 产品角色结构一样,每个具体产品角色都有相似的行为

    2.2、不同点
    • 选择逻辑简单工厂模式感知不了工厂的存在,选择判断的逻辑在工厂类内部实现。工厂方法模式抽象工厂模式的选择逻辑在客户端使用类,需要知道工厂的存在

    • 创建对象简单工厂模式工厂方法模式用于创建一个复杂对象,抽象工厂模式用于创建一系列对象。

    • 扩展产品简单工厂模式需要在工厂类内部增加新分支,改变了工厂类的内部结构;工厂方法模式需要增加相应的工厂类,系统类的个数将成对增加;抽象工厂模式需要修改抽象工厂和所有的具体工厂

    总结

    抽象工厂模式其实就是创建一系列对象时用的,更具有“品牌效应”。我们简单使用的话把工厂三兄弟区别起来就可以了。

    感谢您的阅读~

    推荐阅读

    基础篇:
    设计模式前篇之——UML类图必会知识点
    设计模式前篇之——一起过一下面向对象的概念
    创建型模式:
    简易理解设计模式之:简单工厂模式——来试试接入支付功能
    简易理解设计模式之:工厂方法模式——数据存储例子
    简易理解设计模式之:抽象工厂模式——更换数据库例子
    简易理解设计模式之:建造者模式——学习使用“链式调用”
    简易理解设计模式之:原型模式——深、浅拷贝的概念
    简易理解设计模式之:单例模式——单例模式的几种常用写法
    结构型模式:
    简易理解设计模式之:适配器模式——Android列表视图控件设计方式
    简易理解设计模式之:桥接模式——穿衣服经典案例2
    简易理解设计模式之:组合模式——实现View中的树状结构
    简易理解设计模式之:装饰模式——穿衣服经典案例
    简易理解设计模式之:外观模式——第三方SDK的帮助类
    简易理解设计模式之:享元模式——五子棋游戏例子
    简易理解设计模式之:代理模式——iOS视图控件设计方式
    行为型模式:
    简易理解设计模式之:策略模式——优化一下支付功能
    简易理解设计模式之:模板方法模式——Android中的BaseActivity基类
    简易理解设计模式之:观察者模式——监听与回调
    简易理解设计模式之:状态模式——优化登录操作
    简易理解设计模式之:备忘录模式——Word文档的工作原理
    简易理解设计模式之:迭代器模式——遍历对象的好帮手
    简易理解设计模式之:命令模式——实现命令的参数化配置
    简易理解设计模式之:责任链模式——OA中请假流程示例
    简易理解设计模式之:中介者模式——多人聊天室例子
    简易理解设计模式之:解释器模式——语言和文法
    简易理解设计模式之:访问者模式——员工考核例子

    更多相关内容
  • 文章目录一、工厂方法1、工厂法法模式结构图:2、工厂方法模式的优缺点二、抽象工厂模式1、抽象工厂模式结构图2、抽象工厂模式的优缺点 一、工厂方法 工厂方法定义:定义一个用于创建对象的接口,让子类决定实例化哪...

    一、工厂方法

    工厂方法定义:定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使一个类的实例化延迟到其子类。

    1、工厂法法模式结构图:

    在这里插入图片描述
    工厂方法抽象出一个工厂接口,这个接口只有一个方法,就是创建抽象产品的工厂方法,所有要生产具体类的工厂就去实现这个接口。当需要创建新对象的工厂时,就不需要更改原有的工厂类,只需要增加相应的工厂类。

    产品抽象类 Product

    public abstract class Product {
        protected String name;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    

    具体产品类 ConcreteProductA

    public class ConcreteProductA extends Product{
    
        public ConcreteProductA(){
            super();
            this.name = "具体产品 A";
        }
    }
    

    具体产品类 ConcreteProductB

    public class ConcreteProductB extends Product{
    
        public ConcreteProductB(){
            super();
            this.name = "具体产品 B";
        }
    }
    

    抽象工厂接口 Factory

    public interface Factory {
        public Product createProduct();
    }
    

    创建 ConcreteProductA 的工厂类 ConcreteProductAFactory

    public class ConcreteProductAFactory implements Factory{
        @Override
        public Product createProduct() {
            return new ConcreteProductA();
        }
    }
    

    创建 ConcreteProductB 的工厂类 ConcreteProductBFactory

    public class ConcreteProductBFactory implements Factory{
        @Override
        public Product createProduct() {
            return new ConcreteProductB();
        }
    }
    

    效果测试类

    public class FactoryMethodTest {
        public static void main(String[] args) {
            Factory factoryA = new ConcreteProductAFactory();
            Factory factoryB = new ConcreteProductBFactory();
            Product productA = factoryA.createProduct();
            Product productB = factoryB.createProduct();
    
            System.out.println(productA.getName());
            System.out.println(productB.getName());
        }
    }
    

    2、工厂方法模式的优缺点

    工厂方法模式具有良好的封装性,代码结构清晰。如果一个调用者需要一个具体的产品对象,只要知道这个产品的类名,不用知道创建对象的艰辛过程,降低模块间的耦合,并且拓展性好。但缺点也是相对的,每增加一个产品,就需要加一个产品的工厂类,增加了额外的开发量。

    二、抽象工厂模式

    抽象工厂模式定义:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。

    1、抽象工厂模式结构图

    在这里插入图片描述
    AbstractProductA 和 AbstractProductB 是两个抽象产品,而ProductA1和ProductA2、ProductB1、ProductB2就是对两个抽象产品的具体实现。

    AbstractFactory是一个抽象工厂接口,它里面包含所有产品创建的抽象方法。而ConcreteFactory1 和ConcreteFactory2就是具体的工厂了。

    抽象产品类 AbstractProductA

    public abstract class AbstractProductA {
        protected String type = "A型产品";
    
        protected String name;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        /** 每个产品具体实现该方法 */
        public abstract void doSomething();
    }
    

    抽象产品类 AbstractProductB

    public abstract class AbstractProductB {
        protected String type = "B型产品";
    
        protected String name;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        /** 每个产品具体实现该方法 */
        public abstract void doSomething();
    }
    

    A型具体产品 ProductA1

    public class ProductA1 extends AbstractProductA{
    
        public ProductA1(){
            super();
            this.name = "产品A1";
        }
        @Override
        public void doSomething() {
            System.out.println(this.name + " doSomething");
        }
    }
    

    A型具体产品 ProductA2

    public class ProductA2 extends AbstractProductA{
    
        public ProductA2(){
            super();
            this.name = "产品A2";
        }
        @Override
        public void doSomething() {
            System.out.println(this.name + " doSomething");
        }
    }
    
    

    B型具体产品 ProductB1

    public class ProductB1 extends AbstractProductB{
    
        public ProductB1(){
            super();
            this.name = "产品B1";
        }
        @Override
        public void doSomething() {
            System.out.println(this.name + " doSomething");
        }
    }
    

    B型具体产品 ProductB2

    public class ProductB2 extends AbstractProductB{
    
        public ProductB2(){
            super();
            this.name = "产品B2";
        }
        @Override
        public void doSomething() {
            System.out.println(this.name + " doSomething");
        }
    }
    
    

    抽象工厂接口 AbstractFactory

    public interface AbstractFactory {
    
        public AbstractProductA createProductA();
    
        public AbstractProductB createProductB();
    }
    
    

    创建1系列产品的工厂类 ConcreteFactory1

    public class ConcreteFactory1 implements AbstractFactory{
        @Override
        public AbstractProductA createProductA() {
            return new ProductA1();
        }
    
        @Override
        public AbstractProductB createProductB() {
            return new ProductB1();
        }
    }
    

    创建2系列产品的工厂类 ConcreteFactory2

    public class ConcreteFactory2 implements AbstractFactory{
        @Override
        public AbstractProductA createProductA() {
            return new ProductA2();
        }
    
        @Override
        public AbstractProductB createProductB() {
            return new ProductB2();
        }
    }
    
    

    效果测试类

    public class AbstractFactoryTest {
        public static void main(String[] args) {
            AbstractFactory factory = new ConcreteFactory1();
    
            AbstractProductA productA = factory.createProductA();
            AbstractProductB productB = factory.createProductB();
            productA.doSomething();
            productB.doSomething();
    
            System.out.println("=========切换产品系列工厂=========");
    
            factory = new ConcreteFactory2();
            productA = factory.createProductA();
            productB = factory.createProductB();
            productA.doSomething();
            productB.doSomething();
        }
    
    }
    

    输出:
    产品A1 doSomething
    产品B1 doSomething
    =切换产品系列工厂=
    产品A2 doSomething
    产品B2 doSomething

    由此可见,切换工厂类,即可对获取的产品系列进行切换

    2、抽象工厂模式的优缺点

    抽象工厂最大的好处是便于切换产品系列,其次是它让具体的创建实例过程与客户端分离,客户端是通过抽象接口获取实例,依赖的产品也是抽象的,而不是具体的产品类。

    抽象工厂的缺点是产品族的拓展非常困难,如果增加了一个产品,抽象工厂类中需要增加创建该产品的抽象方法,具体工厂类中也得去实现,涉及到的改动多。

    展开全文
  • 目录前言Abstract Factory设计模式1.模式的应对场景2.案例1:数据库的connection、command依赖3....抽象工厂模式解决的是“一系列相互依赖的对象”的创建工作。 设计模式之工厂模式(Factor Method) 2.案

    前言

    在学习侯捷老师的有关设计模式的课程(李建忠老师主讲)中,老师对23种设计模式的有自己的划分,如下。所以老师讲解是按照这种顺序讲解。
    在这里插入图片描述
    对象创建:
    在这里插入图片描述

    Abstract Factory设计模式

    1.模式的应对场景

    和工厂模式不同,它解决的是单一的对象创建工作。抽象工厂模式解决的是“一系列相互依赖的对象”的创建工作。

    设计模式之工厂模式(Factor Method)

    2.案例1:数据库的connection、command依赖

    先给代码再说明:

    #include <iostream>
    #include <string>
    using namespace std;
    
    
    //database connection
    class IDBConnection
    {
    public:
    	virtual void ConnectionString() = 0;
    };
    
    class SqlConnection : public IDBConnection
    {
    public:
    	void ConnectionString(){ cout << "Sql connection" << endl; }
    };
    class MysqlConnection : public IDBConnection
    {
    public:
    	void ConnectionString(){ cout << "Mysql connection" << endl; }
    };
    
    
    //database command
    class IDBCommand
    {
    public:
    	virtual void CommandText() = 0;
    	virtual void SetConnection(IDBConnection* connect) = 0;
    };
    
    class SqlCommand : public IDBCommand
    {
    public:
    	void CommandText(){ cout << "Sql command text" << endl; }
    	void SetConnection(IDBConnection* connect){ cout << "set connection with "; connect->ConnectionString(); }
    };
    class MysqlCommand : public IDBCommand
    {
    public:
    	void CommandText(){ cout << "Mysql command text" << endl; }
    	void SetConnection(IDBConnection* connect){ cout << "set connection with "; connect->ConnectionString(); }
    };
    
    
    /***********工厂介入 start*****************************/
    
    //抽象工厂
    class IDBFactor
    {
    public:
    	virtual IDBConnection* creatDBConnection() = 0;
    	virtual IDBCommand* creatDBCommand() = 0;
    };
    //sql 工厂
    class SqlFactor : public IDBFactor
    {
    public:
    	virtual IDBConnection* creatDBConnection()
    	{
    		return new SqlConnection;
    	}
    	virtual IDBCommand* creatDBCommand()
    	{
    		return new SqlCommand;
    	}
    };
    //Mysql 工厂
    class MysqlFactor : public IDBFactor
    {
    public:
    	virtual IDBConnection* creatDBConnection()
    	{
    		return new MysqlConnection;
    	}
    	virtual IDBCommand* creatDBCommand()
    	{
    		return new MysqlCommand;
    	}
    };
    
    /***********工厂介入 end*****************************/
    
    
    class EmployeeDAO
    {
    	IDBFactor* dbfactor;
    public:
    	EmployeeDAO(){}
    	EmployeeDAO(IDBFactor* _dbfactor) : dbfactor(_dbfactor){}
    
    	void GetEmployees(){
    
    	//IDBConnection* connection = new SqlConnection();
    	IDBConnection* connection = dbfactor->creatDBConnection();
    	connection->ConnectionString();
    
    	//IDBCommand* command = new SqlCommand();
    	IDBCommand* command = dbfactor->creatDBCommand();
    	command->CommandText();
    	command->SetConnection(connection);
    	}
    };
    
    int main()
    {
    	EmployeeDAO e(new MysqlFactor);
    	e.GetEmployees();
    
    	EmployeeDAO e1(new SqlFactor);
    	e1.GetEmployees();
    
    	system("pause");
    	return 0;
    }
    
    

    EmployeeDAO类中,由于Connection和Command是相互依赖,所以我们把这两个对象的创建放在一个抽象工厂IDBFactor,然后分别有SqlFactorMysqlFactor 两个具体工厂,各自创建自己的Connection和Command(SqlConnection、SqlCommand和MysqlConnection、MysqlCommand)相关类。

    使用工厂模式的影响:
    如果用工厂模式分别生成这两个对象,那么可能会存在这样一种情况:即我们生成了一个SqlConnection,但是command却是MysqlCommand,代码如下:

    #if 1
    #include <iostream>
    #include <string>
    using namespace std;
    
    
    //database connection
    class IDBConnection
    {
    public:
    	virtual void ConnectionString() = 0;
    };
    class SqlConnection : public IDBConnection
    {
    public:
    	void ConnectionString(){ cout << "Sql connection" << endl; }
    };
    class MysqlConnection : public IDBConnection
    {
    public:
    	void ConnectionString(){ cout << "Mysql connection" << endl; }
    };
    
    
    /***connection工厂***/
    class IDBConnectionFactor
    {
    public:
    	virtual IDBConnection* creatorIDBConnection() = 0;
    };
    class SqlConnectionFactor : public IDBConnectionFactor
    {
    public:
    	virtual IDBConnection* creatorIDBConnection(){ return new SqlConnection; }
    };
    class MySqlConnectionFactor : public IDBConnectionFactor
    {
    public:
    	virtual IDBConnection* creatorIDBConnection(){ return new MysqlConnection; }
    };
    /***connection工厂***/
    
    
    //database command
    class IDBCommand
    {
    public:
    	virtual void CommandText() = 0;
    	virtual void SetConnection(IDBConnection* connect) = 0;
    };
    class SqlCommand : public IDBCommand
    {
    public:
    	void CommandText(){ cout << "Sql command text" << endl; }
    	void SetConnection(IDBConnection* connect){ cout << "Sql set connection with "; connect->ConnectionString(); }
    };
    class MysqlCommand : public IDBCommand
    {
    public:
    	void CommandText(){ cout << "Mysql command text" << endl; }
    	void SetConnection(IDBConnection* connect){ cout << "Mysql set connection with "; connect->ConnectionString(); }
    };
    
    /***Command工厂***/
    class IDBCommandFactor
    {
    public:
    	virtual IDBCommand* creatorIDBCommand() = 0;
    };
    class SqlCommandFactor : public IDBCommandFactor
    {
    public:
    	virtual IDBCommand* creatorIDBCommand(){ return new SqlCommand; }
    };
    class MySqlCommandFactor : public IDBCommandFactor
    {
    public:
    	virtual IDBCommand* creatorIDBCommand(){ return new MysqlCommand; }
    };
    /***Command工厂***/
    
    
    class EmployeeDAO
    {
    	IDBConnectionFactor* connectionfactor;
    	IDBCommandFactor* commandfactor;
    public:
    	EmployeeDAO(){}
    	EmployeeDAO(IDBConnectionFactor* _connectionfactor, IDBCommandFactor* _commandfactor)
    		: connectionfactor(_connectionfactor), commandfactor(_commandfactor){}
    
    	void GetEmployees(){
    
    		//IDBConnection* connection = new SqlConnection();
    		IDBConnection* connection = connectionfactor->creatorIDBConnection();
    		connection->ConnectionString();
    
    		//IDBCommand* command = new SqlCommand();
    		IDBCommand* command = commandfactor->creatorIDBCommand();
    		command->CommandText();
    		command->SetConnection(connection);
    	}
    };
    
    int main()
    {
    	EmployeeDAO e(new SqlConnectionFactor, new MySqlCommandFactor);
    	e.GetEmployees();
    
    	system("pause");
    	return 0;
    }
    #endif
    

    这里就会有两个工厂数据成员,在客户使用EmployeeDAO类时,就可能出现下图中创建对象不搭配的情况。
    在这里插入图片描述

    3.产品族和产品等级

    李建忠老师在讲解抽象工厂模式时,并没有提到关于产品族和产品等级这个概念,但是我发现网上很多关于抽象工厂的文章中都提到了这个概念,所以在这里稍微说一下我的理解。

    拿案例1举例,我们可以做这样的一个划分:
    在这里插入图片描述
    如果我们增加一个产品族,程序是可以很好扩展,不会违背开闭原则;但是如果我们增加一个产品等级,你会发现就需要修改而不是扩展代码,会违背开闭原则。

    这里你可能会比较难区分什么是产品族?什么是产品等级?我的理解就是:
    因为抽象工厂模式解决的就是“一系列相互依赖的对象”的创建工作,所以这系列对象就是一个产品族,不是一族怎么会相互依赖呢!

    4.案例2

    下面在举一个例子,如下所示是产品族和产品等级。在这里插入图片描述
    图片来源:链接

    假设我们的客户程序是先打开手机和路由器,再通过手机控制路由器,伪代码如下;

    class Client
    {
    public:
    	void getWorking(){
    		generate 手机;
    		手机start;
    		generate 路由器;
    		路由器start;
    		手机控制路由器;
    	}
    }
    

    代码还是很简单写的,下面一步步写:

    下面开始代码:
    1.先来写华为手机和路由器的类+Client类并做简单测试(不用抽象工厂模式)

    #include <iostream>
    #include <string>
    using namespace std;
    
    //手机基类
    class IPhone
    {
    public:
    	virtual void phoneStart() = 0;
    	virtual string phoneName() = 0;
    };
    class HuaweiPhone : public IPhone
    {
    public:
    	virtual void phoneStart()
    	{
    		cout << "华为手机开机" << endl;
    	}
    	virtual string phoneName()
    	{
    		return string("华为");
    	}
    };
    
    //路由器基类
    class IRouter
    {
    public:
    	virtual void routerStart() = 0;
    	virtual void control(IPhone* _phone) = 0;
    
    };
    class HuaweiRouter : public IRouter
    {
    public:
    	virtual void routerStart()
    	{
    		cout << "华为路由器开机" << endl;
    	}
    	virtual void control(IPhone* _phone)
    	{
    		cout << "华为路由器被" << _phone->phoneName()<<"手机控制"<< endl;
    	}
    };
    
    
    //客户
    class Client
    {
    public:
    	void getWorking()
    	{
    		IPhone* phone = new HuaweiPhone;
    		phone->phoneStart();
    		IRouter* router = new HuaweiRouter;
    		router->routerStart();
    
    		router->control(phone);
    	}
    };
    
    
    int main()
    {
    	Client c;
    	c.getWorking();
    
    
    	system("pause");
    	return 0;
    }
    

    在这里插入图片描述

    2.扩展出小米手机和路由器的类+加入抽象工厂模式

    #include <iostream>
    #include <string>
    using namespace std;
    
    //手机基类
    class IPhone
    {
    public:
    	virtual void phoneStart() = 0;
    	virtual string phoneName() = 0;
    };
    class HuaweiPhone : public IPhone
    {
    public:
    	virtual void phoneStart()
    	{
    		cout << "华为手机开机" << endl;
    	}
    	virtual string phoneName()
    	{
    		return string("华为");
    	}
    };
    class XiaomiPhone : public IPhone
    {
    public:
    	virtual void phoneStart()
    	{
    		cout << "小米手机开机" << endl;
    	}
    	virtual string phoneName()
    	{
    		return string("小米");
    	}
    };
    
    
    
    //路由器基类
    class IRouter
    {
    public:
    	virtual void routerStart() = 0;
    	virtual void control(IPhone* _phone) = 0;
    
    };
    class HuaweiRouter : public IRouter
    {
    public:
    	virtual void routerStart()
    	{
    		cout << "华为路由器开机" << endl;
    	}
    	virtual void control(IPhone* _phone)
    	{
    		cout << "华为路由器被" << _phone->phoneName()<<"手机控制"<< endl;
    	}
    };
    class XiaomiRouter : public IRouter
    {
    public:
    	virtual void routerStart()
    	{
    		cout << "小米路由器开机" << endl;
    	}
    	virtual void control(IPhone* _phone)
    	{
    		cout << "小米路由器被" << _phone->phoneName() << "手机控制" << endl;
    	}
    };
    
    
    /******抽象工厂介入 start******/
    class IAbstractFactor
    {
    public:
    	virtual IPhone* creatPhone() = 0;
    	virtual IRouter* creatRouter() = 0;
    };
    
    //华为工厂
    class HuaweiFactor : public IAbstractFactor
    {
    public:
    	virtual IPhone* creatPhone() { return new HuaweiPhone; }
    	virtual IRouter* creatRouter(){ return new HuaweiRouter; }
    };
    
    //小米工厂
    class XiaomiFactor : public IAbstractFactor
    {
    public:
    	virtual IPhone* creatPhone() { return new XiaomiPhone; }
    	virtual IRouter* creatRouter(){ return new XiaomiRouter; }
    };
    
    /******抽象工厂介入 end******/
    
    
    
    //客户
    class Client
    {
    	IAbstractFactor* factor;
    public:
    	Client(IAbstractFactor* _factor) : factor(_factor){}
    	void getWorking()
    	{
    		IPhone* phone = factor->creatPhone();
    		phone->phoneStart();
    		IRouter* router = factor->creatRouter();
    		router->routerStart();
    
    		router->control(phone);
    	}
    };
    
    
    int main()
    {
    	Client c(new HuaweiFactor);
    	c.getWorking();
    
    	Client c1(new XiaomiFactor);
    	c1.getWorking();
    
    	system("pause");
    	return 0;
    }
    

    5.模式定义

    在这里插入图片描述

    6.模式结构

    在这里插入图片描述
    一个工厂(ConcreteFactor1)生产一系列相互依赖的对象(ProductA1 ProductB1)。

    7.要点总结

    1. 如果没有应对“多系列对象构建”的需求变化,则没有必要使用Abstract Factory模式,这时候使用简单的工厂完全可以。
    2. “系列对象”指的是在某一特定系列下的对象之间有相互依赖、或作用的关系。不同系列的对象(就像案例一中的MysqlCommand、SqlConnection)之间不能相互依赖。
    3. Abstract Factory模式主要在于应对“新系列”的需求变动。其缺点在于难以应对“新对象”的需求变动。(意思就是无法应对产品等级的增加
    展开全文
  • 设计模式 抽象工厂模式 三层架构 设计模式 抽象工厂模式 三层架构 设计模式 抽象工厂模式 三层架构 设计模式 抽象工厂模式 三层架构 设计模式 抽象工厂模式 三层架构 要您一个资源分,也算是对我的尊重,谢谢下载。
  • 抽象工厂设计模式的简单代码,资源大小最小只能为1了。
  • 主要介绍了Android编程设计模式之抽象工厂模式,结合实例形式详细分析了Android抽象工厂模式的概念、原理、使用方法及相关注意事项,需要的朋友可以参考下
  • 某手机操作系统可以根据用户不同的喜好在2种主题之间进行切换,随着主题的变化,系统中的字体、app图标、壁纸、锁屏壁纸等元素会随之发生变化。
  • 抽象工厂模式练习 某软件公司要推出一款新的手机游戏软件,该软件支持IOS、Android和Windows Phone等多个智能手机操作系统平台,针对不同的手机操作系统,该游戏...(1)绘制抽象工厂模式结构视图 (2)给出实例类图

    抽象工厂模式练习

    某软件公司要推出一款新的手机游戏软件,该软件支持IOS、Android和Windows Phone等多个智能手机操作系统平台,针对不同的手机操作系统,该游戏软件提供了不同的游戏操作控制类(OperationController)和游戏界面控制类(InterfaceController),并提供的相应的工厂类来封装这些类的初始化过程。该软件要求具有较好的扩展性,以支持新的操作系统平台,为了满足上述要求,试采用抽象工厂模式对其进行设计。

    (1)绘制抽象工厂模式结构视图

    (2)给出实例类图并实现代码

    package AbstractFactoryPattern;
    /** * 抽象产品-游戏界面控制类 */
    public interface Gj19IInterfaceController {
        public void Interface();
    } 
    
    package AbstractFactoryPattern;
    /** * 具体产品-Android游戏界面控制类 */
    public class Gj19AndroidInterfaceController implements Gj19IInterfaceController {
        @Override
        public void Interface() {
            System.out.println("Android游戏界面控制");
        }
    }
    
    package AbstractFactoryPattern;
    /** * 具体产品-IOS游戏界面控制类 */
    public class Gj19IOSInterfaceController implements Gj19IInterfaceController {
        @Override
        public void Interface() {
            System.out.println("IOS游戏界面控制");
        }
    }
    
    package AbstractFactoryPattern;
    /** * 具体产品-WindowsPhone游戏界面控制类 */
    public class Gj19WindowsPhoneInterfaceController implements Gj19IInterfaceController {
        @Override
        public void Interface() {
            System.out.println("WindowsPhone游戏界面控制");
        }
    }
    
    package AbstractFactoryPattern;
    /** * 抽象产品-游戏操作控制类 */
    public interface Gj19IOperationController {
        public void Operator();
    }
    
    package AbstractFactoryPattern;
    /** * 具体产品-Andriod游戏操作控制类 */
    public class Gj19AndroidOperationController implements Gj19IOperationController {
        @Override
        public void Operator() {
            System.out.println("Andriod游戏操作控制");
        }
    }
    
    package AbstractFactoryPattern;
    /** * 具体产品-IOS游戏操作控制类 */
    public class Gj19IOSOperationController implements Gj19IOperationController {
        @Override
        public void Operator() {
            System.out.println("IOS游戏操作控制");
        }
    }
    
    package AbstractFactoryPattern;
    /** * 具体产品-WindowsPhone游戏操作控制类 */
    public class Gj19WindowsPhoneOperationController implements Gj19IOperationController {
        @Override
        public void Operator() {
            System.out.println("WindowsPhone游戏操作控制");
        }
    }
    
    package AbstractFactoryPattern;
    /** * 抽象工厂--游戏控制类 */
    public interface Gj19GameController {
        //游戏操作控制
        public Gj19IOperationController OperationController();
        //游戏界面控制
        public Gj19IInterfaceController InterfaceController();
    }
    
    package AbstractFactoryPattern;
    /** * 具体工厂--Android游戏控制类 */
    public class AndroidController implements Gj19GameController {
        //Android游戏操作控制
        @Override
        public Gj19IOperationController OperationController() {
            return new Gj19AndroidOperationController();
        }
        //Android游戏界面控制
        @Override
        public Gj19IInterfaceController InterfaceController() {
            return new Gj19AndroidInterfaceController();
        }
    }
    
    package AbstractFactoryPattern;
    /** * 具体工厂--IOS游戏控制类 */
    public class IOSController implements Gj19GameController {
        //IOS游戏操作控制
        @Override
        public Gj19IOperationController OperationController() {
            return new Gj19IOSOperationController();
        }
        //IOS游戏界面控制
        @Override
        public Gj19IInterfaceController InterfaceController() {
            return new Gj19IOSInterfaceController();
        }
    }
    
    package AbstractFactoryPattern;
    /** * 具体工厂-- WindowsPhone游戏控制类 */
    public class WindowsPhoneController implements Gj19GameController {
        // WindowsPhone游戏操作控制
        @Override
        public Gj19IOperationController OperationController() {
            return new Gj19WindowsPhoneOperationController();
        }
        // WindowsPhone游戏界面控制
        @Override
        public Gj19IInterfaceController InterfaceController() {
            return new Gj19WindowsPhoneInterfaceController();
        }
    }
    
    package AbstractFactoryPattern;
    /** * 测试抽象工厂模式 */
    public class TestAbstractFactoryPattern {
        public static void main(String[] args) {
            Gj19GameController  gj19GameController;  //抽象工厂--游戏控制类
             Gj19IInterfaceController gj19IInterfaceController;  //游戏界面控制类
             Gj19IOperationController gj19IOperationController;  //游戏操作控制类
             gj19GameController = new AndroidController();  //具体工厂--Android游戏控制类
             gj19IInterfaceController = gj19GameController.InterfaceController();
             gj19IOperationController = gj19GameController.OperationController();
             gj19IInterfaceController.Interface();
             gj19IOperationController.Operator();
        }
    }

    展开全文
  • 抽象工厂模式 一、题目:某软件公司要推出一款新的手机游戏软件,该软件支持IOS、Android和Windows Phone等多个智能手机操作系统平台,针对不同的手机操作系统,该游戏软件提供了不同的游戏操作控制类...
  • 抽象工厂模式,是一个,狠恶心的模式,那么这个模式在Android有没有用到过呢? 1、定义: 抽象工厂模式:为创建一组相关或者是相互依赖的对象提供一个接口,而不需要指定他们的具体类。 2、使用:  2.1、不...
  • 常见的设计模式
  • 主要介绍了Android编程设计模式工厂方法模式,结合实例形式详细分析了Android工厂方法模式的概念、原理、使用方法及相关注意事项,需要的朋友可以参考下
  • 工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式、适配器模式、装饰者模式、代理模式、外观模式、桥接模式、组合模式、享元模式、策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、...
  • 2、所用模式结构视图 3、本实例类图 4、实例实现代码 4.1、抽象产品 4.2、具体产品 加法类 减法类 乘法类 除法类 指数运算类 对数运算类 4.3、抽象工厂 4.4、具体工厂 加法工厂类 减法工厂 乘法工厂类 ...
  •  外观模式,我们通过外观的包装,使应用程序只能看到外观对象,而不会看到具体的细节对象,这样无疑会降低应用程序的复杂度,并且提高了程序的可维护性。 例子1:一个电源总开关可以控制四盏灯、一个风扇、一台空调...
  • 抽象工厂模式适配器模式对象建模模式责任链模式命令模式复合模式装饰器模式门面模式迭代器模式中介模式备忘录模式模型-视图-控制器模式观察者模式代理模式接待员模式singleton模式模板方法模式1、创造性模式是专门...
  • 本文详细介绍了工厂模式中的简单工厂模式、工厂方法模式、抽象工厂模式。简单工厂模式优点和缺点,然后引出工厂模式,由于无法很好应对多个产品等级结构的问题,引出了抽象工厂模式,以及它的应用场景。
  • 接口和抽象类的区别简单工厂模式总结Java中new和newInstance的区别Java的Class.forName(xxx);Java里创建对象的几个方式总结Java类加载机制总结Java WEB的三层架构和MVC的关系工厂方法模式总结抽象
  • C#设计模式之3——抽象工厂模式

    千次阅读 2012-02-09 17:52:56
    1. 简单工厂模式:http://blog.csdn.net/weixingstudio/article/details/7234423 2. 工厂方法模式:...   声明:本文章参考引用《C#设计模式》(科学出版社)一书。   ...抽象工厂(Abstract Factory)模式
  • 本文是对简单工厂模式、单例模式、以及MVC模式的简单介绍。至于你问,为什么把这三种...在23种设计模式中,有工厂方法模式和抽象工厂模式,而一般我们提到工厂模式却有三种,再加上简单工厂模式。因为,GOF在《设计模式
  • 逻辑视图、进程视图、物理视图、开发视图和场景视图来描述软件体系结构。 3、构件:是具有某种功能的可重用的软件模板单元,表示了系统中主要的计算元素和数据存储。 连接件:表示构件之间的交互. 配置:表示...
  • C#MVC架构、工厂模式的区别 内容很好 讲解很清晰 受益匪浅
  • 简单工厂模式一、题目: 使用简单工厂模式模拟女娲(Nvwa)造人(Person),如果传入参数M,则返回一个Man对象,...(1)绘制简单工厂模式结构视图; (2)请绘制该实例类图,并代码实现。二、所用模式结构视图:三、实
  • 在MVC模式中,应用被分解为相互作用的模块,模型,视图,控制。目的在于分离输入(control),处理逻辑(model),输出格式(view)。 简单的理解: 1. 控制模块用于获取用户输入,并将模型与视图建立联系 2. 模型...
  • 设计模式1

    2022-08-03 18:41:41
    设计模式的原则(SOLID)1 单一职责原则 (SRP):每一个引起类变化的原因就是一个职责,当类具有多职责时,应把多余职责分离出去,分别创建一些类来完成每一个
  • java设计模式

    2015-05-08 06:45:02
    9.3.3 抽象工厂模式的使用场景 9.3.4 抽象工厂模式的注意事项 9.4 最佳实践 第10章 模板方法模式 10.1 辉煌工程—制造悍马 10.2 模板方法模式的定义 10.3 模板方法模式的应用 10.4 模板方法模式的扩展 10.5 最佳实践...
  • 主要介绍了Android编程设计模式之策略模式,结合实例形式详细分析了Android策略模式的概念、原理、实现方法及相关注意事项,需要的朋友可以参考下
  • 主要介绍了Android编程设计模式之模板方法模式,结合实例形式详细分析了Android模板方法模式的概念、功能、使用场景、用法及相关操作注意事项,需要的朋友可以参考下
  • 软件体系结构与设计模式笔记专门摘录重点

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,356
精华内容 8,942
关键字:

抽象工厂模式结构视图