สมมติว่าเราต้องการเขียน โปรแกรมที่ต้องการ reverse string บ่อยๆ เราอาจจะเขียน class ขึ้นมาใหม่และเขียน method ที่ชื่อว่า getReverse ขึ้นมา อาจจะเขียนได้ประมาณนี้ ได้ว่า

@interface ReverseString:NSObject
{
	NSString* m_text;
}
-(void) setString:(NSString*) text;
-(NSMutableString*) getReverse;
@end

แล้วก็เขียน code ในส่วนของ getReverse ได้ว่า

@implementation ReverseString
-(NSMutableString*) getReverse
{
	NSMutableString *temp = [[[NSMutableString alloc] init] autorelease] ;
	unichar c;
	for(int i = [m_text length]-1 ; i >= 0 ; i-- )
	{
		c = [m_text characterAtIndex:i];
		[temp appendString:[NSMutableString stringWithCharacters:&c length:1]];
	}
	return temp;
}
@end

เขียนแบบนี้ก็พอได้ แต่ว่ามันก็มีข้อเสียคือ เมื่อเราต้องการจะ reverse string เราต้องให้ตัวแปร ของเราเป็น ReverseString

	ReverseString *hello = [[ReverseString alloc] init];
	[hello setString:@Hello];
	NSMutableString *revHello = [hello getReverse];

ซึ่งมันไม่สะดวก วิธีที่ดีกว่านั้นก็อาจจะเขียนเป็น function ขึ้นมาเป็น  global ก็พอได้

แต่ถ้าหากเราอยากจะทำให้ NSMutableString มี method ที่ชื่อว่า getReverse เลยจะทำได้ไม๊ ?
คำตอบก็คือ ทำได้

Category นั้นทำให้เราสามารถที่จะเพิ่ม method ต่างๆเข้าไปยัง class ที่มีอยู่เดิมที่เราไม่สามารถจะไปแก้ไขในส่วนของ source ได้ แต่ Category ก็ไม่ได้สิทธิมากขนาดที่จะไปเพิ่ม member ใน Class ได้ เรามาลองดูการใช้ Category เลยอาจจะเข้าใจง่ายกว่า

จากตัวอย่างข้างบนนั้นถ้าหากเราต้องการจะเขียนให้  NSMutableString มี method นั้นเราก็ต้องเขียน category ขึ้นมาวิธีการ ก็สุดแสนจะง่ายดายเพียงแค่ โดยมีรูปแบบดังนี้

@interface ClassName ( CategoryName )

เอาละมาดูของจริงกันเลยดีกว่า ก่อนอื่นเราก็ประกาศ Category ที่ชื่อว่า MyExtend โดยเราจะเพิ่มเติมขยายในส่วนของ NSMutableString และเราก็เขียน method ใหม่ที่ชื่อว่า getReverse

// MyString.h
@interface NSMutableString (MyExtend)
-(NSMutableString*) getReverse;
@end

หลังจากนั้นก็เขียน ในส่วนของ source ได้แบบนี้

// MyString.m
@implementation NSMutableString (MyExtend)
-(NSMutableString*) getReverse
{
	NSMutableString *temp = [[[NSMutableString alloc] init] autorelease] ;
	unichar c;
	for(int i = [self length]-1 ; i >= 0 ; i-- )
	{
		c = [self characterAtIndex:i];
		[temp appendString:[NSMutableString stringWithCharacters:&c length:1]];
	}
	return temp;
}
@end

เพียงแค่เท่านี้ก็เสร็จเรียบร้อย หลังจากนั้นแล้ว NSMutableString ของเราก็จะมี method ใหม่ที่ชื่อว่า getReverse เรียบร้อยแล้ว

การเรียกใช้ก็ไม่ได้ยาก ดังตัวอย่าง

#import "MyString.h"
 
int main (int argc, const char * argv[]) {
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 
	NSMutableString *text = @"Hello";
 
	NSLog(@"%@",[text getReverse]);
    [pool drain];
    return 0;
}

และนอกจากนี้เรายังสามารถใช้ category เพื่อทำเป็น private method ได้ด้วย สมมติว่าเรามี Class ง่ายๆแบบนี้

//AA.h
@interface AA : NSObject
{
}
-(int) getSomeInt;
@end

และเขียน implement ง่ายๆแบบนี้

//AA.m
@implementation AA 
-(int) getSomeInt
{
    return 10;
}
@end

