Java හි this යතුරුපදය පාලනය කිරීම: පූර්ණ ආරම්භක-හිතකාමී මාර්ගෝපදේශය

1. හැඳින්වීම

Java හි වැඩසටහන් ඉගෙනීම ආරම්භ කරන විට, ඔබට විවිධ යතුරුපද හමුවේ. ඒ අතර, “this” යතුර පන්තීන් සහ වස්තු-ආකාරක සංකල්පයන් තේරුම් ගැනීමට ඉතා වැදගත් භූමිකාවක් ගනී. නමුත්, “this” යන වචනය ඉංග්‍රීසි භාෂාවේ “this/this one” යන අර්ථය පමණක් ඇති බැවින්, බොහෝ ආරම්භකයන් පළමුවෙන්ම එය වැඩසටහන් තුළ ඇයි භාවිතා කරනෙදැයි පැහැදිලි නොවනු ඇත.

මෙම ලිපිය Java හි “this” යතුරේ භූමිකාව සහ භාවිතය පැහැදිලි හා ආරම්භක‑හිතකාමී ආකාරයෙන් විස්තර කරයි. ඔබට සාමාජික විචල්‍යයන් සහ ස්ථානීය විචල්‍යයන් අතර වෙනස්කම් හඳුනා ගැනීම සහ ආරම්භකයන් තුළ “this” භාවිතය වැනි මූලික කරුණු, ප්‍රායෝගික කේත උදාහරණ සමඟ ඉගෙන ගත හැක.

අපි සාමාන්‍ය ප්‍රශ්න, දෝෂ, සහ වැදගත් සටහන්ද ආවරණය කරමු. මෙම මාර්ගෝපදේශය අවසන් වන විට, this යතුර කෙසේ ක්‍රියා කරයි, මූලික සිට උසස් තත්ත්ව දක්වා එය විශ්වාසයෙන් භාවිතා කරන ආකාරය ඔබට අවබෝධ වනු ඇත.

2. “this” යතුර කුමක්ද?

Java හි, “this” යනු වත්මන් වස්තුවම යි. පන්තියකින් වස්තුවක් (උදාහරණයක්) නිර්මාණය කරන විට, එම විශේෂ වස්තුවට යොමු වීමට “this” යතුර භාවිතා කරයි.

එම පන්තියෙන් බහු වස්තු නිර්මාණය කරත්, එක් එක් වස්තුවේ this වෙනත් උදාහරණයක් වෙයි. මෙය ඔබේ කේතය තුළ “දැනට ක්‍රියාත්මක වන වස්තුව කුමක්ද?” යන ප්‍රශ්නය පැහැදිලි කරයි.

this හි මූලික භූමිකා

• උදාහරණ විචල්‍යයන් සහ ක්‍රමයන් වෙත ප්‍රවේශය this.variableName හෝ this.methodName() භාවිතා කිරීමෙන් ඔබට විශේෂ වස්තුවේ විචල්‍යයන් සහ ක්‍රමයන් වෙත ප්‍රවේශ විය හැක.
• ස්ථානීය විචල්‍යයන් සහ උදාහරණ විචල්‍යයන් අතර වෙනස්කම් ආරම්භක පරාමිතීන් හෝ ක්‍රම පරාමිතීන් සාමාජික විචල්‍යයන් සමඟ එකම නාමය ගනී නම්, “this” භාවිතා කර ඒවා වෙනස් කරයි.

“this” අපට ඇයි අවශ්‍ය?

Java හි, ඔබට එක පන්තියකින් බහු වස්තු නිර්මාණය කළ හැකි අතර, ඒවාට ස්වතන්ත්‍ර තත්ත්ව සහ හැසිරීමක් ඇත. මෙම වස්තු තුළ, “මෙම වස්තුවම” යන්නට යොමු වීමට ක්‍රමයක් අවශ්‍ය වේ.
ඒ කාර්යය “this” යතුර කරයි.

උදාහරණයක් ලෙස, Person පන්තියක තුළ, “this” භාවිතා කිරීමෙන් “මෙම විශේෂ Person වස්තුව” යන අදහස ප්‍රකාශ කළ හැකිය.

සාරාංශය

“this” යනු වස්තු‑ආකාරක වැඩසටහන්වල ඉතා වැදගත් සංකල්පයකි. එය වස්තුවට තමන්ගේම දත්ත සහ හැසිරීම වෙත ප්‍රවේශ වීමට පාලක පාලකයක් ලෙස කටයුතු කරයි.

