Methods & Modularization (method တွေ ရေးပြီး program ကို အပိုင်းငယ်တွေ ခွဲတည်ဆောက်ခြင်း)

B2.3.4 - Construct functions and modularization.
မြန်မာလို: function (သီးခြား အလုပ်တစ်ခု လုပ်ပေးတဲ့ code အပိုင်း၊ Java မှာ method လို့ ခေါ်ပါတယ်) တွေကို ကိုယ်တိုင် တည်ဆောက်နိုင်ပြီး program ကို modularization (သီးခြား အပိုင်းငယ်တွေ ခွဲရေးခြင်း) လုပ်နိုင်ရပါမယ်။

---

အဓိက အယူအဆများ

Method (သီးခြား အလုပ်တစ်ခု လုပ်ပေးတဲ့ code အပိုင်း) ဆိုတာ သတ်မှတ်ထားတဲ့ အလုပ်တစ်ခုကို လုပ်ပေးပြီး နာမည်ပေးထားကာ ပြန်သုံးလို့ရတဲ့ code block (code အပိုင်း) ပါ။ Logic (လုပ်ဆောင်ပုံ) တစ်ခုတည်းကို အကြိမ်ကြိမ် ပြန်ရေးမယ့်အစား တစ်ကြိမ်ပဲ define (သတ်မှတ်ရေးသား) လုပ်ပြီး လိုတဲ့ နေရာတိုင်းမှာ call (ခေါ်သုံး) လုပ်ပါတယ်။

ဝေါဟာရ	အဓိပ္ပာယ်
Method	အလုပ်တစ်ခု လုပ်ပေးတဲ့ နာမည်ပေးထားတဲ့ code block
Parameter	Method header (method ရဲ့ ပထမ line) ထဲမှာ ရှိပြီး ဒေတာ လက်ခံတဲ့ variable (တန်ဖိုး သိမ်းထားတဲ့ နာမည်ပေးထားတဲ့ နေရာ)
Argument	Method ကို ခေါ်တဲ့အခါ တကယ် ပေးလိုက်တဲ့ တန်ဖိုး
Return type	Method က ပြန်ပေးမယ့် တန်ဖိုးရဲ့ အမျိုးအစား (int, double, boolean, String စသဖြင့်)
void	Method က အလုပ်တစ်ခု လုပ်ပေမယ့် တန်ဖိုး ပြန်မပေးပါ
Modularization	Program ကို သီးခြား အလုပ်လုပ်နိုင်တဲ့ method အငယ်လေးတွေ ခွဲရေးခြင်း
Scope	Variable ကို ဘယ်နေရာကနေ သုံးလို့ရလဲ (local နဲ့ global)

Method တစ်ခုရဲ့ ဖွဲ့စည်းပုံ

//  returnType  methodName(parameterType parameterName)
public static int add(int a, int b) {
    return a + b;
}

#  def function_name(parameter_names):
def add(a, b):
    return a + b

အပိုင်း	အဓိပ္ပာယ်
public static	public က access modifier (ဘယ်ကနေ သုံးခွင့်ရလဲ သတ်မှတ်တဲ့ keyword) ပါ။ static ဆိုတာ method ကို class (object တွေ ဖန်တီးဖို့ ပုံစံခွက်) ကိုယ်တိုင် ပိုင်တယ်လို့ ဆိုလိုပါတယ်။ ဒါကြောင့် main (program စ run တဲ့ method) က object (class တစ်ခုကနေ ဖန်တီးထားတဲ့ instance) မဖန်တီးဘဲ ဒီ method ကို ခေါ်လို့ ရပါတယ်။ နှစ်ခုလုံးကို OOP (object တွေနဲ့ program ရေးတဲ့ နည်း) မှာ ပိုအသေးစိတ် လေ့လာရပါမယ်
int	Return type: method က ပြန်ပေးမယ့် တန်ဖိုးရဲ့ အမျိုးအစား
add	Method ရဲ့ နာမည်ပါ။ ထုံးစံအရ camelCase (ပထမ စကားလုံးကလွဲပြီး စကားလုံးတိုင်းကို စာလုံးကြီးနဲ့ စတဲ့ ရေးပုံ) နဲ့ ရေးပါတယ်
int a, int b	Parameter များ: ပေးလိုက်မယ့် တန်ဖိုးတွေအတွက် နေရာ ကြိုထားတာပါ
return a + b	Method ကို ခေါ်တဲ့သူဆီ ပြန်ပို့ပေးတဲ့ ရလဒ်ပါ

Method က အလုပ်တစ်ခု လုပ်ပေမယ့် တန်ဖိုး ပြန်မပေးတဲ့အခါ void ကို သုံးပါ:

public static void printGreeting(String name) {
    System.out.println("Hello, " + name + "!");
}

# Python has no void keyword - a function that has no
# return statement returns None when it finishes
def print_greeting(name):
    print("Hello, " + name + "!")

