你可以用积木?

@implementation MyClass

id (^createTheObject)() = ^(){ return [[NSObject alloc] init];};

NSInteger (^addEm)(NSInteger, NSInteger) =
^(NSInteger a, NSInteger b)
{
    return a + b;
};

//public methods, etc.

- (NSObject) thePublicOne
{
    return createTheObject();
}

@end

我知道这是一个古老的问题，但这是我在寻找这个问题答案时最先发现的问题之一。我还没有在其他地方看到过这个解决方案，所以如果这样做有什么愚蠢的地方，请告诉我。

您可以尝试在实现的下面或上面定义一个静态函数，该函数接受指向实例的指针。它将能够访问您的任何实例变量。

//.h file
@interface MyClass : Object
{
    int test;
}
- (void) someMethod: anArg;

@end


//.m file    
@implementation MyClass

static void somePrivateMethod (MyClass *myClass, id anArg)
{
    fprintf (stderr, "MyClass (%d) was passed %p", myClass->test, anArg);
}


- (void) someMethod: (id) anArg
{
    somePrivateMethod (self, anArg);
}

@end

在@implementation块中定义私有方法对于大多数目的来说是理想的。不管声明顺序如何，Clang将在@implementation中看到这些。不需要在类延续(又名类扩展)或命名类别中声明它们。

在某些情况下，你需要在类延续中声明方法(例如，如果在类延续和@implementation之间使用选择器)。

静态函数对于特别敏感或速度关键的私有方法非常有用。

命名前缀的约定可以帮助您避免意外重写私有方法(我发现类名作为前缀是安全的)。

命名类别(例如@interface MONObject (PrivateStuff))不是一个特别好的主意，因为在加载时可能会发生命名冲突。它们实际上只对朋友或受保护的方法有用(这很少是一个好的选择)。为了确保你被警告不完整的类别实现，你应该实际实现它:

@implementation MONObject (PrivateStuff)
...HERE...
@end

这里有一个带注释的小抄:

MONObject.h

@interface MONObject : NSObject

// public declaration required for clients' visibility/use.
@property (nonatomic, assign, readwrite) bool publicBool;

// public declaration required for clients' visibility/use.
- (void)publicMethod;

@end

MONObject.m

@interface MONObject ()
@property (nonatomic, assign, readwrite) bool privateBool;

// you can use a convention where the class name prefix is reserved
// for private methods this can reduce accidental overriding:
- (void)MONObject_privateMethod;

@end

// The potentially good thing about functions is that they are truly
// inaccessible; They may not be overridden, accidentally used,
// looked up via the objc runtime, and will often be eliminated from
// backtraces. Unlike methods, they can also be inlined. If unused
// (e.g. diagnostic omitted in release) or every use is inlined,
// they may be removed from the binary:
static void PrivateMethod(MONObject * pObject) {
    pObject.privateBool = true;
}

@implementation MONObject
{
    bool anIvar;
}

static void AnotherPrivateMethod(MONObject * pObject) {
    if (0 == pObject) {
        assert(0 && "invalid parameter");
        return;
    }

    // if declared in the @implementation scope, you *could* access the
    // private ivars directly (although you should rarely do this):
    pObject->anIvar = true;
}

- (void)publicMethod
{
    // declared below -- but clang can see its declaration in this
    // translation:
    [self privateMethod];
}

// no declaration required.
- (void)privateMethod
{
}

- (void)MONObject_privateMethod
{
}

@end

另一种可能不太明显的方法是:c++类型既可以非常快，又可以提供更高程度的控制，同时最大限度地减少导出和加载objc方法的数量。

如果你想避免顶部的@interface块，你可以总是把私有声明放在另一个文件myclasprivate .h中，这并不理想，但它不会使实现混乱。

MyClass.h

interface MyClass : NSObject {
 @private
  BOOL publicIvar_;
  BOOL privateIvar_;
}

@property (nonatomic, assign) BOOL publicIvar;
//any other public methods. etc
@end

MyClassPrivate.h

@interface MyClass ()

@property (nonatomic, assign) BOOL privateIvar;
//any other private methods etc.
@end

MyClass.m

#import "MyClass.h"
#import "MyClassPrivate.h"
@implementation MyClass

@synthesize privateIvar = privateIvar_;
@synthesize publicIvar = publicIvar_;

@end

正如其他人所说，在@implementation块中定义私有方法对于大多数目的来说是可以的。

关于代码组织的话题——我喜欢把它们放在pragma mark private下，以便在Xcode中更容易导航

@implementation MyClass 
// .. public methods

# pragma mark private 
// ...

@end

Objective C中的每个对象都遵循NSObject协议，该协议保留了performSelector:方法。我以前也在寻找一种方法来创建一些“辅助或私有”方法，我不需要在公共级别上公开这些方法。如果你想创建一个没有开销的私有方法，并且不需要在头文件中定义它，那么就试试这个…

用与下面代码相似的签名定义your方法…

-(void)myHelperMethod: (id) sender{
     // code here...
}

然后，当你需要引用该方法时，只需将其作为选择器调用…

[self performSelector:@selector(myHelperMethod:)];

这行代码将调用您创建的方法，并且不会出现关于头文件中没有定义该方法的恼人警告。