【笔记】大话设计模式24-28

阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6

【笔记】大话设计模式24-28

文章目录

24 职责链模式

24.1 Example

阿三刚工作时年底年终奖发的很少很多大专生拿得比他都多。他只好硬着头皮去找主任说。

主任需要跟部门老总商量一下能不能提高一下年终奖部门老总也得要请示公司老总看能不能加个年终奖

这种模式就是职责链模式每个对象都有自己的职责用户发送一个请求这个请求经过每个职责对象只至被处理。

24.2 定义

职责链模式Chain of Responsibility:使多个对象都有机会处理请求从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链并沿着这条链传递该请求直到有一个对象处理它为止

职责链模式结构图

24.3 Show me the code

class Program
{
    static void Main(string[] args)
    {
        Handler h1 = new ConcreteHandler1();
        Handler h2 = new ConcreteHandler2();
        Handler h3 = new ConcreteHandler3();
        // 设置职责链的上家与下家
        h1.SetSuccessor(h2); 
        h2.SetSuccessor(h3);

        int[] requests = { 2, 5, 14, 22, 18, 3, 27, 20 };
		
        // 循环给最小处理者提交请求不同的数额由不同权限处理者处理
        foreach (int request in requests)
        {
            h1.HandleRequest(request);
        }

        Console.Read();

    }
}

// 定义一个处理请示的接口
abstract class Handler
{
    protected Handler successor;
  
	// 设置继任者
    public void SetSuccessor(Handler successor)
    {
        this.successor = successor;
    }
	
    // 处理请求的抽象方法
    public abstract void HandleRequest(int request);
}

// 请求数在0到10之间则有权处理否则转到下一位
class ConcreteHandler1 : Handler
{
    public override void HandleRequest(int request)
    {
        if (request >= 0 && request < 10)
        {
            Console.WriteLine("{0}  处理请求  {1}",
                              this.GetType().Name, request);
        }
        else if (successor != null)
        {
            successor.HandleRequest(request); // 转移到下一位
        }
    }
}

// 请求数在10到20之间则有权处理否则转到下一位
class ConcreteHandler2 : Handler
{
    public override void HandleRequest(int request)
    {
        if (request >= 10 && request < 20)
        {
            Console.WriteLine("{0}  处理请求  {1}",
                              this.GetType().Name, request);
        }
        else if (successor != null)
        {
            successor.HandleRequest(request);
        }
    }
}

// 请求数在20到30之间则有权处理否则转到下一位
class ConcreteHandler3 : Handler
{
    public override void HandleRequest(int request)
    {
        if (request >= 20 && request < 30)
        {
            Console.WriteLine("{0}  处理请求  {1}",
                              this.GetType().Name, request);
        }
        else if (successor != null)
        {
            successor.HandleRequest(request);
        }
    }
}

24.4 总结

  1. 单一职责原则实现解耦 接收者和发送者都没有对方的明确信息且链中的对象自己也并不知道链的结构。

    结果是职责链可简化对象的相互连接它们仅需保持一个指向其后继者的引用而不需要保持它所有的候选者的引用。

  2. 开闭原则可以随时地增加或修改处理一个请求的结构增强了给对象指派职责的灵活性。

  3. 当需要使用不同方式处理不同种类的请求并且请求类型和顺序预先未知时可以使用职责链模式。

    当然如果处理必须按顺序处理多个处理者时就可以使用该模式。

25 中介者模式

25.1 Example

阿三现在上班通勤都是使用电动车很多路口是没有红绿灯的或者即便有红绿灯对于电动车驾驶者来说也是可有可无的存在没有汽车的时候他们一般会无视红绿灯直接通过。但这样会给后面来的汽车带来麻烦明明是绿灯他们必须得停下来导致自己通行受阻。

因此很多交警每天一大早站在这些路口充当一种“中介”人为地调节电瓶车和汽车之间的通行时间使得交通秩序处于一种有序状态。

Picture source: Refactoring GURU

25.2 定义

中介者模式Mediator:用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用从而使其耦合松散而且可以对立地改变他们之间的交互。

中介者模式结构图

25.3 Show me the code

来看看模拟的联合国职责的中介者模式代码

