Abstraction in java
Tags: java
Published: 2021-08-06 14:14:19

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

```java
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 ထည့်လိုက်ရုံပါပဲ။
```java
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 တွေကနေတဆင့် ပြန်ရေးပေးရမှာပါ။
```java
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 လုပ်ကြရအောင်။
```java
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:))။
.zuki