Classes and Objects (class နဲ့ object များ)

B3.1: Design and implement classes, create objects, define attributes and methods.
မြန်မာလို: class (object တွေ ဖန်တီးဖို့ ပုံစံခွက်) တွေကို ဒီဇိုင်းဆွဲပြီး ရေးနိုင်ရမယ်၊ object (class တစ်ခုကနေ ဖန်တီးထားတဲ့ instance) တွေကို ဖန်တီးနိုင်ရမယ်၊ attribute (object ရဲ့ ဒေတာကို သိမ်းတဲ့ variable) တွေနဲ့ method (သီးခြား အလုပ်တစ်ခု လုပ်ပေးတဲ့ code အပိုင်း) တွေကို သတ်မှတ်နိုင်ရပါမယ်။

---

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

Class ဆိုတာ ဘာလဲ

Class ဆိုတာ သူ့ကနေ ဖန်တီးမယ့် object တွေမှာ ဘယ်လို ဒေတာ (attribute တွေ) နဲ့ ဘယ်လို behaviour၊ ဆိုလိုတာက object က လုပ်နိုင်တာတွေ (method တွေ) ရှိမလဲ ဆိုတာကို သတ်မှတ်ပေးတဲ့ blueprint (တည်ဆောက်ဖို့ ပုံစံ ပုံကြမ်း) ပါ။ Class ကိုယ်တိုင်က object မဟုတ်ပါဘူး: object တွေကို ဖန်တီးရာ template (ပုံစံ) ပါ။

Class တစ်ခုမှာ အပိုင်း သုံးပိုင်း ရှိပါတယ်:

1. Attribute တွေ၊ ဒါမှမဟုတ် instance variable (object တစ်ခုချင်းရဲ့ ကိုယ်ပိုင် variable) တွေ: object တစ်ခုစီ သိမ်းထားတဲ့ ဒေတာ
2. Constructor တွေ: object အသစ်ရဲ့ attribute တွေကို စတင် တန်ဖိုး သတ်မှတ်ပေးတဲ့ အထူး method တွေ
3. Method တွေ: object လုပ်နိုင်တဲ့ operation (ဒေတာပေါ်မှာ လုပ်တဲ့ လုပ်ဆောင်ချက်) တွေ

public class Book {
    // 1. Attributes (instance variables)
    private String title;
    private String author;
    private int pages;

    // 2. Constructor
    public Book(String title, String author, int pages) {
        this.title = title;
        this.author = author;
        this.pages = pages;
    }

    // 3. Methods
    public String getTitle() {
        return title;
    }

    public String getAuthor() {
        return author;
    }

    public int getPages() {
        return pages;
    }

    public boolean isLong() {
        return pages > 300;
    }
}

class Book():
    # 1. Attributes are created inside the constructor - Python has no
    #    separate declaration section. The leading underscore marks them
    #    as private (IB convention).
    # 2. Constructor
    def __init__(self, title, author, pages):
        self._title = title
        self._author = author
        self._pages = pages

    # 3. Methods
    def get_title(self):
        return self._title

    def get_author(self):
        return self._author

    def get_pages(self):
        return self._pages

    def is_long(self):
        return self._pages > 300

Python မှာ attribute တွေကို constructor ထဲမှာပဲ ဖန်တီးပါတယ်: Java လို သီးခြား ကြေညာတဲ့ အပိုင်း မရှိပါဘူး။ နာမည် ရှေ့က underscore (_) က private ဖြစ်ကြောင်း ပြတာပါ (IB က သုံးတဲ့ ရေးထုံး)။

ရေးထုံးအရ class နာမည်တွေကို စာလုံးကြီး (Book, Student, Plant) နဲ့ စပါတယ်။ Attribute နဲ့ method နာမည်တွေကိုတော့ စာလုံးသေး (title, getTitle()) နဲ့ စပါတယ်။ ဒီ naming convention (နာမည်ပေးတဲ့ ရေးထုံး) ကို Java မှာ နေရာတိုင်း သုံးပါတယ်။ (Python မှာလည်း class နာမည်တွေကို စာလုံးကြီးနဲ့ပဲ စပါတယ်၊ attribute နဲ့ method နာမည်တွေကတော့ get_title() လို snake_case (စကားလုံးတွေကို underscore နဲ့ ဆက်ပြီး စာလုံးသေးနဲ့ ရေးပုံ) ကို သုံးပါတယ်။)

