Class နဲ႔ Instance ကို​ကြဲ​ေအာင္​လုပ္​ပါ

 ေရးသားသူ   zaw min Lwin  (Myanmar JAVA User Group)

Java ကို​ေလ့​လာ​ရာ​တြင္ ဦးစြာ​ေတြ႕​ၾကဳံ​ရ​မည့္ အခက္​အခဲ​မ်ား​ကေတာ့ Classဆို​တာ​ဘာ​လဲ၊ ၿပီး​ေတာ့ Instanceဆို​တာ​ဘာ​လဲ ဟုေခၚ​ေသာ ေမးခြန္း​မ်ား​ျဖစ္​ၾက​ပါ​သည္။ ဤ Javaကို​အျမန္​ဆုံး​ေလ့​လာ​ျခင္း အခန္း​ဆက္ ဘ​ေလာ့​ထဲ​မွာ​ေတာ့ Object Oriented Programming ရဲ့​အျမင္​က မဟုတ္​ပဲ၊ Memoryေပၚ​က Program တစ္​ခုေပၚ​တြင္ တည္​ရွိ​ေသာ အျမင္​ပိုင္း​ဆိုင္​ရာ ရွု႔​ေထာင့္​မွ Classနဲ႔ Instance တို႔​ရဲ့ ကြဲ​ျခား​ခ်က္​ေတြ​ကို ေလ့​လာ​သြား​ပါ​မည္။
Class ဆို​သည္မွာ အဲ့​ဒီ​အစု​အစည္း​ရဲ့ တန္ဖိုး​ေတြ​ကို​သတ္​မွတ္ရန္အတြက္ အခ်က္အလက္မ်ား (Field)နဲ႔၊ လုပ္ေဆာင္​ခ်က္ (Method)မ်ား​ကို စုစည္း​ထား​တဲ့ အစု​အစည္း​တစ္​ခု​လို႔​သတ္​မွတ္ထား​၏။ ဤ​ရွင္းလင္း​ခ်က္​ကို ၾကည့္​႐ုံျဖင့္ Class နဲ႔ Instance ကို​ကြဲျပား​ၿပီး သိရွိ​နိုင္​မည္​မဟုတ္​ေပ။ ဤသို႔ဆိုလၽွင္ Class နဲ႔ Instance ကြာျခားခ်က္သည္ အဘယ္နည္း ဟုေမးစရာရွိပါမည္။ Java ႏွင့္ ပတ္သက္ေသာ စာအုပ္ေပါင္းမ်ားစြာတြင္ နားလည္လြယ္ေစရန္ နည္းအမ်ိဳးမ်ိဳးျဖင့္ ရွင္းျပထားေလ့ရွိ၏။ ကၽႊန္ေတာ္အႏွစ္အသက္ဆုံး အေျဖမွာ ကြန္ပ်ဴတာ Memory အေပၚတြင္ ျဖစ္ေပၚလာပုံ၏ ဒါ​မွ​မဟုတ္ ဇာစ္​ျမစ္ ဟာ​ကြဲျပားျခားနားသည္ ဟူေသာ ရွင္းလင္းခ်က္ပဲ ျဖစ္ပါသည္။

Class ရဲ့ ဇာစ္​ျမစ္​သည္ .java ဖိုင္​ကို Compileလုပ္​ၿပီး၊ ရ​ရွိ​လာ​တဲ့ .class ဖိုင္ ျဖစ္​ပါ​သည္။ Program တစ္​ခု​မွ Class ကို​ဆက္​သြယ္ အသုံးျပဳ​မည္ ဆို​လၽွင္ .class ကို​ဖတ္​ယူ​ၿပီး Memoryေပၚ​တြင္ Class အျဖစ္ ေနရာ​ခ်ထား​ပါ​မည္။ တ​ဖန္ Instance သည္ Memoryေပၚ​တြင္ တည္​ရွိ​ၿပီး​ျဖစ္​ေသာ Class ကို​အသက္​သြင္း​၍ Memory ေပၚ​မွ​အျခား​ေသာ​ေနရာ​တြင္ ျဖစ္ေပၚ​လာ​ေစ​ပါ​သည္။ မွတ္​ရန္​အခ်က္​မွာ Classသည္ .class ဖိုင္​တစ္​ခု​မွ တစ္​ႀကိမ္​တည္း​သာ ဖတ္​ယူ​ေမြး​ဖြား​ၿပီး၊ Instanceသည္ Memory ေပၚ​တြင္​တည္​ရွိ​ၿပီး​ျဖစ္​ေသာ Class မွ Memory ရွိ​သ​ေလာက္ အႀကိမ္ႀကိမ္ ကူး​ယူ​ေမြး​ဖြား​နိုင္​ျခင္း ျဖစ္​ေပ​သည္။