Parameter နဲ့ Argument ကွာခြားချက်: Parameter ဆိုတာ method header ထဲက variable နာမည် (String name) ပါ။ Argument ဆိုတာ method ကို ခေါ်တဲ့အခါ တကယ် ပေးလိုက်တဲ့ တန်ဖိုး ("Alice") ပါ။

---

အဆင့်ဆင့် ရှင်းပြထားတဲ့ ဥပမာများ

ဥပမာ 1: void method၊ return value (ပြန်ပေးတဲ့ တန်ဖိုး) မရှိ

void method က (print ထုတ်တာလို) လုပ်ဆောင်ချက် တစ်ခု လုပ်ပေမယ့် တန်ဖိုး ပြန်မပို့ပါဘူး။

public class Greeter {
    public static void main(String[] args) {
        printSeparator();
        System.out.println("Welcome to the Grade Manager!");
        printSeparator();
    }

    public static void printSeparator() {
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~");
    }
}

def print_separator():
    print("~~~~~~~~~~~~~~~~~~~~~~~~")

# driver code - Python has no main method; the program starts here
print_separator()
print("Welcome to the Grade Manager!")
print_separator()

Output (program က ထုတ်ပြတဲ့ ရလဒ်):

~~~~~~~~~~~~~~~~~~~~~~~~
Welcome to the Grade Manager!
~~~~~~~~~~~~~~~~~~~~~~~~

အလုပ်လုပ်ပုံ:

• printSeparator() ကို main ကနေ နှစ်ကြိမ် ခေါ်ပါတယ်။ ခေါ်တိုင်း ~ character တွေပါတဲ့ line တစ်ကြောင်းတည်းကို print ထုတ်ပါတယ်။
• ဒီ method မှာ parameter မရှိပါဘူး (ကွင်း အလွတ်)၊ return value လည်း မရှိပါဘူး (void)။
• ဒါက print statement (code ညွှန်ကြားချက်) ကို ထပ်ခါထပ်ခါ မရေးရအောင် ကူညီပါတယ်။ Separator (ခြားတဲ့ line) ကို ပြောင်းချင်ရင် နေရာ တစ်နေရာတည်းမှာပဲ ပြောင်းရုံပါပဲ။

---

ဥပမာ 2: Return value ရှိတဲ့ method

တန်ဖိုး ပြန်ပေးတဲ့ method မှာ return type (int, double, boolean လို) နဲ့ return statement ပါပါတယ်။

public class Calculator {
    public static void main(String[] args) {
        int result = add(5, 3);
        System.out.println("Sum: " + result);
        System.out.println("Product: " + multiply(4, 7));
    }

    public static int add(int a, int b) {
        return a + b;
    }

    public static int multiply(int a, int b) {
        return a * b;
    }
}

def add(a, b):
    return a + b

def multiply(a, b):
    return a * b

result = add(5, 3)
print("Sum:", result)
print("Product:", multiply(4, 7))

Output:

Sum: 8
Product: 28

အလုပ်လုပ်ပုံ:

• add(5, 3) က argument 5 နဲ့ 3 ကို parameter a နဲ့ b ဆီ ပေးပို့ပါတယ်။ Method က a + b ကို တွက်ပြီး 8 ကို return လုပ်ပါတယ် (ပြန်ပေးပါတယ်)။
• ပြန်ရလာတဲ့ တန်ဖိုးကို variable (result) တစ်ခုထဲ သိမ်းထားလို့ ရသလို println ထဲမှာ တိုက်ရိုက်လည်း သုံးလို့ ရပါတယ်။

---

ဥပမာ 3: တခြား method တွေကို ခေါ်တဲ့ method များ

Method တွေက တခြား method တွေကို ခေါ်လို့ ရပါတယ်။ Modularization ရဲ့ အားသာချက်က ဒီမှာ ထင်ရှားလာပါတယ်: method တစ်ခုချင်းက သီးခြား အလုပ် တစ်ခုကိုပဲ အာရုံစိုက် လုပ်ပါတယ်။

public class GradeReport {
    public static void main(String[] args) {
        int[] grades = {85, 92, 78, 95, 88};
        printReport(grades);
    }

    public static void printReport(int[] grades) {
        printSeparator();
        System.out.println("Grade Report");
        printSeparator();
        printGrades(grades);
        double avg = calculateAverage(grades);
        System.out.println("Average: " + avg);
        printSeparator();
    }

    public static void printSeparator() {
        System.out.println("~~~~~~~~~~~~~~~~~~~~~");
    }

    public static void printGrades(int[] grades) {
        for (int i = 0; i < grades.length; i++) {
            System.out.println("Student " + (i + 1) + ": " + grades[i]);
        }
    }

    public static double calculateAverage(int[] grades) {
        int total = 0;
        for (int i = 0; i < grades.length; i++) {
            total = total + grades[i];
        }
        return (double) total / grades.length;
    }
}

