Java OOP

🏗️

Concept 01

Class & Object

පන්තිය සහ වස්තුව

Class = නිවසක සැලැස්ම (Blueprint). ලක්ෂණ හා ක්‍රියාකාරකම් සඳහා "අච්චුව".

Object = ඒ සැලැස්ම පාවිච්චි කරලා හදපු සැබෑ නිවස. එකම Class එකෙන් Objects ගෙඩි ගාණ හදන්න පුළුවන්!

ජීවිතේ උදාහරණය

🏠 Class: නිවසේ සැලැස්ම — කාමර කීයක්ද, පාට මොකක්ද කියලා තිරණය කරනවා. හැබැයි ඒ සැලැස්මෙ ජීවත් වෙන්නේ නෑ.

🏡 Object: නිමල්ගේ ගේ, කමල්ගේ ගේ — ඒ සැලැස්ම (Class) ම භාවිතා කරලා හදපු සැබෑ නිවාස.

Visual Diagram

CLASS (Blueprint)

🚗 Car

brand: String
color: String
──────────
drive()

→

OBJECT

🔴 Toyota

brand = "Toyota"
color = "Red"

OBJECT

⚫ Honda

brand = "Honda"
color = "Black"

            
Java
// මේක තමයි Blueprint එක (Class)
            class Car {

            // Attributes (ලක්ෂණ)
            String brand;
            String color;

            // Methods (ක්‍රියාකාරකම්)
            void drive() {
            System.out.println(color + " " + brand + " කාරය ධාවනය වේ.");
            }
            }

            public class Main {
            public static void main(String[]
            args) {

            // Blueprint පාවිච්චි කරලා Objects හදනවා
            Car nimalGeCar = new Car();
            nimalGeCar.brand = "Toyota";
            nimalGeCar.color = "Red";
            nimalGeCar.drive();

            Car kamalGeCar = new Car();
            kamalGeCar.brand = "Honda";
            kamalGeCar.color = "Black";
            kamalGeCar.drive();
            }
            }
          

Output

Red Toyota කාරය ධාවනය වේ.

Black Honda කාරය ධාවනය වේ.

🔐

Concept 02

Encapsulation

දත්ත සැඟවීම

දත්ත (variables) සහ ඒ දත්ත හසුරුවන methods එකම තැනකට ගොනු කිරීම.

private variables — කෙලින්ම access කරන්න බෑ.
public getters/setters — ආරක්ෂිත ක්‍රමවේදය හරහා පමණයි access කළ හැකි.

ජීවිතේ උදාහරණය

🏦 බැංකු ගිණුම: ඔයාගේ balance (ශේෂය) කාටවත් කෙලින්ම වෙනස් කරන්න බෑ — ඒක private නිසා.

💳 deposit() හෝ withdraw() method හරහා පමණයි ගනුදෙනු කළ හැකි. ඒකෙන් ආරක්ෂාව සහතික වෙනවා!

Visual Diagram

Private Data

private double balance = 5000

⛔ කෙලින්ම access = Error!

⇄

deposit(amount) public

withdraw(amount) public

getBalance() getter

            
Java
// මේක තමයි class එක: BankAccount
            class BankAccount {

            // private - ආරක්ෂාව සඳහා (කෙලින්ම access කළ නොහැක)
            private double balance;

            // සල්ලි දාන method එක (public නිසා පිටතින් access කළ හැක)
            public void deposit(double amount) {
            if (amount > 0) {
            balance = balance + amount;
            System.out.println("රුපියල් " +
            amount + " ක් තැන්පත් කරන ලදී.");
            }
            }

            // Getter - balance බලාගන්න වෙන්කර ඇති method එක
            public double getBalance() {
            return balance;
            }
            }

            public class Main {
            public static void main(String[]
            args) {

            // අලුත් BankAccount object එකක් නිර්මාණය කිරීම
            BankAccount myAccount = new BankAccount();

            // myAccount.balance = 10000; ❌ මෙසේ කිරීම Error එකකි! (balance යනු private variable එකක්
              නිසා)

            // නිවැරදි ක්‍රමයට සල්ලි තැන්පත් කිරීම
            myAccount.deposit(5000);

            // නිවැරදි ක්‍රමයට ඉතිරි මුදල බලාගැනීම
            System.out.println("ශේෂය: " +
            myAccount.getBalance());
            }
            }
          

