برنامه‌نویسی شی‌گرا چیست؟

دید کلی از برنامه‌نویسی شی‌گرا

برنامه‌نویسی شی‌گرا (Object-Oriented Programming یا به‌اختصار OOP) یک «روش فکر کردن» و «سازمان‌دهی کد» است. در این روش، به‌جای این‌که فقط دنباله‌ای از دستورها بنویسیم، برنامه را به مجموعه‌ای از «اشیاء» (Object) تبدیل می‌کنیم؛ هر شیء چیزی را در دنیای واقعی یا در منطق برنامه نمایندگی می‌کند.

ایدهٔ اصلی:
برنامه را طوری می‌نویسیم که انگار با یک مجموعه «چیز» (مثل کاربر، کتاب، سفارش، ماشین، حساب بانکی) کار می‌کنیم، نه فقط با متغیرهای پراکنده و توابع جدا از هم.

به‌طور شهودی:

• در روش شی‌گرا می‌پرسیم:
  «در مسئلهٔ من چه چیزهایی وجود دارند و هرکدام چه ویژگی‌ها و چه کارهایی دارند؟»
• در روش سادهٔ دستوری بیشتر می‌پرسیم:
  «برای حل این مسئله، چه مراحل و دستورهایی باید پشت‌سرهم اجرا شوند؟»

هر دو روش مفیدند، ولی برنامه‌نویسی شی‌گرا مخصوصاً وقتی برنامه بزرگ‌تر و پیچیده‌تر می‌شود، به منظم و قابل‌فهم ماندن کد کمک زیادی می‌کند.

ایدهٔ «شیء» در زندگی روزمره

برای درک OOP، از یک مثال واقعی کمک می‌گیریم: «ماشین».

یک ماشین در دنیای واقعی:

• یک سری ویژگی (خاصیت) دارد:
• رنگ
• مدل
• سال ساخت
• سرعت فعلی
• یک سری کار (رفتار) انجام می‌دهد:
• روشن شدن
• خاموش شدن
• گاز دادن (افزایش سرعت)
• ترمز گرفتن (کاهش سرعت)

در برنامه‌نویسی شی‌گرا، ما کاری شبیه همین انجام می‌دهیم:
برای مفهوم «ماشین» یک «شیء نرم‌افزاری» می‌سازیم که:

• ویژگی‌هایش را در متغیرهای داخلی خودش نگه می‌دارد.
• کارهایش را به شکل تابع‌هایی که مخصوص خودش هستند انجام می‌دهد.

در نتیجه:

• به‌جای این‌که مدام چند متغیر جدا مثل car_speed، car_color، car_model و توابعی مثل increase_speed(car) این‌طرف و آن‌طرف بفرستیم،
• یک «چیز واحد» به نام car داریم که هم اطلاعاتش را در خودش نگه می‌دارد و هم می‌داند با خودش چه کار کند.

در پایتون، این «چیز واحد» همان شیء است.

چرا اصلاً شی‌گرا؟

برای یک برنامهٔ چند خطی شاید مهم نباشد، ولی وقتی برنامه رشد می‌کند، شی‌گرا بودن مزیت‌های زیادی دارد:

۱. نزدیک شدن کد به دنیای واقعی

در مسائل واقعی معمولاً با «موجودیت‌ها» سروکار داریم، نه فقط با اعداد و رشته‌ها:

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

برنامه‌نویسی شی‌گرا کمک می‌کند هرکدام از این‌ها را به‌عنوان یک «نوع شیء» تعریف کنیم و خیلی شبیه به دنیای واقعی با آن‌ها کار کنیم.

۲. سازمان‌دهی و تقسیم کد

در پروژه‌های بزرگ، ده‌ها و صدها فایل و هزاران خط کد وجود دارد. OOP کمک می‌کند:

• هر بخش مسئول یک چیز مشخص باشد.
• تکه‌های کد کمتر در هم مخلوط شوند.
• راحت‌تر بفهمیم «این بخش برنامه دقیقاً مربوط به چیست».

وقتی برای هر «چیز» یک کلاس و شیء داریم، راحت‌تر می‌توانیم بگوییم:
«اگر مشکلی در مدیریت سفارش‌ها است، باید سراغ کدی بروم که مربوط به Order است.»

۳. قابلیت استفادهٔ مجدد (Reusability)

اگر برای چیزی یک کلاس خوب طراحی کنیم، می‌توانیم در جاهای مختلف برنامه، بارها از آن استفاده کنیم.

