Software Engineering ඉගෙන ගන්න ඕනම කෙනෙක් අනිවාර්යයෙන්ම දැනගන්න ඕන දෙයක් තමයි OOP (Object-Oriented Programming) කියන්නේ. ඔයා දන්නවද? ලෝකේ තියෙන ලොකුම Software, Games, සහ Web Apps ඔක්කොම වගේ හදලා තියෙන්නේ මේ OOP ක්රමයටයි.
ඇයි අපි මේක පාවිච්චි කරන්නේ? මෙච්චර කල් අපි කෝඩ් ලිව්වේ පේළියෙන් පේළියට පහළට (Procedural). හැබැයි ලොකු Project එකක් කරද්දි එහෙම කෝඩ් ලියන්න ගියොත් ඒක මහා අවුල් ජාලයක් වෙනවා. අන්න ඒ නිසා, සැබෑ ලෝකයේ තියෙන "වස්තූන්" (Objects) විදියට හිතලා කෝඩ් ලියන ක්රමයට අපි OOP කියලා කියනවා.
1. Class එකක් සහ Object එකක් කියන්නේ මොකක්ද? 🏗️
මේක තේරුම් ගන්න අපි සරල උදාහරණයක් ගමු. හිතන්න ඔයාට ගෙයක් හදන්න ඕනේ කියලා. ගෙයක් හදන්න කලින් ඔයා මොකක්ද කරන්නේ? ආකිටෙක්ට් (Architect) කෙනෙක් ලව්වා ප්ලෑන් එකක් (Blueprint) අඳිනවා නේද?
- Class (ප්ලෑන් එක): Class එකක් කියන්නේ හරියට ගෙදර ප්ලෑන් එක වගේ. ඒක ඇත්තටම පවතින්නේ නෑ. ඒක කොළයක තියෙන සටහනක් විතරයි. ඒකෙන් කියනවා "ගෙදරට කාමර 3යි, පාට සුදුයි" කියලා.
- Object (ඇත්තම ගේ): Object එකක් කියන්නේ අර ප්ලෑන් එක දිහා බලලා ගඩොල්, සිමෙන්ති දාලා හදපු ඇත්තම ගේ. එක ප්ලෑන් එකක් (Class) පාවිච්චි කරලා අපිට ඕන තරම් ගෙවල් (Objects) හදන්න පුළුවන්!
2. අපේ පළවෙනි Class එක ලියමු! (The Blueprint) 📱
අපි Tech බ්ලොග් එකක් කරන නිසා, අපි SmartPhone කියලා Class එකක් (ප්ලෑන් එකක්) හදමු. ඕනෑම Class එකකට ප්රධාන දේවල් දෙකක් තියෙනවා:
- Attributes (ලක්ෂණ): ෆෝන් එකේ බ්රෑන්ඩ් එක, රැම් එක, පාට වගේ දේවල්. (මේවා Java වල Variables).
- Methods (හැකියාවන්/ක්රියාවන්): ෆෝන් එකෙන් කෝල් ගන්න පුළුවන්, ගේම් ගහන්න පුළුවන්. (අපි කලින් පාඩමේ ඉගෙන ගත්ත Methods).
මෙන්න SmartPhone එකේ ප්ලෑන් එක (Class එක):
// 1. Attributes (ලක්ෂණ / Variables)
String brand;
String color;
int ram;
// 2. Methods (හැකියාවන්)
public void makeCall(String number) {
System.out.println("Calling " + number + " from " + brand + " phone...");
}
public void playGames() {
System.out.println("Playing games on " + ram + "GB RAM. No lag!");
}
}
public static void main එක නෑ! ඇයි ඒ? මොකද මේක ප්ලෑන් එකක් විතරයි. මේක තනියම Run වෙන්නේ නෑ.
3. Object එකක් හදමු! (Bringing the Blueprint to Life) 🪄
දැන් අපිට ප්ලෑන් එක (Class) තියෙනවා. අපි මේ ප්ලෑන් එක පාවිච්චි කරලා ඇත්තම ෆෝන් එකක් (Object එකක්) හදමු. මේක කරන්නේ අපේ සුපුරුදු main method එක තියෙන වෙනත් Class එකක් ඇතුලෙයි.
අපි මේකට පාවිච්චි කරන්නේ new කියන මැජික් වචනයයි.
public static void main(String[] args) {
// පළවෙනි Object එක හදනවා (iPhone එකක්)
SmartPhone phone1 = new SmartPhone();
// Dot (.) එක පාවිච්චි කරලා ඒකට දත්ත දෙනවා
phone1.brand = "Apple";
phone1.color = "Black";
phone1.ram = 8;
// දෙවෙනි Object එක හදනවා (Samsung එකක්)
SmartPhone phone2 = new SmartPhone();
phone2.brand = "Samsung";
phone2.color = "White";
phone2.ram = 12;
// ෆෝන් වල වැඩ කෑලි (Methods) Call කරමු
phone1.makeCall("0771234567"); // Output: Calling 0771234567 from Apple phone...
phone2.playGames(); // Output: Playing games on 12GB RAM. No lag!
}
}
ඔයා දැක්කද අපි
phone1.brand කියලා ලියපු හැටි? මේ තිතට (Dot) කියන්නේ Object එක ඇතුලට රිංගන යතුර කියලා. ඒ තිතෙන් තමයි අපි Object එක ඇතුලේ තියෙන දේවල් වලට කතා කරන්නේ.
4. Constructor එක (Object එකක් උපදින මොහොත) 🐣
අර උඩ කෝඩ් එකේ අපි Object එක හදලා, ඊට පස්සේ පේළියෙන් පේළිය පාට, රැම් එක, බ්රෑන්ඩ් එක දුන්නා නේද? ඒක ටිකක් කරදරයි වගේ නේද? කොහොමද අපි Object එක හදන වෙලාවෙම ඒ ඔක්කොම එක පාර දුන්නොත්?
අන්න ඒකට අපි පාවිච්චි කරනවා Constructor එකක්. මේක හරියට විශේෂ Method එකක් වගේ. හැබැයි මේකට තියෙන්නේ Class එකේ නමමයි! ඒ වගේම මේකට Return type එකක් (void, int) නෑ.
String brand;
int ram;
// මෙන්න Constructor එක! (Class එකේ නමමයි)
public SmartPhone(String b, int r) {
brand = b;
ram = r;
System.out.println(brand + " Phone එකක් නිර්මාණය විය!");
}
}
දැන් Main class එකේදි ෆෝන් එක හදද්දිම විස්තර දෙන්න පුළුවන්:
SmartPhone myPhone = new SmartPhone("Google Pixel", 8);
5. 'this' Keyword එක (මම / මගේ) 👤
Constructor එකක් හදද්දි පොඩි ප්රශ්නයක් එන්න පුළුවන්. හිතන්න Class එකේ තියෙන Variable එකේ නමත් brand, Constructor එකට එළියෙන් එන Parameter එකේ නමත් brand කියලා. එතකොට Java වලට පිස්සු හැදෙනවා "මේ කොයි brand එක ගැනද කියන්නේ?" කියලා.
මේක බේරගන්න අපි this කියන වචනේ පාවිච්චි කරනවා. this.brand කිව්වම Java වලට තේරෙනවා "ආ... මේ කියන්නේ Class එකේ (මගේ) brand එක ගැන" කියලා.
String brand; // Class attribute
public SmartPhone(String brand) { // Parameter
// this.brand කියන්නේ Class එකේ එක. අනික එළියෙන් ආපු එක.
this.brand = brand;
}
}
Mega Project: KP Tech Store System 🛒💻
අපි මේ ඉගෙන ගත්ත හැමදේම එකතු කරලා සැබෑ ලෝකයේ Software එකක් ලියන විදියටම කෝඩ් එකක් ලියමු. මේකෙදි අපි ලැප්ටොප් විකුණන කඩයක් (Laptop Store) එකක් හදමු.
💻 OOP Store Management Code
class Laptop {
String model;
int ram;
double price;
// Constructor එක
public Laptop(String model, int ram, double price) {
this.model = model;
this.ram = ram;
this.price = price;
}
// ලැප්ටොප් එකේ විස්තර පෙන්නන Method එක
public void showDetails() {
System.out.println("💻 Model: " + model);
System.out.println("🧠 RAM: " + ram + "GB");
System.out.println("💵 Price: Rs." + price);
System.out.println("-------------------");
}
}
// 2. පාලන මැදිරිය (Main Class)
public class KPTechStore {
public static void main(String[] args) {
System.out.println("Welcome to KP Tech Store! 🚀\n");
// ලැප්ටොප් 3ක් (Objects 3ක්) හදමු
Laptop lap1 = new Laptop("HP EliteBook", 16, 150000.00);
Laptop lap2 = new Laptop("MacBook Air M2", 8, 320000.00);
Laptop lap3 = new Laptop("Asus ROG", 32, 450000.00);
// ඒ ලැප්ටොප් වල විස්තර Print කරමු
lap1.showDetails();
lap2.showDetails();
lap3.showDetails();
}
}
අවසාන වශයෙන්... 🏁
OOP කියන්නේ එක දවසින් ඔලුවට යන දෙයක් නෙමෙයි. මේ කෝඩ් ටික ඔයාගේ IDE එකේ (VS Code හෝ IntelliJ) Type කරලම බලන්න. Class එක කොහොමද ප්ලෑන් එකක් වෙන්නේ, Object එක කොහොමද ඒකෙන් හැදෙන සැබෑ දේ වෙන්නේ කියලා ඔයාටම තේරුම් යයි.
ඊළඟ කොටසින්: OOP වල රහස් බලවේග 4! (Encapsulation, Inheritance, Polymorphism & Abstraction) 🛡️🧬
දිගටම KP Tech Gear සමඟ රැඳී සිටින්න! 👇
Discussion