How to avoid "incomplete implementation" warning in partial base class

I have created a protocol that my classes need to implement, and then factored out some common functionality into a base class, so I did this:

@protocol MyProtocol
- (void) foo;
- (开发者_StackOverflow社区void) bar;
@end

@interface Base <MyProtocol>
@end

@interface Derived_1 : Base
@end

@interface Derived_2 : Base
@end

@implementation Base
- (void) foo{
//something foo
}
@end

@implementation Derived_1
- (void) bar{
//something bar 1
}
@end

@implementation Derived_2
- (void) bar{
//something bar 2
}
@end

In this way in my code I use a generic id<MyProtocol>.

The code works (as long as Base is not used directly) but the compiler chokes at the end of the implementation of Base with a warning:

Incomplete implementation of class Base

Is there a way to avoid this warning or, even better, a more proper way to obtain this partially implemented abstract base class behavior in Objc?

You could conceivably do something like this:

@implementation Base

- (void)bar
{
    if ([self class] == [Base class]) {
        [self doesNotRecognizeSelector:_cmd];
    }
}

@end

That way, you have an implementation, but by default it raises an exception. However, if a derived class accidentally calls [super bar] or does not override bar, then the exception won't be raised. If that's not what you want, you could just shorten it to:

@implementation Base

- (void)bar
{
    [self doesNotRecognizeSelector:_cmd];
}

@end

In which case, an exception will be raised, even if a subclass calls [super bar] or does not override bar.

In your protocol definition, you need to declare your methods under the @optional keyword.

Your code should look like this:

@protocol MyProtocol

@optional
- (void) foo;
- (void) bar;

@end

See this question on SO.

In Obj-C, there is no concept of abstract class. So that, you can not let your Base class to be abstract (which means dont' implements all methods in the protocol). You can only have 2 choices. Let the method in protocol to be optionol and then implements it yourself in the derived class. Or, force all classes in the hierarchy to implement it, but let the caller to be careful not call the incorrect method ones

I do something like this

@protocol MyProtocol
- (void) foo;
- (void) bar;
@end

@interface BaseAbstract
- (void) bar; // give a default implementation
@end

@interface Derived_1 : BaseAbstract<MyProtocol>
// you will get a compiler warning for foo() since it is not implemented

// you will NOT get compiler for bar() warning since a default 
// implementation is inherited
@end

@interface Derived_2 : BaseAbstract<MyProtocol>
@end

typedef BaseAbstract<MyProtocol> Base;