class Program
{
    static void Main(string[] args)
    {
        UnitedNationsSecurityCouncil UNSC = new UnitedNationsSecurityCouncil();

        USA c1 = new USA(UNSC);
        Iraq c2 = new Iraq(UNSC);

        UNSC.Colleague1 = c1;
        UNSC.Colleague2 = c2;

        c1.Declare("不准研制核武器否则要发动战争");
        c2.Declare("我们没有核武器也不怕侵略。");

        Console.Read();
    }
}

//联合国机构
abstract class UnitedNations
{
    /// <summary>
    /// 声明
    /// </summary>
    /// <param name="message">声明信息</param>
    /// <param name="colleague">声明国家</param>
    public abstract void Declare(string message, Country colleague);
}

//联合国安全理事会
class UnitedNationsSecurityCouncil : UnitedNations
{
    private USA colleague1;
    private Iraq colleague2;

    public USA Colleague1
    {
        set { colleague1 = value; }
    }

    public Iraq Colleague2
    {
        set { colleague2 = value; }
    }

    public override void Declare(string message, Country colleague)
    {
        if (colleague == colleague1)
        {
            colleague2.GetMessage(message);
        }
        else
        {
            colleague1.GetMessage(message);
        }
    }
}

//国家
abstract class Country
{
    protected UnitedNations mediator;

    public Country(UnitedNations mediator)
    {
        this.mediator = mediator;
    }
}

//美国
class USA : Country
{
    public USA(UnitedNations mediator)
        : base(mediator)
        {
        }
    //声明
    public void Declare(string message)
    {
        mediator.Declare(message, this);
    }
    //获得消息
    public void GetMessage(string message)
    {
        Console.WriteLine("美国获得对方信息" + message);
    }
}

//伊拉克
class Iraq : Country
{
    public Iraq(UnitedNations mediator)
        : base(mediator)
        {
        }

    //声明
    public void Declare(string message)
    {
        mediator.Declare(message, this);
    }
    //获得消息
    public void GetMessage(string message)
    {
        Console.WriteLine("伊拉克获得对方信息" + message);
    }

}

25.4 总结

  1. 中介者模式减少了各个Coleague的耦合使得可以对立地改变和复用各个Colleague类和Mediator
  2. 由于把对象如何协作进行了抽象将中介作为一个独立的概念并将其封装在一个对象中这样关注的对象从对象各自本身的行为转移到它们之间的交互上来。
  3. 中介者模式一般用于一组对象以定义良好但是复杂的方式进行通信的场合以及想定制一个分布在多个类中的行为而又不想生成太多子类的场合。

26 享元模式

26.1 Example

大头以前的有专门做网站的同事。以前的套路就是做水务平台的是一套代码框架如果有其他城市要做就把代码搬过来修改下对应内容和数据库存储路径等而代码框架是不变的所以最终会出现每个城市的水务网站看似不同其实内在的代码框架是一样的也就是生成了多个网站实例这是一种资源浪费和冗余。

如何能够将核心代码框架抽离出来形成独立的代码核心和数据库通过标识调用不同的数据和页面图标即可这就是享元模式。

26.2 定义

享元模式Flyweight:运用共享技术有效地支持大量细粒度的对象。

享元模式结构图

26.3 Show me the code

  1. 基础代码
class Program
{
    static void Main(string[] args)
    {
        int extrinsicstate = 22;

        FlyweightFactory f = new FlyweightFactory();

        Flyweight fx = f.GetFlyweight("Q");
        fx.Operation(--extrinsicstate);

        Flyweight fy = f.GetFlyweight("C");
        fy.Operation(--extrinsicstate);

        Flyweight fz = f.GetFlyweight("J");
        fz.Operation(--extrinsicstate);

        UnsharedConcreteFlyweight uf = new UnsharedConcreteFlyweight();

        uf.Operation(--extrinsicstate);

        Console.Read();
    }
}

// 享元工厂用来创造并管理Flyweight对象。用来确保合理地共享Flyweight。
class FlyweightFactory
{
    private Hashtable flyweights = new Hashtable();

    public FlyweightFactory()
    {
        flyweights.Add("Q", new ConcreteFlyweight());
        flyweights.Add("J", new ConcreteFlyweight());
        flyweights.Add("J", new ConcreteFlyweight());

    }

    public Flyweight GetFlyweight(string key)
    {
        return ((Flyweight)flyweights[key]);
    }
}

// 接口通过这个接口Flyweight可以接受并作用于外部状态
abstract class Flyweight
{
    public abstract void Operation(int extrinsicstate);
}

