22/05/2026
Gentle Introduction to Object Oriented Programming Part 1
ခုလောလောဆယ် Industry မှာ အသုံးအများဆုံး programming language paradigm အရဆိုရင်တော့ Object Oriented Programming က popular အဖြစ်ဆုံးလို.ပြောရမှာပါ။ အသုံးများတဲ့ OO Language တွေကတော့ Java, C #, JavaScript, PHP, Ruby , Python တို.ပါပဲ၊ Language တခုကိုလေ့လာတဲ့အခါမှာ element ၃ ခုကိုလေ့လာရပါတယ်။ Syntax, Semantic နဲ. Pragmatic တို.ဖြစ်ပါတယ်။ Syntax ကတော့ရှင်းပါတယ် language basic component တွေကို ဘယ်လိုရေးရတာလဲဆိုတဲ့ Grammar ပါ။ ဥပမာ for loop ပတ်ရင်ဘယ်လိုရေးရသလဲပေါ့။ Semantic ကတော့ for loop ရေးထားရင် for loop ကဘယ်လိုအလုပ်လုပ်မလဲဆိုတဲ့ တိကျတဲ့အဓိပ္ပာယ်ကို ဆိုချင်တာပါ။
ဥပမာ for initialization ရှိရင် run မယ်။နောက် for conditional ရှိရင်စစ်မယ် result က true ဆိုရင် for body ကို execute မယ်။ ပြီးရင် for increment ရှိခဲ့ရင် သူ.ကို run မယ် နောက် loop အစကိုပြန်တက်မယ် condition ပြန်စစ်မယ် ပေါ့။ ဒါတွေကို semantic လို.ခေါ်ရမှာပါ။ Programming သင်တယ်လို.ပြောလိုက်ရင် syntax ကိုပဲသင်ကြတာကို တွေ.ရပါတယ်။ language 2 ခုက syntax အရ ဆင်နိုင်ပါတယ် ဒါပေမဲ့ semantic အရ မတူနိုင်ပါဘူး ဥပမာ for loop ဆိုပါစို. C,C++,Java,C #,JavaScript တို.မှာ syntax အရသိပ်မကွာပါဘူး ဒါပေမဲ့ semantic အရ မတူနိုင်ပါဘူး။ ဥပမာ C/C++/JavaScript မှာ conditinal part ဟာ boolean မဟုတ်တဲ့ integer တခုခု (JS မှာဆို Object type ပါဖြစ်နိုင်ပါတယ်) ဖြစ်ခွင့်ရှိပေမဲ့ Java,C # မှာဆိုရင် boolean type ကိုဖြစ်ရမှာပါ။ နောက်တခုက for initialization မှာ variable ကြေငြာ ခဲ့ရင် C,C++,Java,C # မှာဆိုရင် for loop အတွင်းမှာပဲ variable scope ကရှိပေမဲ့ JavaScript မှာဆို the whole function တခုလုံးလို.ပြောရမှာပါ။ ဒါဟာ semantic အရ မတူကြောင်းကိုပြောတာပါ။
နောက်တခုက Pragmatic ပါ။ သူကတော့ language တခုရဲ. construct တွေကို လက်တွေ.ကျကျဘယ်လိုသုံးရမလဲဆိုတာပါ။ Programming language တခုကပေးထားတဲ့ feature တွေ language construct တွေကို သင့်တော်မှန်ကန်စွာ အသုံးချနိုင်မှု.ပါ။ ဘာကိုဆိုချင်သလဲဆိုတော့ OO paradigm ကို support ပေးတဲ့ language မှာ OO program တွေကို ဘယ်လိုရေးရသလဲ ။ ဥပမာ ဘယ်အချိန်မှာ inheritance ကိုသုံးလဲ ရိုးရိုး class ကိုသုံးရမှာလား abstract class ကိုသုံးရမှာလား abstract class နဲ. interface usage ဘယ်လိုကွာလဲ ဘယ်နေရာဘယ်သူ.ကိုသုံးရမှာ correct usage က ဘာတွေလဲ ဒါတွေကို ဆိုချင်တာပါ။ Pragmatic ကိုအဆင့်ထပ်မြှင့်ရင်တော့ design pattern တွေ ,principle တွေ ပါ ပါလာမှာပါ။ Programmer တယောက်အနေနဲ. Language construct တွေ paradigm နဲ.ပတ်သတ်တဲ့ concept တွေကိုသိဖို.လိုပါတယ်။ Java နဲ.ရေးနေပေမဲ့ C မှာရေးသလို function တွေနဲ.ပတ်လည်ရေးနေတယ်ဆိုရင် မဟုတ်တော့ပါဘူး။
Evolution to OOP
Modern high level Programming language တွေမပေါ်ခင်က machine language သို.မဟုတ် assembly language ကိုသုံးရပါတယ်။ Assembly ကိုသုံးရတာဟာ machine language ကို symbolic code အစားထိုးသုံးရတာနဲ.ဘာမှမကွာပါဘူး။ သိပ်မဟန်ပါဘူး ။ဒါကြောင့် high level language တွေထုတ်ပါတယ်။ အစောပိုင်းက data structure နဲ. algorithm တွေရေးလို.အဆင်ပြေအောင် ထုတ်ထားတဲ့ Procedural Language(Fortan, Algo, C) တွေပေါ်လာပါတယ်။ Procedural language တွေရဲ.အဓိက concept ကတော့ fuction တွေခွဲရေးမယ် ။ function တွေကို reusable ဖြစ်အောင်လုပ်မယ်။ ဒီလိုနည်းနဲ.သွားပါတယ်။ နောက်ကျတော့ data abstraction ကိုထဲ့လာပါတယ်။
Data Abstraction
Data Abstraction ဆိုတာ custom data type တွေ create လုပ်ခွင့်ပေးထားတာကိုပြောတာပါ။ ဥပမာ Stack, LinkedList ဆိုတာမျိုးကို data type တခုအနေနဲ.ကိုယ်ပိုင် ဖန်တီးလို.ရမယ်။ ပြန်သုံးလို.ရမယ် ဒါကို data abstraction လို.ပြောလို.ရပါတယ်။ ဥပမာ C မှာ ဆို struct, enum, class ဆိုတာ data abstraction တွေပေးထားတာပါ။ Primitive type တွေကနေ custom data type ဖန်တီးလို.ရမယ် အဲ့ data type ကို maniuplate လုပ်ဖို. function တွေ create လုပ်လို.ရမယ်ဆိုရင် အဲ့ဒီ language ကို data abstraction ပေးတယ်လို.ပြောရမှာပါ။
Beginning of OOP
Data abstraction ကြောင့် custom data type တွေ တော့ဖန်တီးလို.ရပါပြီ။ ဒါပေမဲ့ ပြဿ နာ တခုက သူ.ကိုပြင်မယ်ဆိုရင် ဆိုပါစို. existing ADT(Abstract Data Type) တခုကိုပြင်မယ်ဆိုရင် သူ. source code ကိုပြင်ရမှာပါ။ ဒါကို destructive modification လို.ခေါ်ပါတယ်။ အဲ့ဒါက အန္တရာယ်များပါတယ် ဘာလို.လဲဆိုတော့ project တခုမှာ ADT တခုကို reference လုပ်ပြီးသုံးထားတဲ့ code တွေ အများကြီးရှိနိုင်လို.ပါ။ ADT ရဲ. source code ကိုမထိပဲပြင်နိုင်တဲ့ နည်းကတော့ OOP သုံးပြီး inheritance နဲ. functionality အသစ်ကို ထပ်ထဲ့တာ existing method ကို modify လုပ်တာပါပဲ။ ဒါဆို ရှိပြီးသား code ကို မထိပဲနဲ. ပြင်လို.ရပါပြီ။ Software ဆိုတာ ရေးပြီးတာနဲ.ပြီးတာမဟုတ်ပဲ အမြဲ ပြောင်းလဲနေနိုင်ပါတယ် OOP ရဲ. feature တွေက ဒါတွေကို handle လုပ်နိုင်ပါလိမ့်မယ်။
Data Abstraction versus OOP
Data abstraction က custom data type တွေ တည်ဆောက်လို.ရမယ်။ OOP ဖြစ်ဖို.ကတော့ အောက်ပါ သုံးချက်ကိုမဖြစ်မနေပေးရပါတယ်။ အဲ့ဒါတွေကတော့
Encapsulation
Inheritance
Polymorphism
တို.ပါပဲ။ Object တော့ပေးဆောက်တယ် feature သုံးခုလုံးမပါဘူဆိုရင် Object based language လို.ပဲခေါ်မှာပါ ဥပမာ Visual Basic( VB.NET ကတော့ OOP Feature သုံးခုလုံးပေးထားပါတယ်). OO language ရဲ.အားသာချက်ထဲက တခုက တော့ conceptual modelling ပါပဲ၊ အရင်က software development ကို function တွေ algorithm တွေနဲ.စဉ်းစားမဲ့အစား real world မှာရှိတဲ့အတိုင်း object တွေအနေနဲ. စဉ်းစားရတဲ့ ပိုလွယ်ကူပါတယ်။ real world မှာရှိတဲ့ အတိုင်း classification (by mean of class), taxonomy (by mean of inheritance), specialization (by mean of polymorphism) အတိုင်း model လုပ်လို.ရသွားပါတယ်။
Pure and Impure OO Language
Programming language တခုဟာ Object ကလွဲပြီး တခြား construct တွေပေးမထားဘူးဆိုရင် သု.ကို pure Object Oriented Language လို.သုံးပါတယ်။ ဥပမာ Smalltalk မှာဆို loop ဆိုတာမျိုး မရှိပဲ loop ဆိုတာကို method တစ်ခုအနေနဲ.ယူဆပါတယ်။ integer လိုကောင်မျိုးတွေကအစ object တွေပါ ဒါကြောင့် pure OO language လို.သုံးပါတယ်။ ဘာကောင်းလဲဆိုတော့ program တစ်ခုလုံးကို OO နည်းနဲ.ပဲစဉ်းစားရအောင် လုပ်ထားတာပါ။ C++, Java,C #,JS တို.ကတော့ impure object oriented language လို.ပြောရမှာပါ။ သူတို.မှာ primitive data type တွေပါပြီး control structure (for/switch etc) တွေပါလို.ပါ။
Encapsulation
Procedural language တွေမှာ data ကိုဘုံထားပြီး function တွေကနေဝိုင်းသုံးကြပါတယ်။ Project size ကြီးလာတာနဲ.အမျှ အဲ့ဒီ ဘုံသုံးထားတဲ့ variable(global variable) တွေကို ဘယ် module, ဘယ် function ကသုံးထားတယ်ဆိုတာ လိုက်ကြည့်ဖု.ိတော်တော်ခက်သွားပါပြီ။ PHP မှာဆို global variable သုံးပြီး page အများကြီး ဝိုင်းသုံးတာမျိုးပါ။ နောက်ပြီး ကိစ္စရှိလို. အဲ့ဒီ global variable ကိုပြင်မယ်ဆိုရင် သူ.ကို သုံးထားတဲ့ module တွေ function တွေကို ပါလိုက်ပြင်ရမှာပါ။ တခုခုကိုပြင်ရင် တခြား အပိုင်းတွေပါ ထိခိုက်ကုန်ပါတယ်။ ဒါကြောင့် OO language မှာ အဲ့တာကိုမဖြစ်အောင် ကာကြပါတယ်။ Program တွေကို modular ဖြစ်အောင်ရေးဖို.ကြံဆကြပါတယ်။ Modular ဖြစ်တယ်ဆိုတာ program module, function, contruct တခုဟာ သူ.ဟာသူနဲ.ရပ်တည်နိုင်ရပါမယ်။ သူများ function တွေကို အများကြီးသုံးနေရတာ dependency များနေတာ မဖြစ်ရပါဘူး။ Modular ဖြစ်မှ dependency နည်းမှပဲ ပြင်ရတာ လွယ်ကူမှာဖြစ်ပါတယ်။ ဒါကြောင့် global variable အစား ကို. data ကိုပဲသုံးမယ် သူများက လာသုံးမရအောင် access ကို restrict လုပ်ထားမယ် သူ. data ကို သူ. method တွေကပဲသုံးမယ် တခြားသော module တွေက ဒီ module ကို သုံးချင်ရင် module ကပေးထားတဲ့ public interface(publicly accessible method) တွေ ကနေ သုံး။ ဒါဆိုရင် တခြား module တွေဟာ သူများရဲ. data ကိုသွားထိလို.မရတဲ့အတွက် သီးသန်.ဆန်သွားတဲ့အတွက် modularity ပိုကောင်းပါတယ်။ module တခုကိုပြင်မယ်ဆိုရင် public interface(public interface ကပဲသူများ module နဲ. dependence ဖြစ်ပါတယ်) ကိုမပြင်မချင်း လွတ်လွတ်လပ်လပ်ပြင်နိုင်မယ်။ ဒါကို encapsulation လို.သုံးပါတယ်။ Encapsulation ရဲ.အနှစ်သာရက ကို. data ကိုသူများက accidentally destroy မဖြစ်အောင် dependency မရှိအောင် ထားရတာပါ။ Encapsulation ကို data hidiing နဲ.တွဲသုံးပါတယ်။ Encapsulation နဲ. data hiding ဟာ တူသလိုလိုနဲ. ကွဲပါတယ် data hiding က ကို.data ကိုပြင်ပက လာသုံးလို.မရအောင်ကာထားတာမျိုးပါ။ Encapsulation ကတော့ data ကို ကို. function တွေနဲ. modularity ရအောင် ချိတ်သုံးတာကို ဆိုချင်တာပါ။ Java, C #, C++ မှာဆို private accessifier တွေသုံးပြီး encapsulation ရအောင်လုပ်ကြပါတယ်။ Member variable ကို Private ထားပြီး getter ,setter function တွေနဲ.သုံးကြပါတယ်။ အဲ့လိုသုံးတိုင်း encapsulation မရနိုင်ပါဘူး ။ အောက်က Java Program ကိုကြည့်ပါ။
class WrongEncapsulation
{
private CreditCard card;
public void setCard(CreditCard c){...}
public CreditCard getCard()
{
return card;
}
}
ဒီ Program မှာ card က private ပါ reference type ပါ။ သူ.ကို တိုက်ရိုက်ယူသုံးလို.မရပေမဲ့ getCard ကနေ ယူသုံးလို.ရ့ပါတယ်။ဒါဆို တနည်းအားများ card ကို တိုက်ရိုက်ယူသုံးနိုင်တာနဲ.အတူတူပါပဲ။ Java က reference model ကိုသုံးတဲ့အတွက် အပြင်ကနေ card ကို ပြင်လို.ရမှာပါ။ဒါဆို encapsulated ဖြစ်တယ်လို.မပြောနိုင်တော့ပါဘူး။ JavaScript လို language မျိုးကျတော့ access modifier မပါပါဘူး ဒါပေမဲ့ full encapsulation ကိုလုပ်လို.ရပါတယ်။ Closure သုံးပြီး encapsulate လုပ်နိုင်ပါတယ်။
function getObject() {
var data;
function dataGetter() {
return data;
}
function dataSetter(d)
{
data = d;
}
return {
setData : dataSetter,
getData : dataGetter
};
}
var obj = getObject();
obj.setData(100);
console.log(obj.getData());
အပေါ်မှာပြထားတဲ့ JavaScript code မှာ encapsulation ကိုပြထားပါတယ်။ getObject function ထဲမှာရှိတဲ့ data ဟာ encapsulated လုပ်ခံထားရတာပါ။ သူ.ကိုအပြင်ကနေ တိုက်ရိုက်ယူသုံးလို.မရပါဘူး။ ဘာလို.လဲဆိုတော့ local varaible မို.လို.ပါ။ getObject function အောက်ဆုံးမှာ object တခု return ပြန်ထားပါတယ် အဲ့မှာ setData, getData ကို getObject function ထဲက dataSetter,dataGetter ကိုပေးထားပါတယ်။ dataSetter,နဲ. dataGetter ဟာ inner function တွေဖြစ်တဲ့အတွက် data ကို enclosing scope က data ကိုယူသုံးလို.ရပါတယ် ။ သူတို.ကိုတော့အပြင်ကနေ တိုက်ရိုက်သုံးလို.မရပဲ setData နဲ. getData ကတဆင့်သုံးရမှာပါ။ JS မှာဒီနည်းနဲ. Encapsulation ထိန်းလို.ရပါတယ်။ Encapsulation ဆိုတာ class level ထိန်းမှမဟုတ်ပါဘူး package , module တွေဟာလဲ ပြင်ပ ကကောင်တွေတိုက်ရိုက်သုံးလို.မရအောင် ထိန်းပေးထားတဲ့ encapsulation construct တွေပါပဲ။ Encapsulation နဲ. ပတ်သတ်တဲ့ OO Principle တခုရှိပါတယ် အဲ့ဒါကတော့ Program to interface, not to implementation ပါ။ Program ရေးတဲ့အခါမှာ module တွေ class တွေဟာ သူများရဲ. implementation detail ကိုမသိသင့် မထိသင့်သလို. ကို.ဟာကိုလဲ expose မလုပ်သင့်ပါဘူး။ အပြင်ကသုံးမဲ့ ကိုနဲ.တကယ် interact ပေးလုပ်မဲ့ကောင်တွေကိုပဲ public interface အနေနဲ.ထားပေးရမယ်ဆိုလိုတာပါ။ ဒါမှ maintenance ကောင်းမှာပါ။Encapsulation နဲ.ပတ်သတ်တဲ့ တခြား OO principle တခုကတော့
Open Close Principle ပါပဲ။
A module should be open for extension but closed for modification.
Module တွေ classes တွေဟာ သူတို.ကို accidentally modified မလုပ်နိုင်အောင်ထားသင့်ပြီးတော့ extend လုပ်နိုင်အောင်တော့ ထားပေးရမယ်ဆိုတာပါ။ Encapsulation ရဲ. central theme ကိုက close for modification ပါပဲ။
This is the default welcome page used to test the correct operation of the Apache2 server after installation on Ubuntu systems. It is based on the equivalent page on Debian, from which the Ubuntu Apache packaging is derived. If you can read this page, it means that the Apache HTTP server installed a...
