Abstraction in java

မင်္ဂလာပါဗျ။ ကျနော်ဒီနေ့ပြောပြပေးသွားမှာက abstraction အကြောင်းပါ။ သူကတော့ အခြား class တွေလိုမျိုး object တခုအနေနဲ့အသုံးပြုလို့ရမှာ မဟုတ်ပါဘူး။ ဒါပေမယ့် သူ့ကို အခြားသော class တွေကနေ extends လုပ်ပြီးအသုံးပြုနိုင်မှာပါ။ example code ကိုကြည့်လိုက်ရအောင်။

abstract class Animal {     //create abstract class

}

class Cat extends Animal{       //create a class with Animal extended
}

public class App {
    public static void main(String[] args) throws Exception {
        System.out.println("hello java");
    }
}

အပေါ်က code မှာဆိုလို့ရှိရင် ကျနော်တို့ Animal ဆိုတဲ့ abstract class ကို Cat ဆိုတဲ့ ရိုးရိုး class ကနေ extends လုပ်ပြီးတော့ Animal class ကိုအသုံးပြုသွားမှာပါ။

abstract class Animal {     //create abstract class
    public void sleep(){
        System.out.println("zzz");
    }
}

class Cat extends Animal{       //create a class with Animal extended
}

public class App {
    public static void main(String[] args) throws Exception {
        Cat arKyel = new Cat();
        arKyel.sleep();
    }
}

