Java හි toString ක්‍රමය අවබෝධ කිරීම: ප්‍රායෝගික භාවිතය, අතිරේක කිරීමේ තාක්ෂණ සහ ගැටළු නිරාකරණ මාර්ගෝපදේශය

1. Introduction

Java තුළ සංවර්ධනය කරන විට ඔබට “toString method” එක බොහෝ වරක් හමුවේ. වස්තුවක තත්ත්වය හෝ අන්තර්ගතය ඉක්මනින් පරීක්ෂා කිරීමට, දෝෂ නිරාකරණය කිරීමේදී සහ ලොග් ප්‍රතිදානය ජනනය කිරීමේදී එය වැදගත් භූමිකාවක් ගනී. එNevertheless, අරඹන සහ මධ්‍යම මට්ටමේ සංවර්ධකයින් “toString එක ඇත්තටම කුමක් කරන්නේද?”, “ඉහළින් ලියවීම (overriding) නිර්දේශ කරන්නේ ඇයි?”, “අන්‍ය පරිවර්තන ක්‍රමවලින් එය කෙසේ වෙනස්ද?” යන ප්‍රශ්න අසයි.

මෙම ලිපියේ, Java හි toString method එක විස්තරාත්මකව පැහැදිලි කරමු—මූලික සංකල්පයන් සිට ප්‍රායෝගික භාවිතය, ගැටළු විසඳුම්, valueOf සමඟ වෙනස්කම්, සහ සැබෑ ලෝක භාවිත උදාහරණ දක්වා. අපි පොදු වැරදි සහ ඒවායේ විසඳුම්ද හඳුන්වා දෙමින්, ඔබට ව්‍යාපාරික සංවර්ධන අවස්ථා තුළ ගැටළු වලින් වැළැක්වීමට අවශ්‍ය දැනුම ලබා දෙමු.

ඔබ “වස්තුවක් පෙන්වද්දී අමුතු string එකක් පෙන්වයි” හෝ “toString එක කවදා කැඳවෙන්නේ?” වැනි ප්‍රශ්න අත්විඳි ඇත්නම්, මෙම මාර්ගෝපදේශය ඔබට උදව් කරයි. ඔබ අරඹන්නා වුවත්, Java තවත් ගැඹුරු මට්ටමකට පළපුරුදු වීමට බලාපොරොත්තු වන කෙනෙක් වුවත්, ප්‍රයෝජනවත් උදාහරණ සහ ප්‍රායෝගික අවබෝධයන් ඔබට සපයනු ඇත.

2. What Is the Java toString Method?

Java හි toString method එක යනු Object පන්තියේ (class) නිර්වචනය කරන ලද සාමාන්‍ය පද්ධතියකි, එය සියලු පන්තීන්ගේ පියාපත් (parent) වේ. එය වස්තුවක් “string” එකක් ලෙස නියෝජනය කිරීම සඳහා භාවිතා වේ; Java හි වස්තු සඳහා ව්‍යාපාරික කාඩ්පතක් වැනි කාර්යයක් කරයි.

toString method එක ප්‍රධාන වශයෙන් පහත අවස්ථා වල භාවිතා වේ:

• වස්තුවක් string එකක් ලෙස පෙන්වීමට අවශ්‍ය වන විට
• දෝෂ නිරාකරණය හෝ ලොග් ප්‍රතිදානයේදී වස්තුවේ අන්තර්ගතය ඉක්මනින් පරීක්ෂා කිරීමට අවශ්‍ය වන විට

How the Default Implementation Works

Java හි නව පන්තියක් නිර්මාණය කර ඔබ ඔබේම toString method එක ලියන්නේ නැති විට, Object පන්තියේ පෙරනිමි (default) ක්‍රියාත්මක කිරීම භාවිතා වේ.
මෙම ක්‍රියාත්මක කිරීම පහත පරිදි string එකක් ලබා දෙයි:

ClassName@HashCode (in hexadecimal)

උදාහරණයක් ලෙස, පහත පන්තිය සලකා බලන්න:

public class Product {
    private String name;
    private int price;
}

ඔබ මෙම පන්තියේ උදාහරණයක් (instance) නිර්මාණය කර System.out.println භාවිතා කර මුද්‍රණය කළහොත්, මෙවැනි ප්‍රතිඵලයක් ලැබේ:
Product@7a81197d

මෙම “ClassName@HashCode” ආකෘතිය වස්තු අභ්‍යන්තරයෙන් වෙනස් කිරීමට ප්‍රයෝජනවත් විය හැකි නමුත්, වස්තුවේ අන්තර්ගතය මිනිසුන්ට තේරුම් ගැනීමට අවශ්‍ය තොරතුරු 거의 ලබා නොදේ.