จะเห็นว่า AA นั้นมี getSomeInt ซึ่งเป็น public method และในกรณีที่เราอยากให้มันเป็น private เราอาจจะดัดแปลงได้โดยการใช้ category ได้แบบนี้

//AA.m
@interface AA(hidden)
-(void) getHiddenInt;
@end
 
@implementation(hidden)
-(void) getHiddenInt
{
    return 20;
}
@end
 
@implementation AA 
-(int) getSomeInt
{
    return 10;
}
@end

เป็นไงบ้างครับสำหรับการใช้ category จะเห็นว่ามันมีประโยชน์มากๆเลยสำหรับการขยายคลาส

Technorati Tags: class, objective-c, programming

หลังจากเรื่องที่แล้วได้เขียนเกี่ยวกับ Polymorphism ถ้าจะไม่พูดถึง super – self ก็คงจะไม่ครบสักเท่าไหร่

• super
  เป็น keyword ที่เอาไว้อ้างอิงถึง คลาสที่สืบทอดมา
• self
  ก็คือเป็นการอ้างอิงถึงตัวเอง

เอาละทีนี้ก็คือว่า มันมีความสำคัญอะไรกับ 2 สิ่งนี้ สำหรับ self กับ super
จริงๆแล้ว self กับ super ส่วนมากจะได้ใช้จริงๆ กับ initial ซะส่วนมาก คือหลังจากการ alloc แล้วเราต้องทำการ init ให้มัน ทีนี้มันก็เกิดปัญหาที่ว่า ถ้าที่เราเขียน class ที่เป็น child จาก parent ที่ต้องการ initial ก่อนใช้งาน แล้วจะทำอย่างไร ?

ตัวอย่าง Code ข้างล่างจะไม่มีปัญหา เพราะว่า Child นั้นไม่ต้องการเขียน method ชื่อ init ดังนั้นก็ไปใช้ของ parent ได้

#import <Objc/Object.h>
 
// ---- Children Class -----
@interface Children :Object 
{
	int m_age;
}
- (void) init:(int) age;
@end
 
 
// ---- Student Class -----
@interface Student :Children 
{
	float m_studentID;
}
@end

แบบนี้ก็อาจจะง่าย เวลาใช้งาน ก็อาจจะเขียนประมาณนี้

ChildClass* child = [[ChildClass alloc] init:12];

ก็ตอนนี้ก็เท่ากับว่า ค่า m_age นั้นมีค่าเท่ากับ 12

แต่ถ้าสมมติว่า initial ของ child ต้องการ parameter ด้วย เช่นว่า Children ก็ต้องการให้รับ age ตอน init
และ Student ก็ต้องการให้มี studentID ในตอน init ด้วยละ ดังเช่นตัวอย่าง

#import <Objc/Object.h>
 
// ---- Children Class -----
@interface Children :Object 
{
	int m_age;
}
- (void) init:(int) age;
@end
 
 
// ---- Student Class -----
@interface Student :Children 
{
	float m_studentID;
}
- (void) init:(float) studentID;
@end

เราจะเขียน code ในลักษณะแบบนี้

ChildClass* child = [[ChildClass alloc] init:12.00];

มันก็จะไปเรียก init ของ child และในตอนนี้ m_studentID ก็มีค่าเท่ากับ 12.00 แล้ว m_age ละ ? เราจะทำการ set ค่า initial สำหรับ parent class ได้อย่างไร ?
เราจะรู้ได้อย่างไรว่า parent class นั้นมี member data อะไรอยู่ในนั้นบ้าง ?
เพราะในขณะนี้เรา overriding ไปแล้ว มันก็เป็นการเรียกใช้ init ของ child โดยไม่ได้เรียก init ของ parent

เพื่อความเข้าใจ ลองมาดูตัวอย่างอีกสักอันกันดีกว่า

// Car.h
#import <Objc/Object.h>
@interface Car:Object {
int m_speed;
}
- (void) init;
- (void) setSpeed:(int)speed;
- (int) getSpeed
@end
 
@implementation Car;
- (void) setSpeed:(int) speed
{
	m_speed = speed;
}
- (void) init
{
	m_speed = 20;
}
- (int) getSpeed
{
	return m_speed;
}
@end

แล้วเราก็เขียนในส่วนของ main แบบนี้

#import "car.h"
int main()
{
	Car *honda = [[Car alloc] init];
	printf("Honda speed:", [honda getSpeed]);
	return 0;
}

