Java Constructors සහ Object Initialization - සම්පූර්ණ මගපෙන්වීම

ආයුබෝවන් කට්ටියට! අද අපි කතා කරන්න යන්නේ Java Programming වල ගොඩක්ම වැදගත් කොටසක් ගැන – ඒ තමයි Constructors සහ Object Initialization කියන දේවල්. Java කියන්නේ Object-Oriented Programming (OOP) වල මුල්තැන ගන්න භාෂාවක්නේ. ඉතින් OOP වලදී අපි Objects එක්ක තමයි ගොඩක් වෙලාවට වැඩ කරන්නේ. මේ Objects හරියට හදාගෙන, ඒවට ඕන කරන තොරතුරු මුලින්ම දීලා වැඩේ පටන් ගන්න හැටි තමයි Constructors හරහා වෙන්නේ. අපි හිතමු ඔයාලා අලුත් ගෙයක් හදනවා කියලා. ගේ හදලා ඉවර වෙලා ඒකට වතුර, ලයිට්, ජනේල, දොරවල් දාලා වැඩේ ලෑස්ති කරනවා වගේ තමයි මේ Constructor එකත් කරන්නේ. හරි, එහෙනම් මේක ගැන තව විස්තර දැනගන්න අපි ටිකක් ඇතුලටම යමු!

මොනවද මේ Constructors කියන්නේ?

සරලව කිව්වොත්, Constructor එකක් කියන්නේ, Class එකක Object එකක් හදනකොට ඒ Object එක මුලින්ම initialize කරන්න, එහෙම නැත්නම් ඒකට මුලින්ම ඕන කරන data ටික සෙට් කරන්න පාවිච්චි කරන විශේෂ method එකක් වගේ දෙයක්. "වගේ දෙයක්" කිව්වේ ඒක method එකක් නෙමෙයි, හැබැයි method එකක් වගේ ක්‍රියා කරන නිසයි.

Constructor එකකට තියෙන විශේෂ ලක්ෂණ ටිකක් තියෙනවා:

• එයාගේ නම හැමවෙලේම Class එකේ නමමයි. උදාහරණයක් විදියට Student කියන Class එකට තියෙන්නේ Student() කියන Constructor එකක්.
• Constructor එකකට return type එකක් නැහැ. void වත් නැහැ, මොකද ඒකෙන් කිසිම දෙයක් return කරන්නේ නැති නිසයි.
• අපි new කියන keyword එක පාවිච්චි කරලා Object එකක් හදනකොට තමයි Constructor එක automatically call වෙන්නේ.

මේකේ ප්‍රධාන අරමුණ තමයි අලුතින් හදන Object එකේ instance variables වලට default values දාන එක නැත්නම් අවශ්‍ය නම් අපිට ඕන values ටික දාන එක.

// උදාහරණයක්: Constructor එකක මූලික අදහස
class Car {
    String brand;
    String model;
    int year;

    // මේක තමයි Constructor එක
    public Car() {
        System.out.println("New Car object created!");
        brand = "Unknown";
        model = "Unknown";
        year = 2023;
    }

    public void displayCarInfo() {
        System.out.println("Brand: " + brand + ", Model: " + model + ", Year: " + year);
    }
}

public class ConstructorDemo {
    public static void main(String[] args) {
        Car myCar = new Car(); // Car() Constructor එක call වෙනවා
        myCar.displayCarInfo();
    }
}

මේ උදාහරණයෙන් පේනවා, Car කියන Class එකේ Car() කියන Constructor එකක් තියෙනවා. අපි new Car() කියලා Object එකක් හදනකොට ඒ Constructor එක ඇතුලේ තියෙන දේවල් (මේකේදී System.out.println එකයි variables initialize කරන එකයි) automatically run වෙනවා.

Default Constructor - ඔටෝමැටික් වැඩේ

හරි, දැන් අපි බලමු Default Constructor එකක් කියන්නේ මොකක්ද කියලා. අපි Class එකකට Constructor එකක් හැදුවේ නැත්නම්, Java compiler එක automatically public, no-argument Constructor එකක් අපිට හදලා දෙනවා. මේකට තමයි Default Constructor කියන්නේ.

මේ Default Constructor එක කරන්නේ, Object එකේ instance variables වලට default values දාන එකයි.

• int, float, double වගේ primitive numeric types වලට 0 (හෝ 0.0) දානවා.
• boolean වලට false දානවා.
• Object types (String ඇතුළුව) වලට null දානවා.