When toString Is Automatically Called

toString method එක පහත අවස්ථා වලදී, ඔබ එය පැහැදිලිව කැඳවන්නේ නැතිව ස්වයංක්‍රීයව ක්‍රියාත්මක වේ:

• System.out.println(object) භාවිතා කර වස්තුවක් සෘජුවම මුද්‍රණය කරන විට
• • මෙහෙයුම (operator) භාවිතා කර string එකක් සහ වස්තුවක් එකතු කරන විට (උදා: "Value: " + obj )

Java වස්තු “toString මගින් නියෝජනය කළ හැකි” ලෙස බොහෝ විට සලකන බැවින්, මෙම ක්‍රමය තේරුම් ගැනීම සහ නිසි ලෙස භාවිතා කිරීම අත්‍යවශ්‍ය වේ.

3. Basic Usage and Output Examples

toString method එක Java හි විවිධ අවස්ථා වල භාවිතා වේ. මෙම කොටසේ, ප්‍රමිත පන්තීන්හි toString කෙසේ ක්‍රියා කරයි, ඔබගේ කස්ටම් පන්තීන්හි (custom classes) එය අතිරේක නොකළ විට (override නොකළ විට) කුමක් සිදුවේ යන්න ප්‍රායෝගික උදාහරණ සමඟ පැහැදිලි කරමු.

toString in Primitive Wrapper Classes

Java primitive වර්ග (int, double ආදී) සඳහා ප්‍රමිත wrapper පන්තීන් (Integer, Double වැනි) ලබා දේ. මෙම පන්තීන් toString method එක අර්ථවත් ලෙස අතිරේක කර ඇත.

උදාහරණයක්:

Integer num = 123;
System.out.println(num.toString()); // Output: 123

Double pi = 3.14;
System.out.println(pi.toString()); // Output: 3.14

මෙම ආකාරයෙන්, primitive wrapper පන්තීන් toString භාවිතා කර ඔවුන්ගේ අගයන් සෘජුවම string ලෙස ලබා ගත හැක.

toString in Custom Classes (Without Override)

ඔබ ඔබේම පන්තියක් නිර්මාණය කරන විට, ඔබ එය අතිරේක (override) නොකළහොත්, පෙරනිමි toString ක්‍රියාත්මක කිරීම (ClassName@HashCode) භාවිතා වේ.

public class Product {
    private String name;
    private int price;

    public Product(String name, int price) {
        this.name = name;
        this.price = price;
    }
}

Product p = new Product("りんご", 150);
System.out.println(p.toString()); // Example: Product@4e25154f

මෙම ප්‍රතිදානය පන්ති නම සහ හෙක්සඩෙසිමල් හැෂ් කේතය පමණක් පෙන්වයි. එය කිසිදු අභ්‍යන්තර වටිනාකම් ඇතුළත් නොකරන බැවින්, බොහෝ යථාර්ථ ලෝක තත්ත්වයන්හිදී එය අකාර්යක්ෂම වේ.

System.out.println භාවිතා කිරීමේදී හැසිරීම

System.out.println(object) භාවිතා කිරීමේදී, toString() ස්වයංක්‍රීයව අභ්‍යන්තරව හඳුන්වා දේ.
එබැවින්, පහත දෙවනුන් පහසුවෙන්ම එකම ප්‍රතිදානයක් නිපදවයි:

System.out.println(p);            // toString is automatically called
System.out.println(p.toString()); // Explicit call

වාක්‍ය රචනාවේදී toString ස්වයංක්‍රීය හඳුන්වීම

“+” ක්‍රියාකාරකය භාවිතා කරමින් වාක්‍යයක් සහ වස්තුවක් එකතු කිරීමේදී, Java ස්වයංක්‍රීයව toString හඳුන්වයි.

System.out.println("Product info: " + p);
// Output example: "Product info: Product@4e25154f"

මෙම හැසිරීම තේරුම් ගැනීම debugging හෝ logging වේලාවට අනපේක්ෂිත වාක්‍ය ප්‍රතිදානවල හේතුව හඳුනා ගැනීමට උපකාරී වේ.

4. toString ක්‍රමය ඉක්මනින් කිරීම කෙසේද

Java හි අභිරුචි පන්ති සමඟ වැඩ කිරීමේදී, toString ක්‍රමය ඉක්මනින් කිරීම ඉතා වැදගත් වේ. එය ඉක්මනින් කිරීමෙන්, ඔබට වස්තු තොරතුරු පැහැදිලි, මිනිසුන්ට ලිපිනයට හෝඩුවට ප්‍රතිදානය කළ හැකි, debugging සහ සංවර්ධනය බොහෝමයක් කාර්යක්ෂම කරයි.