ผลจากการ โปรแกรมก็จะได้ว่า

Honda speed: 20

ความจริงแล้วจาก code ข้างบนถ้าทำการ compile มันก็จะไม่แจ้ง error อะไร แต่มันจะแจ้งwarning ออกมา ว่า warning: multiple methods named ‘-init’ found แต่จริงๆแล้วก็ทำงานได้ปกติ เหตุผลทีมันแจ้งแบบนี้ก็เพราะว่า init นั้นเป็น method ของ Object นั่นเอง และเราก็ทำการ Overriding มันไปนั่นเอง ทำให้มันเห็น ว่ามี init อยู่ 2 method

โอเคทีนี้สมมติว่าเรา อาจจะให้มี init กับ initWithSpeed ละ ? ตัวแรกไม่ต้องทำอะไร ส่วนตัวที่สอง ทำการ ใส่ speed เริ่มต้นให้เลย จะเขียนได้แบบไหน เราก็ได้ความคิดว่า งั้น init ก็ไม่ต้องไป Overriding ให้มัน แล้วเราก็เขียน initWithSpeed เพิ่มขึ้นมานั่นเอง โอเค งั้นมาดูเลย

#import <Objc/Object.h>
@interface Car:Object 
{
	int m_speed;
}
- (void) initWithSpeed:(int) speed;
- (void) setSpeed:(int)speed;
- (int) getSpeed;

จะเห็นว่า เราก็แค่ เปลี่ยนจาก init ไปเป็น initWithSpeed เท่านั้นเอง งั้นส่วนของ implement นั้นก็ควรจะเป็น

- (void) initWithSpeed:(int)speed
{
	m_speed = speed;
}

แบบนี้ก็เป็นอันจบ แล้วส่วน main ก็น่าจะเขียนแบบนี้

Car *honda = [[Car alloc] initWithSpeed:20];

แต่ความเป็นจริงแล้ว มันไม่ได้ง่ายขนาดนั้น !!!!

ถ้า compile จริงๆมันจะเกิด error ขึ้น เพราะว่า  initWithSpeed นั้น return void  โอเค เราจะแก้ปัญหานี้ได้โดยการเขียน code ใน main แบบนี้

Car*honda = [Car alloc];
[honda initWithSpeed:20];

แต่ความจริงแล้ว การแก้ปัญหาแบบนี้มันไม่ค่อยถูกเท่าไหร่ เพราะว่าถ้าจะพิจารณาให้ดีแล้ว มันเหมือนกับเราเขียนว่า initWithSpeed เป็นแค่ function ที่่เรียกใช้หลักจากการสร้าง honda แล้วมากกว่า ถ้าจะสรุปง่ายก็คือว่าการเขียนแบบข้างบน ก็เหมือนกับ การเขียนแบบนี้

Car *honda = [[Car alloc] init];
[honda initWithSpeed:20];

เอาละ งั้นเราจะเขียนให้มันใช้ initWithSpeed ร่วมกับ alloc ได้ยังไง

ไม่ยากเลย  เราก็ให้ initWithSpeed ไม่ต้อง return void ให้มัน return Car ออกแทนสิ แต่จะให้มัน return ได้ยังไง นี่คือปัญหา  และ self กับ super จะได้เอามาใช้ตอนนี้เหละ งั้นก็ดูกันเลย

เราทำการเปลี่ยน ในส่วนของ interface ก่อน

โดยเราทำการเปลี่ยนให้ initWithSpeed ทำการ return id ออกมาแทน

- (id) initWithSpeed:(int) speed;

และในส่วนของ implementation นั้น จะเขียนได้แบบนี้

- (id) initWithSpeed:(int) speed;
{
	[super init];
	m_speed = speed;
	return self;
}

จะเห็นว่า เราทำการ เรียกใช้ super และ self

• [super init]
  ในส่วนนี้เป็นการบอกว่า ให้ เรียกใช้ Class แม่ (super) และทำการ เรียกใช้ init เพราะว่า จริงๆแล้ว Car นั้นสืบทอดมาจาก Object และ init นั้นก็เป็น method ที่เรียกใช้เวลา ทำการ  alloc ตัว object ก็เป็นอันว่า เราได้ทำการ init เรียบร้อยแล้ว ต่อไปก็
• m_speed = speed
  ตรงนีก็ไม่ได้มีอะไรพิเศษนอกจากทำการ ใส่ค่าให้กับตัวแปร m_speed
