Adapter模式（适配器模式）

- 日理万妓 2024-03-30 09:59 176阅读 0赞

模式简介

适配器模式在生活中也比较常见，例如我们的手机充电头就是一个适配器，我们无法将家庭电源直接与手机进行连接，因为这可能带来较大的安全隐患，并且也不太便利，所以我们需要一个中间的适配器，这个适配器用来保证我们对手机进行充电时的安全性和便利性，家用电的输出功率是比较大的，通过电源适配器来控制手机的输入功率，而且还需要考虑到电池寿命的问题，长期向手机电池输入大功率可能会导致电池寿命变短，并且220V家用电如果不通过电源适配器来保证安全就很有可能导致触电事故，综上采用适配器模式不仅能够帮助我们将手机与家用电源进行间接连接，同时我们还能控制家用电源面向手机的输出功率。

模式UML图

48537ea2e610400bb2bca8fa94fc0f51.jpeg

代码示例（C#）

提示：可在本栏目的资源篇“设计模式代码示例合集”下载所有完整代码资源。

  1. //接口类型
  2.     public enum InterfaceType
  3.     {
  4.         USB_TypeC, USB, Micro_USB, Lightning
  5.     }
  7.     //安卓手机
  8.     public class AndroidPhone : Phone
  9.     {
  10.         public AndroidPhone(string p_name, InterfaceType p_phoneInterfaceType, float p_inputCurrent, float p_inputVoltage) :
  11.         base(p_name, p_phoneInterfaceType, p_inputCurrent, p_inputVoltage)
  12.         { }
  13.     }
  15.     //苹果手机
  16.     public class ApplePhone : Phone
  17.     {
  18.         public ApplePhone(string p_name, InterfaceType p_phoneInterfaceType, float p_inputCurrent, float p_inputVoltage) :
  19.         base(p_name, p_phoneInterfaceType, p_inputCurrent, p_inputVoltage)
  20.         { }
  21.     }
  23.     //安卓充电线
  24.     public class AndroidChargerCable : ChargerCable
  25.     {
  26.         public override void ConnectPhone(Phone p_phone)
  27.         {
  28.             if (phoneInterfaceType.Equals(p_phone.phoneInterfaceType))
  29.             {
  30.                 if (transmissionCurrent <= p_phone.inputCurrent)
  31.                     Console.WriteLine("【ChargerCable:" + name + "】 successfully connected to 【Phone:" + p_phone.name + "】.");
  32.                 else Console.WriteLine("The transmissionCurrent of 【ChargerCable:" + name + "】 greater than inputCurrent of 【Phone:" + p_phone.name + "】.");
  33.             }
  34.             else Console.WriteLine("The phoneInterfaceType of 【ChargerCable:" + name + "】 doesn't match phoneInterfaceType of 【Phone:" + p_phone.name + "】.");
  35.             // p_phone.Print();
  36.         }
  38.         public class Builder
  39.         {
  40.             private AndroidChargerCable acc = new AndroidChargerCable();
  41.             public Builder BaseInfo(string p_name, string p_material, float p_length, float p_transmissionCurrent)
  42.             {
  43.                 acc.name = p_name;
  44.                 acc.material = p_material;
  45.                 acc.length = p_length;
  46.                 acc.transmissionCurrent = p_transmissionCurrent;
  47.                 return this;
  48.             }
  49.             public Builder InterfaceType(InterfaceType p_chargerInterfaceType, InterfaceType p_phoneInterfaceType)
  50.             {
  51.                 acc.chargerInterfaceType = p_chargerInterfaceType;
  52.                 acc.phoneInterfaceType = p_phoneInterfaceType;
  53.                 return this;
  54.             }
  55.             public AndroidChargerCable Build()
  56.             {
  57.                 return acc;
  58.             }
  59.         }
  60.     }
  62.     //苹果充电线
  63.     public class AppleChargerCable : ChargerCable
  64.     {
  65.         public override void ConnectPhone(Phone p_phone)
  66.         {
  67.             if (phoneInterfaceType.Equals(p_phone.phoneInterfaceType))
  68.             {
  69.                 if (transmissionCurrent <= p_phone.inputCurrent)
  70.                     Console.WriteLine("【ChargerCable:" + name + "】 successfully connected to 【Phone:" + p_phone.name + "】.");
  71.                 else Console.WriteLine("The transmissionCurrent of 【ChargerCable:" + name + "】 greater than inputCurrent of 【Phone:" + p_phone.name + "】.");
  72.             }
  73.             else Console.WriteLine("The phoneInterfaceType of 【ChargerCable:" + name + "】 doesn't match phoneInterfaceType of 【Phone:" + p_phone.name + "】.");
  74.             // p_phone.Print();
  75.         }
  76.         public class Builder
  77.         {
  78.             private AppleChargerCable acc = new AppleChargerCable();
  79.             public Builder BaseInfo(string p_name, string p_material, float p_length, float p_transmissionCurrent)
  80.             {
  81.                 acc.name = p_name;
  82.                 acc.material = p_material;
  83.                 acc.length = p_length;
  84.                 acc.transmissionCurrent = p_transmissionCurrent;
  85.                 return this;
  86.             }
  87.             public Builder InterfaceType(InterfaceType p_chargerInterfaceType, InterfaceType p_phoneInterfaceType)
  88.             {
  89.                 acc.chargerInterfaceType = p_chargerInterfaceType;
  90.                 acc.phoneInterfaceType = p_phoneInterfaceType;
  91.                 return this;
  92.             }
  93.             public AppleChargerCable Build()
  94.             {
  95.                 return acc;
  96.             }
  97.         }
  98.     }
  100.     //公牛插座
  101.     public class BullSocket : Socket
  102.     {
  103.         public BullSocket(string p_name, int p_socketNumber, float p_length, float p_socketCurrent, float p_ratedPower) :
  104.         base(p_name, p_socketNumber, p_length, p_socketCurrent, p_ratedPower)
  105.         { }
  106.         public override void ConnectPower(int p_voltage)
  107.         {
  108.             if (p_voltage < ratedPower / socketCurrent)
  109.                 Console.WriteLine("【Socket:" + name + "】 successfully connected to power.");
  110.             else
  111.                 Console.WriteLine("The inputMaxVoltage of 【Socket:" + name + "】 less than actualInputVoltage.");
  112.         }
  113.     }
  115.     //德力西插座
  116.     public class DelixiSocket : Socket
  117.     {
  118.         public DelixiSocket(string p_name, int p_socketNumber, float p_length, float p_socketCurrent, float p_ratedPower) :
  119.         base(p_name, p_socketNumber, p_length, p_socketCurrent, p_ratedPower)
  120.         { }
  121.         public override void ConnectPower(int p_voltage)
  122.         {
  123.             if (p_voltage < ratedPower / socketCurrent)
  124.                 Console.WriteLine("【Socket:" + name + "】 successfully connected to power.");
  125.             else
  126.                 Console.WriteLine("The inputMaxVoltage of 【Socket:" + name + "】 less than actualInputVoltage.");
  127.         }
  128.     }
  130.     //安卓电源适配器
  131.     public class AndroidCharger : Charger
  132.     {
  133.         private AndroidCharger() { }
  135.         public override ChargerCable ConnectCable(ChargerCable p_cable)
  136.         {
  137.             if (chargerInterfaceType.Equals(p_cable.chargerInterfaceType))
  138.             {
  139.                 if (outputCurrent <= p_cable.transmissionCurrent)
  140.                     Console.WriteLine("【Charger:" + name + "】 successfully connected to 【ChargerCable:" + p_cable.name + "】.");
  141.                 else
  142.                     Console.WriteLine("The outputCurrent of 【Charger:" + name + "】 greater than the transmissionCurrent of 【ChargerCable:" + p_cable.name + "】.");
  143.             }
  144.             else Console.WriteLine("The chargerInterfaceType of 【Charger:" + name + "】 is different from chargerInterfaceType of 【ChargerCable:" + p_cable.name + "】.");
  145.             // p_cable.Print();
  146.             return p_cable;
  147.         }
  149.         public override Socket ConnectSocket(Socket p_socket)
  150.         {
  151.             if (inputCurrent <= p_socket.socketCurrent)
  152.             {
  153.                 if (inputCurrent <= p_socket.socketCurrent)
  154.                 {
  155.                     if (inputVoltage >= (p_socket.ratedPower - 300f) / 10)
  156.                         Console.WriteLine("【Charger:" + name + "】 successfully connected to 【Socket:" + p_socket.name + "】.");
  157.                     else Console.WriteLine("The inputVoltage of 【Charger:" + name + "】 less than outputVoltage of 【Socket:" + p_socket.name + "】.");
  158.                 }
  159.                 else Console.WriteLine("The inputCurrent of 【Charger:" + name + "】 greater than socketCurrent of 【Socket:" + p_socket.name + "】.");
  160.             }
  161.             else Console.WriteLine("The inputCurrent of 【Charger:" + name + "】 greater than socketCurrent of 【Socket:" + p_socket.name + "】.");
  162.             // p_socket.Print();
  163.             return p_socket;
  164.         }
  166.         //构建器
  167.         public class Builder
  168.         {
  169.             private AndroidCharger c = new AndroidCharger();
  170.             public Builder BaseInfo(string p_name, string p_model, InterfaceType p_chargerInterfaceType)
  171.             {
  172.                 c.name = p_name;
  173.                 c.model = p_model;
  174.                 c.chargerInterfaceType = p_chargerInterfaceType;
  175.                 return this;
  176.             }
  178.             public Builder Current(float p_inputCurrent, float p_outputCurrent)
  179.             {
  180.                 c.inputCurrent = p_inputCurrent;
  181.                 c.outputCurrent = p_outputCurrent;
  182.                 return this;
  183.             }
  185.             public Builder Voltage(float p_inputVoltage, float p_outputVoltage)
  186.             {
  187.                 c.inputVoltage = p_inputVoltage;
  188.                 c.outputVoltage = p_outputVoltage;
  189.                 return this;
  190.             }
  192.             public AndroidCharger Build()
  193.             {
  194.                 return c;
  195.             }
  196.         }
  197.     }
  199.     //苹果电源适配器
  200.     public class AppleCharger : Charger
  201.     {
  202.         private AppleCharger() { }
  204.         public override ChargerCable ConnectCable(ChargerCable p_cable)
  205.         {
  206.             if (chargerInterfaceType.Equals(p_cable.chargerInterfaceType))
  207.             {
  208.                 if (outputCurrent <= p_cable.transmissionCurrent)
  209.                     Console.WriteLine("【Charger:" + name + "】 successfully connected to 【ChargerCable:" + p_cable.name + "】.");
  210.                 else
  211.                     Console.WriteLine("The outputCurrent of 【Charger:" + name + "】 greater than the transmissionCurrent of 【ChargerCable:" + p_cable.name + "】.");
  212.             }
  213.             else Console.WriteLine("The chargerInterfaceType of 【Charger:" + name + "】 is different from chargerInterfaceType of 【ChargerCable:" + p_cable.name + "】.");
  214.             // p_cable.Print();
  215.             return p_cable;
  216.         }
  218.         public override Socket ConnectSocket(Socket p_socket)
  219.         {
  220.             if (inputCurrent <= p_socket.socketCurrent)
  221.             {
  222.                 if (inputCurrent <= p_socket.socketCurrent)
  223.                 {
  224.                     if (inputVoltage >= (p_socket.ratedPower - 300f) / 10)
  225.                         Console.WriteLine("【Charger:" + name + "】 successfully connected to 【Socket:" + p_socket.name + "】.");
  226.                     else Console.WriteLine("The inputVoltage of 【Charger:" + name + "】 less than outputVoltage of 【Socket:" + p_socket.name + "】.");
  227.                 }
  228.                 else Console.WriteLine("The inputCurrent of 【Charger:" + name + "】 greater than socketCurrent of 【Socket:" + p_socket.name + "】.");
  229.             }
  230.             else Console.WriteLine("The inputCurrent of 【Charger:" + name + "】 greater than socketCurrent of 【Socket:" + p_socket.name + "】.");
  231.             // p_socket.Print();
  232.             return p_socket;
  233.         }
  235.         //构建器
  236.         public class Builder
  237.         {
  238.             private AppleCharger c = new AppleCharger();
  239.             public Builder BaseInfo(string p_name, string p_model, InterfaceType p_chargerInterfaceType)
  240.             {
  241.                 c.name = p_name;
  242.                 c.model = p_model;
  243.                 c.chargerInterfaceType = p_chargerInterfaceType;
  244.                 return this;
  245.             }
  247.             public Builder Current(float p_inputCurrent, float p_outputCurrent)
  248.             {
  249.                 c.inputCurrent = p_inputCurrent;
  250.                 c.outputCurrent = p_outputCurrent;
  251.                 return this;
  252.             }
  254.             public Builder Voltage(float p_inputVoltage, float p_outputVoltage)
  255.             {
  256.                 c.inputVoltage = p_inputVoltage;
  257.                 c.outputVoltage = p_outputVoltage;
  258.                 return this;
  259.             }
  261.             public AppleCharger Build()
  262.             {
  263.                 return c;
  264.             }
  265.         }
  266.     }
  268.     //电源适配器基类，所有电源适配器继承该类
  269.     public abstract class Charger
  270.     {
  271.         public string name;
  272.         public string model;
  273.         public InterfaceType chargerInterfaceType;
  274.         public float outputCurrent;
  275.         public float inputCurrent;
  276.         public float outputVoltage;
  277.         public float inputVoltage;
  278.         public void Print()
  279.         {
  280.             Console.WriteLine("【Charger:" + name + "】");
  281.             Console.WriteLine("-----------------------------------");
  282.             Console.WriteLine("[model]:" + model);
  283.             Console.WriteLine("[chargerInterfaceType]:" + chargerInterfaceType);
  284.             Console.WriteLine("[outputCurrent]:" + outputCurrent);
  285.             Console.WriteLine("[inputCurrent]:" + inputCurrent);
  286.             Console.WriteLine("[outputVoltage]:" + outputVoltage);
  287.             Console.WriteLine("[inputVoltage]:" + inputVoltage);
  288.             Console.WriteLine("-----------------------------------");
  289.         }
  290.         public abstract ChargerCable ConnectCable(ChargerCable p_cable);
  291.         public abstract Socket ConnectSocket(Socket p_socket);
  292.     }
  294.     //充电线基类，所有充电线继承该类
  295.     public abstract class ChargerCable
  296.     {
  297.         public string name;
  298.         public InterfaceType chargerInterfaceType;
  299.         public InterfaceType phoneInterfaceType;
  300.         public string material;
  301.         public float length;
  302.         public float transmissionCurrent;
  303.         public void Print()
  304.         {
  305.             Console.WriteLine("【ChargerCable:" + name + "】");
  306.             Console.WriteLine("-----------------------------------");
  307.             Console.WriteLine("[chargerInterfaceType]:" + chargerInterfaceType.ToString());
  308.             Console.WriteLine("[phoneInterfaceType]:" + phoneInterfaceType.ToString());
  309.             Console.WriteLine("[material]:" + material);
  310.             Console.WriteLine("[length]:" + length);
  311.             Console.WriteLine("[transmissionCurrent]:" + transmissionCurrent);
  312.             Console.WriteLine("-----------------------------------");
  313.         }
  314.         public abstract void ConnectPhone(Phone p_phone);
  315.     }
  317.     //手机基类，所有手机继承该类
  318.     public abstract class Phone
  319.     {
  320.         public string name;
  321.         public InterfaceType phoneInterfaceType;
  322.         public float inputCurrent;
  323.         public float inputVoltage;
  325.         public Phone(string p_name, InterfaceType p_phoneInterfaceType, float p_inputCurrent, float p_inputVoltage)
  326.         {
  327.             name = p_name;
  328.             phoneInterfaceType = p_phoneInterfaceType;
  329.             inputCurrent = p_inputCurrent;
  330.             inputVoltage = p_inputVoltage;
  331.         }
  333.         public void Print()
  334.         {
  335.             Console.WriteLine("【Phone:" + name + "】");
  336.             Console.WriteLine("-----------------------------------");
  337.             Console.WriteLine("[phoneInterfaceType]:" + phoneInterfaceType.ToString());
  338.             Console.WriteLine("[inputCurrent]:" + inputCurrent);
  339.             Console.WriteLine("[inputVoltage]:" + inputVoltage);
  340.             Console.WriteLine("-----------------------------------");
  341.         }
  342.     }
  344.     //插座类，所有插座继承该类
  345.     public abstract class Socket
  346.     {
  347.         public string name;
  348.         public int socketNumber;
  349.         public float length;
  350.         public float socketCurrent;
  351.         public float ratedPower;
  352.         public Socket(string p_name, int p_socketNumber, float p_length, float p_socketCurrent, float p_ratedPower)
  353.         {
  354.             name = p_name;
  355.             socketNumber = p_socketNumber;
  356.             length = p_length;
  357.             socketCurrent = p_socketCurrent;
  358.             ratedPower = p_ratedPower;
  359.         }
  360.         public void Print()
  361.         {
  362.             Console.WriteLine("【Socket:" + name + "】");
  363.             Console.WriteLine("-----------------------------------");
  364.             Console.WriteLine("[socketNumber]:" + socketNumber);
  365.             Console.WriteLine("[length]:" + length);
  366.             Console.WriteLine("[socketCurrent]:" + socketCurrent);
  367.             Console.WriteLine("[ratedPower]:" + ratedPower);
  368.             Console.WriteLine("-----------------------------------");
  369.         }
  370.         public abstract void ConnectPower(int p_voltage);
  371.     }
  373.     //测试代码
  374.     public void Test()
  375.     {
  376.         AndroidPhone mi12 = new AndroidPhone("小米 12", InterfaceType.USB_TypeC, 13.4f, 5);
  377.         ApplePhone apple13 = new ApplePhone("Apple 13", InterfaceType.Lightning, 1, 5);
  378.         AndroidChargerCable romosChargerCable = new AndroidChargerCable.Builder()
  379.         .BaseInfo("罗马仕CB051-72-113", "TPE", 1.5f, 3)
  380.         .InterfaceType(InterfaceType.USB, InterfaceType.Micro_USB)
  381.         .Build();
  382.         AndroidChargerCable miChargerCable = new AndroidChargerCable.Builder()
  383.         .BaseInfo("小米原装USB-C数据线", "TPE", 1, 6)
  384.         .InterfaceType(InterfaceType.USB, InterfaceType.USB_TypeC)
  385.         .Build();
  386.         AppleChargerCable appleChargerCable = new AppleChargerCable.Builder()
  387.         .BaseInfo("AppleA2244", "TPE", 1, 1)
  388.         .InterfaceType(InterfaceType.USB_TypeC, InterfaceType.Lightning)
  389.         .Build();
  390.         BullSocket bullSocket = new BullSocket("公牛GN-B3440", 8, 1.6f, 10, 2500);
  391.         DelixiSocket delixiSocket = new DelixiSocket("德力西CD98J-LK4X1.8", 4, 1.6f, 10, 2500);
  392.         AndroidCharger miCharger = new AndroidCharger.Builder()
  393.         .BaseInfo("小米MDY-13-ES", "MDY-13-ES", InterfaceType.USB)
  394.         .Current(6.1f, 1.7f)
  395.         .Voltage(220, 11)
  396.         .Build();
  397.         AppleCharger appleCharger = new AppleCharger.Builder()
  398.         .BaseInfo("AppleA2244", "A2244", InterfaceType.USB_TypeC)
  399.         .Current(2.22f, 0.5f)
  400.         .Voltage(240, 9)
  401.         .Build();
  402.         //电源适配器连接充电线，充电线连接手机
  403.         miCharger.ConnectCable(romosChargerCable).ConnectPhone(mi12);
  404.         //电源适配器连接插座，插座连接家用电源
  405.         miCharger.ConnectSocket(delixiSocket).ConnectPower(220);
  406.     }