Object ဆိုတာ ဘာလဲ

Object ဆိုတာ class တစ်ခုကနေ ဖန်တီးထားတဲ့ သီးခြား instance တစ်ခုပါ။ Class က အိမ်တစ်လုံးရဲ့ blueprint ဆိုရင် အဲဒီ blueprint ကနေ ဆောက်လိုက်တဲ့ အိမ် တစ်လုံးချင်းစီက object တွေပါ။ Object တစ်ခုစီမှာ attribute တွေရဲ့ ကိုယ်ပိုင် သီးခြား copy တစ်စုစီ ရှိပါတယ်။

public class Main {
    public static void main(String[] args) {
        // Creating (instantiating) objects
        Book book1 = new Book("1984", "George Orwell", 328);
        Book book2 = new Book("Dune", "Frank Herbert", 412);

        // Each object has its own attribute values
        System.out.println(book1.getTitle());  // 1984
        System.out.println(book2.getTitle());  // Dune

        System.out.println(book1.isLong());    // true (328 > 300)
        System.out.println(book2.isLong());    // true (412 > 300)
    }
}

# Python has no main() wrapper - driver code runs at the top level

# Creating (instantiating) objects - no "new" keyword in Python
book1 = Book("1984", "George Orwell", 328)
book2 = Book("Dune", "Frank Herbert", 412)

# Each object has its own attribute values
print(book1.get_title())   # 1984
print(book2.get_title())   # Dune

print(book1.is_long())     # True (328 > 300) - Python capitalises True; Java prints true
print(book2.is_long())     # True (412 > 300)

Python မှာ main() method မလိုပါဘူး: program ကို run တဲ့ code ကို file ရဲ့ အပြင်ဆုံး အဆင့်မှာ တိုက်ရိုက် ရေးပါတယ်။ new keyword (programming language မှာ အထူး အဓိပ္ပာယ်ရှိတဲ့ စကားလုံး) လည်း မရှိပါဘူး။ Python က True (T အကြီး) လို့ print ထုတ်ပြီး Java က true လို့ ထုတ်ပါတယ်။

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

1984
Dune
true
true

book1 နဲ့ book2 က သီးခြား object နှစ်ခုပါ။ book1 ရဲ့ ဒေတာကို ပြောင်းရင် book2 ကို မထိခိုက်ပါဘူး: သူတို့က class တစ်ခုတည်းရဲ့ သီးခြားစီ ရှိတဲ့ instance တွေပါ။

Instantiation (class ကနေ object အသစ် ဖန်တီးခြင်း)

Instantiation ဆိုတာ class တစ်ခုကနေ object အသစ် ဖန်တီးတဲ့ လုပ်ငန်းစဉ်ပါ။ new Book("1984", "George Orwell", 328) လို့ ရေးလိုက်တဲ့အခါ အရာ သုံးခု ဖြစ်ပါတယ်:

1. Object အသစ်ရဲ့ attribute တွေအတွက် memory နေရာ ချပေးပါတယ်
2. ပေးလိုက်တဲ့ argument (method ကို ခေါ်တဲ့အခါ တကယ် ပေးလိုက်တဲ့ တန်ဖိုး) တွေနဲ့ constructor ကို ခေါ်ပါတယ်
3. Reference (object ရှိရာ memory နေရာကို ညွှန်းတဲ့ တန်ဖိုး) တစ်ခုကို ပြန်ပေးပါတယ်: variable book1 က object အသစ်ရဲ့ memory address (memory ထဲက နေရာ လိပ်စာ) ကို သိမ်းထားပါတယ်

Book book1 = new Book("1984", "George Orwell", 328);
//    ↑              ↑
//    reference       constructor call (creates the object)

book1 = Book("1984", "George Orwell", 328)
#  ↑        ↑
#  reference  constructor call - no "new" keyword; calling the class creates the object