අපි අර කලින් Car Class එකේ Constructor එක අයින් කරලා බලමු.

// Default Constructor එක ක්‍රියා කරන හැටි
class DefaultCar {
    String brand;
    String model;
    int year;

    // Constructor එකක් අපි හැදුවේ නැහැ
    public void displayCarInfo() {
        System.out.println("Brand: " + brand + ", Model: " + model + ", Year: " + year);
    }
}

public class DefaultConstructorDemo {
    public static void main(String[] args) {
        DefaultCar myDefaultCar = new DefaultCar(); // Default Constructor එක call වෙනවා
        myDefaultCar.displayCarInfo();
        // Output: Brand: null, Model: null, Year: 0
    }
}

මේකේ Output එකෙන් පේනවා brand සහ model වලට null ඇවිත්, year වලට 0 ඇවිත් තියෙනවා. ඒක වුණේ Java compiler එක දුන්න Default Constructor එක නිසා.

හැබැයි මතක තියාගන්න, අපි Class එකකට එක Constructor එකක් හරි අතින් හැදුවොත්, compiler එක Default Constructor එක දෙන්නේ නැහැ. එතකොට අපිට ඕන නම් no-argument Constructor එකක් වෙනම හදාගන්න වෙනවා.

Parameterized Constructor - අපිට ඕන විදියට

Default Constructor එකෙන් වෙන්නේ variables වලට default values දාන එකනේ. හැබැයි ගොඩක් වෙලාවට අපිට Object එකක් හදනකොටම ඒකට අපිට ඕන values ටික දීලා initialize කරන්න ඕන වෙනවා. අන්න ඒ වෙලාවට තමයි Parameterized Constructor එකක් පාවිච්චි කරන්නේ. මේකේදී Constructor එකට parameters දාන්න පුළුවන්, ඒ parameters වලින් එන values අරගෙන instance variables initialize කරන්න පුළුවන්.

අපි කලින් Car Class එකම උදාහරණයට ගමු. ඒකට අපි brand, model, year කියන ටික Object එක හදනකොටම දෙන්න පුළුවන් විදියට Parameterized Constructor එකක් හදමු.

// Parameterized Constructor එකක්
class AdvancedCar {
    String brand;
    String model;
    int year;

    // Parameterized Constructor එක
    public AdvancedCar(String brand, String model, int year) {
        this.brand = brand;   // 'this' keyword එකෙන් instance variable එක පෙන්නනවා
        this.model = model;
        this.year = year;
        System.out.println("A new " + brand + " " + model + " created!");
    }

    public void displayCarInfo() {
        System.out.println("Brand: " + brand + ", Model: " + model + ", Year: " + year);
    }
}

public class ParameterizedConstructorDemo {
    public static void main(String[] args) {
        AdvancedCar myNewCar = new AdvancedCar("Toyota", "Prius", 2024); // values දීලා Object එක හැදුවා
        myNewCar.displayCarInfo();

        AdvancedCar anotherCar = new AdvancedCar("Honda", "Civic", 2022);
        anotherCar.displayCarInfo();
    }
}

මේකේදී AdvancedCar("Toyota", "Prius", 2024) කියලා Object එක හදනකොටම Constructor එකට values ටික දෙනවා. Constructor එක ඇතුලේ this.brand = brand; වගේ දේවල් වලින් කරන්නේ parameter එකෙන් එන brand කියන value එක instance variable එකේ තියෙන brand එකට assign කරන එකයි. this කියන keyword එකෙන් කියන්නේ "මේ Object එකේ තියෙන" කියන එක.

Constructor Overloading:

අපි Class එකක Constructor කිහිපයක් හදන්න පුළුවන්. ඒ කියන්නේ parameters ප්‍රමාණයෙන්, නැත්නම් parameters වල data types වෙනස් කරලා එකම නමින් (Class එකේ නමින්) Constructors කිහිපයක් හදන්න පුළුවන්. මේකට තමයි Constructor Overloading කියන්නේ.

// Constructor Overloading
class Vehicle {
    String type;
    String make;
    int year;

    // Default Constructor
    public Vehicle() {
        this.type = "Unknown";
        this.make = "Unknown";
        this.year = 0;
        System.out.println("Default Vehicle created.");
    }

    // Parameterized Constructor (type, make, year)
    public Vehicle(String type, String make, int year) {
        this.type = type;
        this.make = make;
        this.year = year;
        System.out.println(make + " " + type + " created.");
    }

