شیء گرایی چیه Object Oriented Programming

برنامه نویسی شیء گرا یا OOP چیه؟ Object Oriented Programming

توی مصاحه از OOP و خصوصیاتش سوال زیاد میشه. از طرفی لازمه که یه برنامه نویس این رو بدونه. میشه گفت:

به ترکیت دیتا و توابع با هم میگیم OOP. این تعریف خیلی ناقصه. از طرفی به زبان ساده تر میشه گفت “یک روش برنامه نویسی که بشه باهاش دنیای واقعی رو مدل کرد” این هم باز کلیه و اگه بخایم بیشتر توضیح بدیم:

سه تا تکنیک توی برنامه نویسی وجود داره:

Encapsulation یا کپسوله کردن یا بسته بندی کردن

Inheritance یا ازثبری

Polymorphism یا چند شکلی

این 3 تکنیک برنامه نویسی رو اگر در برنامه های خودمون رعایت کنیم، میگیم داریم با تکنیک OOP کد میزنیم. و توی زبانهای OOP مثل Java C# Python و … این تکنیک ها رعایت میشه بخاطر همین بهشون میگیم زبانهای شیء گرا (البته پایتون مجبورتون نمیکنه صد درصد OOP کد بزنید).

آیا این تکنیک ها با پیدایش زبان های OO اومدن؟ خیر خیلی از برنامه نویسان C از قدیم از این تکنیک ها استفاده میکردند اما مجبور نبودند با این تکنیک کد بزنن و چون اینا تکنیک های خوبی بودن بعدا با زبان C++ رسمی شد و بمرور در زبان های مختلف تکامل پیدا کرد و استفاده ازشون آسون تر و بهینه تر شد و حتی اجباری شد.

Encapsulation

فرض کنید که بشه دور دسته ای از داده ها و توابع یک خط کشید و از بیرون این خط به این داده ها نشه دسترسی داشت و فقط خود اون توابع بتونن این داده ها رو تغییر بدن. در واقع داده ها و توابع private باشن و فقط به روش هایی استاندارد بشه بهشون به صورت غیر مستقیم یا بعضی از اونا مستقیم دسترسی داشت. این کار با مفهوم class انجام میشه و به این تکنیک میگن Encapsulation یا کپسوله کردن.

Inheritance

ارثبری ساده است. فرض کنید بخشی از توابع یا داده های یک کلاس رو دوباره از اول تعریف کنیم و بقیه بخش ها رو بدون تغییر کپی کنیم و استفاده کنیم به این میگن ارثبری.

class Animal:
    def __init__(self, feets=-1):
        self.number_of_feet = feets
    
    def move(self):
        print("walking...")
    
    def make_sound(self):
        print("talking...")
        

class Duck(Animal):
    def __init__(self):
        super().__init__(2)
        
    
    def move(self):
        print("swimming...")
    
    def make_sound(self):
        print("quak quak quak")
        
        
class Lion(Animal):
    def __init__(self):
        super().__init__(4)
        
    def move(self):
        print("Running...")
        
    def make_sound(self):
        print("Roarrrr...")

class Animal:

def __init__(self, feets=-1):

self.number_of_feet = feets

def move(self):

print("walking...")

def make_sound(self):

print("talking...")

class Duck(Animal):

def __init__(self):

super().__init__(2)

def move(self):

print("swimming...")

def make_sound(self):

print("quak quak quak")

class Lion(Animal):

def __init__(self):

super().__init__(4)

def move(self):

print("Running...")

def make_sound(self):

print("Roarrrr...")

مثال بالا خیلی خوب ارثبری رو نشون میده. یک کلاس Animal داریم. طبیعتا همه حیوانات یه سری خصوصیات مشترک دارن مثلا پا دارن حرکت میکنن و صدا دارن. دو کلاس Duck و Lion از Animal ارث بردن چون اینها هم حیوان هستن و این خصوصیات رو دارن و اونا رو به ارث بردن اما این خصوصیات مشترکشون کمی فرق داره اردک شنا میکنه و شیر میدوه، صدای هر حیوان هم فرق داره پس همینطور که میبینید این خصوصیات دوباره تعریف شدن با این که به ارث هم بردن.

