Python Tutorial - Learn Programming

OOP ကို မပြောခင် အရင်က Program တွေ

Ok bro... OOP ကို မပြောခင်၊ အရင်က program တွေ ဘယ်လို ရေးကြလဲ စဉ်းစားကြည့်။

အရင် style (သူ့ကို Procedural Programming လို့ခေါ်တယ်) က ဘယ်လိုလဲဆိုတော့၊ ကိုယ် လုပ်ချင်တာတွေကို step-by-step ချရေးတာ။ Function တွေ အများကြီး တစ်နေရာမှာ စုရေး၊ ပြီးတော့ data (variable) တွေ အများကြီး တစ်နေရာမှာ စုထား။ အကုန်လုံးက Global ဖြစ်နေတာ။

ပြဿနာက ဘာလဲ? Program က နည်းနည်းလေး ကြီးလာတာနဲ့... ရှုပ်ပွ သွားတာပဲ။
ဘယ် function က ဘယ် data ကို သုံးနေမှန်း မသိတော့ဘူး။
တစ်ခုခု ပြင်ချင်ရင်၊ ဟိုနားလိုက်ပြင်၊ ဒီနားလိုက်ပြင်... ကုဒ်တွေ ပတ်ချာလည် (spaghetti code) တွေ ဖြစ်ကုန်ရော။

အဲ့ဒီမှာ OOP က ဝင်လာတာ

OOP (Object-Oriented Programming) က ဘာပြောလဲဆိုတော့...

ဟေ့ bro၊ အဲ့လိုတွေ မရှုပ်နဲ့။ အသုပ်မသုပ် နဲ့။ ဆိုင်ရာ ဆိုင်ရာ data နဲ့ အဲ့ data ကို ကလိ မယ့် function တွေကို တစ်နေရာတည်းမှာ စုလိုက်။

အဲ့လို data ရော၊ function ရော ပေါင်းပြီး စုထားတဲ့ အထုပ် (bundle) လေးကို Object လို့ခေါ်တယ်။

အဓိက Idea နှစ်ခု: Class နဲ့ Object

1. Class (ပုံစံခွက်)

ဒါက ပုံစံ ဒီဇိုင်းပဲ။
ဥပမာ၊ ကား (Car) ဆိုတဲ့ ပုံစံခွက် တစ်ခု ဆောက်လိုက်တယ်။
အဲ့ဒီ ပုံစံခွက်ထဲ ကား တစ်စီးမှာ ဘာတွေ ရှိရမလဲ (Data/Attributes) နဲ့၊ သူက ဘာတွေ လုပ်နိုင်ရမလဲ(Functions/Methods) ဆိုတာတွေ ကြိုရေးထားတာ။

                Class Attributes နဲ့ Methods
            
# Data (Attributes):
color, brand, model, current_speed
(အရောင်၊ တံဆိပ်၊ မော်ဒယ်၊ လက်ရှိအမြန်နှုန်း)

# Functions (Methods):
start(), stop(), accelerate(), brake()
(စက်နှိုး၊ စက်ရပ်၊ လီဗာတင်၊ ဘရိတ်အုပ်)

2. Object (အစစ်အမှန်)

ဒါက အဲ့ဒီ ပုံစံခွက် (Class) ကနေ တကယ် ပုံတူ ထုတ်လိုက်တဲ့ အရာ အစစ်။
Class က Car ဆိုရင်...

                Creating Objects
            
# Object တစ်ခု
my_toyota = Car()  (ကျနော့် Toyota ကား)

# နောက်ထပ် Object တစ်ခု
bros_honda = Car()  (bro ရဲ့ Honda ကား)

ကား ပုံစံခွက် (Car class) က တစ်ခုတည်း၊ ဒါပေမယ့် အဲ့ကနေ ထုတ်လိုက်တဲ့ ကား အစစ် (Object) တွေက အများကြီး ဖြစ်လို့ရတယ်။ my_toyota ရဲ့ color က အနီ၊ bros_honda ရဲ့ color က အမည်း ဖြစ်လို့ရတယ်။ တစ်စီးနဲ့ တစ်စီး မရောဘူး။

Concept: Class က ကား ဆိုတဲ့ idea (မဟုတ်ရင် ကားစက်ရုံက ပုံစံခွက်)။ Object က လမ်းပေါ်မှာ မောင်းနေတဲ့ ကား အစစ် တစ်စီး။

ဘာလို့ သုံးရမှာလဲ?

Ok, ဘာလဲ ဆိုတာ သိပြီ။ ဘာလို့ သုံးမှာလဲ။