အျမန္​မွတ္ခ်က္

Class ႏွင့္ Instanceတို႔​သည္၊ တန္ဖိုး​ႏွင့္ လုပ္ေဆာင္​ခ်က္​မ်ား​ကို စုစည္း​ထား​သည့္​အခ်က္​မွာ တူညီ​ၾက​ေပ​သည္။ သို႔ရာတြင္ Class သည္ .class ဖိုင္​မွ တစ္​ႀကိမ္​တည္း​သာ ဖတ္​ယူ​ေမြး​ဖြား​ၿပီး၊ Instanceသည္ Memoryေပၚ​တြင္​တည္​ရွိ​ေသာ Classမွ​တစ္​ဆင့္ အႀကိမ္ႀကိမ္ ကူး​ယူ​ေမြး​ဖြား​နိုင္​ျခင္း တို႔​က​ကြဲျပား​ခ်က္​တို႔ ျဖစ္​ၾက​ပါ​သည္။



သည္လို​ဆို​ရင္Classနဲ႔Instanceကို ဘယ္​လို​ခြဲ​ျခား​ၿပီး အသုံး​ခ်​သင့္​တယ္​ဆို​တာ​ကို လက္ေတြ႕Codeကို​ေရး​ၿပီး ေလ့​လာ​ၾကည့္​ရေအာင္။ ေအာက္​ပါ　န​မွု​နာ​ေတြ​ကို​ၾကည့္⁠ၾကည့္​ၾက​ပါ။　အသီး​သီး　class A နဲ႔

Bကို​ေရးသား​ထား​ၿပီး TestClassမွ​ေန ေခၚ​ယူ​အသုံးျပဳ​ထား​ပါ​သည္။ class A နဲ႔ Bတို႔​ရဲ့ ကြဲျပား​ခ်က္​ကို​ေလ့​လာ​ၾကည့္​ၾက​ပါ​ဆို႔။

class A

public class A {
    static int i;
    static int getTwice() {
        return i*2;
    }
}

 class B

public class B {
    int i;
    public int gatTwice() {
        return i * 2;
    }
}
 

Class AေရာBပါ၊ ကိုယ္စီ Member Fieldအေန​နဲ႔ int i ကို​ပိုင္ဆိုင္​ၿပီး၊ လုပ္ေဆာင္​ခ်က္ 

int တန္ဖိုး​ကို​ျပန္​ေပး​တဲ့ getTwice methodကို ပိုင္ဆိုင္​ၾက​ပါ​တယ္။ class A ရဲ့ i နဲ႔ getTwice() ဟာ 

Classကို​တိုက္ရိုက္​ဆက္​သြယ္​ၿပီး အသုံးျပဳ​နိုင္​ဖို႔​အတြက္ 

အေရွ႕​မွာ staticဆို​ၿပီ သတ္​မွတ္ခ်က္​ကို ေရးသား​ရ​ပါ​တယ္။ 

အဲ့​ဒီ​လို​ေရးသား​ထား​တဲ့ Fields ေတြ​နဲ႔ method ေတြ​ကို 

static field, static methodဆို​ၿပီး ေခၚေဝၚ​ေလ့​ရွိ​ပါ​တယ္။

တ​ဖန္ class B မွာ​ရွိ​တဲ့ field နဲ႔ method ေတြ​ရဲ့​ေရွ႕​မွာ static 

ဆို​တာ​မ​ေရးသား​ထား​ပါ​ဘူး။ အဲ့​ဒါ​ဟာ class B မွ​တ​ဆင့္ ပြား​ယူ​နိုင္​တဲ့ 

instanceေတြ​မွ​တ​ဆင့္ အသုံးျပဳ​ေစ​နိုင္​ဖို႔​အတြက္ ျဖစ္​ပါ​တယ္။ အဲ့​ဒီ​အတြက္

instance field, instance method ဆို​ၿပီးေခၚေဝၚ​ေလ့ ရွိ​ပါ​တယ္။ 

class Test

public class Test {

    public static void main(String [] args) {
        A.i = 10;
        System.out.println("Twice Of Class A : " + A.getTwice());

        B b = new B();
        b.i = 10;
        System.out.println("Twice of Instance b : " + b.gatTwice());
    }
}
 