Code ထဲက မြှားတွေက book1 က reference ဖြစ်ပြီး new Book(...) က object ကို ဖန်တီးတဲ့ constructor call (constructor ကို ခေါ်ခြင်း) ဖြစ်ကြောင်း ပြပါတယ်။ Python မှာ new မပါဘဲ class ကို ခေါ်လိုက်ရုံနဲ့ object ကို ဖန်တီးပါတယ်။

အဖြစ်များတဲ့ အမှား တစ်ခုက variable ကိုယ်တိုင်ကို object လို့ ထင်တာပါ။ အဲဒီလို မဟုတ်ပါဘူး: variable က object ကို ညွှန်းထားတဲ့ reference (memory address) ကို သိမ်းထားတာပါ။ Object variable တစ်ခုရဲ့ တန်ဖိုးကို နောက် object variable တစ်ခုထဲ ထည့်တဲ့အခါ ဒီ ကွာခြားချက်က အရေးကြီးပါတယ် (Object References စာမျက်နှာမှာ လေ့လာပါမယ်)။

Attributes (object ရဲ့ ဒေတာကို သိမ်းတဲ့ variable များ)

Attribute တွေကို field (object ထဲက အချက်အလက် အကွက်) ဒါမှမဟုတ် instance variable လို့လည်း ခေါ်ပါတယ်။ သူတို့က object တစ်ခုရဲ့ state (object ရဲ့ attribute တွေမှာ လက်ရှိ ရှိနေတဲ့ တန်ဖိုးများ) ကို သတ်မှတ်ပေးတဲ့ ဒေတာကို သိမ်းပါတယ်။ Object တစ်ခုစီမှာ attribute တိုင်းရဲ့ ကိုယ်ပိုင် copy ရှိပါတယ်။

public class Student {
    private String name;     // each Student object has its own name
    private int grade;       // each Student object has its own grade
    private double gpa;      // each Student object has its own gpa
}

class Student():
    # Python creates attributes inside __init__ - there is no separate
    # declaration section like Java's
    def __init__(self, name, grade, gpa):
        self._name = name       # each Student object has its own name
        self._grade = grade     # each Student object has its own grade
        self._gpa = gpa         # each Student object has its own gpa

Comment တွေက Student object တစ်ခုစီမှာ ကိုယ်ပိုင် name၊ grade၊ gpa ရှိတယ်လို့ ပြောပါတယ်။ Python မှာ attribute တွေကို __init__ ထဲမှာ ဖန်တီးပြီး Java လို သီးခြား ကြေညာတဲ့ အပိုင်း မရှိပါဘူး။

Attribute တွေကို encapsulation (ဒေတာနဲ့ method ကို တစ်စုတည်း ထုပ်ပိုးခြင်း) ဖြစ်အောင် ပုံမှန်အားဖြင့် private (class ပြင်ပကနေ တိုက်ရိုက် သုံးလို့ မရ) လို့ ကြေညာပါတယ်: တခြား class တွေက သူတို့ကို တိုက်ရိုက် ယူသုံးလို့၊ ပြင်လို့ မရပါဘူး။ Method တွေကနေတဆင့်ပဲ သွားရပါတယ်။

Attribute တစ်ခုစီအတွက် မှန်ကန်တဲ့ data type (ဒေတာ အမျိုးအစား) ကို ရွေးပါ၊ ပြီးတော့ ဘာကြောင့် အသင့်တော်ဆုံး ဖြစ်လဲ ဆိုတာကို ပြောနိုင်အောင် ပြင်ထားပါ။ ဥပမာ: name က String၊ age က int၊ gpa က double၊ isEnrolled က boolean၊ studentID က String ပါ (int မဟုတ်ပါဘူး၊ ဘာလို့လဲဆိုတော့ ID တွေမှာ ရှေ့ဆုံးက သုည တွေ ဒါမှမဟုတ် စာလုံးတွေ ပါနိုင်လို့ပါ)။

Methods (သီးခြား အလုပ်တစ်ခု လုပ်ပေးတဲ့ code အပိုင်းများ)