Output

රුපියල් 5000.0 ක් තැන්පත් කරන ලදී.

ශේෂය: 5000.0

🧬

Concept 03

Inheritance

උරුමය / ප්‍රවේණිය

එක Class එකක ලක්ෂණ (attributes/methods) තවත් Class එකකට ලබා දීම.

keyword: extends — Code නැවත ලියන්නේ නැතිව (No Duplication) නව Class හදන්නේ මේ ක්‍රමයට.

ජීවිතේ උදාහරණය

👨‍👦 දෙමාපියන් → දරුවන්: තාත්තාගේ ලක්ෂණ (ඇස් වර්ණය, රුධිර වර්ගය) පුතාට ඉබේ ලැබෙනවා.

🚗 Vehicle (parent) class ට Car (child) class extends කළාම, රෝද, engine ලිවීම ආයේ කරන්නේ නෑ!

Visual Diagram

Parent Class / Super Class

🐾 Animal

eat() — ආහාර ගැනීම

extends

Child Class

🐕 Dog

bark() — නිජ method

↑ eat() — Animal ගෙන් ලැබේ

Child Class

🐈 Cat

meow() — නිජ method

↑ eat() — Animal ගෙන් ලැබේ

            
Java
// Parent Class (Super Class) - මව් පන්තිය
            class Animal {

            // හැම සතෙකුටම පොදු ක්‍රියාවක්
            void eat() {
            System.out.println("මෙම සත්වයා ආහාර
              ගනී.");
            }
            }

            // Child Class - දරුවාගේ පන්තිය ('extends' keyword මගින් Animal ගේ ලක්ෂණ ලබාගැනීම)
            class Dog extends Animal {

            // බල්ලාට පමණක් ආවේණික ක්‍රියාවක්
            void bark() {
            System.out.println("බල්ලා බුරයි: බව්
              බව්!");
            }
            }

            public class Main {
            public static void main(String[]
            args) {

            // Dog object එකක් නිර්මාණය කිරීම
            Dog myDog = new Dog();

            // Dog ගේම ක්‍රියාව (bark) කැඳවීම
            myDog.bark();

            // Animal ගෙන් inherit (ලැබුණු) ක්‍රියාව (eat) කැඳවීම
            myDog.eat();
            }
            }
          

Output

බල්ලා බුරයි: බව් බව්!

මෙම සත්වයා ආහාර ගනී.

🎭

Concept 04

Polymorphism

බහුරූපතාව

Poly = ගොඩක් | Morph = ස්වරූප

එකම ක්‍රියාවක්, විවිධ Objects මගින් විවිධ ආකාරයට සිදු කිරීම.
@Override annotation — parent ගේ method override කිරීම.

ජීවිතේ උදාහරණය

🔊 makeSound(): හැම සතාම ශබ්ද කරනවා — ඒත් ක්‍රමය වෙනස්!

🐕 Dog → "බව් බව්" | 🐈 Cat → "ඤාව් ඤාව්"
ක්‍රියාව (ශබ්ද) එකයි, ක්‍රමය වෙනස්.

Visual Diagram — Method Overriding

🐾

Animal

makeSound()

"සත්වයා ශබ්ද කරයි"

🐕

Dog

@Override makeSound()

"බව් බව්" 🔊

🐈

Cat

@Override makeSound()

"ඤාව් ඤාව්" 🔊

            
Java — Method Overriding
// Parent Class (සුනඛ හා බළල් යන දෙගොල්ලන්ටම පොදු පන්තිය)
            class Animal {
            // පොදු method එකක්
            void makeSound() {
            System.out.println("සත්වයා ශබ්ද
              කරයි");
            }
            }

            // Dog පන්තිය - Animal ගෙන් උරුමය ලබයි (extends)
            class Dog extends Animal {

            // Polymorphism: මව් පන්තියේ තිබූ method එක මෙහිදී නැවත Override කර වෙනස් කිරීම
            @Override
            void makeSound() {
            System.out.println("බල්ලා: බව්
              බව්");
            }
            }

            // Cat පන්තිය - මේකත් Animal ගෙන් උරුමය ලබයි (extends)
            class Cat extends Animal {

            // Polymorphism: මේ පන්තියෙදිත් makeSound කියන එක වෙනස් කරනවා
            @Override
            void makeSound() {
            System.out.println("පූසා: ඤාව්
              ඤාව්");
            }
            }

            public class Main {
            public static void main(String[]
            args) {

            // මව් වස්තුවක් (Animal reference) භාවිතා කරමින් දරු වස්තූන් සෑදීම ද Polymorphism හි
              කොටසකි
            Animal myDog = new Dog();
            Animal myCat = new Cat();

            // එකම method එක (makeSound) වස්තුව අනුව වෙනස්-වෙනස් ප්‍රතිචාර දක්වයි
            myDog.makeSound();
            myCat.makeSound();
            }
            }
          

Output

බල්ලා: බව් බව්

පූසා: ඤාව් ඤාව්

🎯

Concept 05

Abstraction

වියුක්තකරණය

සංකීර්ණ දේවල් සඟවලා, පරිශීලකයාට අවශ්‍ය දේ පමණක් ලබා දීම.

abstract class — සෘජුව Object හදන්න බෑ. Sub-classes හරහා implement කිරීම අනිවාර්යය.

ජීවිතේ උදාහරණය

🚗 වාහනය පැදවීම: Accelerator පෑගුවාම ඉස්සරහට යනවා — ඇතුලේ කොහොමද? ඔයාට දැනගන්න ඕන නෑ!

💳 ATM: PIN දාලා cash ගන්නවා — ඇතුලේ bank servers, encryption, database — ඔයාට නොපෙනේ.

Visual Diagram — User vs Hidden Complexity

👁️ User දකිනවා

🚗💨

startEngine() → Car ගමන් යයි!

සරලයි, පහසුයි, clean!

⚙️ ඇතුලේ සිදු වේ

Fuel Injection System

Piston Compression

Spark Ignition

Crankshaft Rotation

            
Java — Abstract Class
// Abstract Class — කෙලින්ම Object හදන්න බෑ (සම්පූර්ණ නැති
              පන්තියක්)
            abstract class Vehicle {

            // Abstract method — මෙහි ඇත්තේ නම පමණි (body එකක් නැත), sub-class එකෙන් මෙය අනිවාර්යයෙන්ම
              සම්පූර්ණ කළ යුතුයි
            abstract void startEngine();

            // සාමාන්‍ය method එකක් (මෙය දැනටමත් සම්පූර්ණ කර ඇත)
            void stopEngine() {
            System.out.println("එන්ජිම නතර
              විය.");
            }
            }

            // Vehicle extend කරලා abstract method එක implement කරනවා / සම්පූර්ණ කරනවා
            class Car extends Vehicle {

            @Override
            void startEngine() {
            System.out.println("යතුර කැරකැවීමෙන්
              කාරයේ එන්ජිම ක්‍රියාත්මක විය.");
            }
            }

            public class Main {
            public static void main(String[]
            args) {

            // myCar කියන Object එක හදන්නේ Car පන්තියෙන්, හැබැයි එය Vehicle එකක් විදියට සලකන්නත්
              පුළුවන්
            Vehicle myCar = new Car();

            myCar.startEngine();
            myCar.stopEngine();
            }
            }
          

Output

යතුර කැරකැවීමෙන් කාරයේ එන්ජිම ක්‍රියාත්මක විය.

එන්ජිම නතර විය.

🔌

Concept 06

Interface

අන්තර්මුඛය / ගිවිසගැනීම

Interface එකක් කියන්නේ ඇතැම් rules / contract එකක් — "ඔයා මේ interface implement කළාම, මේ methods අනිවාර්යයෙන්ම ලබා දෙන්න ඕනේ" කියලා කියනවා.

interface keyword → define කරන්න.
implements keyword → class එකක් interface follow කරනවා.

Abstract class ට වඩා flexible — Java class එකකට interfaces කිහිපයක් implements කරන්න පුළුවන් (Multiple Inheritance ගැටලුව නැතිව).

ජීවිතේ උදාහරණය

🔌 Electric Socket (ප්ලග් සොකට්): Socket interface කියනවා "ඔයා plug-in වෙන ඕනෑම device එකක් 230V accept කරන්න ඕනේ" කියලා.

📺 TV, 💡 Fan, 🖨️ Printer — ඒ සෑම device එකක්ම socket interface follow කළාම socket එකට connect කරගන්න පුළුවන්. Device types ගොඩාක් — ඒත් rules (interface) එකයි!

Visual Diagram — Interface & Implementations

<<interface>>

🔌 Drawable

draw() — abstract
getColor() — abstract

implements

Class

🔴 Circle

draw() ✔

getColor() ✔

+ radius

Class

🟦 Rectangle

draw() ✔

getColor() ✔

+ width, height

Abstract Class vs Interface — වෙනස කුමක්ද?

කාරණය	Interface	Abstract Class
Multiple Implement/Extend	✔ ඔව් (කිහිපයක්)	✘ එකක් පමණයි
Constructor	✘ නෑ	✔ තියෙනවා
Instance Variables	✘ constants පමණයි	✔ ඔව්
Method Body (Default)	✔ Java 8+ දී default methods	✔ ඔව්
Access Modifiers	public පමණයි (by default)	ඕනෑ modifier
Keyword	`implements`	`extends`

            
Java — Interface
// Interface එක define කිරීම (ගිවිසුම)
            interface Drawable {
            // Methods — මෙහි ඇත්තේ rules පමණයි (method body නැත)
            void draw();
            String getColor();
            }

            // Circle පන්තිය — Drawable ගිවිසුමට යටත් වීම (implements)
            class Circle implements Drawable {
            private double radius;
            private String color;

            // Constructor එක
            Circle(double r, String c) {
            this.radius = r;
            this.color = c;
            }

            // Interface එකෙහි ඇති methods අනිවාර්යයෙන්ම ක්‍රියාත්මක (implement) කළ යුතුය
            @Override
            public void draw() {
            System.out.println("⭕ රවුම ඇඳේ — Radius:
              " + radius);
            }

            @Override
            public String getColor() {
            return color;
            }
            }

            // Rectangle පන්තිය — Drawable ගිවිසුමට යටත් වීම (implements)
            class Rectangle implements Drawable {
            private double width, height;
            private String color;

            Rectangle(double w, double h, String c) {
            this.width = w;
            this.height = h;
            this.color = c;
            }

            @Override
            public void draw() {
            System.out.println("🟦 සෘජුකෝණාස්‍රය ඇඳේ
              — " + width + "x" + height);
            }

            @Override
            public String getColor() {
            return color;
            }
            }

            public class Main {
            public static void main(String[]
            args) {

            // Interface reference type එකක් විදිහට පාවිච්චි කරන්න පුළුවන් (Polymorphism)
            Drawable shape1 = new Circle(5.0, "Red");
            Drawable shape2 = new Rectangle(4.0, 6.0, "Blue");

            shape1.draw();
            System.out.println("වර්ණය: " +
            shape1.getColor());

            shape2.draw();
            System.out.println("වර්ණය: " +
            shape2.getColor());
            }
            }
          

Output

⭕ රවුම ඇඳේ — Radius: 5.0

වර්ණය: Red

🟦 සෘජුකෝණාස්‍රය ඇඳේ — 4.0x6.0

වර්ණය: Blue

Bonus — Multiple Interfaces (Java ගේ විශේෂ බලය!)

              
Java — Multiple Interfaces
interface Flyable {
              void fly();
              }

              interface Swimmable {
              void swim();
              }

              // Duck පන්තිය — Flyable (පියාසර කිරීම) සහ Swimmable (පිහිනීම) යන අතුරුමුහුණත් දෙකම
                implement කිරීම හැක
              class Duck implements Flyable, Swimmable {

              @Override
              public void fly() {
              System.out.println("🦆 තාරාවා ගුවනේ
                පියාසර කරයි!");
              }

              @Override
              public void swim() {
              System.out.println("🦆 තාරාවා වතුරේ
                පිහිනයි!");
              }
              }

              public class Main {
              public static void main(String[]
              args) {

              Duck duck = new Duck();
              duck.fly();
              duck.swim();
              }
              }
            

Output

🦆 තාරාවා ගුවනේ පියාසර කරයි!

🦆 තාරාවා වතුරේ පිහිනයි!