    // Another Parameterized Constructor (only type and make)
    public Vehicle(String type, String make) {
        this.type = type;
        this.make = make;
        this.year = 2024; // Default year
        System.out.println(make + " " + type + " (current model) created.");
    }

    public void displayVehicleInfo() {
        System.out.println("Type: " + type + ", Make: " + make + ", Year: " + year);
    }
}

public class ConstructorOverloadDemo {
    public static void main(String[] args) {
        Vehicle v1 = new Vehicle(); // Calls default constructor
        v1.displayVehicleInfo();

        Vehicle v2 = new Vehicle("Car", "Mercedes-Benz", 2023); // Calls (type, make, year) constructor
        v2.displayVehicleInfo();

        Vehicle v3 = new Vehicle("Motorbike", "Yamaha"); // Calls (type, make) constructor
        v3.displayVehicleInfo();
    }
}

මේ උදාහරණයේදී අපි Vehicle Class එකට Constructors තුනක් හදලා තියෙනවා – no-argument එකක්, parameters තුනක් තියෙන එකක්, සහ parameters දෙකක් තියෙන එකක්. අපිට ඕන විදියට Object එක හදනකොට අවශ්‍ය Constructor එක call කරන්න පුළුවන්.

Object Initialization - තව දුරටත්

Constructors වලින් තමයි Object එකක instance variables initialize කරන්නේ. හැබැයි Java වල Object එකක් initialize කරන්න Constructors විතරක් නෙමෙයි තව ක්‍රම කිහිපයකුත් තියෙනවා. ඒවා ගැනත් පොඩ්ඩක් දැනගෙන ඉමු.

1. Default Values: අපි කලින් කතා කරපු Default Constructor එක වගේම, අපි කිසිම දෙයක් initialize නොකළොත්, instance variables වලට default values (numeric for 0, boolean for false, object references for null) assign වෙනවා.
2. Instance Initializer Block: මේක Constructor එකටත් කලින් run වෙන code block එකක්. අපි Class එක ඇතුලේ static නැතුව { } වගේ block එකක් දැම්මොත්, ඒක හැම Object එකක් හදනකොටම Constructor එකට කලින් run වෙනවා. මේවා ගොඩක් වෙලාවට භාවිතා කරන්නේ Constructors කිහිපයකටම පොදු initialization එකක් කරන්න වුණාම.

class Product {
    String name;
    double price;

    // Instance Initializer Block
    {
        this.name = "Generic Product";
        this.price = 0.0;
        System.out.println("Instance Initializer Block called for " + name);
    }

    public Product() {
        System.out.println("Default Constructor called.");
    }

    public Product(String name, double price) {
        this.name = name; // This overrides "Generic Product"
        this.price = price;
        System.out.println("Parameterized Constructor called for " + name);
    }

    public void displayProductInfo() {
        System.out.println("Product: " + name + ", Price: " + price);
    }
}

public class InitializationOrderDemo {
    public static void main(String[] args) {
        Product p1 = new Product();
        p1.displayProductInfo(); // Output: Product: Generic Product, Price: 0.0

        Product p2 = new Product("Laptop", 1200.00);
        p2.displayProductInfo(); // Output: Product: Laptop, Price: 1200.0
    }
}

මේකෙන් පේනවා, Instance Initializer Block එක Constructor එකට කලින් run වෙනවා, ඒ නිසා name එක Generic Product වෙනවා. හැබැයි Parameterized Constructor එකේදී ඒක Override වෙලා Laptop බවට පත් වෙනවා.

3. Static Initializer Block: මේක static keyword එකත් එක්ක එන block එකක්. මේක run වෙන්නේ Class එක memory එකට load වෙනකොට එක පාරක් විතරයි. මේක පාවිච්චි කරන්නේ static variables initialize කරන්න.

class Company {
    static String companyName;

    // Static Initializer Block
    static {
        companyName = "Tech Solutions Inc.";
        System.out.println("Static Initializer Block called. Company Name set.");
    }

    public Company() {
        System.out.println("Company object created.");
    }
}

public class StaticInitDemo {
    public static void main(String[] args) {
        System.out.println("Starting main method.");
        System.out.println("Company Name: " + Company.companyName); // Accessing static variable loads the class
        Company c1 = new Company();
        Company c2 = new Company();
    }
}

Static Initializer Block එක run වෙන්නේ Class එක load වෙනකොට විතරයි. c1 සහ c2 කියන Objects දෙක හැදුවත්, ඒ block එක print වෙන්නේ එක පාරක් විතරයි.

Initialization Order:

Java වල Object එකක් හදනකොට මේ initialization ක්‍රියාවලි සිදුවෙන පිළිවෙලක් තියෙනවා:

1. Static initialization: Class එක load වෙනකොට static variables සහ static initializer blocks execute වෙනවා. (එකම වතාවක්)
2. Instance initialization: Object එකක් හදනකොට instance variables වලට default values assign වෙනවා, ඊට පස්සේ instance initializer blocks execute වෙනවා.
3. Constructor execution: අන්තිමට Object එක හදන්න call කරපු Constructor එක execute වෙනවා.

මේ පිළිවෙල දැනගෙන ඉන්න එක, විශේෂයෙන්ම සංකීර්ණ applications හදනකොට ගොඩක් වැදගත්.

කවදාද මොකක්ද පාවිච්චි කරන්නේ?

දැන් අපි Constructors ගැන හොඳ අවබෝධයක් ගත්තා. එහෙනම් කවදාද default එක පාවිච්චි කරන්නේ, කවදාද parameterized එකක් පාවිච්චි කරන්නේ කියලා බලමු.

• Default Constructor:
  • Object එකක් හදනකොට විශේෂ initialization එකක් ඕන නැතිනම්.
  • variables වලට default values (null, 0, false) තියෙන්න දෙනවා නම්.
  • සමහර Frameworks (උදා: Spring, Hibernate) වලදී Objects load කරනකොට no-argument Constructor එකක් ඉල්ලන අවස්ථා තියෙනවා. එතකොට අපිට ඒක අතින්ම හදාගන්න වෙනවා (compiler එක Default Constructor එක දෙන්නේ අපි වෙන Constructor එකක් හැදුවොත් නැති නිසා).
• Parameterized Constructor:
  • Object එකක් හදනකොටම ඒකට අනිවාර්යයෙන්ම අවශ්‍ය data ටික pass කරන්න ඕන නම්. (උදා: new User("John Doe", "[email protected]"))
  • Object එකේ තියෙන data වල validity එක මුලින්ම check කරන්න ඕන නම්. (උදා: age negative ද කියලා Constructor එක ඇතුලේ check කරන්න පුළුවන්).
  • Object එකක් immutable කරන්න ඕන නම් (ඒ කියන්නේ හැදුවට පස්සේ ඒකේ values වෙනස් කරන්න බැරි වෙන්න). මෙතනදී Constructor එකෙන් values අරගෙන ඒවා final variables වලට assign කරනවා.

Best Practices:

• හැමවිටම Class එකක instance variables Initialize කරන්න Constructor එකක් පාවිච්චි කරන්න.
• ඔබ Class එකක් හදනකොට, ඒ Class එකේ Object එකක් හදන්න මොනවද අත්‍යවශ්‍ය කරුණු කියලා හිතලා Parameterized Constructor එකක් හදන්න. (උදා: Book Class එකකට title සහ author අත්‍යවශ්‍ය නම්, ඒවා parameters විදියට ගන්න Constructor එකක් හදන්න).
• Constructor එකක් ඇතුලේ වැඩිපුර logic දාන එකෙන් පුළුවන් තරම් වළකින්න. Constructor එකේ ප්‍රධානම කාර්යය වෙන්න ඕනේ Object එකේ state එක initialize කරන එක විතරයි.
• Constructor Overloading හරියට පාවිච්චි කරන්න. එකම Class එකේ Objects විවිධ ආකාරයට initialize කරන්න පුළුවන් වෙන්න.

Conclusion:

ඉතින් කට්ටිය, අද අපි Java Constructors සහ Object Initialization ගැන හොඳට කතා කළා. Default Constructor එකේ ඉඳලා, Parameterized Constructor එකක් කොහොමද හදන්නේ, Constructor Overloading කියන්නේ මොකක්ද, වගේම Instance සහ Static Initializer Blocks ගැනත් අපි ඉගෙන ගත්තා. මේ concepts ටික හොඳට තේරුම් ගන්න එක Java Programming වලදී ගොඩක්ම වැදගත්. මොකද Object-Oriented විදියට ලස්සනට code ලියන්න මේවා essential නිසා.

අද කතා කරපු දේවල් ඔයාලාගේ code එකේ practice කරලා බලන්න. මොනවා හරි ගැටලුවක්, සැකයක් තියෙනවනම් පහළින් comment එකක් දාගෙන යන්න. ඒ වගේම මේ වගේ තව interesting topics ගැන දැනගන්න ඕන නම්, අපිව follow කරන්න අමතක කරන්න එපා. ජයවේවා!