ඉක්මනින් කිරීම අවශ්‍ය වන්නේ ඇයි?

පෙර පැහැදිලි කළ පරිදි, අකොන්ටි toString ක්‍රම ක්‍රියාත්මකය “පන්තිනාමය@හැෂ්කේතය” පමණක් පෙන්වයි, එය වස්තුවේ අන්තර්ගතය හෙළි නොකරයි.
අඩුම තරමින් සංවර්ධන පරිසරයන්හිදී, ඔබට වස්තුවක තත්ත්වය ඉක්මනින් තේරුම් ගැනීමට අවශ්‍ය වන අතර, එක් එක් ක්ෂේත්‍රය පරිශීලනයෙන් පරීක්ෂා කිරීම අකාර්යක්ෂම වේ.

toString ඉක්මනින් කිරීමෙන්, ඔබට ප්‍රධාන ක්ෂේත්‍ර වටිනාකම් එක බැල්මකින් ප්‍රතිදානය කළ හැකි, පාඨකත්වය සහ ක්‍රියාකාරීත්ව කාර්යක්ෂමතාව වැඩි දියුණු කරයි.
අමතරව, විස්තරාත්මක තොරතුරු logs හෝ දෝෂ පණිවිඩවල ස්වයංක්‍රීයව ඇතුළත් කළ හැකි, troubleshooting වේගවත් කිරීමට උපකාරී වේ.

මූලික ව්‍යාකරණය සහ ක්‍රියාත්මක කිරීමේ උපදෙස්

ඉක්මනින් කළ toString ක්‍රමයක මූලික ගොඩනැගිල්ල පහත පරිදි වේ:

@Override
public String toString() {
    return "ClassName{field1=" + field1 + ", field2=" + field2 + "}";
}

උපදෙස්:

• ප්‍රතිදාන වර්ගය String විය යුතුය.
• වැරදි වළක්වා ගැනීමට @Override annotation භාවිතා කරන්න.
• වැදගත් ක්ෂේත්‍ර පමණක් ප්‍රතිදානය කරන්න (සංවේදී, පෞද්ගලික හෝ අධික ලෙස විශාල දත්ත වළක්වන්න).

සංසන්දන වගුව: අකොන්ටි vs. ඉක්මනින් කළ ප්‍රතිදාන උදාහරණ

ක්‍රියාත්මක කිරීමේ උදාහරණය

පහත දැක්වෙන්නේ පෙර කොටසෙන් ගත් එකම Product පන්තිය භාවිතා කරමින් උදාහරණයකි:

public class Product {
    private String name;
    private int price;

    public Product(String name, int price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Product{name=" + name + ", price=" + price + "}";
    }
}

මෙම ඉක්මනින් කිරීම සමඟ, System.out.println(p) වෙතින් ප්‍රතිදානය වන්නේ:

Product{name=りんご, price=150}

මෙය අකොන්ටි ප්‍රතිදානයට වඩා බොහෝමයක් තේරුම් ගත හැකිය.

සාරාංශය

toString ක්‍රමය ඉක්මනින් කිරීම Java සංවර්ධනයේ අත්‍යවශ්‍ය තාක්ෂණයකි.
එය ඔබට වස්තු තොරතුරු පැහැදිලි සහ පාඨක සැකසුමකින් ප්‍රතිදානය කිරීමට හැකි කරයි, දෛනික සංවර්ධනය සහ debugging බොහෝමයක් කාර්යක්ෂම කරයි.

5. ප්‍රායෝගික උදාහරණ: අභිරුචි පන්තිවල toString භාවිතා කිරීම

toString ක්‍රමය ඉක්මනින් කිරීම ප්‍රායෝගිකව උපකාරී විය හැකි ආකාරය තේරුම් ගැනීමට, මෙම කොටස අභිරුචි පන්ති භාවිතා කරමින් ස්පච්චි උදාහරණ ඉදිරිපත් කරයි. අපි ආරම්භකයින් බොහෝ විට අපහසු වන සුලබ දෝෂ සහ තාක්ෂණයන් ද ඉස්මතු කරමු.

ක්ෂේත්‍ර ඇතුළත්ව toString ඉක්මනින් කිරීමේ උදාහරණය

