以下是Objective-C代码实现26种设计模式的示例：

//工厂方法模式（Factory Method Pattern）
// Product.h
@interface Product : NSObject
- (void)operation;
@end

// Creator.h
@interface Creator : NSObject
- (Product *)createProduct;
@end

// ConcreteProduct.h
@interface ConcreteProduct : Product
@end

// ConcreteCreator.h
@interface ConcreteCreator : Creator
@end

// ConcreteCreator.m
@implementation ConcreteCreator
- (Product *)createProduct {
    return [[ConcreteProduct alloc] init];
}
@end
//抽象工厂模式（Abstract Factory Pattern）
// AbstractFactory.h
@interface AbstractFactory : NSObject
- (ProductA *)createProductA;
- (ProductB *)createProductB;
@end

// ConcreteFactory1.h
@interface ConcreteFactory1 : AbstractFactory
@end

// ConcreteFactory2.h
@interface ConcreteFactory2 : AbstractFactory
@end

// ProductA.h
@interface ProductA : NSObject
- (void)operationA;
@end

// ProductB.h
@interface ProductB : NSObject
- (void)operationB;
@end

// ConcreteProductA1.h
@interface ConcreteProductA1 : ProductA
@end

// ConcreteProductB1.h
@interface ConcreteProductB1 : ProductB
@end

// ConcreteProductA2.h
@interface ConcreteProductA2 : ProductA
@end

// ConcreteProductB2.h
@interface ConcreteProductB2 : ProductB
@end

// ConcreteFactory1.m
@implementation ConcreteFactory1
- (ProductA *)createProductA {
    return [[ConcreteProductA1 alloc] init];
}
- (ProductB *)createProductB {
    return [[ConcreteProductB1 alloc] init];
}
@end

// ConcreteFactory2.m
@implementation ConcreteFactory2
- (ProductA *)createProductA {
    return [[ConcreteProductA2 alloc] init];
}
- (ProductB *)createProductB {
    return [[ConcreteProductB2 alloc] init];
}
@end
//单例模式（Singleton Pattern）
// Singleton.h
@interface Singleton : NSObject
+ (instancetype)sharedInstance;
@end

// Singleton.m
@implementation Singleton
+ (instancetype)sharedInstance {
    static Singleton *instance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        instance = [[self alloc] init];
    });
    return instance;
}
@end
//建造者模式（Builder Pattern）
// Product.h
@interface Product : NSObject
@property (nonatomic, strong) NSString *partA;
@property (nonatomic, strong) NSString *partB;
@property (nonatomic, strong) NSString *partC;
@end

// Builder.h
@interface Builder : NSObject
- (void)buildPartA;
- (void)buildPartB;
- (void)buildPartC;
- (Product *)getResult;
@end

// ConcreteBuilder.h
@interface ConcreteBuilder : Builder
@property (nonatomic, strong) Product *product;
@end

// ConcreteBuilder.m
@implementation ConcreteBuilder
- (instancetype)init {
    if (self = [super init]) {
        _product = [[Product alloc] init];
    }
    return self;
}
- (void)buildPartA {
    _product.partA = @"Part A";
}
- (void)buildPartB {
    _product.partB = @"Part B";
}
- (void)buildPartC {
    _product.partC = @"Part C";
}
- (Product *)getResult {
    return _product;
}
@end

// Director.h
@interface Director : NSObject
- (Product *)construct;
@end

// Director.m
@implementation Director
- (Product *)construct {
    ConcreteBuilder *builder = [[ConcreteBuilder alloc] init];
    [builder buildPartA];
    [builder buildPartB];
    [builder buildPartC];
    return [builder getResult];
}
@end
//原型模式（Prototype Pattern）
// Prototype.h
@interface Prototype : NSObject <NSCopying>
@property (nonatomic, strong) NSString *name;
@property (nonatomic, assign) NSInteger age;
@end

// Prototype.m
@implementation Prototype
- (instancetype)copyWithZone:(NSZone *)zone {
    Prototype *copy = [[[self class] allocWithZone:zone] init];
    copy.name = self.name;
    copy.age = self.age;
    return copy;
}
@end
//适配器模式（Adapter Pattern）
// Target.h
@interface Target : NSObject
- (void)request;
@end

