我最初是一名Java程序员，现在使用Objective-C。我想创建一个抽象类，但是在Objective-C中似乎不可能。这可能吗？

如果没有，我在Objective-C中能接近一个抽象类吗？

通常，Objective-C类仅按惯例是抽象的-如果作者将一个类记录为抽象的类，请不要在不对其进行子类化的情况下使用它。但是，没有编译时强制执行阻止抽象类的实例化。实际上，没有什么可以阻止用户通过类别（即在运行时）提供抽象方法的实现。您可以通过在抽象类的那些方法实现中引发异常来强制用户至少重写某些方法：

[NSException raise:NSInternalInconsistencyException 
            format:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)];

如果您的方法返回一个值，则使用起来会更容易一些

@throw [NSException exceptionWithName:NSInternalInconsistencyException
                               reason:[NSString stringWithFormat:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)]
                             userInfo:nil];

这样一来，您无需从方法中添加return语句。

如果抽象类确实是一个接口（即没有具体的方法实现），则使用Objective-C协议是更合适的选择。

不，没有办法在Objective-C中创建抽象类。

您可以模拟抽象类-通过使方法/选择器调用didNotRecognizeSelector：，并因此引发异常，使该类不可用。

例如：

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

您也可以针对init执行此操作。

只需参考上面的@Barry Wark的答案（并针对iOS 4.3进行更新），然后将其留给我自己参考即可：

#define mustOverride() @throw [NSException exceptionWithName:NSInvalidArgumentException reason:[NSString stringWithFormat:@"%s must be overridden in a subclass/category", __PRETTY_FUNCTION__] userInfo:nil]
#define methodNotImplemented() mustOverride()

然后您可以使用此方法

- (void) someMethod {
     mustOverride(); // or methodNotImplemented(), same thing
}

注意：不确定使宏看起来像C函数是否是一个好主意，但我会一直保留它，直到相反为止。我认为使用NSInvalidArgumentException（而不是NSInternalInconsistencyException）更正确，因为这是运行时系统响应doesNotRecognizeSelector调用而抛出的内容（请参阅NSObject文档）。

我想出的解决方案是：

1. 为您的“抽象”类中的所有内容创建协议
2. 创建实现该协议的基类（或称其为抽象类）。对于您要“抽象”在.m文件而不是.h文件中实现的所有方法。
3. 让您的子类从基类继承并实现协议。

这样，编译器将针对您的子类未实现的协议中的任何方法向您发出警告。

它不像Java中那样简洁，但是您确实得到了所需的编译器警告。

从Omni Group邮件列表：

目前，Objective-C没有像Java这样的抽象编译器构造。

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

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

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

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

与其尝试创建抽象基类，不如考虑使用协议（类似于Java接口）。这使您可以定义一组方法，然后接受所有符合协议的对象并实现这些方法。例如，我可以定义一个操作协议，然后具有如下功能：

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

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

如果您需要抽象基类做的事情不仅仅是简单地定义方法，则可以创建常规的Objective-C类并防止实例化它。只需覆盖-（id）init函数并使它返回nil或assert（false）。这不是一个很干净的解决方案，但是由于Objective-C是完全动态的，所以实际上没有直接等效于抽象基类的方法。

这个线程有点陈旧，我想分享的大部分内容已经在这里。

但是，没有提到我最喜欢的方法，并且AFAIK当前的Clang中没有本机支持，所以我在这里…

首先，也是最重要的（正如其他人已经指出的那样），抽象类在Objective-C中很少见-我们通常使用组合（有时通过委派）代替。这可能是为什么语言/编译器中不存在这样的功能的原因-除了@dynamic属性，IIRC在CoreData引入时已在ObjC 2.0中添加了IIRC。

但是，考虑到这一点（在仔细评估您的情况之后！），您得出的结论是，委派（或总体而言，委派）不适合解决您的问题，因此，我将这样做：

1. 在基类中实现每个抽象方法。
2. 实施[self doesNotRecognizeSelector:_cmd];...
3. …其次是 __builtin_unreachable();使您对非空方法所得到的警告保持沉默，告诉您“控制已到达非空函数的末尾而没有返回”。
4. 可以将第2步和第3步合并到一个宏中，也-[NSObject doesNotRecognizeSelector:]可以__attribute__((__noreturn__))在没有实现的类别中使用注释，以免替换该方法的原始实现，并将该类别的标头包括在项目的PCH中。

我个人更喜欢宏版本，因为它允许我尽可能减少样板。

这里是：

// Definition:
#define D12_ABSTRACT_METHOD {\
 [self doesNotRecognizeSelector:_cmd]; \
 __builtin_unreachable(); \
}

// Usage (assuming we were Apple, implementing the abstract base class NSString):
@implementation NSString