အပေါ်က code မှာဆိုလို့ရှိရင် Animal class ထဲမှာ ရေးထားတဲ့ sleep ဆိုတဲ့ function ကို Cat ဆိုတဲ့ class ကိုသုံးကာ object တခုဆောက်ပြီးပြန်ခေါ်လို့ရပါတယ်။ အဲ့ဒီမှာ မေးခွန်းတခုရှိမယ် ထင်ပါတယ်။ Animal ကိုသုံးပြီး object ဘာလို့မဆောက်တာလဲပေါ့နော်။ ကျနော်တို့ အပေါ်မှာ ပြောထားသလိုမျိုး abstraction class က ပုံမှန် class တွေလိုမျိုး new Animal(); ဆိုပြီး object create လုပ်လို့မရပါဘူး။ အဲ့အတွက်ကြောင့် Cat class ကနေတဆင့် arKyel (sry it's my cat name :)))ဆိုတဲ့ object ကို create ပြီး sleep functionကိုခေါ်သုံးတာပါ။ function မှမဟုတ်ပါဘူး အခြားသော abstraction class ထဲမှာရှိတဲ့ ဟာတွေအကုန်လုံးကို Cat class ကနေတဆင့် ခေါ်သုံးလို့ရမှာပါ။

abstraction class အကြောင်းပြီးပြီဆိုတော့ abstraction function အကြောင်းသွားရအောင်။ abstraction function ဆိုတာက function ရှေ့မှာ abstract ထည့်လိုက်ရုံပါပဲ။

abstract class Animal {     //create abstract class
    public void sleep(){
        System.out.println("zzz");
    }

    abstract public void makeSound();
}

class Cat extends Animal{

}

public class App {
    public static void main(String[] args) throws Exception {
        Cat arKyel = new Cat();
        arKyel.sleep();
    }
}

အပေါ်က code လိုမျိုး makeSound() function ရှေ့မှာ abstract ထည့်လိုက်ရုံနဲ့ abstraction function ဖြစ်သွားမှာပါ။ ဒါပေမယ့် အပေါ် က code ကို run ကြည့်ရင် error တက်နေမှာပါ။ ဘာလို့လဲဆိုတော့ makeSound() ဆိုတဲ့ abstraction function က သူ့ကိုပြန်ခေါ်သုံးတဲ့အခါ ဘာလုပ်ရမှန်း မသိလို့ပဲဖြစ်ပါတယ်။ အဲ့တာကြောင့် makeSound() function အတွက် code တွေရေးပေးရပါဦးမယ်။ ဒါပေမယ့် သူကလည်း အခြား function တွေလိုမျိုး abstract public void makeSound(){\\codes} ဆိုပြီး သွားလုပ်လို့မရပါဘူး။ သူ့ကို extends လုပ်ထားတဲ့ class တွေကနေတဆင့် ပြန်ရေးပေးရမှာပါ။

abstract class Animal {     //create abstract class

    abstract public void makeSound();
}

class Cat extends Animal{

    @Override
    public void makeSound() {
        System.out.println("meow meow");
    }

}

public class App {
    public static void main(String[] args) throws Exception {
        Cat arKyel = new Cat();
        arKyel.makeSound();     //call makeSound function through a object
    }
}

အပေါ်က code ကိုကြည့်မယ်ဆိုရင် makeSound ဆိုတဲ့ function ကို Cat class မှာ ပြန်ရေးထားတာကိုတွေ့ရမှာပါ။ အဲ့အတွက်ကြောင့် object ကနေတဆင့် ပြန်ခေါ်သုံးလို့ရသွားမှာပါ။ ဒါပေမယ့် မေးခွန်းတခု ရှိမယ်ထင်ပါတယ်။ makeSound function ကို abstract အနေနဲ့ Animal class မှာ create မလုပ်ပဲ Cat class မှာရိုးရိုး function အနေနဲ့ create တန်းလုပ်လိုက်လည်း result ကတော့တူနေမှာပါ။ အဲ့ဒီမှာတခုပြောချင်တာက function ပုံမှန် function အနေနဲ့ မသုံးပဲ abstraction function အနေနဲ့ဘာလို့အသုံးပြုကြတာလဲပေါ့နော်။ ဆိုတော့ ကျနော်တို့ create လုပ်ထားတဲ့ Animal class ကိုတချက်ကြည့်လိုက်ရအောင်။ Animal တိုင်းက စကားပြောကြပေမယ့် type(eg: cat, dog) အပေါ်မူတည်ပြီး တကောင်နဲ့တကောင်တူကြမှာမဟုတ်ပါဘူး။ animal တိုင်း စကားပြောကြတဲ့ အမှန်တရားကို abstraction function အနေနဲ့ထည့်ထားတာဖြစ်ပါတယ်။ ပိုပြီးမြင်သာသွားအောင် dog တကောင်လောက် create လုပ်ကြရအောင်။

abstract class Animal {     //create abstract class

    abstract public void makeSound();
}

class Cat extends Animal{

    @Override
    public void makeSound() {
        System.out.println("meow meow");
    }

}

class Dog extends Animal{

    @Override
    public void makeSound() {
        System.out.println("woof woof");
    }

}

public class App {
    public static void main(String[] args) throws Exception {
        Cat arKyel = new Cat();
        arKyel.makeSound();     //call makeSound function through a object

        Dog waTote = new Dog();
        waTote.makeSound();      //call makeSound function through a object
    }
}

ထုံးစံအတိုင်းပဲ ကျနော်တို့ Dog class ကို extends Animal လုပ်ပြီး create လုပ်ကာ makeSound ဆိုတဲ့ abstraction function ကို class ထဲမှာ ပြန်ရေးလုပ်လိုက်ပါတယ်။ ပြီးတော့ Dog class ကို သုံးပြီး object တခု တည်ဆောက်ကာ makeSound ဆိုတဲ့ abstraction function ကိုပြန်ခေါ်သုံးလို့ရပါပြီ။

ကျနော် ပြောသွားတဲ့ထဲမှာ နားမလည်တာရှိရင် ဒါမှမဟုတ် ဖြည့်စွတ် ပြောချင် တာများရှိရင် discussion ထဲမှာ ဝင်ရောက်ရေးသွားလို့ရပါတယ်။ မှားယွင်းနေတာရှိရင်လည်းပြောပြပေးသွားလို့ရပါတယ် ။arigatou:))။