23种设计模式--工厂模式-Factory Pattern

一、工厂模式的介绍

      工厂模式让我们相到的就是工厂,那么生活中的工厂是生产产品的,在代码中的工厂是生产实例的,在直白一点就是生产实例的类,代码中我们常用new关键字,那么这个new出来的实例就就依赖与这个类,2者之间的耦合度就高,此时我们就可以使用面向对象的去解决这个问题,将变化点封装起来,这就是我们将要首先引入的简单工厂模式;先来说一个场景,比如我们吃水果这个例子吧,我们有时候想吃苹果,有时候想吃橘子,但是每次都需要去买这些水果,后来有个水果店,又卖橘子,又卖苹果,这个水果店就当于简单工厂里面的工厂,但是这样的我们想吃什么水果只能看水果店有没有,没有就吃不到,后来人们又想出了一个办法那就是开来了水果园,你想吃什么我就种什么,这样就满足吃一切水果的想法,这也就是所说的工厂模式--下面又我们由普通-简单工厂-工厂模式-最后来个抽象工厂--不过抽象工厂等下篇再谈;

二、工厂模式Demo

     无模式下的吃水果

/// <summary>
    /// 水果类
    /// </summary>
    public abstract class Fruit
    {
        public abstract void Eat();
    }

public class Apple : Fruit
    {
        public override void Eat()
        {
            Console.WriteLine("我吃苹果");
        }
    }

public class Orange : Fruit
    {
        public override void Eat()
        {
            Console.WriteLine("我吃橘子");
        }
    }

static void Main(string[] args)
        {
            //当出现直接new的时候我们就应该考虑是否使用工厂模式
            //这里违反oo的原则,我们需要将改变的封装起来
            //当然下一步我们先进行简单工厂的例子
            Fruit fruit = new Apple();
            fruit.Eat();

Fruit fruit2 = new Orange();
            fruit2.Eat();

Console.ReadKey();
        }

简单工厂模式下的吃水果

水果类在这就贴出来了,和上面的情况一样,主要贴出来简单工厂这一块的,这一块我使用了一个枚举,来表示不同的类型

public enum FruitEnum
      {
        Apple=1,
        Orange=2
      }

/// <summary>
    /// 创建具体实例的简单工厂
    /// 当然明智的大家又会发现下面也都new,假如说我们增加一个类的情况下又要修改代码,好吧我们这么懒惰这不是我们干的事,那就引出我们下一位优秀的设计师那就是工厂设计师;
    /// </summary>
    public class SimpleFactoryFruit
    {
        public static Fruit CreateFactory(FruitEnum friutEnum)
        {
            switch (friutEnum)
            {
                case FruitEnum.Apple:
                    return new Apple();
                case FruitEnum.Orange:
                    return new Orange();
                default:
                    throw new Exception("暂时没有你想吃的水果");
            }
        }
    }

static void Main(string[] args)
        {
            //简单工厂将变化的水果封装到工厂里面使用不同的类型创建不同的对象将我们对水果的依赖变成间接的,使得对象之间的耦合度降低,但是创建对象的工厂里面,每增加一种水果就需要增加一种判断,这就是简单工厂的缺点;
            Fruit fruit = SimpleFactoryFruit.CreateFactory(FruitEnum.Apple);
            fruit.Eat();
            Fruit fruit2 = SimpleFactoryFruit.CreateFactory(FruitEnum.Orange);
            fruit2.Eat();
            Console.ReadKey();
        }

工厂模式下的吃水果

还是一样水果类不进行贴出来,下面就要关键是创建工厂这一类,

//抽象出创建水果的工厂类,将创建真正实例的推到子类上
    //这样就不存在简单工厂的缺点,每次只需要子类增加就可以不需要在原来代码上做更改
    public abstract class CreateFruitFactory
    {
        public abstract Fruit CreateFruit();
    }

public class CreateAppleFactory : CreateFruitFactory
    {
        public override Fruit CreateFruit()
        {
            return new Apple();
        }
    }

public class CreateOrangeFruit : CreateFruitFactory
    {
        public override Fruit CreateFruit()
        {
            return new Orange();
        }
    }

//工厂模式解决了简单工厂模式需要更改代码的问题
            //是不是这样就结束了尼,我们的程序的扩展性也好了各种都好了那还需要更改什么尼,假如我们又增加一种水果罐头,这样我们工厂模式就不适用了,那么又该怎么养去设计尼,接下来请听下回分解--抽象工厂
            CreateFruitFactory createApple = new CreateAppleFactory();
            Fruit apple = createApple.CreateFruit();
            apple.Eat();

CreateFruitFactory createOrage = new CreateOrangeFruit();
            Fruit orange = createOrage.CreateFruit();
            orange.Eat();
            Console.ReadKey();

三、GitHub

https://github.com/wangtongzhou520/Designpattern

时间: 2024-10-14 04:32:06

23种设计模式--工厂模式-Factory Pattern的相关文章

23种设计模式--建造者模式-Builder Pattern