Method တွေက object တစ်ခု ဘာလုပ်နိုင်လဲ၊ ဆိုလိုတာက သူ့ရဲ့ behaviour (object က လုပ်နိုင်တာတွေ) ကို သတ်မှတ်ပေးပါတယ်။ Method တွေက attribute တွေကို ဖတ်နိုင်ပါတယ်၊ ပြင်နိုင်ပါတယ်၊ တွက်ချက်မှုတွေ လုပ်နိုင်ပါတယ်၊ တခြား object တွေနဲ့ ဆက်သွယ် အလုပ်လုပ်နိုင်ပါတယ်။

public class Plant {
    private String name;
    private int heightCm;
    private int waterLevel;

    public Plant(String name, int heightCm) {
        this.name = name;
        this.heightCm = heightCm;
        this.waterLevel = 50;
    }

    // Accessor method (getter) -- reads an attribute
    public int getHeightCm() {
        return heightCm;
    }

    // Accessor method (getter)
    public String getName() {
        return name;
    }

    // Mutator method (setter/modifier) -- changes an attribute
    public void water(int amount) {
        if (amount > 0) {
            waterLevel = waterLevel + amount;
        }
    }

    // Method with logic -- reads attributes and returns a result
    public boolean canGrow() {
        return waterLevel >= 10;
    }

    // Mutator method with validation
    public void grow(int cm) {
        if (cm > 0 && canGrow()) {
            heightCm = heightCm + cm;
            waterLevel = waterLevel - 10;   // growing uses water
        }
    }
}

class Plant():
    def __init__(self, name, height_cm):
        self._name = name
        self._height_cm = height_cm
        self._water_level = 50

    # Accessor method (getter) - reads an attribute
    def get_height_cm(self):
        return self._height_cm

    # Accessor method (getter)
    def get_name(self):
        return self._name

    # Mutator method (setter/modifier) - changes an attribute
    def water(self, amount):
        if amount > 0:
            self._water_level = self._water_level + amount

    # Method with logic - reads attributes and returns a result
    def can_grow(self):
        return self._water_level >= 10

    # Mutator method with validation
    def grow(self, cm):
        if cm > 0 and self.can_grow():
            self._height_cm = self._height_cm + cm
            self._water_level = self._water_level - 10   # growing uses water

Code ထဲက comment တွေက method တစ်ခုစီရဲ့ အမျိုးအစားကို ပြပါတယ်: attribute ကို ဖတ်တဲ့ method၊ attribute ကို ပြောင်းတဲ့ method၊ attribute တွေကို ဖတ်ပြီး ရလဒ်ကို return (ရလဒ်အဖြစ် ပြန်ပေး) လုပ်တဲ့ method နဲ့ validation (တန်ဖိုး မှန်မမှန် စစ်ခြင်း) ပါတဲ့ method တို့ပါ (အောက်မှာ ရှင်းပြထားပါတယ်)။ grow() ထဲက comment က ကြီးထွားတိုင်း ရေ ကုန်တယ်လို့ ဆိုလိုပါတယ်။

Method အမျိုးအစားများ:

• Accessor (getter): private attribute ရဲ့ တန်ဖိုးကို မပြောင်းဘဲ ပြန်ပေးပါတယ်။ နာမည်ကို getAttributeName() လို့ ပေးပြီး boolean (true ဒါမှမဟုတ် false တန်ဖိုးပဲ ယူတဲ့) attribute တွေအတွက် isAttributeName() လို့ ပေးပါတယ်။
• Mutator (setter/modifier): private attribute ရဲ့ တန်ဖိုးကို ပြောင်းပါတယ်၊ ပုံမှန်အားဖြင့် validation ပါပါတယ်။ နာမည်ကို setAttributeName() ဒါမှမဟုတ် water()၊ grow() လို လုပ်ဆောင်ချက်ကို ဖော်ပြတဲ့ ကြိယာ နာမည် ပေးပါတယ်။

Class တစ်ခုတည်းကနေ Object အများ

Class တစ်ခုကနေ လိုသလောက် object တွေ ဖန်တီးနိုင်ပါတယ်။ တစ်ခုချင်းစီက သီးခြား ရပ်တည်ပါတယ်:

Plant basil = new Plant("Basil", 12);
Plant mint = new Plant("Mint", 8);
Plant fern = new Plant("Fern", 30);