def print_report(grades):
    print_separator()
    print("Grade Report")
    print_separator()
    print_grades(grades)
    avg = calculate_average(grades)
    print("Average:", avg)
    print_separator()

def print_separator():
    print("~~~~~~~~~~~~~~~~~~~~~")

def print_grades(grades):
    for i in range(len(grades)):
        print("Student " + str(i + 1) + ": " + str(grades[i]))

def calculate_average(grades):
    total = 0
    for i in range(len(grades)):
        total = total + grades[i]
    return total / len(grades)    # / always gives a decimal - no cast needed

grades = [85, 92, 78, 95, 88]
print_report(grades)

Output:

~~~~~~~~~~~~~~~~~~~~~
Grade Report
~~~~~~~~~~~~~~~~~~~~~
Student 1: 85
Student 2: 92
Student 3: 78
Student 4: 95
Student 5: 88
Average: 87.6
~~~~~~~~~~~~~~~~~~~~~

အလုပ်လုပ်ပုံ:

• main က printReport ကို ခေါ်ပြီး printReport က printSeparator၊ printGrades နဲ့ calculateAverage တို့ကို ခေါ်ပါတယ်။
• Method တစ်ခုချင်းမှာ ရှင်းလင်းတဲ့ အလုပ် တစ်ခုစီ ရှိပါတယ်။ main ကို ဖတ်ရင် program တစ်ခုလုံးရဲ့ အကျဉ်းချုပ်ကို ဖတ်ရသလို ဖြစ်ပါတယ်။
• calculateAverage က double တန်ဖိုး တစ်ခုကို return လုပ်ပြီး printReport က အဲဒါကို သိမ်းကာ print ထုတ်ပါတယ်။

စမ်းကြည့်ပါ: အရင်က ရေးခဲ့တဲ့ ပိုရှည်တဲ့ program တစ်ခု (ဥပမာ array (အရွယ်အစား ပုံသေ၊ အမျိုးအစားတူ ဒေတာစု) လေ့ကျင့်ခန်း တစ်ခု) ကို ပြန်ကြည့်ပါ။ သီးခြား method တွေအဖြစ် ခွဲထုတ်လို့ရမယ့် အပိုင်းတွေကို ရှာတွေ့နိုင်မလား။

---

ဥပမာ 4: boolean return၊ validation helper (မှန်မမှန် စစ်ပေးတဲ့ အကူ method)

boolean (true ဒါမှမဟုတ် false တန်ဖိုးပဲ ယူတဲ့) တန်ဖိုး ပြန်ပေးတဲ့ method တွေက condition (မှန်လား မှားလား စစ်တဲ့ အခြေအနေ) တွေကို စစ်ဖို့ အသုံးဝင်ပါတယ်။ အဲဒီ method တွေက code ကို English စာကြောင်း ဖတ်ရသလို ဖတ်ရလွယ်စေပါတယ်။

public class Validator {
    public static void main(String[] args) {
        int score = 85;
        if (isValidGrade(score)) {
            System.out.println(score + " is a valid grade.");
        } else {
            System.out.println(score + " is not valid.");
        }
        System.out.println("Is 150 valid? " + isValidGrade(150));
    }

    public static boolean isValidGrade(int grade) {
        return grade >= 0 && grade <= 100;
    }
}

def is_valid_grade(grade):
    return grade >= 0 and grade <= 100

score = 85
if is_valid_grade(score):
    print(score, "is a valid grade.")
else:
    print(score, "is not valid.")
print("Is 150 valid?", is_valid_grade(150))
# Python prints booleans with a capital: False (Java prints false)

Output:

85 is a valid grade.
Is 150 valid? false

---

Scope (variable ကို သုံးလို့ရတဲ့ နယ်ပယ်): local variable နဲ့ global variable

Scope က variable တစ်ခုကို ဘယ်နေရာတွေကနေ သုံးလို့ရလဲ ဆုံးဖြတ်ပါတယ်။ ဒါက IB syllabus (IB သင်ရိုး) ရဲ့ B2.3.4 အပိုင်းမှာ ပါပါတယ်။

Local Variables (method ထဲမှာပဲ ရှိတဲ့ variable များ)

Local variable ကို method တစ်ခုထဲမှာ ကြေညာပါတယ်။ အဲဒီ method run နေတုန်းမှာပဲ ရှိပြီး တခြား ဘယ် method ကနေမှ သုံးလို့ မရပါဘူး။

public class ScopeDemo {
    public static void main(String[] args) {
        int x = 10;           // local to main
        printDouble(x);
        // System.out.println(result);  // ERROR: result does not exist here
    }

    public static void printDouble(int num) {
        int result = num * 2;  // local to printDouble
        System.out.println(result);
        // System.out.println(x);      // ERROR: x does not exist here
    }
}

