DEV Community: UCSYSG

Java Class and Object

UCSYSG — Fri, 06 Aug 2021 14:22:31 +0000

java က object-oriented language ဖြစ်တာကြောင့် class နဲ့ object တွေက အရေးပါလှပါတယ်။ class ဆိုတာက object တွေတည်ဆောက်လို့ရတဲ့ template တစ်ခုပေ့ါ။ real world မှာဆိုလို့ရှိရင် car အတွက် attributes(color, price, size, etc) နဲ့ methods(drive, upgrade, broke, etc) တွေကို car ဆိုတဲ့ class ထဲမှာ ကြေငြာပြီးတော့ လိုအပ်တဲ့အခါတိုင်း object ကနေတဆင့်ပြန်ခေါ်သုံးလို့ရပါတယ်။ ဆိုတော့ classတစ်ခုကို create လုပ်ကြရအောင်။

 class car{     //creating a class
     String color, brand;   //attributes
     int price;

     public static void carCondition(){     //method
         System.out.println("everything is good");
     }
 }

အပေါ်က code မှာဆိုလို့ရှိရင် car ဆိုတဲ့ class မှာပါဝင်တဲ့ (color, brand, price)attributes သုံးခုနဲ့ (carCondition) method တစ်ခုကို လိုအပ်တဲ့အခါတိုင်း object ကနေ တဆင့် ပြန်ခေါ်သုံးလို့ရမှာပါ

class အကြောင်း အကြမ်းဖျင်း သိသွားကြပြီဆိုတော့ အပေါ်က classကို main class ကနေပြီးတော့ objectအနေနဲ့ ပြန်ခေါ်သုံးကြည့်ရအောင်။

 class car{     //creating a class
     String color, brand;   //attributes
     int price;

     public void carCondition(){     //method
         System.out.println("everything is good");
     }
 }

 public class App {
     public static void main(String[] args) throws Exception {
         car myCar = new car();     //creating an object

         myCar.color = "red";       //insert values to created object
         myCar.brand = "Toyota";
         myCar.price = 10000;

         System.out.println(myCar.color);       //get value from inserted object
         System.out.println(myCar.brand);  
         System.out.println("$ "+myCar.price); 
         myCar.carCondition();      //call a method that we created in class
    }
 }

အပေါ်က code မှာဆိုလို့ရှိရင် ကျနော်တို့ createခဲ့တဲ့ car classကိုပဲ main app classကနေ myCar ဆိုတဲ့ object ကို create လိုက်ပြီး အဲ့ object ကနေပဲ attributes valueတွေထည့်လို့ရမယ် ပြန်ခေါ်သုံးမယ် ပြီးရင် method တွေကို ပြန်ခေါ်သုံးမယ် စတာတွေကို အသုံးပြုခဲ့တာပါ။

အဲ့တာဆို ကျနော်တို့ classမှာ constructor တစ်ခုတည်ဆောက်ကြည့်ရအောင်။ အရင်ဆုံး constructor ကို ဘာလို့သုံး ကြတာလဲပေါ့နော်။ အပေါ်က code မှာဆိုလို့ရှိရင် object create လုပ်ပြီးတာနဲ့ attributes တွေထဲ value တွေကို တစ်ခုချင်းဆီထည့်ခဲ့ကြတယ်။ အဲ့လိုဆို အလုပ်ရှုပ်တာပေါ့နော်။ အဲ့လိုမလုပ်ပဲ object create လုပ်ကတည်းက value တွေကို parameter အနေနဲ့ တခါတည်း ထည့်ပေးလိုက်လို့ရပါတယ်။ ဟုတ်ပြီ ရေးကြည့်ရအောင်။

 class car{     //creating a class
     String color, brand;   //attributes
     int price;

     public car(String newColor,String newBrand,int newPrice){
         color = newColor;
         brand = newBrand;
         price = newPrice;
     }
     public void carCondition(){     //method
         System.out.println("everything is going fine");
     }
 }

 public class App {
     public static void main(String[] args) throws Exception {
         car myCar = new car("red", "Tesla", 100000);     //creating an object with parameter

         System.out.println(myCar.color);       //get value from inserted object
         System.out.println(myCar.brand);  
         System.out.println("$ "+myCar.price);

         myCar.carCondition();      //call a method that we created in class
    }
 }

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

Abstraction in java

UCSYSG — Fri, 06 Aug 2021 14:14:19 +0000

မင်္ဂလာပါဗျ။ ကျနော်ဒီနေ့ပြောပြပေးသွားမှာက 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:))။
.zuki

Polymorphism

UCSYSG — Mon, 26 Jul 2021 10:05:25 +0000

polymorphismဆိုတာကတော့OOPရဲ့featuresတွေထဲကတစ်ခုဖြစ်ပါတယ်။polymorphismဆိုတာကတော့Greekဘာသာစကားpoly(many)နဲ့morph(form)ကနေဆင်းသက်လာခြင်းဖြစ်ပါတယ်။ဆိလိုချင်တာကတော့လုပ်ဆောင်ချက်တစ်ခုထဲကိုပဲပုံစံအမျိုးမျိုးနဲ့ဖော်ပြနိုင်ခြင်းဖြစ်ပါတယ်။

Polymorphismကိုအသုံးပြုခြင်း