// Adaptee.h
@interface Adaptee : NSObject
- (void)specificRequest;
@end

// Adapter.h
@interface Adapter : Target
@property (nonatomic, strong) Adaptee *adaptee;
@end

// Adapter.m
@implementation Adapter
- (void)request {
    [self.adaptee specificRequest];
}
@end
//桥接模式（Bridge Pattern）
// Implementor.h
@interface Implementor : NSObject
- (void)operationImp;
@end

// Abstraction.h
@interface Abstraction : NSObject
@property (nonatomic, strong) Implementor *implementor;
- (void)operation;
@end

// ConcreteImplementorA.h
@interface ConcreteImplementorA : Implementor
@end

// ConcreteImplementorB.h
@interface ConcreteImplementorB : Implementor
@end

// RefinedAbstraction.h
@interface RefinedAbstraction : Abstraction
@end

// Implementor.m
@implementation Implementor
- (void)operationImp {
    // implementation
}
@end

// Abstraction.m
@implementation Abstraction
- (void)operation {
    [self.implementor operationImp];
}
@end

// ConcreteImplementorA.m
@implementation ConcreteImplementorA
- (void)operationImp {
    // implementation A
}
@end

// ConcreteImplementorB.m
@implementation ConcreteImplementorB
- (void)operationImp {
    // implementation B
}
@end

// RefinedAbstraction.m
@implementation RefinedAbstraction
- (void)operation {
    [super operation];
    // additional implementation
}
@end
//组合模式（Composite Pattern）
// Component.h
@interface Component : NSObject
@property (nonatomic, strong) NSString *name;
- (void)add:(Component *)component;
- (void)remove:(Component *)component;
- (void)display:(NSInteger)depth;
@end

// Leaf.h
@interface Leaf : Component
@end

// Composite.h
@interface Composite : Component
@property (nonatomic, strong) NSMutableArray *children;
@end

// Component.m
@implementation Component
- (instancetype)init {
    if (self = [super init]) {
        _name = @"";
    }
    return self;
}
- (void)add:(Component *)component {}
- (void)remove:(Component *)component {}
- (void)display:(NSInteger)depth {}
@end

// Leaf.m
@implementation Leaf
- (void)display:(NSInteger)depth {
    NSString *prefix = [@"" stringByPaddingToLength:depth withString:@"-" startingAtIndex:0];
    NSLog(@"%@%@", prefix, self.name);
}
@end

// Composite.m
@implementation Composite
- (instancetype)init {
    if (self = [super init]) {
        _children = [NSMutableArray array];
    }
    return self;
}
- (void)add:(Component *)component {
    [self.children addObject:component];
}
- (void)remove:(Component *)component {
    [self.children removeObject:component];
}
- (void)display:(NSInteger)depth {
    NSString *prefix = [@"" stringByPaddingToLength:depth withString:@"-" startingAtIndex:0];
    NSLog(@"%@%@", prefix, self.name);
    for (Component *component in self.children) {
        [component display:depth + 2];
    }
}
@end
//装饰器模式（Decorator Pattern）
// Component.h
@interface Component : NSObject
- (void)operation;
@end

// ConcreteComponent.h
@interface ConcreteComponent : Component
@end

// Decorator.h
@interface Decorator : Component
@property (nonatomic, strong) Component *component;
@end

// ConcreteDecoratorA.h
@interface ConcreteDecoratorA : Decorator
@end

// ConcreteDecoratorB.h
@interface ConcreteDecoratorB : Decorator
@end

// Component.m
@implementation Component
- (void)operation {}
@end

// ConcreteComponent.m
@implementation ConcreteComponent
- (void)operation {
    // implementation
}
@end

// Decorator.m
@implementation Decorator
- (instancetype)initWithComponent:(Component *)component {
    if (self = [super init]) {
        _component = component;
    }
    return self;
}
- (void)operation {
    [self.component operation];
}
@end

// ConcreteDecoratorA.m
@implementation ConcreteDecoratorA
- (void)operation {
    [super operation];
    // additional implementation A
}
@end