Test Classထဲ​မွာ​ေတာ့ class A နဲ႔ B တို႔​ရဲ့ အသုံးျပဳ​ပုံ​ေတြ​ကို ေဖာ္​ျပ​ေပး​ေန​ပါ​တယ္။

 A.i ဆို​တဲ့ class field i ရဲ့​တန္ဖိုး​ကို 10ဆို​ၿပီး​သတ္​မွတ္​ေန​ပါ​တယ္။

 ၿပီး​ေသာ​အခါ A.getTwice()ဆို​ၿပီး A class ရဲ့ getTwiceလုပ္ေဆာင္​ခ်က္​ကို

 ေခၚ​ယူ​ၿပီး system consoleမွာ​ေရးသား​ေစ​ပါ​တယ္။ A class ရဲ့ i နဲ႔ getTwice 

ကို static အေန​နဲ႔ သတ္​မွတ္ထား​တဲ့​အတြက္ class A မွ တိုက္ရိုက္​အသုံး​ခ်​နိုင္​ျခင္း

 ျဖစ္​ပါ​တယ္။
တ​ဖန္ class B ရဲ့ instance b ကို B b = new B(); ဆို​ၿပီး သတ္​မွတ္​ေပး​ေန​ပါ​တယ္။

 ေနာက္​တစ္​ေၾကာင္း​တြင္ b.i = 10ဆို​ၿပီး instance b ရဲ့ i ရဲ့​တန္ဖိုး​ဟာ 10 ျဖစ္​ပါ​တယ္ 

လို႔​သတ္​မွတ္​ေန​ျပန္​တယ္။ ဆက္​ၿပီး instance methodျဖစ္​တဲ့ b.getTwiceကိုေခၚ ၿပီး 

System Consoleမွာ ေရးသား​ေန​ပါ​တယ္။ b instance မွ​ေန​အသုံးျပဳ​နိုင္​ရန္ အတြက္

 သူ႔​ရဲ့ Field နဲ႔ methodရဲ့​ေရွ႕​မွာ staticဆို​တာ မ​ေရးသား​ထား​ပါ​ဘူး။ အဲ့​ဒီ​လို 

instance field နဲ႔ instance method ေတြ​ရွိ​တဲ့​အတြက္ B classရဲ့ instance 

b မွ​တ​ဆင့္ အသုံးျပဳ​နိုင္​ျခင္း​ျဖစ္​ပါ​တယ္။
 

အျမန္​မွတ္ခ်က္

Class ရဲ့ static field နဲ႔ static methodေတြ​ဟာ memory ေပၚ​မွာ တစ္​ႀကိမ္​တည္း​သာ

 ျဖစ္​တည္​တယ္​ဆို​တဲ့ ထူးျခား​ခ်က္​ကို အသုံး​ခ်​ၿပီး Class field နဲ႔ 

လုပ္ေဆာင္​ခ်က္ ေတြ​ကို​ေရးသား​သင့္​ပါသည္။


တ​နည္း​ေတြး​ၾကည့္​ၾက​ရေအာင္။ class A ကို​ေရာ instance မ​လုပ္​နိုင္​ဘူး​လား။

 လုပ္​နိုင္​ပါ​တယ္။ ဒါ​ေပ​မယ့္ class A မွာ static field နဲ႔ static method 

သာ​ပိုင္ဆိုင္​ၿပီး insatance fieldေတြ methodေတြ မ​ပါ​တဲ့​အတြက္

 သူ႔​ရဲ့ instance ကို​ပြား​ယူ​လုပ္​ေအာင္ အဓိပၸါယ္​မ​ရွိ​နိုင္​ပါ​ဘူး။

ဒါ​ျဖင့္ Classလည္း​အဲ​လုပ္​လို႔​ရ​တယ္၊ instanceလည္း​အလုပ္​လုပ္​လို႔​ရ​တယ္။ 

ဘာ​လို႔ instanceက​လို​အပ္​ရ​တာ​လဲဆို​တာ​ကို စဥ္းစား​ၾကည့္​ၾက​ရေအာင္။

 ေအာက္​ပါ Personဆို​တဲ့ Classကို​ၾကည့္​ပါ။ name နဲ႔ ageဆို​တဲ့ instance

 fieldကို​ပိုင္ဆိုင္​ၿပီး introdude() ဆို​တဲ့ instance methodရယ္

 Person(String name, int age)ဆို​တဲ့ constructor ကို​ပိုင္ဆိုင္​ပါ​တယ္။

 Constructorဟာ instance ေတြ​ကို ပြား​ယူ​တဲ့​အခါ​မွာ အျမဲ​တမ္းေခၚ​ယူ​ခံ​ရ​မည့္ 