• return self
  ตรงนี้สำคัญเพราะเมื่อเราทำการ initตัวแม่แล้ว และเราก็ทำการ ใส่ค่าให้กับตัวแปรที่ต้องการแล้ว แน่นอนว่า การ alloc นั้น ต้องการขอจอง memory สำหรับตัวมันเอง ไม่ใช่ตัวแม่ ดังนั้นเราก็ return ตัวมันเองออกไป

และทีนี้เราก็จะเขียน main โปรแกรมได้ใหม่ว่า

#import "car.h"
int main()
{
	Car *honda = [[Car alloc] initWithSpeed:50 ];
	Car *toyota = [[Car alloc] init];
	printf("Honda speed:", [honda getSpeed]);
	printf("Honda speed:", [toyota getSpeed]);
	[honda release];
	[toyota release];
	return 0;
}

แบบนี้ก็จะไม่เกิด error หรือ warning ใดๆ เลย และถ้าไม่อยาก initWithSpeed ก็ทำได้เหมือนกัน

ผลจากการ run โปรแกรมก็จะออกมาได้ว่า

Honda speed: 50
Toyota speed: 0

ลองโหลด source ไปลองดูได้ครับ

Technorati Tags: class, objective-c, programming

Polymorphisms สรุปง่ายๆว่าเป็นการอนุญาติให้ derived class ( child class ) สามารถใช้ function ของ parent ได้ สำหรับ polymorphisms นั้นเห็นเด่นชัดมากที่สุดก็คงจะเป็น Overriding / Overloading

• Overriding
  เป็นการเขียน function ของ Child class ใช้เองโดยไม่ต้องใช้ function ของ Parent Class ถ้าจะยกตัวอย่างง่ายๆ ก็เป็นต้นว่า ถ้าเรามี class ชื่อว่า Car แล้ว Car นั้นมีฟังชั่นขื่อว่า drive สมมติว่าเราจะเขียน class ใหม่ขึ้นมาโดยสืบทอด (inherit) มาจาก Car โดยชื่อว่า Tank มีฟังชั่นชื่อว่า drive เหมือนกัน แต่ว่า class ทั้งสองนั้น Drive ทำงานไม่เหมือนกัน คือพูดง่ายๆว่า รถยนต์ก็ ขับ(drive)ได้ รถถังก็ ขับ(drive) ได้ แต่วิธีการที่จะขับไม่เหมือนกัน
• Overloading
  เป็นการเขียน Function ชื่อเหมือนกัน ใน class เดียวกัน แต่รับ parameter คนละอย่างกัน เช่นว่า เรามี class ชื่อว่า Rectangle และมี function ในการคำนวนพื้นที่ เราอาจจะต้องการให้มันรับ parameter ได้ทั้ง int และ float ในลักษณะแบบนี้เราก็จะใช้ overloading เข้ามาให้เกิดประโยชน์

อาจจะงง เล็กน้อย สรุปสั้น Overriding ก็คือ child class ที่มีการเขียน function ที่ชื่อเหมือนกับ parent ขึ้นมาเองโดยไม่ต้องสืบทอดจาก parent และ Overloading คือ method ที่สามารถรับ parameter ได้หลายๆรูปแบบ

แต่มาดู code อาจจะเข้าใจง่ายกว่า

// Car.h
#import 
@interface Car:Object {
int m_speed;
}
- (void) drive;
- (void) drive:(int)speed;
@end

และในส่วน implement

// Car.m
#import 
@implementation Car;
- (void) drive
{
printf("Car drive n");
}
- (void) drive:(int)speed
{
m_speed = speed;
printf ("Car drive at speed %d n",m_speed); }
@end

จากตัวอย่างข้างบนเป็นการ แสดงให้เห็นถึง Overloading คือ จะเห็นว่า Car นั้นมี Function ชื่อเหมือนกัน นั่นคือ drive แต่รับ parameter มาไม่เหมือนกัน โดยที่ drive แรกนั้น ไม่ได้รับ parameter มาเลย ส่วนตัวที่สอง รับ int เข้ามาและ ก็ในส่วนการทำงานของแต่ละฟังชั่นก็ต่างกัน

เวลาเรียกใช้เราอาจจะเขียนได้ว่า

#import "car.h"
int main()
{
Car *honda = [[Car alloc] init];
[honda drive];
[honda drive:80];
return 0;
}

ส่วนผลลัพธ์ที่ออกมาก็จะเป็น