ප්‍රෝඩක්ට් තොරතුරු කළමනාකරණය සඳහා භාවිතා වන Product පන්තිය සලකන්න.
ඔබ toString ඉක්මනින් නොකළහොත්, ප්‍රතිදානය “Product@හැෂ්කේතය” පමණක් වේ.
කෙසේ වෙතත්, පහත පරිදි toString ක්‍රියාත්මක කිරීමෙන් අන්තර්ගතය ඉක්මනින් පැහැදිලි වේ.

public class Product {
    private String name;
    private int price;
    private String category;

    public Product(String name, int price, String category) {
        this.name = name;
        this.price = price;
        this.category = category;
    }

    @Override
    public String toString() {
        return "Product{name=" + name + ", price=" + price + ", category=" + category + "}";
    }
}

When you output an instance of this class:

Product apple = new Product("りんご", 150, "果物");
System.out.println(apple);
// Output example: Product{name=りんご, price=150, category=果物}

Practical Tips for Real-World Use

• During Debugging Overriding toString allows you to check each field’s value directly with System.out.println or log output.
• Displaying Arrays or Lists If you output an array or List of Product objects, the overridden toString method will be used for each element, making bulk inspection far easier.

  List<Product> products = Arrays.asList(
      new Product("みかん", 100, "果物"),
      new Product("バナナ", 120, "果物")
  );
  System.out.println(products);
  // Output example: [Product{name=みかん, price=100, category=果物}, Product{name=バナナ, price=120, category=果物}]
  

• Integration with IDE Debuggers Many IDEs (Eclipse, IntelliJ, etc.) use the toString output when showing object details at breakpoints. Writing a clean and readable toString greatly improves debugging efficiency.

Common Pitfalls Beginners Should Watch For

• There is no need to display all fields. Exclude sensitive or private data when necessary.
• Be careful of circular references when calling another object’s toString inside your own (e.g., A → B → A).

Summary

By overriding toString, you dramatically improve visibility during development, debugging, and even troubleshooting in production environments.
Use these sample implementations as a reference and apply them proactively in your custom classes.

6. Common Issues and Troubleshooting (Q&A Format)

While the toString method is convenient, incorrect implementation or usage can lead to unexpected problems.
This section summarizes frequently encountered errors and questions in a Q&A format, along with their causes and solutions.

Q1. What happens if I forget to override toString?

A1.
If you forget to override it, System.out.println or log output will show only “ClassName@HashCode,” which makes it impossible to understand the object’s internal state.
For complex classes or objects stored in arrays and lists, this often makes it difficult to distinguish one item from another.
To maintain development and debugging efficiency, always override toString when needed.

Q2. What happens if I call toString on null?

A2.
Calling toString on null throws a NullPointerException.

Example:

Product p = null;
System.out.println(p.toString()); // NullPointerException

Always check for null when it is possible:

if (p != null) {
    System.out.println(p);
} else {
    System.out.println("Product is null");
}

Q3. What if toString causes recursive calls and results in StackOverflowError?

A3.
If toString in one class calls another toString that eventually calls back into the original class, you will trigger infinite recursion, leading to a StackOverflowError.
This is common in parent–child or bidirectional references.

Possible Solutions:

• Limit output to one side of the relationship
• Output only summaries (e.g., IDs or key fields)

Q4. Why is toString called automatically during string concatenation?

A4.
When concatenating a string and an object using the “+” operator, Java automatically calls toString.
If the default toString is used, unexpected and unreadable strings may appear.
This is another reason why overriding toString is recommended.

Q5. What should I be careful about regarding security when implementing toString?

A5.
Never include passwords, personal information, private keys, or other sensitive data in the toString output.
Since logs or error messages may be exposed externally, include only the information that is safe and necessary.

Summary

toString හි කුඩා දෝෂ debugging කාර්යක්ෂමතාව බෙහෙවින් අඩු කළ හැකි බවට හෝ අනපේක්ෂිත දෝෂ ඇති කළ හැකි බවට.
මේ සඳහා පහත කරුණු මතක තබා ගන්න:

• අවශ්‍ය විට toString override කිරීම අමතක කරන්න එපා
• toString කැඳවීමට පෙර සැමවිටම null සඳහා පරීක්ෂා කරන්න
• වෘත්තාකාර සම්බන්ධතා සහ අධික ප්‍රතිදාන වළක්වන්න

මේ සුලබ ගැටලු පිළිබඳව දැනුවත් වීමෙන්, Java සංවර්ධනය බොහෝ සුමට සහ වඩාත් විශ්වාසනීය වේ.

7. toString සහ valueOf අතර වෙනස්කම්, සහ ඒවා නිවැරදිව භාවිතා කිරීම