// ConcreteDecoratorB.m
@implementation ConcreteDecoratorB
- (void)operation {
    [super operation];
    // additional implementation B
}
@end
//外观模式（Facade Pattern）
// SubsystemA.h
@interface SubsystemA : NSObject
- (void)operationA;
@end

// SubsystemB.h
@interface SubsystemB : NSObject
- (void)operationB;
@end

// SubsystemC.h
@interface SubsystemC : NSObject
- (void)operationC;
@end

// Facade.h
@interface Facade : NSObject
@property (nonatomic, strong) SubsystemA *subsystemA;
@property (nonatomic, strong) SubsystemB *subsystemB;
@property (nonatomic, strong) SubsystemC *subsystemC;
- (void)operation;
@end

// SubsystemA.m
@implementation SubsystemA
- (void)operationA {
    // implementation
}
@end

// SubsystemB.m
@implementation SubsystemB
- (void)operationB {
    // implementation
}
@end

// SubsystemC.m
@implementation SubsystemC
- (void)operationC {
    // implementation
}
@end

// Facade.m
@implementation Facade
- (instancetype)init {
    if (self = [super init]) {
        _subsystemA = [[SubsystemA alloc] init];
        _subsystemB = [[SubsystemB alloc] init];
        _subsystemC = [[SubsystemC alloc] init];
    }
    return self;
}
- (void)operation {
    [self.subsystemA operationA];
    [self.subsystemB operationB];
    [self.subsystemC operationC];
}
@end
//享元模式（Flyweight Pattern）
// Flyweight.h
@interface Flyweight : NSObject
- (void)operation:(NSString *)extrinsicState;
@end

// ConcreteFlyweight.h
@interface ConcreteFlyweight : Flyweight
@property (nonatomic, strong) NSString *intrinsicState;
@end

// FlyweightFactory.h
@interface FlyweightFactory : NSObject
@property (nonatomic, strong) NSMutableDictionary *flyweights;
- (Flyweight *)getFlyweight:(NSString *)key;
@end

// Flyweight.m
@implementation Flyweight
- (void)operation:(NSString *)extrinsicState {}
@end

// ConcreteFlyweight.m
@implementation ConcreteFlyweight
- (void)operation:(NSString *)extrinsicState {
    NSLog(@"Intrinsic state: %@, extrinsic state: %@", self.intrinsicState, extrinsicState);
}
@end

// FlyweightFactory.m
@implementation FlyweightFactory
- (instancetype)init {
    if (self = [super init]) {
        _flyweights = [NSMutableDictionary dictionary];
    }
    return self;
}
- (Flyweight *)getFlyweight:(NSString *)key {
    Flyweight *flyweight = self.flyweights[key];
    if (!flyweight) {
        flyweight = [[ConcreteFlyweight alloc] init];
        flyweight.intrinsicState = key;
        self.flyweights[key] = flyweight;
    }
    return flyweight;
}
@end
//代理模式（Proxy Pattern）
// Subject.h
@interface Subject : NSObject
- (void)request;
@end

// RealSubject.h
@interface RealSubject : Subject
@end

// Proxy.h
@interface Proxy : Subject
@property (nonatomic, strong) RealSubject *realSubject;
@end

// Proxy.m
@implementation Proxy
- (void)request {
    [self.realSubject request];
}
@end
//责任链模式（Chain of Responsibility Pattern）
// Handler.h
@interface Handler : NSObject
@property (nonatomic, strong) Handler *successor;
- (void)handleRequest:(NSInteger)request;
@end

// ConcreteHandler1.h
@interface ConcreteHandler1 : Handler
@end

// ConcreteHandler2.h
@interface ConcreteHandler2 : Handler
@end

// Handler.m
@implementation Handler
- (void)handleRequest:(NSInteger)request {
    if (self.successor) {
        [self.successor handleRequest:request];
    }
}
@end

// ConcreteHandler1.m
@implementation ConcreteHandler1
- (void)handleRequest:(NSInteger)request {
    if (request == 1) {
        // handle request
    } else {
        [super handleRequest:request];
    }
}
@end