#pragma mark - Abstract Primitives
- (unichar)characterAtIndex:(NSUInteger)index D12_ABSTRACT_METHOD
- (NSUInteger)length D12_ABSTRACT_METHOD
- (void)getCharacters:(unichar *)buffer range:(NSRange)aRange D12_ABSTRACT_METHOD

#pragma mark - Concrete Methods
- (NSString *)substringWithRange:(NSRange)aRange
{
    if (aRange.location + aRange.length >= [self length])
        [NSException raise:NSInvalidArgumentException format:@"Range %@ exceeds the length of %@ (%lu)", NSStringFromRange(aRange), [super description], (unsigned long)[self length]];

    unichar *buffer = (unichar *)malloc(aRange.length * sizeof(unichar));
    [self getCharacters:buffer range:aRange];

    return [[[NSString alloc] initWithCharactersNoCopy:buffer length:aRange.length freeWhenDone:YES] autorelease];
}
// and so forth…

@end

如您所见，该宏提供了抽象方法的完整实现，从而将必要的样板数量减少到绝对最小。

更好的选择是游说 Clang团队通过功能请求为此情况提供编译器属性。（更好的是，因为这还将为您子类化例如NSIncrementalStore的那些方案启用编译时诊断。）

为什么选择这种方法

1. 它可以高效，方便地完成工作。
2. 这很容易理解。（好的，这__builtin_unreachable()可能会让人们感到惊讶，但也很容易理解。）
3. 在不生成其他编译器警告或错误的情况下，不能在发行版本中删除它-与基于一个断言宏之一的方法不同。

我想最后一点需要一些解释：

一些（大多数？）人在发行版本中剥离断言。（我不同意这种习惯，但这是另一个故事……）但是，未能实施所需的方法是不好的，可怕的，错误的，而且基本上是宇宙的终结程序。在这方面，您的程序无法正常运行，因为它是未定义的，并且未定义的行为是最糟糕的事情。因此，能够剥离那些诊断而不产生新的诊断将是完全不能接受的。

您无法获得针对此类程序员错误的正确编译时诊断，并不得不在运行时发现这些错误，这非常糟糕，但是如果您可以在发行版本中使用它，那么为什么尝试在第一名？

使用@property和@dynamic也可以。如果声明动态属性并且不提供匹配的方法实现，则所有内容仍将在没有警告的情况下编译，并且unrecognized selector如果尝试访问它，则会在运行时出现错误。这基本上与call相同[self doesNotRecognizeSelector:_cmd]，但是键入少得多。

在Xcode中（使用clang等），我喜欢使用__attribute__((unavailable(...)))标记抽象类，因此，如果尝试使用它，则会收到错误/警告。

它提供了一些防止意外使用该方法的保护。

例

在基类@interface标签中，“抽象”方法：

- (void)myAbstractMethod:(id)param1 __attribute__((unavailable("You should always override this")));

更进一步，我创建了一个宏：

#define UnavailableMacro(msg) __attribute__((unavailable(msg)))

这使您可以执行此操作：

- (void)myAbstractMethod:(id)param1 UnavailableMacro(@"You should always override this");

就像我说的那样，这不是真正的编译器保护，但与使用不支持抽象方法的语言一样好。

问题的答案分散在已经给出答案的评论中。因此，我只是在这里进行总结和简化。

选项1：协议

如果要创建没有实现的抽象类，请使用“协议”。继承协议的类必须实现协议中的方法。

@protocol ProtocolName
// list of methods and properties
@end

选项2：模板方法模式

如果要使用部分实现（例如“模板方法模式”）创建抽象类，那么这就是解决方案。 Objective-C-模板方法模式？

另一种选择

只需检查Abstract类中的类以及Assert或Exception，即可随心所欲。

@implementation Orange
- (instancetype)init
{
    self = [super init];
    NSAssert([self class] != [Orange class], @"This is an abstract class");
    if (self) {
    }
    return self;
}
@end

这消除了覆盖的必要 init

（更多相关建议）

我想让程序员知道“不要从孩子那里打电话”并完全覆盖（在我的情况下，当未扩展时，它仍代表父母提供一些默认功能）：

typedef void override_void;
typedef id override_id;

@implementation myBaseClass

// some limited default behavior (undesired by subclasses)
- (override_void) doSomething;
- (override_id) makeSomeObject;

// some internally required default behavior
- (void) doesSomethingImportant;

@end

这样做的好处是，程序员将在声明中看到“替代”，并且知道他们不应该调用[super ..]。

诚然，为此必须定义单独的返回类型是很丑陋的，但是它可以作为足够好的视觉提示，并且您不能轻易在子类定义中使用“ override_”部分。

当然，当扩展是可选的时，类仍然可以具有默认实现。但是就像其他答案所说的那样，在适当的时候实现一个运行时异常，就像抽象（虚拟）类一样。

