与其尝试创建抽象基类，不如考虑使用协议(类似于Java接口)。这允许您定义一组方法，然后接受符合协议的所有对象并实现这些方法。例如，我可以定义一个操作协议，然后有一个这样的函数:

- (void)performOperation:(id<Operation>)op
{
   // do something with operation
}

其中op可以是任何实现Operation协议的对象。

如果您需要抽象基类做的不仅仅是定义方法，那么您可以创建一个常规的Objective-C类并防止它被实例化。只需重写- (id)init函数，并使其返回nil或assert(false)。这不是一个非常干净的解决方案，但由于Objective-C是完全动态的，所以实际上没有与抽象基类直接等价的东西。

不，在Objective-C中无法创建抽象类。

你可以模拟一个抽象类——通过让methods/ selectors调用doesNotRecognizeSelector:从而引发一个异常，使该类不可用。

例如:

- (id)someMethod:(SomeObject*)blah
{
     [self doesNotRecognizeSelector:_cmd];
     return nil;
}

你也可以为init这样做。

从Omni组邮件列表:

Objective-C没有像Java那样的抽象编译器结构 这一次。

因此，您所要做的就是将抽象类定义为任何其他正常类 并为抽象方法实现方法存根 空或报告不支持选择器。例如……

- (id)someMethod:(SomeObject*)blah
{
     [self doesNotRecognizeSelector:_cmd];
     return nil;
}

我还执行以下操作来防止抽象的初始化 通过默认初始化式初始化。

- (id)init
{
     [self doesNotRecognizeSelector:_cmd];
     [self release];
     return nil;
}

Cocoa不提供任何所谓抽象的东西。我们可以创建一个只在运行时检查的类抽象，而在编译时不检查。

你不能创建一个委托吗?

委托就像一个抽象基类，你说需要定义什么函数，但实际上你不定义它们。

然后，每当你实现委托(即抽象类)时，编译器就会警告你需要为哪些可选函数和强制函数定义行为。

对我来说，这听起来像一个抽象基类。

如果你习惯了编译器在其他语言中捕捉抽象实例化的冲突，那么Objective-C的行为是令人失望的。

作为一种后期绑定语言，Objective-C显然不能对一个类是否真的是抽象的做出静态决定(你可能在运行时添加函数……)，但对于典型的用例来说，这似乎是一个缺点。我更喜欢编译器直接阻止抽象类的实例化，而不是在运行时抛出错误。

下面是我们使用的一个模式，使用一些技术来隐藏初始化式来获得这种类型的静态检查:

//
//  Base.h
#define UNAVAILABLE __attribute__((unavailable("Default initializer not available.")));

@protocol MyProtocol <NSObject>
-(void) dependentFunction;
@end

@interface Base : NSObject {
    @protected
    __weak id<MyProtocol> _protocolHelper; // Weak to prevent retain cycles!
}

- (instancetype) init UNAVAILABLE; // Prevent the user from calling this
- (void) doStuffUsingDependentFunction;
@end

//
//  Base.m
#import "Base.h"

// We know that Base has a hidden initializer method.
// Declare it here for readability.
@interface Base (Private)
- (instancetype)initFromDerived;
@end

@implementation Base
- (instancetype)initFromDerived {
    // It is unlikely that this becomes incorrect, but assert
    // just in case.
    NSAssert(![self isMemberOfClass:[Base class]],
             @"To be called only from derived classes!");
    self = [super init];
    return self;
}

- (void) doStuffUsingDependentFunction {
    [_protocolHelper dependentFunction]; // Use it
}
@end

//
//  Derived.h
#import "Base.h"

@interface Derived : Base
-(instancetype) initDerived; // We cannot use init here :(
@end

//
//  Derived.m
#import "Derived.h"

// We know that Base has a hidden initializer method.
// Declare it here.
@interface Base (Private)
- (instancetype) initFromDerived;
@end

// Privately inherit protocol
@interface Derived () <MyProtocol>
@end

@implementation Derived
-(instancetype) initDerived {
    self= [super initFromDerived];
    if (self) {
        self->_protocolHelper= self;
    }
    return self;
}

// Implement the missing function
-(void)dependentFunction {
}
@end