Ho 2 classi, una include il metodo A e l'altra include il metodo B. Quindi in una nuova classe ho bisogno di sovrascrivere i metodi methodA e methodB. Allora come ottengo l'ereditarietà multipla nell'obiettivo C? Sono un po 'confuso con la sintassi.
Risposte:
Objective-C non supporta l'ereditarietà multipla e non ne hai bisogno. Usa composizione:
@interface ClassA : NSObject {
}
-(void)methodA;
@end
@interface ClassB : NSObject {
}
-(void)methodB;
@end
@interface MyClass : NSObject {
ClassA *a;
ClassB *b;
}
-(id)initWithA:(ClassA *)anA b:(ClassB *)aB;
-(void)methodA;
-(void)methodB;
@end
Ora devi solo richiamare il metodo sull'ivar pertinente. È più codice, ma semplicemente non c'è ereditarietà multipla come caratteristica del linguaggio in Object-C.
ClassA
e ClassB
? Fa chiamando methodA:
in MyClass
qualche modo chiamare automaticamente methodA:
su ClassA
?
Questo è il modo in cui codice singletonPattern come "genitore". Fondamentalmente ho usato una combinazione di protocollo e categoria.
L'unica cosa che non posso aggiungere è un nuovo "ivar", tuttavia, posso spingerlo con l'oggetto associato.
#import <Foundation/Foundation.h>
@protocol BGSuperSingleton
+(id) singleton1;
+(instancetype)singleton;
@end
@interface NSObject (singleton) <BGSuperSingleton>
@end
static NSMutableDictionary * allTheSingletons;
+(instancetype)singleton
{
return [self singleton1];
}
+(id) singleton1
{
NSString* className = NSStringFromClass([self class]);
if (!allTheSingletons)
{
allTheSingletons = NSMutableDictionary.dictionary;
}
id result = allTheSingletons[className];
//PO(result);
if (result==nil)
{
result = [[[self class] alloc]init];
allTheSingletons[className]=result;
[result additionalInitialization];
}
return result;
}
-(void) additionalInitialization
{
}
Ogni volta che voglio che una classe "erediti" questo BGSuperSingleton, faccio semplicemente:
#import "NSObject+singleton.h"
e aggiungi @interface MyNewClass () <BGSuperSingleton>
Conosci i protocolli, i protocolli sono il modo per implementare l'ereditarietà multipla
JAVA
, Interfaces
non devono fornire o imitare l'ereditarietà multipla.