// ConcreteHandler2.m
@implementation ConcreteHandler2
- (void)handleRequest:(NSInteger)request {
    if (request == 2) {
        // handle request
    } else {
        [super handleRequest:request];
    }
}
@end
//命令模式（Command Pattern）
// Receiver.h
@interface Receiver : NSObject
- (void)action;
@end

// Command.h
@interface Command : NSObject
@property (nonatomic, strong) Receiver *receiver;
- (void)execute;
@end

// ConcreteCommand.h
@interface ConcreteCommand : Command
@end

// Invoker.h
@interface Invoker : NSObject
@property (nonatomic, strong) Command *command;
- (void)invoke;
@end

// Receiver.m
@implementation Receiver
- (void)action {
    // implementation
}
@end

// Command.m
@implementation Command
- (void)execute {
    [self.receiver action];
}
@end

// ConcreteCommand.m
@implementation ConcreteCommand
- (void)execute {
    [super execute];
    // additional implementation
}
@end

// Invoker.m
@implementation Invoker
- (void)invoke {
    [self.command execute];
}
@end
//解释器模式（Interpreter Pattern）
// Context.h
@interface Context : NSObject
@property (nonatomic, strong) NSString *input;
@property (nonatomic, strong) NSString *output;
@end

// AbstractExpression.h
@interface AbstractExpression : NSObject
- (void)interpret:(Context *)context;
@end

// TerminalExpression.h
@interface TerminalExpression : AbstractExpression
@end

// NonterminalExpression.h
@interface NonterminalExpression : AbstractExpression
@property (nonatomic, strong) AbstractExpression *expression;
@end

// Context.m
@implementation Context
- (instancetype)init {
    if (self = [super init]) {
        _input = @"";
        _output = @"";
    }
    return self;
}
@end

// AbstractExpression.m
@implementation AbstractExpression
- (void)interpret:(Context *)context {}
@end

// TerminalExpression.m
@implementation TerminalExpression
- (void)interpret:(Context *)context {
    // implementation
}
@end

// NonterminalExpression.m
@implementation NonterminalExpression
- (void)interpret:(Context *)context {
    [self.expression interpret:context];
    // additional implementation
}
@end
//迭代器模式（Iterator Pattern）
// Iterator.h
@interface Iterator : NSObject
- (id)next;
- (BOOL)hasNext;
@end

// Aggregate.h
@interface Aggregate : NSObject
- (Iterator *)createIterator;
@end

// ConcreteIterator.h
@interface ConcreteIterator : Iterator
@property (nonatomic, strong) NSMutableArray *items;
@property (nonatomic, assign) NSInteger position;
@end

// ConcreteAggregate.h
@interface ConcreteAggregate : Aggregate
@property (nonatomic, strong) NSMutableArray *items;
@end

// Iterator.m
@implementation Iterator
- (id)next {
    return nil;
}
- (BOOL)hasNext {
    return NO;
}
@end

// Aggregate.m
@implementation Aggregate
- (Iterator *)createIterator {
    return nil;
}
@end

// ConcreteIterator.m
@implementation ConcreteIterator
- (id)next {
    if ([self hasNext]) {
        id item = self.items[self.position];
        self.position++;
        return item;
    } else {
        return nil;
    }
}
- (BOOL)hasNext {
    return self.position < self.items.count;
}
@end

// ConcreteAggregate.m
@implementation ConcreteAggregate
- (instancetype)init {
    if (self = [super init]) {
        _items = [NSMutableArray array];
    }
    return self;
}
- (Iterator *)createIterator {
    ConcreteIterator *iterator = [[ConcreteIterator alloc] init];
    iterator.items = self.items;
    return iterator;
}
@end
//中介者模式（Mediator Pattern）
// Mediator.h
@interface Mediator : NSObject
- (void)send:(NSString *)message colleague:(Colleague *)colleague;
@end

// Colleague.h
@interface Colleague : NSObject
@property (nonatomic, strong) Mediator *mediator;
- (void)send:(NSString *)message;
- (void)receive:(NSString *)message;
@end

// ConcreteMediator.h