Classတခုဟာတခြားclassတခုကိုအမွေဆက်ခံလိုက်ပြီဆိုတာနဲ့polymorphismရဲ့သဘောတရားဟာအသက်ဝင်လာပြီဖြစ်ပါတယ်။Polymorphismကိုprogramming concept အနေနဲ့ပြောရမယ်ဆိုရင်Objectတခုခြင်းပေါ်မူတည်ပြီးတော့Methodရဲ့လုပ်ဆောင်နိုင်စွမ်းကွဲပြားသွားတာဖြစ်ပါတယ်။ထိုကဲ့သိုကွဲပြားရာကိုမူတည်ပြီးတော့ကျွန်တော်တိုconceptနှစ်မျိုးခွဲခြားနိုင်ပါတယ်။ထိုအရာတွေကတော့-

1.Method Overloading(compile time or static polymorphism )

2.Method Overriding (run time or dynamic polymorphism )တိုပဲဖြစ်ပါတယ်။

Method Overloading

Method Overloadingဆိုတာကတော့Class တစ်ခုထဲမှာmethod nameတွေတူပေမယ့်parameterတွေမတူတာကိုဆိုလိုခြင်းဖြစ်ပါတယ်။method return typeလဲကွဲပြားမှုရှိနိုင်ပါတယ်။

Method Overloading လုပ်လျှင်လိုက်နာရမည့်စည်းမျဉ်းများ

methodနှစ်ခုကိုoverloadအဖြစ်သတ်မှတ်ချင်လျှင်အထက်ပါအချက်နှစ်ချက်တူညီရမည်-

1.methodနှစ်ခုလုံးmethod name တူရမည်။

2.methodနှစ်ခုလုံးparameter listကွဲပြားရမည်။

ထိုနှစ်ချက်သာမရှိမဖြစ်လိုအပ်သည်။အောက်တွင်ဖော်ပြထားသောအကြောင်းအရာများလဲကွဲပြားမှုရှိနိုင်သည်။

1.return typeများကွဲပြားနိုင်သည်။

2.access modifier များကွဲပြားနိုင်သည်။

3.exceptionများကိုthrowsလုပ်ရာတွင်လဲကွဲပြားနိုင်သည်။

Method overloading ဥပမာ

class Example{
.....
public void method(int a)
{return;}

private void method(int a,int b)
{return;}

int method(int a,int b,int c)
{ return a+b+c;}

private void method(Object object)throws Exception
{ }
.....
}

Method Overriding

MethodOverridingဆိုတာကတော့Parent classကနေလက်ခံရရှိတဲ့methodကိုမိမိကိုယ်ပိုင်ပုံစံဖြင့်ပြုပြင်ရေးသားခြင်းပဲဖြစ်ပါတယ်။

Method overriding လုပ်လျှင်လိုက်နာရမည့်စည်းမျဉ်းများ

အောက်ပါဖော်ပြထားသောစည်းမျဉ်းများကိုမဖြစ်မနေလိုက်နာရမည်။

1.method name တူရမည်။

2.argument listတူရမည်။

3.return typeတူညီရမည်။(JDK5မှစတင်၍convariant return typeများsupportလုပ်လာသည်။အရှင်းလင်းဆုံးပြောရလျှင်different return typeများဖြစ်သည်။different return typeဟုဆိုသော်လဲပဲထို return typeသည်parentရဲ့sub typeသာဖြစ်ရမည်။ပို၍ရှင်းလင်းစေရန်အောက်တွင်ဖော်ပြထားသောcodeကိုကြည့်ပါ)

class A{    
A get(){return this;}    
}    

class B extends A{    
@Override  
B get(){return this;}//convariant type (B is Sub type of it's parent A)

4.အကယ်၍parentရဲ့method access modifierသည်protectedဖြစ်လျှင်child classတွင်ပြုပြင်လိုသောmethod access modifier သည်private မဖြစ်ရပါ။

5.new သိုမဟုတ် border checked exceptionများကိုthrow၍မရပါ။

အထက်တွင်ဖော်ပြထားသောစည်းမျဉ်းများတူညီလျှင်override methodများတွင်အောက်ပါကိစ္စရပ်များကွဲလွဲနိုင်သည်။

အကယ်၍parentရဲ့method access modifierသည်protectedဖြစ်လျှင်child classတွင်ပြုပြင်လိုသောmethod access modifier သည်publicဖြစ်လိုရပါသည်။

2.fewer, narrower checked exeeptions(သို) unchecked exceptionများthrowနိုင်သည်။(ထိုအကြောင်းအရာများကိုException handlingအပိုင်းတွင်အသေးစိတ်ဖော်ပြသွားပါမည်။)

Appendix Rules for Overriding

1.Inheritance methodများသာoverrideပြုလုပ်နိုင်သည်။ဆိုလိုတာကတော့child classတွင်သာover ride လုပ်နိုင်သည်။

2.Constructorsနှင့်private methodများကိုinheritedလုပ်၍မရသောကြောင့်oveerideမလုပ်နိုင်ပါ။

3..Abstract methodများကိုလက်ခံသောconcrete class များသည်overrideမဖြစ်မနေလုပ်ရမည်။

4.final methodတွေကိုoverrideလုပ်၍မရပါ။

5.subclassများတွင်parentရဲ့methodများအသုံးပြုလိုပါကsuper.method()ဆိုပြီးအသုံးပြုနိုင်သည်။

အထက်ပါဖော်ပြချက်များကတော့overidingနှင့်overloadingအကြောင်းဖြစ်ပါသည်။ဖတ်ရှုပေးတဲ့အတွက်ကျေးဇူးအထူးတင်ရှိပါသည်။

Method overloading ဥပမာ

class A {
    void show()
    {
        System.out.println("Parent's show()");
    }
}

// Inherited class
class B extends A {
    @Override//method overiding
    void show()
    {
        System.out.println("Child's show()");
    }
}

ရေးသားသူ
Thaw Htin Aung