1. ရှင်းတယ်၊ စနစ်တကျ ဖြစ်သွားတယ် (Organized)

ကုဒ်တွေ ရှုပ်မနေတော့ဘူး။ ကား နဲ့ ပတ်သက်တဲ့ data ရော၊ function ရော အကုန် Car class ထဲမှာပဲ စုထားတယ်။ လူ (User) နဲ့ ပတ်သက်တာ User class ထဲမှာပဲ။ ကိုယ့်ဟာနဲ့ ကိုယ် အကန့် (module) လေးတွေ ဖြစ်သွားတယ်။ ရှာရ လွယ်တယ်၊ ပြင်ရ လွယ်တယ်။

2. တစ်ခါတည်းနဲ့ ပြီးတယ် (Reusability)

Car class ကို တစ်ခါပဲ ပင်ပန်းခံ ရေးလိုက်။ ပြီးရင်... ကား အစီး ၁၀၀၀ လိုချင်လား? Object အခု ၁၀၀၀ တန်း ဆောက် (create) လိုက်။ code တွေ ထပ်ခါထပ်ခါ ပြန်ရေးနေစရာ မလိုတော့ဘူး။

ဒါပဲမဟုတ်သေးဘူး... Inheritance (အမွေဆက်ခံခြင်း) ဆိုတာ ရှိသေးတယ်။ Car class ကို အမွေယူပြီး SportsCar class ဆောက်လို့ရတယ်။ SportsCar မှာ Car ရဲ့ start(), stop() တွေ အကုန် ပါလာမယ်။ ကိုယ်က turbo() ဆိုတဲ့ function အသစ်လေးပဲ ပိုထည့်လိုက်ရုံပဲ။

3. ဖွက်ထားလို့ရတယ် (Encapsulation)

ကျနော်တို့ ကားမောင်းရင် လီဗာ (accelerator) ကို နင်းလိုက်တာပဲ သိတယ်။ အထဲက ပစ္စတင် (piston) ဘယ်လိုရွေ့လဲ၊ ဆီ ဘယ်လို ပန်းလဲ... သိစရာမလိုဘူး။

OOP မှာလည်း အဲ့လိုပဲ။ Object ကို my_car.accelerate() လို့ ခေါ်လိုက်တာနဲ့ သူဟာသူ အလုပ်လုပ်သွားမယ်။ အထဲက အတွင်းစနစ် (internal details) တွေကို လိုက်သိနေစရာ၊ လိုက်ပြင်နေစရာ မလိုဘူး။ ဒါကို Encapsulation (ဖုံးကွယ်ထားခြင်း) လို့ခေါ်တယ်။ ဒါကြောင့် ကိုယ့် code ကို တခြားသူက မတော်တဆ လာ ကလိ လို့ ပျက်သွားမှာ ပူစရာမလိုတော့ဘူး။

4. ပြင်ရ လွယ်တယ် (Maintainability)

Project ကြီးလာတဲ့အခါ... ကား ဘရိတ်အုပ်တဲ့ ပုံစံကို ပြင်ချင်တယ် ဆိုပါစို့။

အရင် style (Procedural) မှာ: code တွေ အများကြီးထဲမှာ ဘယ်နားက ဘရိတ်အုပ်တဲ့ function လဲ လိုက်ရှာရမယ်။ နေရာအနှံ့မှာ ပတ်သက်နေတာတွေ လိုက်ပြင်ရမယ်။
OOP မှာ: Car class ထဲက brake() method တစ်ခုတည်းကိုပဲ ဝင်ပြင်လိုက်။ ပြီးပြီ။ ကျန်တဲ့ ဘယ်နေရာကိုမှ သွားမထိဘူး။

အနှစ်ချုပ်

တကယ်တော့ OOP ဆိုတာ code တွေကို စနစ်တကျ နဲ့ ရှုပ်မသွားအောင် ရေးတဲ့ vibe တစ်ခုပါပဲ။

Program သေးသေးလေးတွေ ရေးရင်တော့ OOP က အပို လို့ ထင်ရတယ်။ ဒါပေမယ့် bro တို့ project တွေ ကြီးလာလေ... (ဥပမာ ဂိမ်းတွေ၊ app ကြီးတွေ) OOP မသုံးရင် အီးနယ် နိုင်လေလေပဲ။

Common: ပထမတော့ နည်းနည်း အာရုံနောက်တယ် လို့ ထင်ရပေမယ့်၊ သဘောပေါက်သွားရင်... OOP က နတ်ဘုရား ဖြစ်လာလိမ့်မယ် ဘရို။