# The driver is wrapped in a main() function here so that x is
# local to main, as in Java. (Top-level variables in Python are
# global - functions could read them.)
def main():
    x = 10                # local to main
    print_double(x)
    # print(result)       # ERROR: result does not exist here

def print_double(num):
    result = num * 2      # local to print_double
    print(result)
    # print(x)            # ERROR: x is local to main, not visible here

main()

printDouble ထဲမှာ x ကို သုံးဖို့ ကြိုးစားရင်၊ ဒါမှမဟုတ် main ထဲမှာ result ကို သုံးဖို့ ကြိုးစားရင် variable က scope အပြင်ဘက် ရောက်နေလို့ error ဖြစ်ပါတယ်: Java မှာ cannot find symbol ဆိုတဲ့ compile error (compile လုပ်ချိန်မှာ ဖြစ်တဲ့ error) ဖြစ်ပြီး Python မှာတော့ အဲဒီ line ကို run တဲ့အခါ NameError ဖြစ်ပါတယ်။

Global (Class-Level) Variables (class တစ်ခုလုံးက သုံးလို့ရတဲ့ variable များ)

Global variable ကို class level (method တွေရဲ့ အပြင်၊ class ထဲမှာ) မှာ static နဲ့ ကြေညာပြီး class ထဲက method အားလုံးက သုံးလို့ ရပါတယ်။

public class CounterDemo {
    private static int count = 0;  // global: accessible by all methods in this class

    public static void main(String[] args) {
        increment();
        increment();
        increment();
        System.out.println("Count: " + count);  // Count: 3
    }

    public static void increment() {
        count++;  // can access the global variable
    }
}

count = 0                  # global - accessible by all functions

def increment():
    global count           # required to CHANGE a global inside a function
    count = count + 1

increment()
increment()
increment()
print("Count:", count)     # Count: 3

ဘယ်အချိန်မှာ ဘယ်ဟာကို သုံးမလဲ

	Local	Global (static)
ကြေညာတဲ့ နေရာ	Method ထဲမှာ	Method တွေရဲ့ အပြင်၊ class level မှာ
သုံးလို့ရတဲ့ နေရာ	အဲဒီ method ထဲမှာပဲ	Class ထဲက method အားလုံးမှာ
Lifetime (ရှိနေတဲ့ ကာလ)	Method စတဲ့အခါ ဖန်တီးပြီး method ပြီးတဲ့အခါ ပျက်သွားတယ်	Program တစ်ခုလုံး run နေသရွေ့ ရှိနေတယ်
ပိုသုံးသင့်လား	ဟုတ်ကဲ့: ပုံမှန်အားဖြင့် ဒါကို သုံးပါ	Method အများက ဒေတာ တစ်ခုတည်းကို မျှသုံးဖို့ လိုမှသာ

Local variable တွေကို ဦးစားပေး သုံးပြီး ဒေတာကို parameter တွေနဲ့ return value တွေကနေ ပေးပို့ပါ။ Global variable တွေကို ဘယ် method ကမဆို ဘယ်အချိန်မဆို ပြောင်းနိုင်လို့ program ကို နားလည်ရ ခက်စေပြီး debug (program ထဲက အမှားကို ရှာပြီး ပြင်) လုပ်ရလည်း ခက်စေပါတယ်။ လိုအပ်မှသာ နည်းနည်း သုံးပါ။

---

Program ကို ဘာကြောင့် modularize လုပ်သလဲ

အကျိုးကျေးဇူး	ရှင်းလင်းချက်
Readability (ဖတ်ရလွယ်ခြင်း)	main ရဲ့ အလယ်မှာ တွက်ချက်မှု line 5 ကြောင်း ရေးထားတာထက် calculateAverage(grades) က ပိုရှင်းပါတယ်
Reusability (ပြန်သုံးနိုင်ခြင်း)	တစ်ကြိမ် ရေးပြီး အကြိမ်ကြိမ် ခေါ်သုံးနိုင်ပါတယ်၊ copy-paste လုပ်စရာ မလိုပါ
Testing (စမ်းသပ် စစ်ဆေးခြင်း)	Method တစ်ခုကို သီးခြား test လုပ်လို့ ရပါတယ်
Maintainability (ပြင်ဆင် ထိန်းသိမ်းရလွယ်ခြင်း)	Logic ပေါ်တဲ့ နေရာတိုင်းမှာ လိုက်ပြင်စရာ မလိုဘဲ နေရာ တစ်နေရာတည်းမှာ ပြင်ရုံပါပဲ
Team development (အဖွဲ့လိုက် ရေးသားခြင်း)	Developer (program ရေးသူ) အမျိုးမျိုးက မတူတဲ့ method တွေကို တစ်ပြိုင်နက် ရေးနိုင်ပါတယ်

