რა არის გენერიკები?

ජෙනරිකස් (generics) යනු වැඩසටහනක නැවත භාවිතා කළ හැකි කොටස් නිර්මාණය කිරීම සඳහා උපකරණයකි, එය විවිධ දත්ත වර්ග සමඟ වැඩ කිරීමට හැකි වන අතර එමඟින් වර්ග ආරක්ෂාව අහිමි නොවේ. එය පන්තියන්, අතුරුමුහුණත් සහ ක්‍රම ලිවිය හැකි අතර, එම වර්ග පරාමිතියන් සමඟ ක්‍රියා කරයි.

ප්‍රධාන වාසි:

• සංයුක්ත මට්ටමේ වර්ග ආරක්ෂාව: වර්ග නොගැලපීමේ දෝෂ හඳුනාගැනීම් වැඩසටහන ක්‍රියාත්මක වීමට පෙර හඳුනාගත හැක.
• කේත ප්‍රතිචක්‍රාකරණය අඩු කිරීම: විවිධ වර්ග සමඟ වැඩ කිරීමට හැකි එක් සමාන්‍ය අල්ගොරිතමයක් හෝ දත්ත ව්‍යුහයක් ලිවිය හැක.
• කාර්යක්ෂමතාව: Object වැනි සමාන්‍ය වර්ග භාවිතා කිරීමේ වෙනුවට, වර්ග මාරු (cast) අවශ්‍ය නොවේ, එය කාර්යක්ෂමතාව වැඩි කරයි.

Java උදාහරණයක්:

// ජෙනරික් නොමැති List පන්තිය (පැරණි ආකෘතිය)
List list = new ArrayList();
list.add("hello");
list.add(123); // ඕනෑම වර්ගයක් එකතු කළ හැක
String s = (String) list.get(0); // අතිරේක වර්ග මාරු අවශ්‍ය
Integer i = (Integer) list.get(1); // අතිරේක වර්ග මාරු අවශ්‍ය

// ජෙනරික් සමඟ List
List<String> stringList = new ArrayList<>();
stringList.add("world");
// stringList.add(123); // දෝෂයක්! පමණක් පේළි අනුමත

String s2 = stringList.get(0); // වර්ග මාරු අවශ්‍ය නොවේ

ජෙනරිකස් collection එකක් හෝ වෙනත් පොදු පන්තියක්/අතුරුමුහුණතක් සමඟ වැඩ කිරීමේදී, එම collection එකට වැඩ කිරීමට වර්ගය නියමිත කරයි. මෙය වර්ග දෝෂ වලින් ආරක්ෂා කරයි, ක්‍රියාත්මක වීමේ දෝෂ වලින් වළක්වයි.

C# භාෂාවේ උදාහරණයක්:

// පේළි ලැයිස්තුවක් (List) ජෙනරිකස් සමඟ
List<string> names = new List<string>();
names.Add("Alice");
// names.Add(123); // දෝෂයක්

string firstName = names[0]; // වර්ග මාරු අවශ්‍ය නොවේ

Python තුළ, ජෙනරිකස් සංකල්පය වර්ග අනුකේතන (type hints) සහ typing මොඩියුලය භාවිතා කරමින් ක්‍රියාත්මක වේ:

from typing import List, Dict, Any

# වර්ග අනුකේතනය සමඟ පේළි
def process_strings(data: List[str]):
    for item in data:
        print(item)

# යතුරු-පේළි සහ අගයන් විවිධ වර්ගවලින් යුක්ත ශබ්දකෝෂ
def process_dict(data: Dict[str, Any]):
    for key, value in data.items():
        print(f"{key}: {value}")

Python හි, වර්ග අනුකේතන තහවුරු කිරීමේදී දැඩි නොවුවත්, එය කේතයේ කියවීම පහසු කරයි සහ දෝෂ හඳුනාගැනීම සරල කරයි.

සමස්ත වශයෙන්, ජෙනරිකස් ශක්තිමත් මෙවලමක් වන අතර, එය විවිධ භාෂාවලදී, ලවණාකාර, නැවත භාවිතා කළ හැකි, වර්ග ආරක්ෂිත කේත නිර්මාණය සඳහා භාවිතා වේ.