Java ඉගෙන ගැනීමේදී, සමාන නමකින් තවත් ක්‍රමයක් “valueOf” ලෙස හමු වේ.
ඔබ්ජෙක්ට් හෝ වටිනාකම් සඳහා විලේසි දමන සඳහා දෙකම ක්‍රම භාවිතා වන බැවින්, ඒවා මිශ්‍ර කිරීම පහසුය.
කෙසේ වෙතත්, ඒවායේ භූමිකා සහ සුදුසු භාවිතා කිරීම් වෙනස් ය.
මෙම කොටස දෙකම ක්‍රම සංසන්දනය කරයි සහ නිවැරදි එක තෝරා ගැනීමට පැහැදිලි කරයි.

සංසන්දනය: toString vs. valueOf

toString භාවිතා කළ යුත්තේ කවදාද

• ඔබ්ජෙක්ට් තත්ත්වයන් මිනිසුන්ට කියවිය හැකි ආකෘතියකින් පෙන්වීමට ඕනෑම විට
• debugging හෝ logging වේලාවේ ඔබ්ජෙක්ට් අන්තර්ගත පරීක්ෂා කිරීමට
• ඔබේම පන්තිය සඳහා ප්‍රතිදාන අභිරුචිකරණය (override කිරීමෙන්)

valueOf භාවිතා කළ යුත්තේ කවදාද

• ඕනෑම වටිනාකමක් හෝ ඔබ්ජෙක්ට් String බවට පරිවර්තනය කිරීමට ඕනෑම විට
• වටිනාකම null විය හැකි වුවද ව්‍යතිරේක වළක්වා ගැනීමට ඕනෑම විට
• null ආරක්ෂාව අවශ්‍ය පෙන්වීම් හෝ logging සඳහා වටිනාකම් සූදානම් කිරීමට

  Object obj = null;
  System.out.println(String.valueOf(obj)); // Output: "null"
  System.out.println(obj.toString());      // NullPointerException
  

ප්‍රායෝගික භාවිතා කිරීම්

• පන්තියකින් පැහැදිලි, අභිරුචිකෘත තොරතුරු ලබා ගැනීමට toString භාවිතා කරන්න
• null ඇතුළුව ඕනෑම දෙයක් string බවට ආරක්ෂිතව පරිවර්තනය කිරීමට String.valueOf භාවිතා කරන්න

අමතර සටහන්

මූලික වර්ග සඳහා, toString සහ valueOf දෙකම සමාන ප්‍රතිඵල ලබා දෙයි.
කෙසේ වෙතත්, තර්කය null විය හැකි අවස්ථාවකදී, String.valueOf ආරක්ෂිත තේරීම වේ.

8. toString හි ප්‍රායෝගික භාවිතා රටා

toString ක්‍රමය නිවැරදිව ක්‍රියාත්මක කිරීමෙන්, දෛනික සංවර්ධනය සහ පද්ධති ක්‍රියාකාරීත්වයේදී බොහෝ වාසි ලැබෙනු ඇත.
මෙම කොටස සුලබ යථාර්ථ භාවිතා කිරීම් සහ කණ්ඩායම් සංවර්ධනය සඳහා හොඳම පිළිවෙත් හඳුන්වා දෙයි.

Debugging සහ Log ප්‍රතිදාන

toString ක්‍රමය සංවර්ධනය සහ නිෂ්පාදන ක්‍රියාකාරීත්වයේදී debugging හෝ logs ජනනය කිරීමේදී ඉතා වටිනාකම් ඇත.
උදාහරණයක් ලෙස, ව්‍යතිරේකයක් සිදු වූ විට හෝ ක්‍රියාකාරීත්ව ප්‍රවාහය ලුහුබඳින්නට ඕනෑම විට, toString භාවිතයෙන් ඔබ්ජෙක්ට් විස්තර මුද්‍රණය කිරීම මූල හේතු විශ්ලේෂණය බොහෝ වේගවත් කරයි.

Product p = new Product("バナナ", 120, "果物");
System.out.println(p); // Product{name=バナナ, price=120, category=果物}

Log4j හෝ SLF4J වැනි logging frameworks සමඟ ඒකාබද්ධ වූ විට, override කළ toString බොහෝ පැහැදිලි log පණිවිඩ ජනනය කරයි.

ගොනු සුරකීම සහ බාහිර පද්ධති ඒකාබද්ධතා

පාඨ මාරුවලට දත්ත සුරකින විට හෝ APIs හරහා වෙනත් පද්ධතිවලට තොරතුරු යැවීමේදී, toString භාවිතයෙන් ඔබ්ජෙක්ට් දත්ත විලේසි දමන්න.
toString ප්‍රතිදාන CSV හෝ JSON නිරූපණ ජනනය කිරීමේදී මූලාශ්‍රයක් ලෙසද ක්‍රියා කළ හැක.