3. this හි ප්‍රධාන භාවිතා

Java හි “this” යතුර බොහෝ ස්ථානවල පෙනේ. පහත දැක්වෙන්නේ කේත උදාහරණ සමඟ නියෝජිත උදාහරණ කිහිපයක් වේ.

3.1 සාමාජික විචල්‍යයන් සහ ස්ථානීය විචල්‍යයන් අතර වෙනස්කම්

Java හි, ආරම්භක පරාමිතීන් සහ සාමාජික විචල්‍යයන් එකම නාමය භාවිතා කරන අවස්ථා බොහොමයක් වේ. එවැනි අවස්ථා වල, “this” ඒවා වෙනස් කරයි.

උදාහරණය: සාමාජික විචල්‍යයන් සහ ස්ථානීය විචල්‍යයන් අතර වෙනස්කම්

public class Student {
    private String name;

    public Student(String name) {
        this.name = name; // Left: member variable, Right: constructor parameter
    }
}

ඔබ this නොදැක්වූ විට, ස්ථානීය විචල්‍යය ප්‍රමුඛත්වය ලබා ගනී, එවිට සාමාජික විචල්‍යය නිසි ලෙස පවරා නොගනී.

3.2 ආරම්භකයන් තුළ this භාවිතය

Java හි ආරම්භක අතිරේකය (constructor overloading) මගින් බහු ආරම්භකයන් නිර්මාණය කළ හැක. this() භාවිතා කර ඔබට වෙනත් ආරම්භකයක් කැඳවිය හැකි අතර, මෙය කේතයේ අනුකරණය අඩු කරයි.

උදාහරණය: this() භාවිතා කර වෙනත් ආරම්භකයක් කැඳවීම

public class Book {
    private String title;
    private int price;

    public Book(String title) {
        this(title, 0); // calls another constructor
    }

    public Book(String title, int price) {
        this.title = title;
        this.price = price;
    }
}

මෙය ආරම්භක ලොජික් එකම තැනක එකතු කර, අනුකරණ කේතය වැළැක්වීමට උපකාරී වේ.

3.3 ක්‍රම චේන් කිරීම

this ආපසු ලබා දීමෙන් එකම උදාහරණය මත ක්‍රම එකට එකට කැඳවීමට හැකියාව ලැබේ.

උදාහරණය: ක්‍රම චේන් කිරීම

public class Person {
    private String name;
    private int age;

    public Person setName(String name) {
        this.name = name;
        return this;
    }

    public Person setAge(int age) {
        this.age = age;
        return this;
    }
}

// Method chaining
Person p = new Person().setName("佐藤").setAge(25);

This is widely used in builder patterns and configuration classes.

3.4 වත්මන් උදාහරණය ලබාදීම

You can use “this” when you need to pass the current instance to another method or class.

උදාහරණය: වත්මන් වස්තුව ලබාදීම

public class Printer {
    public void print(Person person) {
        System.out.println(person);
    }
}

public class Person {
    public void show(Printer printer) {
        printer.print(this); // passes this instance
    }
}

4. “this” භාවිතා කිරීමේ වැදගත් සටහන්

Although very useful, “this” must be used carefully to avoid errors.

4.1 static පරිසරයන්හි this භාවිතා කළ නොහැක

A static method or variable belongs to the class itself—not to an instance—so “this” cannot be used.

වලංගු නොවන උදාහරණය

public class Example {
    private int value;

    public static void printValue() {
        // System.out.println(this.value); // Compile error
    }
}

4.2 this අධික ලෙස භාවිතා කිරීම කියවීමට අඩු කරයි

Using “this” unnecessarily may make the code harder to read. Use it only when needed.

අවශ්‍ය නොවන භාවිතයේ උදාහරණය

public class Test {
    private int x;

    public void setX(int x) {
        this.x = x; // needed
        // this.x = this.x + 1; // excessive use
    }
}

4.3 this සහ super එකිනෙකට ගැලපෙන්න එපා

• this → වත්මන් උදාහරණය
• super → මව් පන්තිය (superclass)

උදාහරණය: this සහ super භාවිතය

public class Parent {
    public void greet() {
        System.out.println("Parent method");
    }
}

public class Child extends Parent {
    public void greet() {
        System.out.println("Child method");
        super.greet();
    }
}

5. ප්‍රායෝගික කේත උදාහරණ