Car drive
Car drive at speed 80

ทีนี้เรามาดู Overriding กันบ้าง ก็อย่างที่บอกไปแล้วว่า เราสารมารถเขียน ให้ child class ทำงานต่างจาก parent โดยที่ ขื่อเหมือนกันได้มาดู กันเลยดีกว่า

// Tank.h
#import "car.h"
@interface Tank:Car {
}
@end

ก็จะเห็นว่าใน class tank นั้นไม่มีอะไรเลย คือ inherit มาจาก car อย่างเดียว แต่เราสารมารถเขียน implement ของตัวเองโดยอิงจาก parent ได้

#import "tank.h"
@implementation Tank
- (void) drive
{
printf ("Tank Driven");
}
@end

ก็เป็นอันเสร็จ คือเรา เขียน funtion drive ขึ้นมาใหม่ แทนที่ ตัวเก่าที่มีอยู่ใน Car

และก็มาลองเรียกใช้งานกันดู

#import "car.h"
#import "tank.h
int main()
{
Car *honda = [[Car alloc] init];
Tank *tank = [[Tank alloc] init];
[honda drive];
[tank drive];
[tank drive:20];
return 0;
}

ส่วนผลลัพธ์ที่ได้ก็จะได้ว่า

Car drive
Tank drive
Car drive at speed 20

จากผลลัพธ์ก็จะเห็นว่า Tank drive ที่ออกมา โปรแกรมจะไปเรียก function ใน class Tank

ส่วนบรรทัดสุดท้าย ตัวโปรแกรมจะไปเรียกใช้ parent ของ tank นั่นก็คือ Car เพราะเนื่องจากว่า tank นั้น Overriding เพียงแค่ฟังชั่น

- (void) drive;

แต่สำหรับ

- (void) drive:(int)speed;

ไม่ได้ทำการ overriding

มันจึงไปใช้งาน parent ของมันแทน

เพิ่มเติม http://gd.tuwien.ac.at/languages/c/c++oop-pmueller/
และ http://developer.apple.com/documentation/Cocoa/Conceptual/OOP_ObjC/Introduction/chapter_1_section_1.html

Technorati Tags: advance, class, objective-c, programming

#include <stdio.h>
class Base;
void foo(Base*);
class Base
{
	public:
		Base(){};
		virtual ~Base()
		{
			foo(this);
		}
		virtual void banana() = 0;
};
 
void foo(Base* base)
{
	base->banana();
}
 
class Derived: public Base
{
	public:
		Derived(){}
		~Derived(){}
		void banana()
		{
			std::cout << "Banana";
		}
};
 
int main (int argc, char * const argv[])
{
 
	Derived* test = new Derived();
	std::cout << "Hello, World!\n";
	delete test;
	return 0;
 
}

ก็ถ้า ดูตาม code ก็จะเห็นว่า มี Base กับ Derived เนื่องจากว่า Base Class มันเป็น Pure Virtual (Abtract Class) เราต้อง implement ส่วนของ code การทำงานใน derived class เสมอไม่อาจจะเขียน implement ใน Base Class ได้ และปัญหาจากโปรแกรมข้างบนเกิดขึ้นเพราะในขณะที่ base class ได้เรียก destructor ของตัวเองนั้น มันกลับไปเรียกใช้งานฟังชั่นใน derived class ด้วย ซึ่งนั่นก็ทำให้มันเกิด error เพราะว่า derived class ได้ถูกทำลายไปก่อนแล้ว ทำให้ไม่สามารถเรียกได้

ลองดูตรง

virtual ~Base()
{
	foo(this);
}

จาก destructor นี้จะเห็นว่า มีการเรียกฟังก์ชั่น foo และแน่นอนว่า foo ไปเรียก

base->banana();

อีกที สืบเนื่องจากว่ามันเป็น pure virtual แปลว่าตัว Base Class เองไม่อาจจะเขียน implement code ได้มันจึงต้องไปเรียก banana ในตัว Derived Class ที่มีการเขียน implement code และ Derived นั้นได้ทำลายจาก destructor ไปเรียบร้อยแล้ว มันเลยไม่เจอ banana ทำให้เกิด error นั่นเอง

ลองศึกษา เพิ่มเติมเกี่ยวกับ Virtual Function ได้ที่ http://en.wikipedia.org/wiki/Virtual_function

Technorati Tags: advance, c++, class, programming