最好有这样的内置编译器提示，甚至可以提示何时最好先/后调用super的工具，而不必深入研究注释/文档或...假设。

如果您习惯了编译器捕获其他语言中的抽象实例冲突，那么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

这种情况可能只发生在开发时，所以这可能起作用：

- (id)myMethodWithVar:(id)var {
   NSAssert(NO, @"You most override myMethodWithVar:");
   return nil;
}

您可以使用@Yar提出的方法（进行一些修改）：

#define mustOverride() @throw [NSException exceptionWithName:NSInvalidArgumentException reason:[NSString stringWithFormat:@"%s must be overridden in a subclass/category", __PRETTY_FUNCTION__] userInfo:nil]
#define setMustOverride() NSLog(@"%@ - method not implemented", NSStringFromClass([self class])); mustOverride()

在这里，您将收到类似以下的消息：

<Date> ProjectName[7921:1967092] <Class where method not implemented> - method not implemented
<Date> ProjectName[7921:1967092] *** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '-[<Base class (if inherited or same if not> <Method name>] must be overridden in a subclass/category'

或断言：

NSAssert(![self respondsToSelector:@selector(<MethodName>)], @"Not implemented");

在这种情况下，您将获得：

<Date> ProjectName[7926:1967491] *** Assertion failure in -[<Class Name> <Method name>], /Users/kirill/Documents/Projects/root/<ProjectName> Services/Classes/ViewControllers/YourClass:53

您也可以使用协议和其他解决方案-但这是最简单的协议之一。

可可不提供任何所谓的摘要。我们可以创建一个仅在运行时检查的类摘要，而在编译时不检查。

我通常只是在要抽象的类中禁用init方法：

- (instancetype)__unavailable init; // This is an abstract class.

每当您在该类上调用init时，这将在编译时生成错误。然后，我将类方法用于其他所有方面。

Objective-C没有内置的方法来声明抽象类。

通过应用@dotToString的注释稍微更改@redfood的建议，实际上您具有Instagram的IGListKit采用的解决方案。

1. 为没有必要在基类（抽象类）中定义的所有方法创建协议，即它们需要在子代中进行特定的实现。
2. 创建基础（抽象）类，不实现此协议。您可以在类中添加有意义的通用实现方法。
3. 在项目中的任何地方，如果AbstractClass必须通过某种方法将子项输入或输出，请AbstractClass<Protocol>改为输入。

因为AbstractClass没有实现Protocol，所以拥有AbstractClass<Protocol>实例的唯一方法是通过子类化。由于AbstractClass无法在项目的任何地方单独使用，因此它变得抽象。

当然，这不会阻止不建议使用的开发人员添加仅引用的新方法AbstractClass，最终将允许（不再有）抽象类的实例。

实际示例：IGListKit有一个IGListSectionController不实现协议的基类IGListSectionType，但是，每个需要该类实例的方法实际上都要求该类型IGListSectionController<IGListSectionType>。因此，无法将类型的对象IGListSectionController用于其框架中有用的任何东西。

实际上，Objective-C没有抽象类，但是您可以使用Protocols达到相同的效果。这是示例：

CustomProtocol.h

#import <Foundation/Foundation.h>

@protocol CustomProtocol <NSObject>
@required
- (void)methodA;
@optional
- (void)methodB;
@end

测试协议

#import <Foundation/Foundation.h>
#import "CustomProtocol.h"

@interface TestProtocol : NSObject <CustomProtocol>

@end

测试协议

#import "TestProtocol.h"

@implementation TestProtocol

- (void)methodA
{
  NSLog(@"methodA...");
}

- (void)methodB
{
  NSLog(@"methodB...");
}
@end

创建抽象类的简单示例

// Declare a protocol
@protocol AbcProtocol <NSObject>

-(void)fnOne;
-(void)fnTwo;

@optional

-(void)fnThree;

@end

// Abstract class
@interface AbstractAbc : NSObject<AbcProtocol>

@end

@implementation AbstractAbc

-(id)init{
    self = [super init];
    if (self) {
    }
    return self;
}

-(void)fnOne{
// Code
}

-(void)fnTwo{
// Code
}

@end

// Implementation class
@interface ImpAbc : AbstractAbc

@end

@implementation ImpAbc

-(id)init{
    self = [super init];
    if (self) {
    }
    return self;
}

// You may override it    
-(void)fnOne{
// Code
}
// You may override it
-(void)fnTwo{
// Code
}

-(void)fnThree{
// Code
}

@end

您不能只创建一个代表吗？

委托就像一个抽象基类，从某种意义上说，您需要定义哪些功能，但实际上并没有定义它们。

然后，无论何时实现委托（即抽象类），编译器都会警告您需要为其定义行为的可选函数和强制函数。

在我看来，这听起来像是一个抽象基类。