Modularization ရဲ့ အကျိုးကျေးဇူးတွေကို explain (ရှင်းပြ) လုပ်နိုင်အောင် အသင့်ပြင်ထားပါ: အကျိုးကျေးဇူး အနည်းဆုံး သုံးခုကို ဖော်ပြပြီး တစ်ခုချင်းကို ဥပမာနဲ့ ရှင်းပြပါ။

---

Quick Check (အမြန် စစ်ဆေးမေးခွန်း)

Q1. Parameter နဲ့ argument ဘာကွာသလဲ။

Q2. Method header ထဲမှာ void ဆိုတာ ဘာကို ဆိုလိုသလဲ။

Q3. Method တစ်ခုထဲမှာ ကြေညာထားတဲ့ local variable ကို ဘယ်ကနေ သုံးလို့ရသလဲ။

Q4. အောက်ပါတို့ထဲက modularization ရဲ့ အကျိုးကျေးဇူး မဟုတ်တာ က ဘာလဲ။

Q5. public static double calculateAverage(int[] grades) ကို ပေးထားရင် ဒီ method က ဘယ်လို အမျိုးအစား တန်ဖိုးကို ပြန်ပေးသလဲ။

---

Trace Exercise (code ကို တစ်ဆင့်ချင်း လိုက်ကြည့်ခြင်း)

Method call (method ကို ခေါ်တာ) တွေကို trace လုပ်ပါ: အဆင့်တိုင်းမှာ return value နဲ့ output ကို ဖြည့်ပါ။

public class TraceMethods {
    public static void main(String[] args) {
        int a = 4;
        int b = 6;
        int sum = add(a, b);
        System.out.println("Sum: " + sum);
        System.out.println("Max: " + findMax(a, b));
        greet("Alice");
    }

    public static int add(int x, int y) {
        return x + y;
    }

    public static int findMax(int x, int y) {
        if (x > y) {
            return x;
        }
        return y;
    }

    public static void greet(String name) {
        System.out.println("Hello, " + name);
    }
}

def add(x, y):
    return x + y

def find_max(x, y):
    if x > y:
        return x
    return y

def greet(name):
    print("Hello, " + name)

a = 4
b = 6
total = add(a, b)
print("Sum:", total)
print("Max:", find_max(a, b))
greet("Alice")

Return value နဲ့ Output ကော်လံတွေမှာ program ထုတ်ပေးတဲ့ အတိုင်း English လို ရိုက်ထည့်ပါ။

အဆင့်	ခေါ်တဲ့ method	Argument များ	Return value	Output
1	add(a, b)	4, 6
2	findMax(a, b)	4, 6
3	greet("Alice")	"Alice"

---

Code Completion (code ကွက်လပ် ဖြည့်ခြင်း)

ဒီ method က integer (ကိန်းပြည့်) array တစ်ခုရဲ့ ပျမ်းမျှကို တွက်ပါတယ်။ ကွက်လပ်တွေကို ဖြည့်ပါ: return type၊ loop (ထပ်ခါထပ်ခါ run တဲ့ code အပိုင်း) condition နဲ့ integer division (ကိန်းပြည့် အချင်းချင်း စားရင် ဒသမ ပျောက်သွားတာ) မဖြစ်အောင် မှန်ကန်တဲ့ cast (data type တစ်ခုကနေ တစ်ခုကို ပြောင်းခြင်း) ပါတဲ့ return statement ပါ။

public static  calculateAverage(int[] grades) {
    int total = 0;
    for (int i = 0; i < ; i++) {
        total = total + grades[i];
    }
    return ;
}

---

ဒီ method က String array တစ်ခုနဲ့ ရှာမယ့် စကားလုံး (search term) တစ်ခုကို ယူပြီး အဲဒီ စကားလုံးကို တွေ့တဲ့ index (နေရာအမှတ်) ကို return လုပ်ပါတယ်၊ မတွေ့ရင် -1 ကို return လုပ်ပါတယ်။ Return type၊ နှိုင်းယှဉ်တဲ့ method နဲ့ မတွေ့တဲ့အခါ return လုပ်မယ့် တန်ဖိုးကို ဖြည့်ပါ။

public static  searchStudent(String[] names, String target) {
    for (int i = 0; i < names.length; i++) {
        if (names[i].) {
            return i;
        }
    }
    return ;
}

---

Spot the Error (အမှား ရှာခြင်း)

ဒီ method က array ထဲက အကြီးဆုံး တန်ဖိုးကို return လုပ်ရမှာပါ။ ဒါပေမယ့် နှိုင်းယှဉ်ချက်က ပြောင်းပြန် ဖြစ်နေလို့ အငယ်ဆုံး တန်ဖိုးကို ရှာမိပါတယ်။ အမှားပါတဲ့ line ကို ရှာပြီး မှန်ကန်တဲ့ ပြင်နည်းကို ရွေးပါ။

ဒီ method က array ထဲက အကြီးဆုံး တန်ဖိုးကို return လုပ်ရမှာ ဖြစ်ပေမယ့် အငယ်ဆုံး တန်ဖိုးကို return လုပ်နေပါတယ်:

1public static int findMax(int[] arr) { 2 int max = arr[0]; 3 for (int i = 1; i < arr.length; i++) { 4 if (arr[i] < max) { 5 max = arr[i]; 6 } 7 } 8 return max; 9}

Line 4 အတွက် မှန်ကန်တဲ့ ပြင်နည်းကို ရွေးပါ:

---

ဒီ method က array ထဲမှာ စုံကိန်း ဘယ်နှစ်ခု ရှိလဲ ရေတွက်ရမှာပါ။ ဒါပေမယ့် scope error တစ်ခု ရှိပါတယ်။ count variable ကို loop block ထဲမှာ ကြေညာထားလို့ return statement ရောက်တဲ့အခါ မရှိတော့ပါဘူး။ Bug ကို ရှာပါ။

ဒီ method က စုံကိန်းတွေကို ရေတွက်ရမှာ ဖြစ်ပေမယ့် compile မဖြစ်ပါဘူး:

1public static int countEvens(int[] arr) { 2 for (int i = 0; i < arr.length; i++) { 3 int count = 0; 4 if (arr[i] % 2 == 0) { 5 count++; 6 } 7 } 8 return count; 9}

မှန်ကန်တဲ့ ပြင်နည်းကို ရွေးပါ:

---

Predict the Output (output ကို ကြိုခန့်မှန်းခြင်း)

ဒီ program က return value ရှိတဲ့ method တစ်ခုနဲ့ void method တစ်ခု ပူးပေါင်း အလုပ်လုပ်ပုံကို ပြပါတယ်။ Method call တွေကို trace လုပ်ပြီး output ကို ကြိုခန့်မှန်းပါ။

public class OutputDemo {
    public static void main(String[] args) {
        int x = 3;
        int y = doubleIt(x);
        System.out.println(x + " " + y);
        printStars(y);
    }

    public static int doubleIt(int n) {
        return n * 2;
    }

    public static void printStars(int count) {
        for (int i = 0; i < count; i++) {
            System.out.print("*");
        }
        System.out.println();
    }
}

def double_it(n):
    return n * 2

def print_stars(count):
    for i in range(count):
        print("*", end="")
    print()

x = 3
y = double_it(x)
print(x, y)
print_stars(y)

Output ကို အတိအကျ ရိုက်ထည့်ပါ:

---

ဒီ program က local scope ဘယ်လို အလုပ်လုပ်လဲ ပြပါတယ်။ Method တစ်ခုချင်းမှာ ကိုယ်ပိုင် variable copy တွေ ရှိပါတယ်။

public class ScopeOutput {
    public static void main(String[] args) {
        int x = 5;
        change(x);
        System.out.println("main: " + x);
    }

    public static void change(int x) {
        x = x + 10;
        System.out.println("change: " + x);
    }
}

def change(x):
    x = x + 10             # x is local to change: reassigning it does not affect the caller
    print("change:", x)

def main():
    x = 5
    change(x)
    print("main:", x)

main()

Output ကို အတိအကျ ရိုက်ထည့်ပါ:

အဓိက သိထားရမှာ: Primitive (Java ရဲ့ အခြေခံ ဒေတာ အမျိုးအစား) တန်ဖိုး တစ်ခု (int လို) ကို method ဆီ ပေးလိုက်ရင် copy တစ်ခု ဖန်တီးပါတယ်။ Method ထဲမှာ copy ကို ပြောင်းတာက မူလ variable ကို မထိခိုက်ပါဘူး။ ဒါကို pass by value (တန်ဖိုးရဲ့ copy ကို ပေးလိုက်ခြင်း) လို့ ခေါ်ပါတယ်။ Array တွေကိုလည်း ဒီနည်းအတိုင်း ပေးပို့ပါတယ်၊ ဒါပေမယ့် copy ကူးတဲ့ တန်ဖိုးက array ကို ညွှန်းတဲ့ reference (array ရှိရာ memory နေရာကို ညွှန်းတဲ့ တန်ဖိုး) ဖြစ်လို့ method နဲ့ ခေါ်တဲ့သူက array တစ်ခုတည်းကို မျှသုံးပါတယ်: method ထဲမှာ element (အစုထဲက အချက်) တစ်ခုကို ပြောင်းရင် မူလ array လည်း ပြောင်းသွားပါတယ်၊ parameter ကို array အသစ် တစ်ခု ပေးလိုက်တာကတော့ မူလ array ကို မပြောင်းပါဘူး။ Python အတွက် မှတ်ချက်: Python မှာလည်း ဒီအတိုင်းပါပဲ။ Parameter ကို တန်ဖိုး အသစ် ပြန်ထည့်တာ (reassign) က ဘယ် type ပဲ ဖြစ်ဖြစ် ခေါ်တဲ့သူကို မထိခိုက်ပါဘူး။ List တွေက Java array တွေလိုပဲ အလုပ်လုပ်ပါတယ်: function ထဲမှာ list ရဲ့ element တွေကို ပြောင်းရင် မူလ list လည်း ပြောင်းသွားပါတယ်။