basil.grow(3);
// Only basil.heightCm changes. mint and fern are unaffected.

System.out.println(basil.getHeightCm());  // 15
System.out.println(mint.getHeightCm());   // 8
System.out.println(fern.getHeightCm());   // 30

basil = Plant("Basil", 12)
mint = Plant("Mint", 8)
fern = Plant("Fern", 30)

basil.grow(3)
# Only basil's height changes. mint and fern are unaffected.

print(basil.get_height_cm())   # 15
print(mint.get_height_cm())    # 8
print(fern.get_height_cm())    # 30

Comment က basil ရဲ့ အမြင့်ပဲ ပြောင်းပြီး mint နဲ့ fern ကို မထိခိုက်ဘူးလို့ ဆိုပါတယ်။

Object တွေရဲ့ Array

int ဒါမှမဟုတ် String array (အရွယ်အစား ပုံသေ၊ အမျိုးအစားတူ ဒေတာစု) တွေ ဖန်တီးနိုင်သလိုပဲ object တွေရဲ့ array တွေကိုလည်း ဖန်တီးနိုင်ပါတယ်:

// Assuming a Student class with constructor(String name, int grade)
// and a getName() accessor method

Student[] roster = new Student[30];  // array of 30 Student references

roster[0] = new Student("Alice", 11);
roster[1] = new Student("Bob", 11);
// roster[2] through roster[29] are still null

// Loop through and print names (with null check)
for (int i = 0; i < roster.length; i++) {
    if (roster[i] != null) {
        System.out.println(roster[i].getName());
    }
}

# Assuming a Student class with constructor(name, grade)
# and a get_name() accessor method

# A Python list starts empty and grows as objects are added -
# there are no pre-made empty (None) slots like Java's null references
roster = []

roster.append(Student("Alice", 11))
roster.append(Student("Bob", 11))

# Loop through and print names
for i in range(len(roster)):
    if roster[i] != None:      # only needed if None was ever stored in the list
        print(roster[i].get_name())

Code က constructor(String name, int grade) နဲ့ getName() accessor ပါတဲ့ Student class ရှိတယ်လို့ ယူဆထားပါတယ်။ new Student[30] က Student reference 30 ခုပါတဲ့ array ကို ဖန်တီးပြီး roster[2] ကနေ roster[29] အထိက null (ဘာ object ကိုမှ မညွှန်းတဲ့ တန်ဖိုး) ဖြစ်နေတုန်းပါ။ ဒါကြောင့် loop (ထပ်ခါထပ်ခါ run တဲ့ code အပိုင်း) က နာမည်ကို print မထုတ်ခင် null ဟုတ်မဟုတ် စစ်ပါတယ်။ Python list ကတော့ ဗလာနဲ့ စပြီး object ထည့်တိုင်း ကြီးလာပါတယ်: Java ရဲ့ null reference တွေလို ကြိုပြင်ထားတဲ့ ဗလာ (None) နေရာတွေ မရှိပါဘူး။ ဒါကြောင့် Python ရဲ့ None စစ်တာက list ထဲကို None ထည့်ဖူးမှပဲ လိုပါတယ်။

Object တွေရဲ့ array ကို ဖန်တီးတာက object တွေကိုယ်တိုင်ကို မဖန်တီးပါဘူး။ new Student[30] က null reference 30 ခုပါတဲ့ array ကို ဖန်တီးပါတယ်။ Object တစ်ခုချင်းစီကို new Student(...) နဲ့ သီးခြားစီ instantiate လုပ်ရပါမယ်။ Array element (အစုထဲက အချက်) တွေပေါ်မှာ method တွေ မခေါ်ခင် null ဟုတ်မဟုတ် အမြဲ စစ်ပါ။

---

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

ဥပမာ 1: လိုအပ်ချက်တွေကနေ Class ကို ဒီဇိုင်းဆွဲခြင်း

