iOS 模拟JAVA 抽象类 抽象工厂方法

JAVA接口 和iOS 的协议 大差不差。

先定义一个协议

@protocol Quackable <NSObject>

@required

-(void)quack;

@end

然后我们定义一个抽象类！

#import "Quackable.h"

@interface AbstractDuckFactory : NSObject<Quackable>

//抽象类方法

-(id<Quackable>)createMallardDuck;

-(id<Quackable>)createRubberDuck;

@end

#import "AbstractDuckFactory.h"

#define AbMethodNotImplemented() \

@throw [NSException exceptionWithName:NSInternalInconsistencyException \

                               reason:[NSString stringWithFormat:@"please You must override %@ in a subclass.", NSStringFromSelector(_cmd)] \

                             userInfo:nil]

@implementation AbstractDuckFactory

- (instancetype)init

{

    NSAssert(![self isMemberOfClass:[self class]], @"AbstractDuckFactory is an abstract class, you should not instantiate it directly.");

    

    return [super init];

}

-(void)quack{

    AbMethodNotImplemented();

}

-(id<Quackable>)createRubberDuck{

    AbMethodNotImplemented();

    return nil;

}

-(id<Quackable>)createMallardDuck{

    AbMethodNotImplemented();

    return nil;

}

用这个抽象类的时候我们可以通过继承的方式！

#import "AbstractDuckFactory.h"

@interface DuckFactory : AbstractDuckFactory

@end

#import "DuckFactory.h"

#import "MallardDuck.h"

#import "RubberDuck.h"

@implementation DuckFactory

-(id<Quackable>)createMallardDuck{

    return [[MallardDuck alloc] init];

}

-(id<Quackable>)createRubberDuck{

    return [[RubberDuck alloc] init];

}

@end

然后是我们的MallardDuck类：

#import <Foundation/Foundation.h>

#import "Quackable.h"

@interface MallardDuck : NSObject<Quackable>

@end

#import "MallardDuck.h"

@implementation MallardDuck

-(void)quack{

    NSLog(@"qucak");

}

@end

我们这里通过抽象工厂来创建MallardDuck类 并执行quack方法。

这里初始化一个鸭子模拟器类，模拟器类通过抽象工厂方法来创建出鸭子 并且让它呱呱的叫。

#import <Foundation/Foundation.h>

#import "Quackable.h"

#import "GooseAdapter.h"

#import "AbstractDuckFactory.h"

@class MallardDuck;

@class RubberDuck;

@interface DuckSimulator : NSObject

@property(nonatomic,strong) id<Quackable> MallardDuck;

@property(nonatomic,strong) id<Quackable> RubberDuck;

@property(nonatomic,strong) id<Quackable> GooseAdapter;

-(void)simulate:(AbstractDuckFactory*)abstractDuckFactory;

@end

这是鸭子模拟器类。

#import "DuckSimulator.h"

#import "RubberDuck.h"

#import "MallardDuck.h"

#import "Goose.h"

#import "QuackCounter.h"

@implementation DuckSimulator

-(instancetype)init{

    self = [super init];

    if (self) {

    }

    return self;

}

-(void)simulate:(AbstractDuckFactory *)abstractDuckFactory{

    _MallardDuck =  [abstractDuckFactory createMallardDuck];

    _RubberDuck  =  [abstractDuckFactory createRubberDuck];

    [self simulateObj:_MallardDuck];

    [self simulateObj:_RubberDuck];

}

-(void)simulateObj:(id<Quackable>)Obj{

    [Obj quack];

}

@end

大体流程是：我们有N个鸭子(例如MallardDuck类)，鸭子的种类很多（例如真鸭子，玩具鸭子等），我们通过协议（Quackable）定义了鸭子的行为，好比叫（quack方法），好比飞或者游泳什么的，然后鸭子类实现这个协议，在具体鸭子类里实现具体的方法。

鸭子实例对象创建？

我们创建一个抽象工厂类（AbstractDuckFactory），抽象工厂类里有N个不同鸭子各种对应 的N个创建方法（

-(id<Quackable>)createMallardDuck

），然后我们实现这个抽象工厂（DuckFactory 为 AbstractDuckFactory的子类），继承。然后实现具体鸭子的实例对象。

-(id<Quackable>)createMallardDuck{

    return [[MallardDuck alloc] init];

}

我们创建一个鸭子模拟器（DuckSimulator），模拟器有一个方法接受抽象工厂实例（就是继承自抽象工厂的类）

-(void)simulate:(AbstractDuckFactory*)abstractDuckFactory;

然后在这个方法里通过工厂创建鸭子，并且执行具体鸭子的具体行为。

再UIViewController 里这么用先初始化模拟器对象。

 DuckSimulator * dsr = [[DuckSimulator alloc] init];

然后创建工厂

 DuckFactory *abdf = [[DuckFactory alloc] init];

用的时候就调用模拟器的

-(void)simulate:(AbstractDuckFactory *)abstractDuckFactory

[dsr simulate:abdf];

NSLog 如下：

2018-01-11 23:35:32.931227+0800 HeadFirst[64643:6443090] qucak

2018-01-11 23:35:32.931474+0800 HeadFirst[64643:6443090] Squeak