• Root class
  ความหมายของ root คือ class ที่ไม่มี parent หรือหมายความง่ายๆว่ามันไม่ได้ไปสืบทอดใคร
• Parent class
  ส่วน parent นั้นก็คือ class ที่เป็นต้นแบบของ class อื่นๆ และตัว parent เองก็อาจจะสืบทอดคนอื่น(child) มาอีกทีก็ได้
• Child class
  เป็นการเรียก class ที่สืบทอดมาจากคนอื่น

เพื่อความเข้าใจง่ายๆ ยกตัวอย่าง เรื่องของสัตว์มาประกอบ ก็แล้วกันน่ะสัตว์ทั้งหมดในโลก ขอเรียกว่า เป็น Animal ทั้งหมดเลยแล้วกัน แล้วสัตว์ต่างๆ ก็อาจจะแบ่งออกได้เป็น Mammal ( สัตว์เลี้ยงลูกด้วยนม ) และ Fish ( ปลา ) และ ถ้าในบรรดาเหล่า Mammal ก็มี Dog ซึ่งเป็นสัตว์ชนิดหนึ่งเหมือนกัน
เพื่อความเข้าใจง่ายๆ ดูภาพประกอบ

อธิบายตามภาพ

• Animal เป็น Root Class
• คลาสที่ต่อออกมาจาก animal ก็คือ mammal ( สัตว์เลี้ยงลูกด้วยนม ) ดังนั้น parent class ของ mammal ก็คือ Animal
• Fish เป็น class ที่สืบทอดมากจา animal พูดง่ายๆว่าเป็น child ของ animal และก็แน่นอนว่า Fish มี parent class คือ animal เช่นเดียวกัน
• และสุดท้าย mammal มี child class ที่ชื่อว่า dog และในทางกลับกัน dog ก็จะมี parent class เป็น Mammal

ถ้าหากเราให้คุณสมบัติของ class ต่างๆ เช่นว่า

• animal เป็นสิ่งมีชีวิตที่ต้องกินอาหาร
• mammal เลี้ยงลูกด้วยนม
• fish หายใจในน้ำได้

นั่นก็แปลได้ว่า dog นั้นเป็นสิ่งมีชีวิตที่ต้องกินอาหาร ( สืบทอดจาก animal ) และเป็นสัตว์เลี้ยงลูกด้วยนม ( สืบทอดจาก mammal ) แต่ไม่อาจจะหายใจในน้ำได้เพราะไม่ได้สืบทอดมาจาก Fish

เราลองมาเขียน class จากแผนภาพในแบบง่ายๆกัน

// animal class
@interface Animal
{
string name;
}
- (void) eat;

จาก code ข้างบน ประกาศ class ชื่อว่า animal โดยมี ตัวแปรเป็น string เอาไว้เก็บชื่อของสัตว์ตัวนี้ และสัตว์ต่างๆก็ต้องการ การกินอาหาร เลยประกาศ method ชื่อว่า eat ขึ้นมา

// Mammal.h
@interface Mammal :Animal
{
int blood_temperature;
}
- (void) feedMilk;

แล้วก็ประกาศ class ชื่อว่า mammal ขึ้นมา โดยสืบทอดมาจาก animal และก็เพิ่ม method ชื่อว่า feedMilk เข้าไป จากตรงนี้ Mammal ก็จะสามารถเรียกใช้ method ของ animal ได้ด้วย นั่นก็คือ eat นั่นเอง และส่วนตัวของ mammal เองก็มี method ของตัวเองที่ชื่อ feedMilk ด้วย

// dog.h
@interface Dog :Mammal
{
}
- (void) bite;
- (void) run;

สุดท้ายที่เราประกาศก็คือ dog โดยเพิ่ม method เข้ามาอีกสองอันนั่นก็คือ bite กับ run

สรุปได้ว่า ตอนนี้ dog นั้นสามารถ eat , feedMilk , bite , run ทำได้ทั้ง 4 อย่างเลย
จะเห็นได้ว่า inheritance นั้นมีประโยชน์มาก เพราะว่าเราสามารถ สร้าง class ใหม่ขึ้นมาได้ จาก class ที่มีอยู่แล้ว ทำให้เราลดเวลาการเขียนโปรแกรมลงได้ได้เยอะมาก และเป็นส่วนสำคัญสำหรับ การเขียนโปรแกรมในแบบ OOP ( Object Oriented Programming )

Technorati Tags: basic, class, objective-c, programming