UI (පරදෘශ්‍ය පෙන්වීම) හි භාවිතය

Swing හෝ JavaFX වැනි Java GUI frameworks හි, ලැයිස්තු හෝ වගුවල ඔබ්ජෙක්ට් පෙන්වීමේදී toString ක්‍රමය නිතර භාවිතා වේ.
toString හි ප්‍රතිදාන වටිනාකම බොහෝ විට ලැයිස්තු අයිතම හෝ වගු පූෂ්පාංශවල පෙන්වන සෘජු නිරූපණය වේ.

DefaultListModel<Product> model = new DefaultListModel<>();
model.addElement(new Product("みかん", 100, "果物"));
// When the model is set to a JList or JTable, the toString output is used as the display text.

කණ්ඩායම් සංවර්ධනය සඳහා හොඳම පිළිවෙත්

• කණ්ඩායම පුරා toString සඳහා ඒකාබද්ධ ආකෘතිකරණ නීති ස්ථාපිත කරන්න. මෙය logs සහ debugging ප්‍රතිදානවල කියවිය හැකිබව සහ ප්‍රමිතිකම වැඩි දියුණු කරයි.
• විශාල දත්ත ව්‍යුහ සාරාංශගත කිරීම සහ සංවේදී තොරතුරු ඉවත් කිරීම වැනි මාර්ගෝපදේශ සකසන්න.

ඵලදායීව භාවිතා කළ විට, toString ක්‍රමය සංවර්ධන වේගය සහ කේත නඩත්තුකරණය බෙහෙවින් වැඩි දියුණු කරයි.

9. සංස්කරණ-විශේෂිත සහ උසස් තොරතුරු

The toString method has been part of Java since its earliest versions, and its core behavior has not changed significantly across releases.
However, improvements in language features and coding styles have influenced how developers implement and utilize toString.
This section covers version-related notes and modern application examples.

Java අනුවාද අතර වෙනස්කම්

• toString හි මූලික හැසිරීම ස්ථාවරයි Since Java 1.0, the Object class’s toString method has followed the same format: “ClassName@HashCode.” Overriding and using toString has essentially been the same across all Java versions.
• Key Notes
• • toString හැසිරීම Java අනුවාද යාවත්කාලීනවලින් වෙනස් නොවේ.
• • සමහර තෙවන පාර්ශව පුස්තකාල සහ රාමුවල toString ප්‍රතිදානය අභිරුචිකරණය කිරීම සඳහා විශේෂාංග හඳුන්වා දී ඇත (උදාහරණයක් ලෙස, Lombok හි @ToString සටහන).

නවීන කේත ලේඛන රීති සහ යෙදුම් උදාහරණ

• Record පන්තීන් (Java 16 සහ පසු) With the introduction of records in Java 16, simple data carriers automatically generate a readable toString implementation.

  public record Book(String title, int price) {}
  
  Book book = new Book("Java入門", 2500);
  System.out.println(book); // Book[title=Java入門, price=2500]
  

• Lombok සමඟ ස්වයංක්‍රීය ක්‍රියාත්මක කිරීම Lombok allows automatic generation of toString output simply by adding the @ToString annotation. This is especially useful in large projects where manual implementation becomes time-consuming.

  import lombok.ToString;
  
  @ToString
  public class Item {
      private String name;
      private int price;
  }
  

සාරාංශය

Although the fundamental behavior of toString is consistent across Java versions, modern features and libraries help developers implement it more efficiently and safely.
Choose the appropriate implementation style based on your project requirements and team coding guidelines.

10. සාරාංශය සහ නිර්දේශිත සම්බන්ධිත විෂයයන්

The toString method is a fundamental technique in Java programming, used to represent object contents in a human-readable format.
Since the default implementation does not provide enough useful information, overriding it—when appropriate—significantly enhances both development efficiency and debugging productivity.

This article covered the structure of toString, how to implement it, common mistakes and troubleshooting tips, as well as differences between toString and valueOf and practical usage patterns.
With the included sample code and guidance, even beginners can confidently implement effective toString methods.

ප්‍රධාන සාරාංශ