အခြေအနေ: အားကစားရုံ (gym) တစ်ခုက အသင်းဝင်တွေရဲ့ မှတ်တမ်းကို ထိန်းဖို့ လိုပါတယ်။ အသင်းဝင် တစ်ယောက်စီမှာ နာမည်၊ အသင်းဝင် အမျိုးအစား (“basic” ဒါမှမဟုတ် “premium”) နဲ့ အသင်းဝင်ခွင့် ကျန်တဲ့ လ အရေအတွက် ရှိပါတယ်။

အဆင့် 1: Attribute တွေကို ခွဲခြားသတ်မှတ်ပါ

Attribute	Type	ဘာကြောင့်လဲ
name	String	စာသား ဒေတာ
membershipType	String	“basic” ဒါမှမဟုတ် “premium”
monthsRemaining	int	လ အရေအတွက် (ကိန်းပြည့်)

အဆင့် 2: Method တွေကို ခွဲခြားသတ်မှတ်ပါ

Method	Return type (ပြန်ပေးတဲ့ ဒေတာ အမျိုးအစား)	ရည်ရွယ်ချက်
getName()	String	name အတွက် accessor
getMembershipType()	String	အသင်းဝင် အမျိုးအစားအတွက် accessor
getMonthsRemaining()	int	ကျန်တဲ့ လ အရေအတွက်အတွက် accessor
renewMembership(int months)	void	အသင်းဝင်ခွင့်ကို လ ထပ်တိုးပေးခြင်း
isExpired()	boolean	ကျန်တဲ့ လ 0 ဖြစ်မဖြစ် စစ်ခြင်း

အဆင့် 3: Class ကို ရေးပါ

public class Member {
    private String name;
    private String membershipType;
    private int monthsRemaining;

    public Member(String name, String membershipType, int monthsRemaining) {
        this.name = name;
        this.membershipType = membershipType;
        this.monthsRemaining = monthsRemaining;
    }

    public String getName() { return name; }
    public String getMembershipType() { return membershipType; }
    public int getMonthsRemaining() { return monthsRemaining; }

    public void renewMembership(int months) {
        if (months > 0) {
            monthsRemaining = monthsRemaining + months;
        }
    }

    public boolean isExpired() {
        return monthsRemaining <= 0;
    }
}

class Member():
    def __init__(self, name, membership_type, months_remaining):
        self._name = name
        self._membership_type = membership_type
        self._months_remaining = months_remaining

    def get_name(self):
        return self._name

    def get_membership_type(self):
        return self._membership_type

    def get_months_remaining(self):
        return self._months_remaining

    def renew_membership(self, months):
        if months > 0:
            self._months_remaining = self._months_remaining + months

    def is_expired(self):
        return self._months_remaining <= 0

---

ဥပမာ 2: Main ထဲမှာ Object တွေကို သုံးခြင်း

public class Main {
    public static void main(String[] args) {
        Member m1 = new Member("Alice", "premium", 6);
        Member m2 = new Member("Bob", "basic", 0);

        System.out.println(m1.getName() + " expired: " + m1.isExpired());
        System.out.println(m2.getName() + " expired: " + m2.isExpired());

        m2.renewMembership(12);
        System.out.println(m2.getName() + " expired: " + m2.isExpired());
        System.out.println(m2.getName() + " months: " + m2.getMonthsRemaining());
    }
}

m1 = Member("Alice", "premium", 6)
m2 = Member("Bob", "basic", 0)

print(m1.get_name(), "expired:", m1.is_expired())
print(m2.get_name(), "expired:", m2.is_expired())

m2.renew_membership(12)
print(m2.get_name(), "expired:", m2.is_expired())
print(m2.get_name(), "months:", m2.get_months_remaining())
# Python prints booleans as False/True (capitalised); Java prints false/true

Python က boolean တန်ဖိုးတွေကို False/True (စာလုံးကြီးနဲ့ စ) လို့ print ထုတ်ပြီး Java က false/true လို့ ထုတ်ပါတယ်။

Output:

Alice expired: false
Bob expired: true
Bob expired: false
Bob months: 12

---

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

Q1. OOP (object တွေကို အခြေခံပြီး program ရေးနည်း) မှာ class ဆိုတာ ဘာလဲ။

Q2. new Student("Alice", 11) က ဘာလုပ်သလဲ။