• Data type
  ก็จำพวกว่า สามารถประกาศ int , char , array ได้ประมาณนี้ก็พอ
• Expression
  เป็นต้นว่า เข้าใจการใช้งาน if – else , neatest if-else อะไรทำนองนี้
• Function
  ใช้งานฟังชั่นในเบื้องต้นเป็น รวมทั้งความเข้าใจในการส่ง Parameter และการส่งค่ากลับของ function
• Pointer
  เข้าใจการทำงานของ pointer และการใช้งานเป็นในระดับหนึ่ง
• Basic Memory Management
  รู้และเข้าใจการจอง memory และการใช้งาน เป็นต้นว่า malloc , free , delete

คือเพราะว่า โดยภาษา Objective-C นั้น มีการใช้งาน Syntax คล้ายๆกับ ภาษา C และ java ค่อนข้างมาก สำหรับคนที่ไม่เคยเขียน โปรแกรมมาก่อน แนะนำว่า ควรไปศึกษา C/C++ มาก่อน ( ผมว่าจะเขียน เหมือนกันแต่เอาให้ obj-c เสร็จก่อนละกัน )

การเขียน Class

การเขียน class ในภาษา objc นั้นจะแบ่งออกเป็น สามส่วนหลักๆคือ

1. interface
2. implement
3. program

ในภาษา objc นั้น มีรูปแบบการประกาศแบบนี้ครับ

@interface classname: parentClassname
{
// Data member
}
function
@end

การประกาศ class นั้นจะเริ่มด้วย @interface แล้วก็ตามด้วยชื่อของ classname และสำหรับ :parentClassname นั้นก็เป็นส่วนที่บอกว่า class นี้สืบทอด (inheritance) มาจาก class ไหน ในส่วนของ data member นั้นจะประกาศภายในเครื่องหมาย { และ } ส่วน function จะทำการประกาศ ข้างนอก { } และปิดท้ายด้วย @end

เอาละมาดูตัวอย่าง class แรกของเราเลยละกัน

// book.h
@interface Book :NSObject
{
int book_id;
float price;
}
- (void) printDetail;
- (void) setPrice: ( float ) p;
- (void) setID: ( int ) id;
- (void) setPriceAndID: (float) p:(int) id;
- (float) getPrice;
@end

เราทำการสร้าง class ขึ้นมาใหม่ ชื่อว่า Book ซึ่งประกอบไปด้วย ข้อมูลสองอย่างคือ book_id และ price โดย class นี้สืบทอดมาจาก NSObject และประกอบด้วย 5 method ( function ) นั่นคือ

• - (void) printDetail ;
  สำหรับ method นี้ ได้สั่งค่ากลับเป็นแบบ void ( พูดอีกนัยได้ว่าไม่ต้องส่งค่ากลับ )
• - (void) setPrice: (float) p;
  ในส่วนของ setPrice นั้นมีการส่งค่ากลับเป็นแบบ void เหมือนกัน แต่ว่าสิ่งที่ต่างจาก printDetail คือ มีการรับ parameter เข้าไปด้วย โดยรับเข้าไปเป็น int และให้ parameter นี้ชื่อว่า p
• - (void) setID: (int) id;
  ทำงานเหมือนกับ setPrice แต่เป็นการใส่ค่าให้กับ book_id
• - (void) setPriceAndID: (float) p : (int) id;
  method นี้จะทำการรับ ค่า parameter เข้ามาสองค่า คือ float กับ int การรับค่า parameter เข้ามาหลายๆค่านั้น จะทำการ แบ่งด้วยเครื่องหมาย : (โคล่อน )
• - (float) getPrice;
  ฟังชั่นนี้จะทำการส่งค่า price กลับไปเป็นแบบ float

เพียงเท่านี้ก็เป็นการประกาศ Class แบบง่ายๆเสร็จแล้ว

อาจจะงงว่าทำไมต้อง inherit มาจาก NSObject ด้วย ก็ขออธิบายเพิ่มเติมง่ายๆว่า มันคือ Root ของ class ต่างๆในภาษา objective-c สำหรับคำว่า NS นั้น ย่อมาจาก NextStep (เป็นชื่อของบริษัทเก่าที่ Steve Job เคยตั้ง) NSObject นั้นจะมี function ที่สำคัญอันได้แก่ การจอง memory ( alloc ) ให้กับ object นั้นๆ และการ เลิกการจอง ( dealloc) พูดง่ายว่า การประกาศ class ใหม่นั้นต้องสืบทอดมาจาก class นี้