مثال ساده:

• اگر کلاس User را یک بار طراحی کنیم،
• بعداً در صفحات مختلف (پنل کاربری، خرید، پیام‌ها) می‌توانیم از همان تعریف استفاده کنیم، بدون این‌که دوباره منطق مدیریت کاربر را از صفر بنویسیم.

این استفادهٔ مجدد، هم وقت را کم می‌کند هم خطا را.

۴. نگهداری و توسعهٔ راحت‌تر

بیشترِ وقت یک برنامه‌نویس صرف «تغییر دادن» و «بهبود دادن» برنامه‌های موجود می‌شود، نه فقط نوشتن از صفر.

برنامه‌نویسی شی‌گرا کمک می‌کند:

• وقتی لازم است چیزی تغییر کند (مثلاً نحوهٔ محاسبهٔ تخفیف یک محصول)،
• به‌جای گشتن در کل برنامه، فقط سراغ کلاسی برویم که مسئول محصول‌ها است.

این کار باعث می‌شود:

• کد راحت‌تر قابل‌تغییر باشد.
• احتمال این‌که یک تغییر، جاهای نامربوط را خراب کند کمتر شود.

۵. همکاری تیمی بهتر

در پروژه‌های گروهی، OOP کمک می‌کند:

• هر نفر مسئول چند کلاس مخصوص خودش باشد.
• مرزها و مسئولیت‌ها روشن‌تر باشد (مثلاً «تو مسئول بخش کاربرها، من مسئول سفارش‌ها»).

این باعث می‌شود:

• افراد کمتر سرِ یک کد مشترک با هم تداخل پیدا کنند.
• هماهنگ کردن کار تیمی ساده‌تر شود.

نگاه مفهومی: داده + رفتار با هم

در برنامه‌های ساده معمولاً داده و رفتار جدا هستند:

• داده‌ها (متغیرها): مثل x, y, user_name
• رفتارها (تابع‌ها): مثل calculate_area(), login_user()

در برنامه‌نویسی شی‌گرا، این دو را کنار هم می‌گذاریم:

• هر شیء:
• داده‌های خودش را دارد (مثلاً name, age برای یک کاربر)
• رفتارهای مخصوص خودش را دارد (مثلاً login(), logout())

این ترکیب «داده + رفتار» در یک واحد، باعث می‌شود:

• منطق مربوط به یک چیز، در یک جا متمرکز باشد.
• نیاز نداشته باشیم مدام داده‌های مربوط به یک چیز را این‌طرف و آن‌طرف پاس بدهیم.

نمونهٔ سادهٔ ذهنی (بدون ورود به جزئیات فنی کلاس‌ها)

فرض کنید در برنامه‌تان با «دانشجو» کار می‌کنید. در حالت شی‌گرا، شما:

• یک نوع شیء ذهنی به نام «دانشجو» در نظر می‌گیرید.
• هر دانشجو:
• ویژگی‌هایی دارد، مثل:
• نام
• شماره دانشجویی
• لیست نمرات
• رفتارهایی دارد، مثل:
• محاسبهٔ معدل
• چاپ کارنامه

به‌صورت مفهومی، شبیه این است:

دانشجو:
    ویژگی‌ها:
        نام
        شماره_دانشجویی
        نمرات
    کارها:
        محاسبه_معدل()
        چاپ_کارنامه()

فعلاً لازم نیست بدانید دقیقاً در پایتون چطور پیاده‌سازی می‌شود؛ نکتهٔ مهم این است که:

• به‌جای داشتن چند متغیر جدا برای هر دانشجو،
• یک «شیء دانشجو» داریم که همه‌چیز را دربارهٔ خودش می‌داند.

مفهوم «شیء» در پایتون

در پایتون، تقریباً همه‌چیز یک «شیء» است:

• عددها (int, float)
• رشته‌ها (str)
• لیست‌ها (list)
• دیکشنری‌ها (dict)
• توابع
• حتی خود کلاس‌ها

یعنی:

• هرکدام از این‌ها هم داده دارند، هم رفتار (متدها)؛
• مثلاً یک رشته ("salam") هم مقدار متن نگه می‌دارد، هم متدهایی مثل upper() دارد.

مثال:

text = "salam"
print(text.upper())  # SALAM

در اینجا:

• text یک شیء رشته است.
• "salam" دادهٔ درون این شیء است.
• upper() رفتاری است که این شیء بلد است انجام دهد (تبدیل به حروف بزرگ).