// 为内部状态增加存储空间
class ConcreteFlyweight : Flyweight
{
    public override void Operation(int extrinsicstate)
    {
        Console.WriteLine("具体Flyweight:" + extrinsicstate);
    }
}

// 指不需要共享的Flyweight子类。Flyweight接口共享成为可能并不强制共享
class UnsharedConcreteFlyweight : Flyweight
{
    public override void Operation(int extrinsicstate)
    {
        Console.WriteLine("不共享的具体Flyweight:" + extrinsicstate);
    }
}
  1. 网站的享元模式
class Program
{
    static void Main(string[] args)
    {

        WebSiteFactory f = new WebSiteFactory();

        WebSite fx = f.GetWebSiteCategory("产品展示");
        fx.Use(new User("阿三"));

        WebSite fy = f.GetWebSiteCategory("产品展示");
        fy.Use(new User("大头"));

        WebSite fz = f.GetWebSiteCategory("产品展示");
        fz.Use(new User("小豆子"));

        WebSite fl = f.GetWebSiteCategory("博客");
        fl.Use(new User("王五"));

        WebSite fm = f.GetWebSiteCategory("博客");
        fm.Use(new User("钱六"));

        WebSite fn = f.GetWebSiteCategory("博客");
        fn.Use(new User("大批古"));

        Console.WriteLine("得到网站分类总数为 {0}", f.GetWebSiteCount());

        Console.Read();
    }
}

//用户
public class User
{
    private string name;

    public User(string name)
    {
        this.name = name;
    }

    public string Name
    {
        get { return name; }
    }
}


//网站工厂
class WebSiteFactory
{
    private Hashtable flyweights = new Hashtable();

    //获得网站分类
    public WebSite GetWebSiteCategory(string key)
    {
        if (!flyweights.ContainsKey(key))
            flyweights.Add(key, new ConcreteWebSite(key));
        return ((WebSite)flyweights[key]);
    }

    //获得网站分类总数
    public int GetWebSiteCount()
    {
        return flyweights.Count;
    }
}

//网站
abstract class WebSite
{
    public abstract void Use(User user);
}

//具体的网站
class ConcreteWebSite : WebSite
{
    private string name = "";
    public ConcreteWebSite(string name)
    {
        this.name = name;
    }

    public override void Use(User user)
    {
        Console.WriteLine("网站分类" + name + " 用户" + user.Name);
    }
}

26.4 总结

如果一个应用程序使用了大量对象而这些对象造成了很大的存储开销时就应该考虑使用享元模式

27 解释器模式

27.1 Example

阿三最近喜欢看短视频有一类挺有意思的。

工作几年的人想跳槽再正常不过了不过面试的时候能不能听懂面试官或单位领导的画外之音就决定了正常面试的互相理解程度。比如老板说我们这边可以发挥的空间很大有人就会解释说这里没多少人需要你干的任务比较多老板说我们这里工作时间比较自由有人解释需要你加班的场景会比较多等等。搞笑的同时确实和现实有几分相似。

因此能不能正确解读HR和老板的话语需要通过解释器帮助我们正确理解他人的真正意图。

27.2 定义

解释器模式Interpreter:给定一个语言定义它的文法的一种表示并定义一个解释器这个解释器使用该表示来解释语言中的句子。

解释器结构图

27.3 Show me the code

  1. 基本代码
class Program
{
    static void Main(string[] args)
    {
        Context context = new Context();
        IList<AbstractExpression> list = new List<AbstractExpression>();
        list.Add(new TerminalExpression());
        list.Add(new NonterminalExpression());
        list.Add(new TerminalExpression());
        list.Add(new TerminalExpression());

        foreach (AbstractExpression exp in list)
        {
            exp.Interpret(context);
        }

        Console.Read();
    }
}

class Context
{
    private string input;
    public string Input
    {
        get { return input; }
        set { input = value; }
    }

    private string output;
    public string Output
    {
        get { return output; }
        set { output = value; }
    }
}

// 抽象表达式声明一个抽象的解释操作这个接口为抽象语法树中所有节点所共享
abstract class AbstractExpression
{
    public abstract void Interpret(Context context);
}

// 终结符表达式实现与文法中的终结符相关联的解释操作。
class TerminalExpression : AbstractExpression
{
    public override void Interpret(Context context)
    {
        Console.WriteLine("终端解释器");
    }
}