เมื่อทำการประกาศ class ไปแล้ว เรายังเหลือส่วนที่ต้องเขียน นั่นก็คือ ส่วนของ implementation งั้นมาดูกันเลย

//book.m
#import <stdio.h>
@implementation Book
-(void) printDetail {
	printf( "book id: %i , price %f", book_id, price );
}
 
-(void) setPrice: (float) p {
	price = p;
}
 
-(void) setID: (int ) id {
	book_id = id;
}
 
-(void) setPriceAndID: (float) p: (int) id {
	book_id = id;
	price = p;
}
 
-(float) getPrice{
	return price;
}
 
@end

ก็เป็นว่าเสร็จในส่วนของการ implementation แล้ว เหลือส่วนสุดท้ายนั่นก็คือ program

// main.m
#import "book.h"
int main( int argc, const char *argv[] ) {
	// create a new instance
	Book *scibook;
	scibook = [Book alloc];
	[scibook init];
	Book *mathbook = [[Book alloc] init];
	// set the values
	[mathbook setID: 1];
	[mathbook setPrice: 3];
	[scibook setPriceAndID: 2 : 5];
 
	// print it
	printf( "The Book detail: \n " );
	[mathbook printDetail];
	[scibook printDetail];
	printf( "\n" );
 
	// free memory
	[mathbook release];
	[scibook release];
	return 0;
}

Sending Message

สำหรับ ภาษา  objective-c นั้นจะทำการเรียก function หรือว่า method ว่าเป็นการส่ง message ไปให้มัน ซึ่งรูปแบบก็คือ

[receiver message];

ซึ่งถ้าเทียบกับภาษา C/C++ ก็จะได้ประมาณว่า

receiver->message();

เหมือนเราต้องการจะให้ receiver นั้นทำอะไร เราก็ต้องบอกให้มันทำให้เรานั่นเอง

ขออธิบายในส่วนของ main program กันก่อนละกัน

Book *scibook;
scibook = [Book alloc];
[scibook init];

เราเริ่มประกาศตัวแปร scibook ให้เป็น pointer ของ Book และทำการส่ง message ที่ชื่อว่า alloc ไปให้ Book เพื่อทำการจอง memory แล้วหลังจากการจองแล้ว ก็ยังไม่สามารถใช้ได้เลย ต้องทำการ initialize มันซะก่อน ด้วยการส่ง message บอกให้ init อีกที

ปล. initialize คือการให้ค่าเริ่มต้นสำหรับตัวแปรต่างๆ เพราะว่าในการจอง memory  นั้น พื้นที่ที่โดนจองอาจจะมีค่าต่างๆที่หลงเหลือจากโปรแกรม อื่นๆ เราก็ต้องปัดกวาด พื้นที่ตรงนั้นให้มันพร้อม เสียก่อน

สำหรับ บรรทัดต่อมา เป็นการรวมสองบรรทัดเข้าด้วยกันเลย ก็จะได้ว่า

Book *mathbook = [[Book alloc] init];

การทำงานเหมือน กับ scibook เลยแค่ ลดให้มันเหลือ 1 บรรทัด อาจจะมองได้ดังรูปต่อไปนี้

เมื่อเรามี object แล้วก็สามารถเรียกใช้ function โดยการส่ง message ไปให้ object เช่น

[mathbook setID: 1];

จากตัวอย่างเป็นการส่ง message ที่ชื่อว่า setID และส่ง parameter ที่มีค่าเป็น 1 ไปให้ตัวแปรที่ชื่อ mathbook ด้วย
และส่วนสุดท้าย

[mathbook release];

เป็นการส่ง message ที่ชื่อ release เพื่อคืนหน่วยความจำให้กับระบบ เราต้องทำทุกครั้งเมื่อจะจบโปรแกรม เพราะว่าไม่งั้นมันจะไม่รู้ว่าโปรแกรมของเราได้ยกเลิกการใช้งานในพื้นที่ตรงนั้นไปแล้ว

ถ้าลอง compile และ run ก็จะได้ผลลัพธ์แบบนี้ครับ

The Book detail:
book id: 1 , price 3.0000
book id: 5 , price 2.0000

ก็ลองๆ โหลด source file ไป compile ดูได้ครับ

Objective-C Programming Part I Source File

Technorati Tags: basic, class, objective-c, programming