Polymorphism

برای توضیح چندشکلی یه مثال واقعی میزنیم. میدونیم توی UNIX برای خوندن و نوشتن داده device های مختلفی وجود داره که به دیوایس های ورودی میگیم STDIN و به دیوایس های خروجی میگیم STDOUT. دیوایس خروجی مثل صفحه مانتور و اسپیکر و دیوایس ورودی مثل کیبورد و ماوس. حالا یه تابع نوشتیم با اسم کپی که از یه دیوایس ورودی میخونه و کپی میکنه تو دیوایس خروجی

#include <stdio.h>

void copy(){
	int c;
	while((c=getchar()) != EOF){
		putchar();
	}
}

#include <stdio.h>

void copy(){

int c;

while((c=getchar()) != EOF){

putchar();

}

ولی توی این کد ما مشخص نکردیم کدوم دیوایس ورودی و خروجی. UNIX این مشکل رو حل کرده میگه شما هر دیوایس که میسازی و می نویسی توی دایورش باید 5 تا تابع تغریف کنی که برنامه های مختلف بتونن باهاش کار کنن. این توابع open close read write seek هستن. یعنی همه دیوایس ها توی درایورشون این توابع رو دارن. و باید تعریف اونا رو هم بنویسید مثلا چجوری بخونی و بنویسی توش چه جوری باز کنی و ببندیش بنابراین مثلا یک فایل باید این توابع رو اینجوری تعریف کنن براش:

struct FILE {
	void (*open)(char* name, int mode);
	void (*close)();
	void (*read)();
	void (*write)(char);
	void (*seek)(long index, int mode);
}

struct FILE {

void (*open)(char* name, int mode);

void (*close)();

void (*read)();

void (*write)(char);

void (*seek)(long index, int mode);

}

و توی اون درایور باید همین توابع رو تعریف کنه و اون رو لود کنه چیزی مثل زیر (یعنی در واقع قابل استفاده اش کنه)

#include "file.h"

void open(char* name, int mode) {/*.....*/}
void close() {/*.....*/}
void read() {int c; /*.....*/ return c;}
void write(char c) {/*.....*/}
void seek(long index, int mode) {/*.....*/}

#include "file.h"

void open(char* name, int mode) {/*.....*/}

void close() {/*.....*/}

void read() {int c; /*.....*/ return c;}

void write(char c) {/*.....*/}

void seek(long index, int mode) {/*.....*/}

حالا اون تابع copy میتونه ازش استفاده کنه اگر تابع getchar اینجوری تعریف شده باشه

extern struct FILE* STDIN;

int getchar() {
	return STDIN->read();
}

extern struct FILE* STDIN;

int getchar() {

return STDIN->read();

}

ببینید اینجوری تابع copy نیاز به تغییر نداره فقط getchar رو صدا میزنه و این getchar هم همون تابع read رو صدا میزنه که توی درایور هست.

بنابراین polymorhpism این قابلیت رو به برنامه ها میده که مثل پلاگین عمل کنن. یعنی اگر صد تا دیوایس اضافه بشه با صد تا درایور دیگه نیازی به تغییر copy نیست چون بهرحال اون درایور تابع read داره.

plymophism اینه یعنی این تابع copy صد شکل از دیوایس رو پوشش میده پس بهش میگیم تکنیک چند شکلی.

قدرت polymorphism در همینه که بخش های برنامه از هم جدا میشن و میتونی هر کدوم رو جدا توسعه بدی و تکامل بدی بخش های محتلف برنامه مثل پلاگین با هم کار میکنن توسعه هرکدام مستقل ادامه پیدا میکنه.

دیدگاهتان را بنویسید لغو پاسخ