代码解说

我们这里的示例简单模拟了手机充电的过程，这个过程中需要手机Phone、充电头Charger、数据线ChargerCable、插座Socket，为了更真实地模拟，我们特意加入了输入电流、输出电流、输入电压、输出电压、接口类型等属性，并且对目前市面上主流地两种类型手机进行了模拟，一个是安卓手机AndroidPhone，另一个是苹果手机ApplePhone，数据线和充电头共同组成电源适配器，插座有两种，一个是BullSocket，另一个是DelixiSocket，我们需要模拟家用电源向手机充电的过程。

如果这篇文章对你有帮助，请给作者点个赞吧！

发表评论

表情：
评论列表 （有 0 条评论，176人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Adapter模式（适配器模式）

    模式简介 适配器模式在生活中也比较常见，例如我们的手机充电头就是一个适配器，我们无法将家庭电源直接与手机进行连接，因为这可能带来较大的安全隐患，并且也不太便利，所以我们需

    - 日理万妓- 日理万妓/ 0 赞/ 177 阅读

    相关 适配器模式（Adapter）

    网上看到不少关于适配器模式的讲解，其中对于适配器模式解释的过于专业，一时不是特别理解适配器模式到底是用来干嘛的，具体的适用场景在哪，其最精髓的地方到底在哪。 本文结合自己的理

    深碍√TFBOYSˉ_深碍√TFBOYSˉ_/ 0 赞/ 314 阅读

    相关 适配器模式（adapter）

    适配器模式的定义： 将一个类的接口转换成客户希望的另外一个接口，适配器模式使得原本由于接口不兼容而不能在一起的那些类可以一起工作。 主要分为三类：类的适配器模式、

    悠悠悠悠/ 0 赞/ 307 阅读

    相关 适配器模式（Adapter）

    “适配器模式把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。” 适配器模式主要通过继承、对象组合来实现适配器功能，

    迈不过友情╰迈不过友情╰/ 0 赞/ 289 阅读

    相关 适配器模式（adapter）

    适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。首先

    蔚落蔚落/ 0 赞/ 336 阅读

    相关 设计模式--适配器模式（Adapter）

    适配器模式 在现实生活中，经常出现两个对象因接口不兼容而不能在一起工作的实例，这时需要第三者进行适配。例如，讲中文的人同讲英文的人对话时需要一个翻译，用直流电的笔记本电脑

    朱雀朱雀/ 0 赞/ 460 阅读