• toString, Object පන්තියෙන් උත්පන්න වන අතර, වස්තු තොරතුරු මනුෂ්‍ය-කියවිය හැකි ආකාරයකින් පෙන්වීමට භාවිතා වේ.
• පෙරනිමි ක්‍රියාත්මක කිරීම ප්‍රයෝජනවත් නොවේ; පැහැදිලිත්වය සඳහා අභිරුචි පන්තීන් එය අතිරේක කළ යුතුය.
• ක්‍රියාත්මක කිරීමේදී null අගයන්, වටකුරු යොමුකිරීම්, සහ සංවේදී දත්ත සැලකිල්ලෙන් පරිහරණය කරන්න.
• toString සහ valueOf අතර වෙනස්කම් තේරුම් ගැනීම වඩා ලවච්ච සහ ශක්තිමත් කේත ලේඛනයට ඉඩ සලසයි.

නිර්දේශිත සම්බන්ධිත විෂයයන්

• Java හි equals සහ hashCode භාවිතය සඳහා හොඳම පුරුදු
• StringBuilder සහ StringBuffer සමඟ කාර්යක්ෂම string සැකසීම
• IDE මෙවලම් (Eclipse, IntelliJ, ආදිය) භාවිතා කර ප්‍රායෝගික දෝෂ නිරාකරණ තාක්ෂණ
• Java හි දෝෂ හසුරවීම (try-catch-finally) සහ පොදු වැරදි
• Lombok වැනි ප්‍රයෝජනවත් පුස්තකාල භාවිතා කර boilerplate කේතය අඩු කිරීම

ඔබේ අවබෝධය තවත් ගැඹුරු කිරීමට, ඉහත විෂයයන් පරීක්ෂා කරන්න.
ඔබට ප්‍රයෝජනවත් උපදෙස් සොයාගත හැකි වන අතර ඒවා ඔබේ Java සංවර්ධනය වඩා කාර්යක්ෂම, පිරිසිදු, සහ නිෂ්පාදනශීලී කරනු ඇත.

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

This section answers common questions about Java’s toString method—many of which also appear frequently in search suggestions.
Use this reference whenever you are unsure or encounter a related problem.

Q1. මට සෑම විටම toString අතිරේක (override) කිරීමට අවශ්‍යද?
A1.
එය අනිවාර්ය නොවේ, නමුත් ඔබට වස්තු අන්තර්ගතය පරීක්ෂා කිරීමට හෝ දෝෂ නිරාකරණය (debug) කිරීමට අවශ්‍ය වන අභිරුචි පන්තීන් සඳහා, එය අතිරේක (override) කිරීම ඉතාමත් නිර්දේශිතය.
පෙරනිමි ක්‍රියාත්මක කිරීම “ClassName@HashCode” පමණක් පෙන්වයි, එය ප්‍රායෝගික වශයෙන් අඩු වටිනාකමක් පමණක් ලබා දෙයි.

Q2. valueOf සහ toString අතර වෙනස කුමක්ද?
A2.
toString යනු වස්තුවේ අන්තර්ගතය නියෝජනය කරන 문자열යක් 반환 කරන instance ක්‍රමයකි.
valueOf යනු සාමාන්‍යයෙන් String පන්තියේ static ක්‍රමයක් වන අතර, ඕනෑම අගයක් හෝ වස්තුවක් String එකකට පරිවර්තනය කරයි.
ප්‍රධාන වෙනස null හසුරුවීමේදී වේ:

• toString → NullPointerException එකක් දෝෂය දක්වයි
• valueOf → “null” යන literals 문자열ය 반환 කරයි

Q3. toString තුළ මට කුමන තොරතුරු ඇතුළත් කළ යුතුද?
A3.
වස්තුව වෙනස් කරගැනීමට හෝ ඒක වෙන් කරගැනීමට උපකාරී වන ලක්ෂණ හෝ ප්‍රධාන ක්ෂේත්‍ර ඇතුළත් කරන්න.
මුරපද, පුද්ගලික දත්ත හෝ වෙනත් සංවේදී තොරතුරු මුද්‍රණය කිරීමෙන් වැළකින්න.

Q4. toString ක්‍රියාවලිය ක්‍රියාත්මක කරන විට මොනවාට අවධානය යොමු කළ යුතුද?
A4.

• අවශ්‍ය තැන null අගයන් පරීක්ෂා කරන්න
• වටකුරු යොමු (circular references) නිසා ඇතිවන අසීමිත පනස් (infinite recursion) වලට සැලකිල්ලෙන් සිටින්න
• සියලු දත්ත මුද්‍රණය කිරීමේ වෙනුවට විශාල හෝ සංකීර්ණ දත්ත සාරාංශ කර පෙන්වන්න
• ආරක්ෂාව සහ පෞද්ගලිකත්වය පිළිබඳ කරුණු සැලකිල්ලට ගන්න