---

Practice Exercises (လေ့ကျင့်ခန်းများ)

Core (အခြေခံ အဆင့်)

1. Separator ကို print ထုတ်ခြင်း။ Dash (-) 30 ခုပါတဲ့ line တစ်ကြောင်းကို print ထုတ်ပေးတဲ့ public static void printSeparator() method ကို ရေးပါ။ ကိုယ့်နာမည်ကို print မထုတ်ခင်နဲ့ ထုတ်ပြီးနောက်မှာ main ကနေ အဲဒီ method ကို ခေါ်ပါ။

2. ကိန်း နှစ်ခုရဲ့ ပေါင်းလဒ်။ Integer နှစ်ခုရဲ့ ပေါင်းလဒ်ကို return လုပ်ပေးတဲ့ public static int sum(int a, int b) method ကို ရေးပါ။ main ထဲမှာ မတူတဲ့ တန်ဖိုးတွေနဲ့ ခေါ်ပြီး ရလဒ်တွေကို print ထုတ်ပါ။

3. စုံကိန်း ဟုတ်မဟုတ်။ n က စုံကိန်း ဖြစ်ရင် true၊ မဟုတ်ရင် false ကို return လုပ်ပေးတဲ့ public static boolean isEven(int n) method ကို ရေးပါ။ main ထဲမှာ တန်ဖိုး အမျိုးမျိုးနဲ့ စမ်းသပ်ပါ။

4. နှုတ်ဆက်ခြင်း။ "Hello, [name]! Welcome to CS." ကို print ထုတ်ပေးတဲ့ public static void greet(String name) method ကို ရေးပါ။ main ကနေ မတူတဲ့ နာမည် အနည်းဆုံး သုံးခုနဲ့ ခေါ်ပါ။

Extension (တိုးချဲ့ အဆင့်)

5. အပူချိန် ပြောင်းစက်။ Method နှစ်ခု ရေးပါ:
   • public static double celsiusToFahrenheit(double celsius): Fahrenheit တန်ဖိုးကို return လုပ်ပါတယ်
   • public static double fahrenheitToCelsius(double fahrenheit): Celsius တန်ဖိုးကို return လုပ်ပါတယ်

   main ထဲမှာ 0C, 100C, 32F, 212F ကို ပြောင်းပြီး print ထုတ်ပါ။

6. Array စာရင်းအင်း။ int[] parameter တစ်ခုစီ ယူတဲ့ method သုံးခု ရေးပါ:
   • public static int findMax(int[] arr): အကြီးဆုံး တန်ဖိုးကို return လုပ်ပါတယ်
   • public static int findMin(int[] arr): အငယ်ဆုံး တန်ဖိုးကို return လုပ်ပါတယ်
   • public static double calculateAverage(int[] arr): ပျမ်းမျှကို return လုပ်ပါတယ်

   main ထဲမှာ test grade (စာမေးပွဲ အမှတ်) တွေပါတဲ့ array တစ်ခု ဖန်တီးပြီး method သုံးခုလုံးကို ခေါ်ကာ report တစ်ခု print ထုတ်ပါ။

7. Password စစ်စက်။ Password မှာ character အနည်းဆုံး 8 လုံး ရှိပြီး ဂဏန်း (digit) အနည်းဆုံး တစ်လုံးနဲ့ စာလုံးကြီး (uppercase letter) အနည်းဆုံး တစ်လုံး ပါရင် true ကို return လုပ်ပေးတဲ့ public static boolean isStrongPassword(String password) method ကို ရေးပါ။ main ကနေ password အမျိုးမျိုးနဲ့ စမ်းသပ်ပါ။

Challenge (စိန်ခေါ်မှု အဆင့်)

8. GradeArray ကို refactor လုပ်ခြင်း။ RefactorGrades.java starter code (အစပြု code၊ အားလုံး main ထဲမှာ ရှိပါတယ်) ကို ယူပြီး ဒီ method ခြောက်ခုကို ဒီအစဉ်အတိုင်း ခွဲထုတ်ပါ (refactor: code ရဲ့ ရလဒ် မပြောင်းဘဲ ပုံစံကို ပြင်ရေးခြင်း):
   • printSeparator(): ~ character တွေပါတဲ့ line ကို print ထုတ်ပေးတဲ့ parameter မရှိတဲ့ void method
   • calculateAverage(int[] grades): ပျမ်းမျှကို double အဖြစ် return လုပ်ပါတယ်
   • findMax(int[] grades): အမြင့်ဆုံး grade ကို return လုပ်ပါတယ်
   • findMin(int[] grades): အနိမ့်ဆုံး grade ကို return လုပ်ပါတယ်
   • printGrades(String[] names, int[] grades): စာရင်းကို print ထုတ်ပါတယ်
   • searchStudent(String[] names, String target): index ဒါမှမဟုတ် -1 ကို return လုပ်ပါတယ်

   main method ကို ဖတ်ရင် program တစ်ခုလုံးရဲ့ အကျဉ်းချုပ်ကို ဖတ်ရသလို ဖြစ်ရပါမယ်။