လုပ္ေဆာင္​ခ်က္​တစ္​ခု​ျဖစ္​ပါ​တယ္။ Classမွ​တ​ဆင့္ instanceကို လုပ္​ယူ​တဲ့​အခါ​မွာ 

လုပ္ေဆာင္​ရ​မည့္ လုပ္ေဆာင္​ခ်က္​ဆို​ရင္​လည္း မ​မွား​နိုင္​ပါ​ဘူး။
သည္Person Constructor ကေတာ့ String name နဲ႔ int age ကို Argumentအေန​နဲ႔

လက္ခံ​ရ​ယူ​ၿပီး၊ instance member ျဖစ္​ၾက​တဲ့ name နဲ႔ ageမွာ အသီး​သီး 

အစားထိုး​သတ္​မွတ္​ေန​ပါ​တယ္။ ၿပီး​ေတာ့ လုပ္ေဆာင္​ခ်က္ introduceထဲ​မွာ​ေတာ့

 သူ႔​ရဲ့ name နဲ႔ ageကို System Consoleမွာ ေရးသား​ျပ​ေန​ပါ​တယ္။

class Person 

public class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void introduce() {
        System.out.print("My name is " + name);
        System.out.println(" and I am " + age + "years old.");
    }
}

ေအာက္​ပါ Test class ထဲ​မွာ​ေတာ့ Person ရဲ့ a instance နဲ႔ b instance ကို​လုပ္​ယူ​ၿပီး အသီး​သီး​ရဲ့ introduceလုပ္ေဆာင္​ခ်က္​ကို လုပ္ေဆာင္​ေစ​ပါ​တယ္။

classTest

public class Test {   
    public static void main(String [] args) {

        Person a = new Person("Aung Aung", 30);
        Person b = new Person("Thida", 24);
        a.introduce();
        b.introduce();
    }
} 

အထက္​ပါ Test Classကို Run ၾကည့္​မည္​ဆို​ပါ​က System Console

 မွာ ေအာက္​ပါ​အတိုင္း စာ​ေၾကာင္း​မ်ား​က ထြက္ေပၚ​လာ​ပါ​လိမ့္​မည္။
My name is Aung Aung and I am 30years old.

My name is Thida and I am 24years old.

အထက္ပါ န​မွု​နာ​ကို​ၾကည့္​ျခင္း​အား​ျဖင့္ Classတစ္​ခု​မွ

 မ​တူညီ​ေသာ​တန္ဖိုး​မ်ား​ႏွင့္ မ​တူညီ​ေသာ Instanceမ်ား​ကို

 အႀကိမ္ႀကိမ္ လုပ္​ယူ​နိုင္​တယ္ ဆို​တာ​ကို သိရွိ​နိုင္​ပါ​တယ္။

 အျမန္​မွတ္ခ်က္

Constructorမွ​တ​ဆင့္ ပုံစံ​ခ်​ယူ​ျခင္း​အား​ျဖင့္ Class တစ္​ခု​မွ​ေန Instanceကို အႀကိမ္ႀကိမ္​ပြား​ယူ​နိုင္​ပါ​သည္။


အလြယ္​ဆုံး​ေျပာ​ရ​မည္​ဆို​လၽွင္ Classနဲ႔ Instance ဟာ ဒယ္အိုး​နဲ႔ ဘိန္း​မုန႔္​လို​ပါ​ပဲ။ ဒယ္အိုး​တစ္​လုံး​လို​ပဲ 

Classဟာ​တစ္​ခု​တည္း​ရွိ​ၿပီး၊ ဒယ္အိုး​ထဲ​မွာ​ပါဝင္​တဲ့ အစာ​ေတြ​ကို အမ်ိဳး​မ်ိဳး​ေျပာင္း​ထည့္​ၿပီး၊

 ေထာ​ပါတ္​ဘိန္း​မုန႔္​ေတြ ရိုး⁠ရိုး​ဘိန္း​မုန႔္​ေတြ​ကို ဖုတ္​ယူ​နိုင္​သ​လို၊ Classတစ္​ခု​မွ

 တန္ဖိုး​အမ်ိဳး​မ်ိဳး​ေျပာင္း​လည္း​ၿပီး Instanceေတြ​ကို အမ်ိဳး​မ်ိဳး​လုပ္​ယူ​နိုင္​ပါ​တယ္။

Class နဲ႔ Instanceတို႔​ရဲ့ ကြဲ​ျခား​ခ်က္​ကို​သိရွိ​ၿပီး Javaဆန္​တဲ့ Codeမ်ား​ကို​ေရးသား​သြား​ၾက​ပါ​ဆို႔။