Q3. Book[] shelf = new Book[5]; က ဘာကို ဖန်တီးသလဲ။

Q4. getHeightCm() က ဘယ်လို method အမျိုးအစားလဲ။

Q5. plant1 နဲ့ plant2 နှစ်ခုလုံးက Plant object တွေ ဖြစ်ပြီး plant1.grow(5) ကို ခေါ်လိုက်ရင် plant2 မှာ ဘာဖြစ်မလဲ။

---

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

ဒီ code ကို Trace (တစ်ဆင့်ချင်း လိုက်ပြီး မှတ်ပါ) လုပ်ပါ။ Line တစ်ကြောင်း ပြီးတိုင်း object တစ်ခုစီရဲ့ state ကို မှတ်သွားပါ။ ဇယားထဲမှာ အဖြေတွေကို code ထဲကအတိုင်း English နဲ့ ရိုက်ထည့်ပါ (ဥပမာ true ဒါမှမဟုတ် false)။

Trace: object အများ

Book b1 = new Book("1984", "Orwell", 328);
Book b2 = new Book("Dune", "Herbert", 412);
Book b3 = new Book("Hamlet", "Shakespeare", 150);

Object	title	author	pages	isLong()?
b1
b2
b3

---

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

ဒီ code က NullPointerException နဲ့ crash (program ရုတ်တရက် ပျက်ပြီး ရပ်သွားခြင်း) ဖြစ်ပါတယ်။ Line 2 က comment ပါ: Student 3 ယောက်ကို အလိုအလျောက် ဖန်တီးပေးမယ်လို့ မျှော်လင့်ထားတယ်လို့ ဆိုပါတယ်။ အမှားပါတဲ့ line ကို ရွေးပါ၊ ပြီးရင် ပြင်နည်းကို ရွေးပါ။

1Student[] roster = new Student[3]; 2// Expecting 3 students to be created automatically 3System.out.println(roster[0].getName());

ပြင်နည်းကို ရွေးပါ:

---

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

ဒီ code က ဘာကို print ထုတ်မလဲ။

Member m = new Member("Alice", "basic", 0);
System.out.println(m.isExpired());
m.renewMembership(6);
System.out.println(m.isExpired());

Output line နှစ်ကြောင်းလုံးကို \n နဲ့ ခြားပြီး ရိုက်ထည့်ပါ:

---

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

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

1. Product class တစ်ခု ဖန်တီးပါ: ဆိုင်တစ်ဆိုင်က ကုန်ပစ္စည်းတွေရဲ့ မှတ်တမ်းကို ထိန်းပါတယ်။ ကုန်ပစ္စည်း တစ်ခုစီမှာ နာမည် (String)၊ ဈေးနှုန်း (double) နဲ့ လက်ကျန် အရေအတွက် (int) ရှိပါတယ်။ Constructor တစ်ခု၊ attribute အားလုံးအတွက် getter (private attribute ရဲ့ တန်ဖိုးကို ပြန်ပေးတဲ့ method) တွေ၊ အရေအတွက်ကို လျှော့ပေးတဲ့ sell(int amount) method (လက်ကျန် လုံလောက်မှသာ လျှော့ပါ) နဲ့ အရေအတွက် 0 ထက် ကြီးရင် true ကို return လုပ်တဲ့ isInStock() method တို့ပါတဲ့ class ကို ရေးပါ။

2. ကိုယ့် Product class ကို သုံးပါ: Main class ထဲမှာ Product object 3 ခု ဖန်တီးပါ၊ အဲဒီထဲက တစ်ခုကနေ ပစ္စည်း တချို့ ရောင်းပါ၊ ပြီးရင် သုံးခုလုံးရဲ့ လက်ကျန် အခြေအနေကို print ထုတ်ပါ။