一.建造模式的介绍       建造者模式就是将零件组装成一个整体,用官方一点的话来讲就是将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示.生活中比如说组装电脑,汽车等等这些都是建造者模式的具体体现,组装电脑反应到软件上就是一个复杂的对象,然后我们使用建造者模式的时候需要抽象一个建造类,抽象一个指挥者指挥具体实现的那个类,然后就是具体实现这个对象的类,这样就避免了每新创建一个不同的复杂对象就需要重新写一下这个类,这样就只要重写建造者就可以了,我们接下来就用组装电脑这个来说明一

二十三种设计模式——工厂模式

二十三种设计模式--工厂模式 简单工厂模式 简单工厂模式又称静态工厂方法(StaticFactory Method)模式,不属于23种模式之一. 简单工厂模式是工厂模式最简单使用的模式. 类图: 程序: #include <iostream> #include<string> using namespace std; class NationalFlag//父类 { public: NationalFlag(){} ~NationalFlag(){} virtual void di

设计模式-工厂模式[Factory]

先看下一个简单的实现: 1 package org.masque.designpatterns.factorymethod.one; 2 /** 3 * 4 * Description: Sample子类的标示 5 * BeanEm.java Create on 2014年7月11日 下午2:37:58 6 * @author [email protected] 7 * @version 1.0 8 * Copyright (c) 2014 Company,Inc. All Rights Res

23种设计模式----------代理模式(二)

(上一篇)23种设计模式----------代理模式(一) 之前说了基本的代理模式和普通代理模式.接下来开始看下强制代理模式和虚拟代理模式 三,强制代理模式: 一般的代理模式都是通过代理类找到被代理的对象,从而调用被代理类中的方法(即完成被代理类中的任务). 而,强制代理模式则是先找到被代理类自己去完成事情,然后被代理类又将该做的事情转交到代理类中,让代理类来完成. 假如:你有事求助于某位名人. 你告诉名人说有事想请他帮忙,然后他说最近一段时间比较忙,要不你找我的经纪人来办吧. (本来找名人办事

23种设计模式----------代理模式(一)

代理模式也叫委托模式. 代理模式定义:对其他对象提供一种代理从而控制对这个对象的访问.就是,代理类 代理 被代理类,来执行被代理类里的方法. 一般情况下,代理模式化有三个角色. 1,抽象的主题类(或者接口) IGamePlayer 2,代理类. 3,被代理类. 下面以游戏玩家代理为例. 一,先来看下最基本的代理模式. 代码如下: 主题接口: 1 package com.yemaozi.proxy.base; 2 3 //游戏玩家主题接口 4 public interface IGamePlaye

【设计模式】工厂模式 Factory Pattern

1)简单工厂(不是模式) 简单工厂只是一种变成习惯,并非23种设计模式之一. 简单工厂提供将实例话那种类型留给运行时判断,而非编译时指定.简单工厂模式就是由一个工厂类根据传入的参数决定创建出哪一个类的实例. 角色: 工厂类:接收参数,返回参数指定的类的实例. 抽象产品:返回实例的类型,具体产品的基类. 具体产品:继承自抽象产品的类. 2)工厂方法模式 沿着上面的思路,创建的接口是稳定的,但是创建对象剧烈变化.将稳定的接口抽象成基类,让子类确定实例哪个产品,将实际创建工作推迟到子类中. 工厂方法用

23种设计模式----------代理模式(三) 之 动态代理模式

(上一篇)种设计模式----------代理模式(二) 当然代理模式中,用的最广泛的,用的最多的是  动态代理模式. 动态代理:就是实现阶段不用关系代理是哪个,而在运行阶段指定具体哪个代理. 抽象接口的类图如下: --图来自设计模式之禅 所以动态代理模式要有一个InvocationHandler接口 和 GamePlayerIH实现类.其中 InvocationHandler是JD提供的动态代理接口,对被代理类的方法进行代理. 代码实现如下 抽象主题类或者接口: 1 package com.ye

设计模式 - 出厂模式(factory pattern) 详细说明

出厂模式(factory pattern) 详细说明 本文地址: http://blog.csdn.net/caroline_wendy/article/details/27081511 工厂方法模式: 定义了一个创建对象的接口, 但由子类决定要实例化的类是哪一个. 工厂方法让类把实例化推迟到子类. 包括: 创建者父类(creator), 包括创建对象的方法(取代new详细的对象, 通过參数创建不同的对象), 和一些主要的方法; 详细创建者(concrete creator), 继承创建者父类,

Android设计模式之一个例子让你彻底明白工厂模式(Factory Pattern)

提出疑问 这几天研究工厂模式的时候,看到网上的一些文章中举的例子我就很疑惑,我相信这也是许多人的疑惑:工厂模式的功能就是创建实例,我们创建实例直接new不就完了吗,干嘛还得再封装一层工厂类,然后用工厂类再去new出这个实例?这不多此一举吗? 比如我看到这样的例子,我们的用户分为金牌用户和银牌用户,我们要创建一个金牌用户或者银牌用户. 定义一个用户接口 public interface ICustomer { String describe(); } 金牌用户实现类 public class Go