IOS4 note 11 (2)

Private Method Declarations

 

A problem arises when you’d like to declare a method in such a way that all other methods in the same class can see the declaration (and can thus call the method) without putting that declaration in the class’s interface section where every other class that imports the header file will also be able to see and call it.

 

The  solution  is  to put  an  interface  section  for  a  category on  your own  class  in  the implementation file, which no one imports (Example 10-1).

Example 10-1. Declaring a method privately

// [in MyClass.m]

#import "MyClass.h"

@interface MyClass (Tricky)

- (void) myMethod;

@end

 

@implementation MyClass

// all methods here can call myMethod

@end

 

This  trick  cannot  completely  prevent  some  other  class  from  calling  this  class’s myMethod — Objective-C  is too dynamic for that — but at  least a normal call to myMethod from some other class will get its hand slapped by the compiler.

In Example 10-1, the compiler will not warn if the methods declared in the category interface section (such as myMethod) are not defined in the implementation section. If this worries you, there are two solutions. One is to provide a named category implementation section, corresponding to the named category interface section; if you fail to implement the category-declared methods in this category implementation section, the compiler will warn:

@implementation MyClass (Tricky)

// must implement myMethod here, or compiler will warn

@end

 

The other approach is just the opposite, namely to remove the category name altogether from the category implementation section; if you then fail to implement the categorydeclared methods in the normal implementation section, the compiler will warn:

@interface MyClass ()

- (void) myMethod;

@end

This nameless type of category is called a class extension.

 

 

 

Protocols

A protocol is just a named list of method declarations, with no implementation. A class may formally declare that it conforms to (or adopts) a protocol; such conformance is inherited by subclasses. This declaration satisfies the compiler when you try to send a corresponding message.

A protocol method may be required or optional.

A protocol is just a named list of method declarations, with no implementation. A class may formally declare that it conforms to (or adopts) a protocol; such conformance is inherited by subclasses.

Here’s how the NSCopying protocol is defined (in NSObject.h, where your code can see it):

@protocol NSCopying

- (id)copyWithZone:(NSZone *)zone;

@end

That’s all there is to defining a protocol. The definition uses the @protocol compiler directive; it states the name of the protocol; it consists entirely of method declarations; and it is terminated by the @end compiler directive. A protocol definition will typically appear in a header file, so that classes that need to know about it (in order to call its methods) can  import  it. A @protocol section of a header  file  is not  inside any other section (such as an @interface section).

 

  Conform formally to the NSCopying protocol

@interface MyClass : NSObject <NSCopying>

Example of how Cocoa uses protocols

@property (nonatomic, assign) id<UITableViewDataSource> dataSource

 

 

Checking if object responds to some method, you can call respondsToSelector: but  it slows things down a  little.