[UML Class relationships] Phân biệt quan hệ Generalization và Realization trong Objective C và Swift

2 quan hệ này tương đối dễ phân biệt và thực thi.

Generalization: 

giống quan hệ kế thừa trong những ngôn ngữ lập trình.

Theo sơ đồ trên thì ClassB đang kế thừa ClassA
Code ví dụ trong Objective C:

	#import <Foundation/Foundation.h>
	@interface ObjCGeneralization_ClassA : NSObject
	- (void)doAction;
	@end
	@implementation ObjCGeneralization_ClassA
	- (void)doAction {
	NSLog(@"Do action A");
	}
	@end

view raw ObjCGeneralization_ClassA hosted with ❤ by GitHub

	#import "ObjCGeneralization_ClassA.h"
	@interface ObjCGeneralization_ClassB : ObjCGeneralization_ClassA
	@end
	@implementation ObjCGeneralization_ClassB
	- (void)doAction {
	[super doAction];
	NSLog(@"Do action B");
	}
	@end

view raw ObjCGeneralization_ClassB hosted with ❤ by GitHub

Code ví dụ trong Swift:

	class SwiftGeneralization_ClassA {
	func doAction() {
	NSLog("Do action A")
	}
	}
	class SwiftGeneralization_ClassB : SwiftGeneralization_ClassA {
	override func doAction() {
	super.doAction()
	NSLog("Do action B")
	}
	}

view raw SwiftGeneralization hosted with ❤ by GitHub

Realization: 

là quan hệ thực thi 1 interface.

Theo sơ đồ trên thì ClassA thực thi những chức năng được định nghĩa sẵn trong InterfaceA.

Code ví dụ trong Objective C:

	@protocol InterfaceA <NSObject>
	- (void)doAction;
	@end

view raw InterfaceA hosted with ❤ by GitHub

	#import "InterfaceA.h"
	@interface ObjCRealization_ClassA : NSObject <InterfaceA>
	@end
	@implementation ObjCRealization_ClassA
	- (void)doAction {
	NSLog(@"Do action");
	}
	@end

view raw ObjCRealization_ClassA hosted with ❤ by GitHub

Code ví dụ trong Swift:

	protocol InterfaceA {
	func doActionA()
	/* As with type property requirements, you always prefix type method requirements with the static keyword when they are defined in a protocol. This is true even though type method requirements are prefixed with the class or static keyword when implemented by a class:*/
	static func doActionB()
	/*If you mark a protocol instance method requirement as mutating, you do not need to write the mutating keyword when writing an implementation of that method for a class. The mutating keyword is only used by structures and enumerations.*/
	mutating func doActionC()
	}
	class SwiftRealization_ClassA : InterfaceA {
	func doActionA() {
	NSLog("Do action A")
	}
	static func doActionB() {
	NSLog("Do action B")
	}
	func doActionC() {
	NSLog("Do action C")
	}
	}

view raw SwiftRealization hosted with ❤ by GitHub