“xixigi”通过精心收集，向本站投稿了7篇Objective C设计模式之外观模式facade，以下是小编为大家整理后的Objective C设计模式之外观模式facade，希望对您有所帮助。

篇1：Objective C设计模式之外观模式facade

一个框架中如果包含的类比较多，或者功能比较复杂的情况下，可以通过一个较辅助类为一些常用的情况提供简单的接口，这样客户在使用这个框架的时候既可以比较简单的应付常见的场景，又可以使用框架中的内实现符合自己要求的功能。这就好比买电脑的时候，即可以买品牌机，又可以自己买配件组装。下面就拿买电脑来举例。

假设电脑由显示器、主板、CPU、内存和显卡组成。当然，实际远远不止这些。每个设备都有许多的参数需要选择，我们给它们分别定义一个类去完成选择的工作。

//选择显示器@interface Display : NSObject- (void)chooseDisplay:(NSString *)type;@end@implementation Display- (void)chooseDisplay:(NSString *)type { NSLog(@选择显示器：%@, type);}@end//选择主板@interface MainBoard : NSObject- (void)chooseMainBoard:(NSString *)type;@end@implementation MainBoard- (void)chooseMainBoard:(NSString *)type { NSLog(@选择主板：%@, type);}@end//选择CPU@interface CPU : NSObject- (void)chooseCPU:(NSString *)type;@end@implementation CPU- (void)chooseCPU:(NSString *)type { NSLog(@选择CPU：%@, type);}@end//客户代码@interface Client : NSObject- (void)assebleComputer;@end@implementation Client - (void)assebleComputer { Display *display = [Display new]; [display chooseDisplay: @AOC]; MainBoard *mainBoard = [MainBoard new]; [mainBoard chooseMainBoard: @华硕]; CPU *cpu = [CPU new]; [cpu chooseCPU: @i7处理器]}@end

这时的输出结果应该是：

选择显示器：AOC选择主板：华硕选择CPU：i7处理器

类图：

我们可以利用这几个选取的类去组装任意配置的电脑，

但是如果遇到小白用户，他们可能从来没有听说过什么是处理器，什么是主板。这时我们可能希望有一个简单一点地方式去做这件事。

@interface MacBookPro : NSObject- (void)chooseDevice;@end@implementation MacBookPro- (void)chooseDevice { Display *display = [Display new]; [display chooseDisplay: @三星]; MainBoard *mainBoard = [MainBoard new]; [mainBoard chooseMainBoard: @华硕]; CPU *cpu = [CPU new]; [cpu chooseCPU: @i5处理器]}@end

这时客户的代码为：

@interface Client : NSObject- (void)assebleComputer;@end@implementation Client- (void)assembleComputer { MacBookPro *computer = [MacBookPro new]; [computer chooseDevice];}@end

输出结果为：

选择显示器：三星选择主板：华硕选择CPU：i5处理器

使用MacBookPro这个类的好处就是客户可以不去了解电脑的组成的情况下，也可以得到一台完整的电脑。这样就可以同时满足小白用户和专业用户了。

篇2：设计模式之工厂模式

1、概念

Define an interface for creating an object,but let subclasses decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses.（定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。）

工厂模式是经常用到的设计模式之一。其作用是，延迟子类初始化，客户端只需从工厂中获取产品，而不用了解产品生产的细节，降低了模块之间的耦合。也是面向接口编程体现。

2、通用类图

图片摘自HeadFirst<?www.2cto.com/kf/ware/vc/“ target=”_blank“ class=”keylink“>vcD4NCjxwPrTTwODNvMnPv7SjrNPQsvrGt73Tv9qjrNbG1OzV39Kyvs3Kx7mks6e907/aoaO+38zlsvrGt8q1z9ay+sa3vdO/2qOsvt/M5bmks6fKtc/WuaSzp73Tv9qho8i7uvO5pLOntcTKtc/WwOCjrLnYwaq+38zltcSy+sa3oaPOqsHLuPy6w7XYwO294tXiuPbEo8q9o6zHw8HL0ru49tChwP3X06OsvNPS1Lio1vqjrM+jzfu/ydLUyKG1w9K70KnW+rmloaOhvsnuyOvBy73i1eK49sSjyr2/ydLUss6/vCChtsnovMbEo8q91q7s+KG3ILrNobZIZWFkRmlyc3ShtyDV4sG9sb7K6ba8ysfBvNDE1q7X9yDOxLW1z8LU2Lz7ss6/vNfKwc+hvzwvcD4NCjxoMSBpZD0=”3例子“>3、例子

例子背景：有个平板工厂，工厂可以生产苹果平板，安卓平板。平板可以连接wifi关闭wifi等功能。

例子类图如下：

PAD接口代码：

package phlin.samples.factory.pad;public interface PAD { /** * 联网功能 */ public void linkToNet; /** * 打开wifi功能 */ public void openWifi(); /** * 关闭wifi功能 */ public void closeWifi(); /** * other functions */}

工厂接口代码：