Q5. අතිරේක (overridden) toString ප්‍රතිඵලය බාහිරව ප්‍රදර්ශනය කිරීම ආරක්ෂිතද?
A5.
එය අන්තර්ගතය මත පදනම් වේ.
ලොග් සහ දෝෂ වාර්තා ඔබේ පද්ධතියෙන් පිටතට ප්‍රවේශ විය හැකි බැවින්, toString ප්‍රතිඵලයේ සංවේදී හෝ රහස්‍ය තොරතුරු කිසිදාම ඇතුළත් නොකරන්න.

Q6. ප්‍රතිචක්‍රාත්මක (recursive) හෝ පදනම් (hierarchical) පන්තීන් සඳහා toString ක්‍රමය කෙසේ ක්‍රියාත්මක කළ යුතුද?
A6.
පියා–පුත්‍ර සම්බන්ධතා හෝ දෙදාරි (bidirectional) සබඳතා වැනි වටකුරු ව්‍යුහ (circular structures) අසීමිත පනස් (infinite recursion) හා StackOverflowError එකක් ඇති කරයි.
ප්‍රභාවී විසඳුම්:

• ID හෝ අත්‍යවශ්‍ය ක්ෂේත්‍ර පමණක් ප්‍රදර්ශනය කිරීම
• පනස් ගැඹුර සීමා කිරීම
• නේස්ට් වස්තු (nested objects) “[…]” වැනි placeholder මගින් නියෝජනය කිරීම

Q7. IDE ඩිබග් කරුවන් (debuggers) තුළ toString ප්‍රතිඵලය පරීක්ෂා කළ හැද?
A7.
ඔව්. බොහෝ IDE (Eclipse, IntelliJ, ආදිය) වස්තු පරීක්ෂා කරන විට toString ප්‍රතිඵලය ස්වයංක්‍රීයව පෙන්වයි.
toString අභිරුචි කිරීම ඩිබග් කිරීමේ කාර්යක්ෂමතාවය විශාල ලෙස වැඩි කරයි.

toString ක්‍රමය සරල පෙනුමක් ඇති වුවත්, නිසි භාවිතය Java සංවර්ධනයේ නිෂ්පාදනශීලීතාවය සහ කේත ගුණාත්මකභාවය ගණනීය ලෙස වැඩි කරයි. ඔබට අවශ්‍ය විස්තර හෝ කෙටි මතකයන් සඳහා මෙම FAQ වෙත නැවත යොමු වන්න.

12. Diagrams and Comparison Tables

toString සහ valueOf ක්‍රම අතර වෙනස්කම්, අතිරේක (overridden) සහ අතිරේක නොකළ ප්‍රතිඵල අතර වෙනස්කම් වචන මත පමණක් නොව, රූප සහ වගු මගින්ද පැහැදිලි කිරීම අත්‍යවශ්‍ය වේ.
මෙම කොටස රූප සහ වගු භාවිතයෙන් ප්‍රධාන කරුණු සාරාංශ කර ඔබට දෘශ්‍යමය ලෙස සංකල්ප තේරුම් ගැනීමට උපකාරී වේ.

[1] Comparison: toString vs. valueOf

[2] Output Difference Before and After Overriding toString (Diagram)

[Before Override]
Product@3e3abc88
↑
(Only displays ClassName@HashCode)

[After Override]
Product{name=りんご, price=150, category=果物}
↑
(Displays meaningful field information!)

[3] Auto Invocation of toString (Concept Illustration)

Product p = new Product("りんご", 150, "果物");
System.out.println(p);
// ↑ Automatically calls p.toString()

String text = "Product: " + p;
// ↑ Also automatically calls p.toString()

[4] Example of toString in Recursive Structures

class Node {
    Node child;
    @Override
    public String toString() {
        // Calling child.toString() directly may cause infinite recursion
        return "Node{" + "child=" + (child != null ? "[...]" : "null") + "}";
    }
}

*ප්‍රතිචක්‍රාත්මක පන්තීන් සඳහා, වටකුරු යොමු (circular references) සහ අසීමිත ලූප් (infinite loops) වලින් වැළැක්වීම අත්‍යවශ්‍ය වේ.

මෙම රූප සහ වගු එකතුව toString ක්‍රමය කෙසේ ක්‍රියා කරයි, එහි ප්‍රතිලාභ සහ විශේෂ අවධානය අවශ්‍ය වන කරුණු දෘශ්‍යමය ලෙස පෙන්වීමට උපකාරී වේ.
මෙම දෘශ්‍ය ආධාර භාවිතා කර පැහැදිලි, නඩත්තු කළ හැකි Java යෙදුම් නිර්මාණය කරන්න.