DEV Community: Zuki Desu

Java String Builder class

Zuki Desu — Mon, 29 Nov 2021 06:52:12 +0000

Hi guys!
ဒီနေ့ကျနော်ပြောပြပေးမှာက StringBuilder class အကြောင်းပါ။

StringBuilder class ကနာမ်မည်အတိုင်း string တွေကို build လုပ်ပေးပါတယ်။ String class နဲ့မတူတာက String မှာကြ သူက immutable ဖြစ်ပါတယ်။ ဆိုလိုချင်တာက create လုပ်ထားတဲ့ string တခုကို String class မှာပါတဲ့ method တွေနဲ့ character တွေကို lower and upper case ပြောင်းတာတို့ character တွေဖြတ်ထုတ်ပြစ်တာတို့ စတာတွေ လုပ်တဲ့အခါကြရင် မူရင်း string က ပြောင်းလဲသွားမှာမဟုတ်ပါဘူး။ နောက်ထပ် String အသစ်ကိုပဲ return ပြန်ပေးမှာပါ။အိုကေ အဲ့တာလေးစမ်းကြည့်ရအောင်။

source code:

အပေါ်က source code မှာဆိုရင် str ကို toUpperCase() နဲ့သုံးပြီး ပြောင်းထားပေမယ့်လည်း မူရင်း str variable ကတော့ တန်ဖိုးပြောင်းသွားချင်းမရှိပါဘူး။ uppercase ပြောင်းထားတဲ့ string ကိုသိမ်းမယ်ဆိုရင်တော့ နောက်ထပ် variable အသစ်လိုပါလိမ့်မယ်။ ဘယ်လိုလုပ်လုပ် မူရင်း value ကိုပြောင်းလဲလို့မရတာမျိုးကို immutable ဖြစ်တယ်လို့ခေါ်ကြပါတယ်။

StringBuilder မှာကြတော့ mutable ဖြစ်ပါတယ်။ ဆိုလိုတာက မူရင်း string ကို တခုခု ပြောင်းလိုက်တာနဲ့ အဲ့ string ကို reference လုပ်ထားတဲ့ variable တွေရဲ့တန်ဖိုးတွေအကုန် ပြောင်းမှာပါ။ အဲ့အကြောင်းအောက်မှာဆက်ပြောပေးပါမယ်။ အဲ့တာဆို StringBuilder ကို create လုပ်ကြည့်ရအောင်။

create လုပ်နည်း လေးခုရှိပါတယ်။ ပထမတခုက default ပါ။ StringBuilder class ရဲ့ constructor ခေါ်လိုက်ရုံပါပဲ။ သူက capacity 16 ရှိတဲ့ object ကို return ပြန်ပေးမှာဖြစ်လို့ variable ကို ပြန်ခေါ်လိုက်ရင် StringBuilder အလွတ်(ဘာမှ မပါပေမယ့် capacity 16 ခုကိုတော့ယူထားပါတယ်) တခုကို ရလာမှာပါ။
eg code: StringBuilder str = new StringBuilder();
နောက်တနည်းကတော့ capacity ကို argument အနေနဲ့ထည့်ရမှာပါ။ ကျနော်တို့ ထည့်လိုက်တဲ့ capacity အတိုင်း StringBuilder object ထွက်လာမှာပါ။
eg code: StringBuilder str1 = new StringBuilder(20);
နောက်တနည်းကတော့ String ကို argument အနေနဲ့ထည့်ပေးရမှာပါ။ သူကတော့ ကျနော်တို့ထည့်ထားတဲ့ string value ပါတဲ့ StringBuilder object ကို return ပြန်ပေးမှာပါ။
eg code: StringBuilder str2 = new StringBuilder("my string");
နောက်တနည်းကတော့ CharSequence ကို argument အနေနဲ့ထည့်ပေးရမှာပါ။ CharSequence ဆိုတာ String က implements လုပ်ထားတဲ့ interface(interface အကြောင်းလည်းတင်ဖြစ်ဦးမယ်ထင်ပါတယ်) ဖြစ်တာမလို့ အပေါ်က String ကိုထည့်ပြီး create လုပ်တာနဲ့မကွာပါဘူး။အပေါ်ကပြောခဲ့တာတွေကို စမ်းကြည့်ရအောင်ဗျာ။

source code :

အပေါ်က ရှင်းပြထားတာတွေကိုပဲရေးထားတာမလို့ code တွေကို ဖတ်ကြည့်ရင်တော့ နားလည်ကြမယ်လို့ထင်ပါတယ်။

ok, StringBuilder က mutable ဖြစ်တဲ့အကြောင်း ဆက်ရအောင်ဗျာ။

mutable, immutable အကြောင်းကအပေါ်မှာပြောထားပြီးပြီမလို့ example code လေးနဲ့ပဲရှင်းပြပေးပါမယ်။

example code:

class StringBuilderDemo {

    public static void main(String[] args) {

        StringBuilder person1 = new StringBuilder("Maung"); //create a StringBuilder with defined name
        System.out.println("Person 1 is :" + person1); //"Maung"

        StringBuilder person2 = person1;

        StringBuilder person3 = person1.append(" Maung"); //initialize person2 with the value of changed person1 and it will get "Maung Maung"

        System.out.println("Person 3 is :" + person3);
        System.out.println("Person 1 is :" + person1); //that appen method also change person1 and 2
        System.out.println("Person 2 is :" + person2);
    }
}

အပေါ်က code မှာဆိုလို့ရှိရင် person 1 ကို "Maung" ဆိုပြီး StringBuilder အနေနဲ့ initialize လုပ်ထားတာပါ။ ပြီးတော့ person 2 ကိုလည်း person 1 ကိုပဲသုံးပြီး "Maung" အနေနဲ့ပဲ ထည့်ထားတာပါ။ အဲ့တော့ StringBuilder ကို person 1 and person 2 က reference လုပ်နေကြပါတယ်။ အဲ့အထိက ပြဿနာမဖြစ်သေးပါဘူး။ person 3 အတွက် initialize လုပ်တဲ့အခါမှာတော့ person 1 ကို append(); method သုံးပြီး space တခုရယ် "Maung" ရယ်ထပ်ထည့်လိုက်တာကြောင့် person 2 က "Maung Maung" ဖြစ်သွားပေမယ့် အဲ့ StrngBuilder object ကိုမှီခိုနေတဲ့ person 1 နဲ့ person 2 ကလည်းပဲ "Maung Maung" ဆိုပြီးလိုက်ပြောင်းကုန်ကြပါတယ်။

အဲ့တာဆိုရင် StringBuilder က mutable ဖြစ်တဲ့အကြောင်းရယ် StringBuilder ကိုသုံးတဲ့အခါ သတိထားရမှာလေးတွေကို သိလောက်ပြီထင်ပါတယ်။
နောက်မှတွေ့ကြတာပေါ့။ BB

Abstraction in java

Zuki Desu — Fri, 06 Aug 2021 07:50:09 +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:))။

Java Class and Object

Zuki Desu — Tue, 13 Jul 2021 05:46:26 +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 ထဲမှာ ဝင်ရောက်ရေးသွားလို့ရပါတယ်။ ကျေးဇူးတင်ပါတယ်။

testing dev

Zuki Desu — Fri, 02 Jul 2021 14:49:02 +0000

Hello World

print("hello python")