این یعنی شما عملاً از قبل دارید با اشیاء کار می‌کنید، حتی اگر هنوز واژه‌های «کلاس» و «OOP» را نیاموخته باشید.

مزایا و معایب در سطح ابتدایی

هیچ روشی جادویی نیست؛ OOP هم مزایا و هم محدودیت‌هایی دارد.

مزایا (در سطحی که الان نیاز داریم بدانیم)

• ساختارمند کردن برنامه
  به‌ویژه وقتی کد بزرگ می‌شود.
• خوانایی بهتر
  وقتی کد حول «چیزها» سازمان‌دهی شده باشد، فهمش برای انسان ساده‌تر است.
• کاهش تکرار کد
  با تعریف خوب کلاس‌ها و استفادهٔ مجدد از آن‌ها.
• توسعهٔ تدریجی
  می‌توانیم قدم‌به‌قدم اشیاء جدید اضافه کنیم بدون این‌که کل برنامه را از نو بنویسیم.

چالش‌ها برای مبتدیان

• ابتدا ممکن است مفاهیم «کلاس» و «شیء» کمی抽象 به‌نظر برسد.
• اگر برنامه خیلی ساده باشد (مثلاً چند خط تمرینی)، شاید استفاده از OOP کمی «سنگین» به‌نظر برسد.
• درک این‌که «چه چیزی را تبدیل به کلاس کنیم» خودش مهارتی است که با تمرین به‌دست می‌آید.

هدف این فصل این است که به‌تدریج این مفاهیم را برایتان قابل‌لمس و کاربردی کند.

مقایسهٔ شهودی: شی‌گرا در برابر غیرشی‌گرا

برای دید کلی، فرض کنید برنامه‌ای داریم برای مدیریت نمرات دانشجو.

رویکرد غیرشی‌گرا (دستوری)

• لیستی از نام‌ها
• لیستی از نمرات
• توابعی برای محاسبهٔ معدل، چاپ اطلاعات و …

کد ذهنی:

names = [...]
grades = [...]
def average(grades):
    ...
def print_report(names, grades):
    ...

باید حواسمان باشد که همیشه نام‌ها و نمرات با هم هماهنگ بمانند و توابع ورودی درست بگیرند.

رویکرد شی‌گرا

• یک «نوع» دانشجو تعریف می‌کنیم.
• هر دانشجو نام و نمرات مخصوص خودش را دارد.
• هر دانشجو خودش می‌تواند معدلش را حساب کند.

کد ذهنی:

دانشجو:
    نام
    نمرات
    محاسبه_معدل()
    چاپ_گزارش()

این رویکرد کمک می‌کند «منطق مربوط به دانشجو» در یک جا جمع شود و بقیهٔ برنامه فقط با اشیاء «دانشجو» کار کند، نه با لیست‌های پراکنده.

جایگاه OOP در مسیر یادگیری شما

تا این‌جا در دوره، شما:

• با متغیرها و انواع داده آشنا شده‌اید.
• کار با شرط‌ها، حلقه‌ها و ساختارهای داده مثل لیست و دیکشنری را دیده‌اید.
• توابع و استفادهٔ مجدد از کد را یاد گرفته‌اید.

برنامه‌نویسی شی‌گرا روی همین پایه‌ها سوار می‌شود:

• از متغیرها و انواع داده درون اشیاء استفاده می‌کنیم.
• توابع به «متد» تبدیل می‌شوند؛ یعنی توابعی که متعلق به یک شیء هستند.
• ساختارهای داده معمولی (مثل لیست و دیکشنری) می‌توانند مجموعه‌ای از اشیاء را نگه دارند.

در بخش‌های بعدی این فصل، به‌صورت گام‌به‌گام می‌بینید:

• «کلاس» چیست و چطور تعریف می‌شود.
• چطور از روی یک کلاس، شیء بسازیم.
• چطور برای اشیاء ویژگی (داده) و متد (رفتار) تعریف کنیم.
• و چطور با استفاده از این‌ها برنامه‌های منظم‌تر و قابل‌گسترش‌تری بنویسیم.

تا همین‌جا کافی است این ایدهٔ کلی در ذهن‌تان بماند:

در برنامه‌نویسی شی‌گرا، به‌جای فکر کردن فقط به «دستورها»،
به «چیزهایی که در مسئله وجود دارند» فکر می‌کنیم
و برای هرکدام، یک مدل نرم‌افزاری می‌سازیم که هم داده داشته باشد و هم رفتار.