5.1 සාමාජික සහ ස්ථානීය විචල්‍ය වෙනස් කිරීම

public class Account {
    private String owner;

    public Account(String owner) {
        this.owner = owner;
    }

    public void printOwner() {
        System.out.println("Account Owner: " + this.owner);
    }
}

5.2 ගොඩනැගීමේ චේන් කිරීම

public class Rectangle {
    private int width;
    private int height;

    public Rectangle(int width) {
        this(width, 1);
    }

    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }

    public void printSize() {
        System.out.println("Size: " + width + " x " + height);
    }
}

5.3 ක්‍රම චේන් කිරීම

public class BuilderExample {
    private String name;
    private int age;

    public BuilderExample setName(String name) {
        this.name = name;
        return this;
    }

    public BuilderExample setAge(int age) {
        this.age = age;
        return this;
    }

    public void printInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

BuilderExample person = new BuilderExample().setName("山田").setAge(30);
person.printInfo();

5.4 වත්මන් උදාහරණය ලබාදීම

public class Notifier {
    public void notifyUser(User user) {
        System.out.println(user.getName() + " has been notified.");
    }
}

public class User {
    private String name;
    public User(String name) { this.name = name; }
    public String getName() { return this.name; }

    public void sendNotification(Notifier notifier) {
        notifier.notifyUser(this);
    }
}

Notifier notifier = new Notifier();
User user = new User("佐藤");
user.sendNotification(notifier);

6. නිතර අසන ප්‍රශ්න (FAQ)

Q1. මට “this” සෑම විටම ලියවිය යුතුද?

A.
එකිනෙකට නොවේ. අවශ්‍ය වන විට එය භාවිතා කරන්න:

• ස්ථානීය සහ සාමාජික විචල්‍ය නාමයන් එකිනෙකට අඩංගු වේ
• ඔබට වත්මන් උදාහරණය පැහැදිලිව සඳහන් කිරීමට අවශ්‍ය නම්

Q2. static ක්‍රමයක් තුළ this භාවිතා කළහොත් කුමක් වේද?

A.
ඔබට සංයුක්ත දෝෂයක් ලැබේ. static ක්‍රමයන් පන්තියට අයත් වේ, උදාහරණයක් නොවේ.

Q3. this සහ super අතර වෙනස කුමක්ද?

• this : වත්මන් උදාහරණය
• super : මව් පන්තිය

Q4. What is the benefit of returning this in method chaining?

එය එකම අවස්ථාවේ (instance) අනුක්‍රමික ඇමතුම් කිරීමට ඉඩ සලසයි, කියවීමට පහසුකම වැඩි කරයි.

Q5. What happens if I forget to use this when needed?

ස්ථානීය (local) විචල්‍යයන් සාමාජික (member) විචල්‍යයන් මත අධික්‍රමණය කරනු ඇත, එමඟින් වැරදි පවරාම් සහ දෝෂ ඇති වේ.

7. Conclusion

මෙම ලිපිය Java “this” යතුරුපදය මූලික සිට ප්‍රායෝගික භාවිතය දක්වා පැහැදිලි කරයි. ඔබ ඉගෙන ගත්තා:

• සාමාජික විචල්‍යයන් සහ ස්ථානීය විචල්‍යයන් අතර වෙනස්කම් හඳුනා ගැනීම
• ආරම්භක (constructor) තර්කය (logic) එකම ස්ථානයකට එකතු කිරීම
• method chains නිර්මාණය කිරීම
• වත්මන් අවස්ථාව (instance) වෙනත් ක්‍රමවලට (methods) ලබා දීම

අපි තවත් වැදගත් සටහන් කිහිපයක් ආවරණය කළෙමු, උදාහරණ ලෙස:

• “this” ස්ථාවර (static) පරිසරවල භාවිතා කළ නොහැක
• “this” අධික ලෙස භාවිතා නොකරන්න
• “super” සමඟ එය නිවැරදිව භාවිතා කරන්න

“this” කෙසේ ක්‍රියා කරන්නේදැයි අවබෝධ කර ගැනීම ඔබේ Java පන්තිය (class) නිර්මාණය පැහැදිලි කර දෝෂ අඩු කරයි. Java මූලික කරුණු අධ්‍යයනය කරගෙන යන්න, සහ මෙම සංකල්පයන් වාස්තුක කේත (real code) තුළ යොදා ගන්න.