// 非终结符表达式为文法中的非终结符实现解释操作。
// 对文法中每一条规则R2、R2.....Rn都需要一个具体的非终结表达式类
class NonterminalExpression : AbstractExpression
{
    public override void Interpret(Context context)
    {
        Console.WriteLine("非终端解释器");
    }
}

结果

终端解释器
非终端解释器
终端解释器
终端解释器
  1. 乐谱解释控制台代码实现

class Program
{
    static void Main(string[] args)
    {
        PlayContext context = new PlayContext();
        //音乐-上海滩
        Console.WriteLine("上海滩");
        //context.演奏文本 = "T 500 O 2 E 0.5 G 0.5 A 3 E 0.5 G 0.5 D 3 E 0.5 G 0.5 A 0.5 O 3 C 1 O 2 A 0.5 G 1 C 0.5 E 0.5 D 3 D 0.5 E 0.5 G 3 D 0.5 E 0.5 O 1 A 3 A 0.5 O 2 C 0.5 D 1.5 E 0.5 D 0.5 O 1 B 0.5 A 0.5 O 2 C 0.5 O 1 G 3 P 0.5 O 2 E 0.5 G 0.5 A 3 E 0.5 G 0.5 D 3 E 0.5 G 0.5 A 0.5 O 3 C 1 O 2 A 0.5 G 1 C 0.5 E 0.5 D 3 D 0.5 E 0.5 G 3 D 0.5 E 0.5 O 1 A 3 A 0.5 O 2 C 0.5 D 1.5 E 0.5 D 0.5 O 1 B 0.5 A 0.5 G 0.5 O 2 C 3 P 0.5 O 3 C 0.5 C 0.5 O 2 A 0.5 O 3 C 2 P 0.5 O 2 A 0.5 O 3 C 0.5 O 2 A 0.5 G 2.5 G 0.5 E 0.5 A 1.5 G 0.5 C 1 D 0.25 C 0.25 D 0.5 E 2.5 E 0.5 E 0.5 D 0.5 E 2.5 O 3 C 0.5 C 0.5 O 2 B 0.5 A 3 E 0.5 E 0.5 D 1.5 E 0.5 O 3 C 0.5 O 2 B 0.5 A 0.5 E 0.5 G 2 P 0.5 O 2 E 0.5 G 0.5 A 3 E 0.5 G 0.5 D 3 E 0.5 G 0.5 A 0.5 O 3 C 1 O 2 A 0.5 G 1 C 0.5 E 0.5 D 3 D 0.5 E 0.5 G 3 D 0.5 E 0.5 O 1 A 3 A 0.5 O 2 C 0.5 D 1.5 E 0.5 D 0.5 O 1 B 0.5 A 0.5 G 0.5 O 2 C 3 ";
        context.PlayText = "T 500 O 2 E 0.5 G 0.5 A 3 E 0.5 G 0.5 D 3 E 0.5 G 0.5 A 0.5 O 3 C 1 O 2 A 0.5 G 1 C 0.5 E 0.5 D 3 ";
        //音乐-隐形的翅膀
        //Console.WriteLine("隐形的翅膀"); 
        //context.演奏文本 = "T 1000 O 1 G 0.5 O 2 C 0.5 E 1.5 G 0.5 E 1 D 0.5 C 0.5 C 0.5 C 0.5 C 0.5 O 1 A 0.25 G 0.25 G 1 G 0.5 O 2 C 0.5 E 1.5 G 0.5 G 0.5 G 0.5 A 0.5 G 0.5 G 0.5 D 0.25 E 0.25 D 0.5 C 0.25 D 0.25 D 1 A 0.5 G 0.5 E 1.5 G 0.5 G 0.5 G 0.5 A 0.5 G 0.5 E 0.5 D 0.5 C 0.5 C 0.25 D 0.25 O 1 A 1 G 0.5 A 0.5 O 2 C 1.5 D 0.25 E 0.25 D 1 E 0.5 C 0.5 C 3 O 1 G 0.5 O 2 C 0.5 E 1.5 G 0.5 E 1 D 0.5 C 0.5 C 0.5 C 0.5 C 0.5 O 1 A 0.25 G 0.25 G 1 G 0.5 O 2 C 0.5 E 1.5 G 0.5 G 0.5 G 0.5 A 0.5 G 0.5 G 0.5 D 0.25 E 0.25 D 0.5 C 0.25 D 0.25 D 1 A 0.5 G 0.5 E 1.5 G 0.5 G 0.5 G 0.5 A 0.5 G 0.5 E 0.5 D 0.5 C 0.5 C 0.25 D 0.25 O 1 A 1 G 0.5 A 0.5 O 2 C 1.5 D 0.25 E 0.25 D 1 E 0.5 C 0.5 C 3 E 0.5 G 0.5 O 3 C 1.5 O 2 B 0.25 O 3 C 0.25 O 2 B 1 A 0.5 G 0.5 A 0.5 O 3 C 0.5 O 2 E 0.5 D 0.5 C 1 C 0.5 C 0.5 C 0.5 O 3 C 1 O 2 G 0.25 A 0.25 G 0.5 D 0.25 E 0.25 D 0.5 C 0.25 D 0.25 D 3 E 0.5 G 0.5 O 3 C 1.5 O 2 B 0.25 O 3 C 0.25 O 2 B 1 A 0.5 G 0.5 A 0.5 O 3 C 0.5 O 2 E 0.5 D 0.5 C 1 C 0.5 C 0.5 C 0.5 O 3 C 1 O 2 G 0.25 A 0.25 G 0.5 D 0.25 E 0.25 D 0.5 C 0.5 C 3 ";
        Expression expression = null;
        try
        {
            while (context.PlayText.Length > 0)
            {
                string str = context.PlayText.Substring(0, 1);
                switch (str)
                {
                    case "O":
                        expression = new Scale();
                        break;
                    case "T":
                        expression = new Speed();
                        break;
                    case "C":
                    case "D":
                    case "E":
                    case "F":
                    case "G":
                    case "A":
                    case "B":
                    case "P":
                        expression = new Note();
                        break;

                }
                expression.Interpret(context);

            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }

        Console.Read();
    }
}
//演奏内容
class PlayContext
{
    //演奏文本
    private string text;
    public string PlayText
    {
        get { return text; }
        set { text = value; }
    }
}

//表达式
abstract class Expression
{
    //解释器
    public void Interpret(PlayContext context)
    {
        if (context.PlayText.Length == 0)
        {
            return;
        }
        else
        {
            string playKey = context.PlayText.Substring(0, 1);
            context.PlayText = context.PlayText.Substring(2);
            double playValue = Convert.ToDouble(context.PlayText.Substring(0, context.PlayText.IndexOf(" ")));
            context.PlayText = context.PlayText.Substring(context.PlayText.IndexOf(" ") + 1);

            Excute(playKey, playValue);

        }
    }
    //执行
    public abstract void Excute(string key, double value);
}

//音符
class Note : Expression
{
    public override void Excute(string key, double value)
    {
        string note = "";
        switch (key)
        {
            case "C":
                note = "1";
                break;
            case "D":
                note = "2";
                break;
            case "E":
                note = "3";
                break;
            case "F":
                note = "4";
                break;
            case "G":
                note = "5";
                break;
            case "A":
                note = "6";
                break;
            case "B":
                note = "7";
                break;

        }
        Console.Write("{0} ", note);
    }
}

//音阶
class Scale : Expression
{
    public override void Excute(string key, double value)
    {
        string scale = "";
        switch (Convert.ToInt32(value))
        {
            case 1:
                scale = "低音";
                break;
            case 2:
                scale = "中音";
                break;
            case 3:
                scale = "高音";
                break;

        }
        Console.Write("{0} ", scale);
    }
}

//音速
class Speed : Expression
{
    public override void Excute(string key, double value)
    {
        string speed;
        if (value < 500)
            speed = "快速";
        else if (value >= 1000)
            speed = "慢速";
        else
            speed = "中速";

        Console.Write("{0} ", speed);
    }
}

27.4 总结