package phlin.samples.factory.pad;/** *平板 工厂 接口 * @author lin * */public interface PADFactoryI { public PAD createPad(String padType); }

安卓平板代码：【实现平板接口】

package phlin.samples.factory.pad;public class AndroidPad implements PAD { @Override public void linkToNet() { // TODO Auto-generated method stub UtilClass.Dis(I use a android pad to get msg from Intener); } @Override public void openWifi() { // TODO Auto-generated method stub UtilClass.Dis(open android pad wifi); } @Override public void closeWifi() { // TODO Auto-generated method stub UtilClass.Dis(close android pad wifi); }}

苹果平板代码：【实现平板接口】

package phlin.samples.factory.pad;public class IOSPad implements PAD{ @Override public void linkToNet() { // TODO Auto-generated method stub UtilClass.Dis(I use a IOS pad to get msg from Intener); } @Override public void openWifi() { // TODO Auto-generated method stub UtilClass.Dis(open IOS pad wifi); } @Override public void closeWifi() { // TODO Auto-generated method stub UtilClass.Dis(close IOS pad wifi); }}

工厂实现代码：【实现工厂接口】

package phlin.samples.factory.pad;public class PadFactory implements PADFactoryI{ PAD pad=null; @Override public PAD createPad(String padType) { // TODO Auto-generated method stub if(padType.equals(android)) {pad=new AndroidPad(); }else if(padType.equals(iso)) {pad=new IOSPad(); }else {UtilClass.Dis(no instance); } return pad; }}

辅助显示类：

package phlin.samples.factory.pad;public final class UtilClass { /** * 终端显示 * @param str */ public static void Dis(String str) { System.out.println(str); }}

测试类代码：

package phlin.samples.factory.pad;public class TestClass { public static void main(String[] args) { PAD andPad=null,iosPad=null; //pad工厂实例化 PadFactory factory=new PadFactory(); //生产安卓平板 andPad=factory.createPad(android); andPad.linkToNet(); //生产苹果平板 iosPad=factory.createPad(iso); iosPad.linkToNet(); }}

测试结果：

I use a android pad to get msg from IntenerI use a IOS pad to get msg from Intener

可以发现，

测试类代码中只需实例化工厂，然后通过createPad方法 就可以实例化相对应的平板，而且，关键是，测试类中，无需关系平板是如何生产的，极大降低了模块直接耦合，有利于拓展。

但是这种通过 String padType 的方式来判断那类产品要生产，似乎比较麻烦，如果款式比较多，还得一个个加。这里有一种比较好的优化方案，用泛型来实现，直接通过类名来实例化子类。

下面对工厂接口和工厂实现类做一些改动：

注意不同之处：

工厂接口：

package phlin.samples.factory.pad;/** *平板 工厂 接口 * @author lin * */public interface PADFactoryI { publicT ceratePad(Classc);}

工厂实现类：

package phlin.samples.factory.pad;public class PadFactory implements PADFactoryI{ PAD pad=null;@Override publicT ceratePad(Classc) { // TODO Auto-generated method stub PAD pad=null; try { pad=(PAD)Class.forName(c.getName()).newInstance(); } catch (Exception e) { // TODO: handle exception } return (T)pad; }}

测试类代码：

package phlin.samples.factory.pad;public class TestClass { public static void main(String[] args) { PAD andPad=null,iosPad=null; PadFactory factory=new PadFactory(); andPad=factory.ceratePad(AndroidPad.class); andPad.linkToNet(); iosPad=factory.ceratePad(IOSPad.class); iosPad.linkToNet(); }}

测试结果：

I use a android pad to get msg from IntenerI use a IOS pad to get msg from Intener

测试结果一样，但是对于工厂实现类，要添加新类型产品是，该类几乎不用改动。对于产品，只需拓展产品也就是平板类型即可。

篇3：五分钟一个设计模式之组合模式

在基于关系型数据库的应用程序中，一对多的关系是在太多了，那么如何来轻松地遍历一棵树呢？

我们今天来介绍一个专门为树形结构而生的设计模式，组合模式。

一棵树包括分支节点和叶子节点，我们让他们实现同样的接口

public interface IComponent{ string GetInfo();}

定义分支节点

public class Composite : IComponent{ private string name; public Composite(string _name) { this.name = _name; } private Listchildren = new List(); public string GetInfo() { return string.Format(”我是{0}，我有{1}个子节点“, name, children.Count); } ///

public void RemoveChild(IComponent child) { children.Remove(child); } public ListGetChildren() { return children; }}

下面是叶子节点

public class Leaf:IComponent{ private string name; public Leaf(string _name) { this.name = _name; } public string GetInfo() { return ”我是“ + name; }}

组合模式到底是如何实现遍历一棵树的呢？下面来看场景类

class Program{ static void Main(string[] args) { //先来组织一棵树，根节点包含manage1和manage2，manager1包括员工1和员工2， //manager2包括员工3和员工4 Composite root = new Composite(”Boss“); Composite manager1 = new Composite(”Manager1“); Composite manager2 = new Composite(”Manager2“); IComponent empl1 = new Leaf(”员工1“); IComponent empl2 = new Leaf(”员工2“); IComponent empl3 = new Leaf(”员工3“); IComponent empl4 = new Leaf(”员工4“); manager1.AddChild(empl1); manager1.AddChild(empl2); manager2.AddChild(empl3); manager2.AddChild(empl4); root.AddChild(manager1); root.AddChild(manager2); Console.WriteLine( root.GetInfo()); DisplayTreeInfo(root); Console.ReadKey(); } //遍历函数，递归调用 static void DisplayTreeInfo(Composite composite) { foreach (IComponent item in composite.GetChildren()) {if (item is Composite){ Composite c = item as Composite; Console.WriteLine(c.GetInfo()); DisplayTreeInfo(c);}else{ Console.WriteLine(item.GetInfo());} } }}

运行结果：

我是Boss，我有2个子节点

我是Manager1，我有2个子节点

我是员工1

我是员工2

我是Manager2，我有2个子节点

我是员工3

我是员工4

篇4：五分钟一个设计模式之组合模式

组合模式的定义是：将对象组合成树形结构以表示“部分-整体”的层次结构，

组合模式使得用户对单个对象和组合对象的使用具有一致性。

在上面的例子中，无论是分支节点还是叶子节点，都实现了同一个接口IComponent，这样的好处是，客户端不需要区分是分支节点还是叶子节点，都可以调用GetInfo方法来完成某个功能。

组合模式的缺点也很明显，违反了依赖倒置原则，客户端在使用时，尽管都可以调用IComponent的GetInfo方法，但是，在遍历时，还是用到了具体的类Composite和Leaf。

篇5：五分钟一个设计模式之工厂方法模式

下面定义一个抽象类，这个类中有一个具体方法（MyMethod）和一个抽象方法（AbstractMethod），具体方法调用了抽象方法。

public abstract class AbstractClass{ public void MyMethod { string str = AbstractMethod(); Console.WriteLine(str); } protected abstract string AbstractMethod();}

具体方法调用了抽象方法，并且，抽象方法需要在子类中实现，所以，子类实现的抽象方法会对父类中的具体方法产生影响。下面定义两个子类

public class Class1 : AbstractClass{ protected override string AbstractMethod() { return ”I am class1“; }}public class Class2 : AbstractClass{ protected override string AbstractMethod() { return ”I am class2“; }}

在上面的代码中，子类实现的AbstractMethod方法的返回值，直接决定了父类中MyMethod方法中的输出，

下面是场景类

class Program{ static void Main(string[] args) { AbstractClass class1 = new Class1(); AbstractClass class2 = new Class2(); class1.MyMethod(); class2.MyMethod(); }}

输出结果为：

I am class1

I am class2

篇6：五分钟一个设计模式之工厂方法模式

百度百科是这么定义工厂方法模式的：

工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

篇7：(C/C++ 版) 设计模式 学习之 工厂模式

大话设计模式这本书使用 C# 语言写的，我用的是 C++ 语言，最近在看这本书，所以用 C++ 语言走了一遍，

以下是部分笔记，包括代码

若不涉及面向对象这个概念，我们写的简易计算器可能是下面这个样子

//User.cpp --- 客户端#include iostreamint main(){ using namespace std; cout<>number_a; cout<>opera; cout<>number_b; int avaliable = 1; float result = 0; switch(opera) { case '+': result = number_a + number_b; break; case '-': result = number_a - number_b; break; case '*': result = number_a * number_b; break; case '/': { if(number_b) { result = number_a / number_b; break; } else avaliable = 0; } default: result = 0; } if(avaliable) cout<可以看出，很呆板，很麻烦，自能实现特定计算，不可调用，没有移植的可能。

而 C++ 是一种面向对象的语言，下面我们用 OOP 思想来重写这段代码。

下面是一个简单的例子，不是很合题，循序渐进，可配合这本书来看。

” int=“int” number_a=“number_a;” number_b=“number_b;” operatepublic:=“operate{public:” pre=“pre” resultpublic:=“result;public:” sign=“sign;”>

//Factory.cpp#include Factory.hfloat operate::calculate(){ switch(sign) { case '+': result = number_a + number_b; break; case '-': result = number_a - number_b; break; case '*': result = number_a * number_b; break; case '/': { if(number_b) { result = number_a / number_b;break; } } default: result = 0; } return result;}

//User.cpp --- 客户端#include Factory.h#include iostreamint main(){ using namespace std; operate myOpera; cout<>myOpera.number_a; cout<>myOpera.number_b; cout<>myOpera.sign; float my_result = myOpera.calculate(); cout<上面就是 OOP 模式了。咱们继续设计模式，下面实现工厂模式。

【Objective C设计模式之外观模式facade】相关文章：

1.教学设计模式

2.策划书模式

3.课堂教学模式

4.教学设计模式有哪些

5.个人设计模式学习总结

6.网站运营之思维模式分析

7.计算机应用基础课考核模式设计

8.凌乱模式诗歌

9.初中英语作文模式

10.广告策划书模式