9. Calculator အသေးလေး။ ဒီ method တွေပါတဲ့ calculator တစ်ခု တည်ဆောက်ပါ:
   • add(double a, double b), subtract(double a, double b), multiply(double a, double b), divide(double a, double b)
   • isValidOperation(String op): op က +, -, * ဒါမှမဟုတ် / ဖြစ်ရင် true ကို return လုပ်ပါတယ်
   • main ထဲမှာ loop တစ်ခု သုံးပြီး ကိန်း နှစ်ခုနဲ့ operation တစ်ခုကို ထပ်ခါထပ်ခါ မေးပါ၊ မှန်ကန်တဲ့ method ကို ခေါ်ပြီး ရလဒ်ကို print ထုတ်ပါ။ User က "quit" လို့ ရိုက်ရင် ထွက်ပါ (string တွေကို နှိုင်းယှဉ်ဖို့ == မဟုတ်ဘဲ .equals() ကို သုံးဖို့ မမေ့ပါနဲ့)။

---

GitHub Classroom (အလိုအလျောက် စစ်ဆေးတဲ့ test တွေပါတဲ့ programming assignment များ)

Methods & Modularization Exercises

Practice void methods, return methods, array parameters, scope, and methods calling methods. Multiple files: work on them in class and complete the rest as homework.

A class assignment on GitHub Classroom: use it when your teacher has set it. It needs a free GitHub account.

Core + Extension + Challenge Accept the assignment on GitHub

Working in the Codespace

1. Accept and open. Accept the assignment above, open the link in the email from GitHub, then press Open in Codespace. In Java, change the status bar from Lightweight to Standard mode.
2. Write and check. Open src/RefactorGrades.java and complete each TODO. Start with RefactorGrades.java (in-class activity), then move to the other files. Press Run and compare the output with the comments, or run bash run-tests.sh in the Terminal.
3. Submit. In Source Control, write a message, press Commit, then Sync Changes. Your teacher’s feedback arrives as a pull request called Feedback.

The full Codespace guide, with pictures

---

ဆက်စပ် ခေါင်းစဉ်များ

အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်များ:

• Selection (if/else) (condition ပေါ်မူတည်ပြီး လမ်းကြောင်း ရွေးခြင်း): method logic ထဲမှာ သုံးတဲ့ condition တွေ
• Iteration (Loops) (ထပ်ခါထပ်ခါ လုပ်ခြင်း): method တွေထဲမှာ သုံးတဲ့ loop တွေ
• 1D Arrays (တန်းတစ်တန်းတည်းမှာ စီထားတဲ့ ဒေတာအစု): method parameter အဖြစ် ပေးပို့တဲ့ array တွေ

ဆက်စပ် ခေါင်းစဉ်များ:

• Searching Algorithms (ရှာဖွေရေး အယ်လ်ဂိုရီသမ်များ): linear search (တစ်ခုချင်း ဆက်တိုက် ရှာနည်း) နဲ့ binary search (တစ်ဝက်စီ ခွဲပြီး ရှာနည်း) တို့ဟာ method တွေပါ
• Sorting Algorithms (ဒေတာကို အစဉ်လိုက် စီတဲ့ အယ်လ်ဂိုရီသမ်များ): selection sort (အငယ်ဆုံးကို ရှာပြီး နေရာချ စီခြင်း) ကို method အဖြစ် ရေးခြင်း

နောက်ထပ် လေ့လာမယ့် ခေါင်းစဉ်များ:

• OOP: Classes & Objects (class နဲ့ object များ): method တွေက object တွေရဲ့ အစိတ်အပိုင်း ဖြစ်လာပါတယ်
• OOP: Encapsulation (ဒေတာနဲ့ method ကို တစ်စုတည်း ထုပ်ပိုးခြင်း): access modifier တွေက method ကို ဘယ်ကနေ မြင်ရ၊ သုံးရလဲ ထိန်းချုပ်ပါတယ်

Method တွေက နောက်ပိုင်း လေ့လာမယ့် အရာအားလုံးရဲ့ အခြေခံ အုတ်မြစ်တွေပါ။ OOP မှာ method တွေက static မဖြစ်တော့ဘဲ object တွေမှာ ပိုင်ပါတယ်။ Method တွေကို အခု ကျွမ်းကျင်အောင် လေ့လာထားရင် OOP ကို ကူးပြောင်းတဲ့အခါ သဘာဝကျကျ လွယ်ကူပါလိမ့်မယ်။