  1. 当有一个语言需要解释执行并且你可将该语言中的句子表示为一个抽象语法树时可使用解释器模式
  2. 优点比较容易改变和扩展文法因为该模式使用类来表示文法规则可使用继承实现也比较容易实现文法因为定义抽象语法树中各个节点的类的实现大体类似这些类都易于直接编写。
  3. 缺点每个文法中的每一条规则至少定义了一个类因为包含许多规则的文法可能难以管理和维护。
  4. 建议当文法非常复杂时使用其他的技术如语法分析程序或编译器生成器来处理。

28访问者模式

28.1 Example

大头平时喜欢吃汉堡之类的快餐。

因此每次去快餐店大头总是先了解一下快餐店最近的促销产品然后了解一下所有可购买产品的状态再根据自己的喜好进行购买。这就是访问者模式。访问一个对象可以对这个对象所有子类进行读取。

Picture Source: Refactoring GURU

28.2 定义

访问者模式Visitor:表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作

访问者模式结构图

28.3 Show me the code

class Program
{
    static void Main(string[] args)
    {
        ObjectStructure o = new ObjectStructure();
        o.Attach(new ConcreteElementA());
        o.Attach(new ConcreteElementB());

        ConcreteVisitor1 v1 = new ConcreteVisitor1();
        ConcreteVisitor2 v2 = new ConcreteVisitor2();

        o.Accept(v1);
        o.Accept(v2);

        Console.Read();
    }
}

abstract class Visitor
{
    public abstract void VisitConcreteElementA(ConcreteElementA concreteElementA);