3. Data type ကို ခွဲခြားသတ်မှတ်ခြင်း: ဒီ attribute တစ်ခုစီအတွက် အသင့်တော်ဆုံး Java data type ကို State (ဖော်ပြပါ) လုပ်ပြီး ဘာကြောင့် ရွေးလဲ Explain (ရှင်းပြပါ) လုပ်ပါ:

   • (a) ကျောင်းသား တစ်ယောက်ရဲ့ နာမည် အပြည့်အစုံ
   • (b) ဒီ semester (စာသင်နှစ်ရဲ့ တစ်ဝက်) မှာ ကျောင်း ပျက်ခဲ့တဲ့ အကြိမ်ရေ
   • (c) ကျောင်းသား တစ်ယောက်က assignment (ဆရာ ပေးတဲ့ လုပ်ရမယ့် အလုပ်) ကို တင်ပြီးပြီလား
   • (d) ကျောင်းသား တစ်ယောက်ရဲ့ GPA (အမှတ် ပျမ်းမျှ၊ ဥပမာ 3.75)
   • (e) ကျောင်းသား တစ်ယောက်ရဲ့ ID နံပါတ် (ဥပမာ “STU-00142”)

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

4. Object တွေရဲ့ array: Product object 5 ခုပါတဲ့ array တစ်ခု ဖန်တီးပါ။ ဈေးအကြီးဆုံး ကုန်ပစ္စည်းရဲ့ နာမည်ကို ရှာပြီး print ထုတ်ပေးတဲ့ loop ကို ရေးပါ။ null စစ်တာတွေ ထည့်ပါ။

5. Method ဒီဇိုင်း: အရေအတွက်ကို တိုးပေးတဲ့ restock(int amount) method ကို ကိုယ့် Product class ထဲ ထည့်ပါ။ Validation ထည့်ပါ: amount က အပေါင်းကိန်း ဖြစ်ရမယ်၊ စုစုပေါင်း လက်ကျန်က 1000 ထက် မကျော်ရပါဘူး။ Edge case (ပုံမှန် မဟုတ်တဲ့ အစွန်းဆုံး အခြေအနေ) တွေနဲ့ စမ်းသပ်ပါ။

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

6. စနစ် အပြည့်အစုံ: Student object တွေရဲ့ array (အများဆုံး 35) ကို သိမ်းထားတဲ့ Classroom class ကို Design (အစီအစဉ် ဒါမှမဟုတ် model တစ်ခု ရေးဆွဲပါ) လုပ်ပြီး ရေးပါ။ ဒီအလုပ်တွေ လုပ်တဲ့ method တွေ ထည့်ပါ:
   • ကျောင်းသား တစ်ယောက် ထည့်ခြင်း
   • နာမည်နဲ့ ကျောင်းသား တစ်ယောက်ကို ဖယ်ရှားခြင်း
   • GPA အမြင့်ဆုံး ကျောင်းသားကို ရှာခြင်း
   • အတန်းရဲ့ ပျမ်းမျှ GPA ကို တွက်ခြင်း
   • ပေးထားတဲ့ တန်ဖိုး တစ်ခုထက် GPA ပိုမြင့်တဲ့ ကျောင်းသား အားလုံးကို print ထုတ်ခြင်း

---

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

• အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်: What is OOP? (OOP ဆိုတာ ဘာလဲ): OOP ရဲ့ အခြေခံ သဘောတရား လေးခုနဲ့ အဓိက ဝေါဟာရများ
• အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်: Programming Constructs (Program တည်ဆောက်တဲ့ အခြေခံ ပုံစံများ): method တွေကို ဘယ်လို သတ်မှတ်ပြီး ခေါ်မလဲ၊ selection (condition ပေါ်မူတည်ပြီး လမ်းကြောင်း ရွေးခြင်း)၊ iteration (ထပ်ခါထပ်ခါ လုပ်ခြင်း) နဲ့ method တွေ
• နောက်ထပ် လေ့လာမယ့် ခေါင်းစဉ်: Constructors: object တွေကို ဘယ်လို စတင် တန်ဖိုး သတ်မှတ်လဲ ဆိုတာကို ပိုနက်နက် လေ့လာခြင်း
• ဆက်စပ် ခေါင်းစဉ်: 1D Arrays (တန်းတစ်တန်းတည်းမှာ စီထားတဲ့ ဒေတာအစုများ): object တွေရဲ့ array တွေက primitive type (Java ရဲ့ အခြေခံ ဒေတာ အမျိုးအစား) array တွေနဲ့ ပုံစံ အတူတူပါပဲ