    public abstract void VisitConcreteElementB(ConcreteElementB concreteElementB);
}

class ConcreteVisitor1 : Visitor
{
    public override void VisitConcreteElementA(ConcreteElementA concreteElementA)
    {
        Console.WriteLine("{0}被{1}访问", concreteElementA.GetType().Name, this.GetType().Name);
    }

    public override void VisitConcreteElementB(ConcreteElementB concreteElementB)
    {
        Console.WriteLine("{0}被{1}访问", concreteElementB.GetType().Name, this.GetType().Name);
    }
}

class ConcreteVisitor2 : Visitor
{
    public override void VisitConcreteElementA(ConcreteElementA concreteElementA)
    {
        Console.WriteLine("{0}被{1}访问", concreteElementA.GetType().Name, this.GetType().Name);
    }

    public override void VisitConcreteElementB(ConcreteElementB concreteElementB)
    {
        Console.WriteLine("{0}被{1}访问", concreteElementB.GetType().Name, this.GetType().Name);
    }
}

abstract class Element
{
    public abstract void Accept(Visitor visitor);
}

class ConcreteElementA : Element
{
    public override void Accept(Visitor visitor)
    {
        visitor.VisitConcreteElementA(this);
    }

    public void OperationA()
    { }
}

class ConcreteElementB : Element
{
    public override void Accept(Visitor visitor)
    {
        visitor.VisitConcreteElementB(this);
    }

    public void OperationB()
    { }
}

class ObjectStructure
{
    private IList<Element> elements = new List<Element>();

    public void Attach(Element element)
    {
        elements.Add(element);
    }

    public void Detach(Element element)
    {
        elements.Remove(element);
    }

    public void Accept(Visitor visitor)
    {
        foreach (Element e in elements)
        {
            e.Accept(visitor);
        }
    }
}

28.4 总结

  1. 访问者模式适用于数据结构相对稳定的系统将数据结构和作用于结构上的操作耦合解脱开使得操作集合可以相对自由地演化。
  2. 当你需要对一个复杂对象结构如对象树中所有元素执行某些操作可使用访问者模式
  3. 优点增加新的访问者即增加新操作比较容易。访问者模式将有关行为集中到一个访问者对象中。
  4. 缺点增加新的数据结构比较困难有的操作需要重新修改。
阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6
返回列表

上一篇：WireShark无法找到网卡_wireshark没有网卡列表

下一篇：邂逅Vue.js开发

“【笔记】大话设计模式24-28” 的相关文章

订阅福利-免费领取激光检测领域的共269份自然基金结题报告(PDF文档-大小为2.91G)1年前 (2023-02-02)
SpringBoot 项目中配置多个 Jackson 的 ObjectMapper ，以及配置遇到的坑1年前 (2023-02-02)
基于jQuery的三种AJAX请求1年前 (2023-02-02)
Openmp Runtime 库函数汇总（上）1年前 (2023-02-02)
轻松解决 CSS 代码都在一行的问题1年前 (2023-02-02)
MySQL必知必会第十二章-汇总数据1年前 (2023-02-02)
Python如何运行程序1年前 (2023-02-02)
基于Xlinx的时序分析与约束（6）----如何读懂vivado下的时序报告？1年前 (2023-02-02)
前端面试题学习-个人总结1年前 (2023-02-02)
浅谈PHP设计模式的访问者模式1年前 (2023-02-02)

阿里云国际版