1. හැඳින්වීම
Java යනු ව්යාපාරික පද්ධති, වෙබ් යෙදුම්, Android සංවර්ධනය වැනි විවිධ ක්ෂේත්රවල පුළුල් ලෙස භාවිතා වන වැඩසටහන් භාෂාවකි. එහි බොහෝ විශේෂාංග අතර, “උරුමය” (inheritance) යනු වස්තු-ඝටිත වැඩසටහන් (object‑oriented programming) ඉගෙනීමේදී අතිශය වැදගත් සංකල්පයක් වේ.
උරුමය භාවිතා කිරීමෙන්, නව පන්තියක් (උප‑පන්තිය/දර පන්තිය) පවතින පන්තියක (උපරිම‑පන්තිය/පියා පන්තිය) ක්රියාකාරිත්වය අරගෙන ගත හැක. මෙය කේත පිළිලකරණය (code duplication) අඩු කර, වැඩසටහන් දිගුවට සහ නඩත්තු කිරීමේ පහසුව වැඩි කරයි. Java හි, උරුමය extends යතුර භාවිතයෙන් ක්රියාත්මක වේ.
මෙම ලිපියේ, Java හි extends යතුරේ භූමිකාව, මූලික භාවිතය, ප්රායෝගික යෙදුම්, සහ සාමාන්ය ප්රශ්න පැහැදිලිව විස්තර කරයි. මෙම මාර්ගෝපදේශය Java ආරම්භකයන්ට පමණක් නොව, උරුමය නැවත සමාලෝචනය කිරීමට කැමති අය සඳහාද ප්රයෝජනවත් වේ. අවසානයේ, ඔබට උරුමයේ වාසි හා අවාසි, සහ වැදගත් නිර්මාණ සැලසුම් ගැන සම්පූර්ණ අවබෝධයක් ලැබෙනු ඇත.
“Java හි උරුමය කුමක්ද?” යන ප්රශ්නයට ආරම්භයෙන්ම අවධානය යොමු කරමු.
2. Java උරුමය කුමක්ද?
Java උරුමය යනු, එක් පන්තියක් (උපරිම‑පන්තිය/පියා පන්තිය) තම ලක්ෂණ සහ ක්රියාකාරිත්වය වෙනත් පන්තියකට (උප‑පන්තිය/දර පන්තිය) ලබා දෙන යාන්ත්රණයකි. උරුමය සමඟ, පියා පන්තියේ නිර්වචනය කරන ලද ක්ෂේත්ර (variables) සහ ක්රම (functions) දර පන්තිය තුළ නැවත භාවිතා කළ හැක.
මෙම යාන්ත්රණය කේතය සංවිධානය කිරීම, කළමනාකරණය කිරීම, හවුල් ක්රියාවලීන් එකතු කිරීම, සහ ක්රියාකාරිත්වය සවිස්තරාත්මකව දිගුවට හෝ වෙනස් කිරීමට පහසුකම් සලසයි. උරුමය, වස්තු‑ඝටිත වැඩසටහන් (OOP) තුළ Encapsulation සහ Polymorphism සමඟ එක්ක ත්රිත්වය (three core pillars) ලෙස සැලකේ.
“is‑a” සම්බන්ධතාවය ගැන
උරුමයේ සාමාන්ය උදාහරණයක් “is‑a සම්බන්ධතාවය” වේ. උදාහරණයක් ලෙස, “බල්ලා (Dog) යනු සතුන් (Animal) එකකි.” මෙයින් අදහස් වන්නේ Dog පන්තිය Animal පන්තියෙන් උරුම කරගනී. බල්ලා, සතුන්ගේ ලක්ෂණ සහ හැසිරීම් අරගෙන, තමන්ගේ විශේෂාංග එක් කර ගත හැක.
class Animal {
void eat() {
System.out.println("食べる");
}
}
class Dog extends Animal {
void bark() {
System.out.println("ワンワン");
}
}
මෙම උදාහරණයේ, Dog පන්තිය Animal පන්තියෙන් උරුම කරයි. Dog නමැති උදාහරණයක් bark ක්රමය සහ උරුම කරගත් eat ක්රමය දෙකම භාවිතා කළ හැක.
උරුමය භාවිතා කරන විට කුමක් සිදුවේ?
- ඔබට හවුල් තර්ක (logic) සහ දත්ත පියා පන්තිය තුළ එකතු කර, සෑම උප‑පන්තියකම එකම කේතය නැවත ලිවීමට අවශ්යතාවය අඩු කළ හැක.
- සෑම උප‑පන්තියක්ම තමන්ගේ විශේෂාංග එක් කර හෝ පියා පන්තියේ ක්රම අතිරේක (override) කළ හැක.
උරුමය වැඩසටහනේ ව්යුහය සංවිධානය කිරීමට සහ අංග එකතු කිරීම හා නඩත්තු කිරීම පහසු කරයි. එNevertheless, උරුමය සෑම විටම හොඳම විකල්පය නොවේ, නිර්මාණයේදී සැබැවින්ම “is‑a සම්බන්ධතාවය” පවතිනදැයි කාරුණිකව ඇගයීම වැදගත් වේ.
3. extends යතුර කෙසේ ක්රියා කරයි
Java හි extends යතුර පන්තිය උරුමය ප්රකාශ කිරීම සඳහා නිශ්චිතව භාවිතා වේ. දර පන්තිය පියා පන්තියගේ ක්රියාකාරිත්වය උරුම කරන විට, පන්තිය ප්රකාශයේ extends ParentClassName යන වාක්යය භාවිතා කරයි. මෙයින් දර පන්තියට පියා පන්තියේ සියලු පොදු සාමාජික (fields සහ methods) සෘජුවම භාවිතා කිරීමට හැකියාව ලැබේ.
මූලික වාක්ය රචනය
class ParentClass {
// Fields and methods of the parent class
}
class ChildClass extends ParentClass {
// Fields and methods unique to the child class
}
උදාහරණයක් ලෙස, පෙර සඳහන් Animal සහ Dog පන්තීන් භාවිතා කරමින්, අපට ලැබෙන්නේ:
class Animal {
void eat() {
System.out.println("食べる");
}
}
class Dog extends Animal {
void bark() {
System.out.println("ワンワン");
}
}
Dog extends Animal ලෙස ලියීමෙන්, Dog පන්තිය Animal පන්තියෙන් උරුම කර, eat ක්රමය භාවිතා කළ හැකිය.
පියා පන්තියේ සාමාජික භාවිතය
උරුමය සමඟ, දර පන්තියේ උදාහරණයක් පියා පන්තියේ ක්රම සහ ක්ෂේත්ර (ඇතුළත් ප්රවේශකාරක (access modifiers) ඉඩ දෙන තරම්) ප්රවේශ කර ගත හැකිය:
Dog dog = new Dog();
dog.eat(); // Calls the parent class method
dog.bark(); // Calls the child class method
වැදගත් සටහන්
- Java එකේ උරුමය එක පන්තියක් පමණක් (single inheritance) ලබා ගත හැක.
extendsපසු බහු පන්තීන් සඳහන් කළ නොහැක. - ඔබට උරුමය තහනම් කිරීමට අවශ්ය නම්, පන්තියට
finalසංශෝධකය භාවිතා කළ හැක.
ප්රායෝගික සංවර්ධන උපදෙස්
extends නිවැරදිව භාවිතා කිරීම මගින් ඔබට පොදු ක්රියාකාරිත්වය පියාපත් පන්තියක එකතු කර, උප පන්තීන්හි හැසිරීම විස්තාරණය හෝ අභිරුචි කිරීමේ හැකියාව ලැබේ. පවත්නා කේතය වෙනස් නොකර නව විශේෂාංග එකතු කිරීමටද මෙය ප්රයෝජනවත් වේ.
4. ක්රම අතිරේක කිරීම සහ super යතුර
උරුමය භාවිතා කරන විට, පියාපත් පන්තිය තුළ නිර්වචනය කරන ලද ක්රමයක්ගේ හැසිරීම වෙනස් කිරීමට අවශ්ය වන අවස්ථා ඇත. මෙය “ක්රම අතිරේක කිරීම” ලෙස හැඳින්වේ. Java හි, අතිරේක කිරීම යනු උප පන්තිය තුළ ඒම නාමය සහ ඒම පරාමිතීන් සමඟ ක්රමයක් නිර්වචනය කිරීමෙන් සිදු වේ.
ක්රම අතිරේක කිරීම
ක්රමයක් අතිරේක කරන විට, @Override සටහන එකතු කිරීම සාමාන්යයයි. මෙය සංයුක්තකයා (compiler) අසත්ය නාම හෝ අත්සන් වැනි අහඹු දෝෂ හඳුනා ගැනීමට උපකාරී වේ.
class Animal {
void eat() {
System.out.println("食べる");
}
}
class Dog extends Animal {
@Override
void eat() {
System.out.println("ドッグフードを食べる");
}
}
මෙම උදාහරණයේ, Dog පන්තිය eat ක්රමය අතිරේක කරයි. Dog වස්තුවක් මත eat කැඳවීමේදී, ප්රතිඵලය “ドッグフードを食べる” ලෙස පෙන්වයි.
Dog dog = new Dog();
dog.eat(); // Displays: ドッグフードを食べる
super යතුර භාවිතා කිරීම
අතිරේක කරන ලද ක්රමයක් තුළ පියාපත් පන්තියේ මුල් ක්රමය කැඳවීමට අවශ්ය නම්, super යතුර භාවිතා කරන්න.
class Dog extends Animal {
@Override
void eat() {
super.eat(); // Calls the parent class’s eat()
System.out.println("ドッグフードも食べる");
}
}
මෙය පියාපත් පන්තියේ eat ක්රමය පළමුව ක්රියාත්මක කර, පසුතැවෙනුයේ උප පන්තියේ හැසිරීම එකතු කරයි.
නිර්මාතෘ (Constructors) සහ super
පියාපත් පන්තියට පරාමිතීන් සමඟ නිර්මාතෘ (constructor) එකක් ඇත්නම්, උප පන්තිය එය super(arguments) භාවිතා කර පළමු පේළිය ලෙස පැහැදිලිව කැඳවිය යුතුය.
class Animal {
Animal(String name) {
System.out.println("Animal: " + name);
}
}
class Dog extends Animal {
Dog(String name) {
super(name);
System.out.println("Dog: " + name);
}
}
සාරාංශය
- අතිරේක කිරීම යනු පියාපත් පන්තියේ ක්රමයක් උප පන්තියේ නැවත නිර්වචනය කිරීමයි.
@Overrideසටහන භාවිතා කිරීම නිර්දේශිතයි.- පියාපත් පන්තියේ ක්රම ක්රියාත්මක කිරීම නැවත භාවිතා කිරීමට අවශ්ය නම්
superභාවිතා කරන්න. - පියාපත් පන්තියේ නිර්මාතෘ (constructors) කැඳවීමටද
superභාවිතා වේ.
5. උරුමයේ වාසි සහ අවාසි
Java හි උරුමය භාවිතා කිරීම වැඩසටහන් නිර්මාණය සහ සංවර්ධනය සඳහා බොහෝ ප්රතිලාභ ලබා දෙයි. එහෙත්, වැරදි භාවිතය ගැඹුරු ගැටළු ඇති කරවිය හැක. පහත, වාසි සහ අවාසි විස්තරාත්මකව පැහැදිලි කරමු.
උරුමයේ වාසි
- කේත ප්රතිභාවිතය වැඩිදියුණු කිරීම පියාපත් පන්තියේ බෙදාගත් තර්ක සහ දත්ත නිර්වචනය කිරීමෙන්, එක් එක් උප පන්තියේ එකම කේතය නැවත නැවත ලිවීමට අවශ්ය නොවේ. මෙය අනුපිළිවෙළ අඩු කර, නඩත්තු කිරීම සහ කියවීම පහසු කරයි.
- විස්තාරණය පහසු කිරීම නව ක්රියාකාරිත්වයක් අවශ්ය වූ විට, පියාපත් පන්තිය මත නව උප පන්තියක් සාදමින් පවත්නා කේතය වෙනස් නොකර හැක. මෙය වෙනස්කම් වල බලපෑම අඩු කර, දෝෂ ඇති වීමේ අවස්ථාව අඩු කරයි.
- බහුරූපීත්වය (Polymorphism) සක්රිය කිරීම උරුමය “පියාපත් පන්තියේ විචල්යයක් උප පන්තියේ වස්තුවක් යොමු කර ගැනීමට” ඉඩ සලසයි. මෙය පොදු අතුරුමුහුණත් (interfaces) සහ බහුරූපී හැසිරීම භාවිතා කර ලවච්චි (flexible) නිර්මාණයක් සලසයි.
උරුමයේ අවාසි
- ගැඹුරු වර්ගීකරණය නිර්මාණය සංකීර්ණ කරයි උරුමය දාමයන් බොහෝ ගැඹුරු වුවහොත්, හැසිරීම කොහේ නිර්වචනය කර ඇතිදැයි තේරුම් ගැනීමට අමාරු වේ, නඩත්තු කිරීම දුෂ්කර වේ.
- පියාමව් පන්තියේ වෙනස්කම් සියලු උපපන්තීන්ට බලපායි පියාමව් පන්තියේ හැසිරීම වෙනස් කිරීම අනපේක්ෂිතව සියලු උපපන්තීන්ට ගැටළු ඇති කරවිය හැක. පියාමව් පන්තීන් සැලකිලිමත් නිර්මාණය සහ යාවත්කාලීන කිරීම අවශ්ය වේ.
- නිර්මාණයේ සවිස්තරතාවය අඩු කරයි උරුමය අධික ලෙස භාවිතා කිරීම පන්තීන් අතර දැඩි සම්බන්ධතාවයක් ඇති කරයි, එමඟින් අනාගත වෙනස්කම් කරදරකාරී වේ. සමහර අවස්ථා වල, “has-a” සම්බන්ධතා (සංයෝජනය) “is-a” උරුමය වඩා සවිස්තරවත් වේ.
සාරාංශය
උරුමය ශක්තිමත් වේ, නමුත් සියල්ලටම එය භාවිතා කිරීම දිගුකාලීන ගැටළු ඇති කරයි. සැබැවින්ම “is-a” සම්බන්ධතාවයක් පවතිනදැයි සෑම විටම පරීක්ෂා කර, අවශ්ය විට පමණක් උරුමය යොදා ගන්න.
6. උරුමය සහ අතුරුමුහුණත් අතර වෙනස්කම්
Java දෙකක් වැදගත් යන්ත්රණයන් ලබා දෙයි: පන්තී උරුමය (extends) සහ අතුරුමුහුණත් (implements). දෙකම කේතය නැවත භාවිතා කිරීම සහ සවිස්තරවත් නිර්මාණය සඳහා උපකාරී වන නමුත්, ඒවායේ ව්යුහය සහ අදහස් කරන භාවිතය විශාල ලෙස වෙනස් වේ. පහතදී අපි ඒ වෙනස්කම් පැහැදිලි කරමින්, කෙසේ තෝරා ගත යුතුද යන්න පැහැදිලි කරමු.
extends සහ implements අතර වෙනස්කම්
- extends (උරුමය)
- ඔබට එක පන්තියක් පමණක් උරුම කර ගත හැක (තනි උරුමය).
- පියාමව් පන්තියේ ක්ෂේත්ර සහ සම්පූර්ණයෙන් ක්රියාත්මක වූ ක්රමයන් උපපන්තියේ සෘජුව භාවිතා කළ හැක.
“is-a” සම්බන්ධතාවයක් නියෝජනය කරයි (උදා: බල්ලාක් නම් සතුන්).
implements (අතුරුමුහුණත් ක්රියාත්මක කිරීම)
- එකවර බහු අතුරුමුහුණත් ක්රියාත්මක කළ හැක.
- අතුරුමුහුණත් වල ක්රම ප්රකාශන පමණක් (Java 8 පසු දීපූර්ව ක්රම තිබේ) අඩංගු වේ.
- “can-do” සම්බන්ධතාවයක් නියෝජනය කරයි (උදා: බල්ලා හඬා ගත හැක, බල්ලා ඇවිදිය හැක).
අතුරුමුහුණත් භාවිතයේ උදාහරණය
interface Walkable {
void walk();
}
interface Barkable {
void bark();
}
class Dog implements Walkable, Barkable {
public void walk() {
System.out.println("歩く");
}
public void bark() {
System.out.println("ワンワン");
}
}
මෙම උදාහරණයේ, Dog පන්තිය Walkable සහ Barkable යන අතුරුමුහුණත් දෙකක් ක්රියාත්මක කරයි, එමඟින් බහු උරුමයක් වැනි හැසිරීම ලබා දේ.
අතුරුමුහුණත් අවශ්ය වන්නේ ඇයි
Java පන්තී බහු උරුමය තහනම් කරයි, මන්ද පියාමව් පන්තීන් එකම ක්රම හෝ ක්ෂේත්ර නිර්වචනය කළ විට ගැටළු උදාවිය හැක. අතුරුමුහුණත් මෙම ගැටළුව විසඳයි, පන්තියකට බහු “වර්ග” අනුග්රහය ලබා දී, ගැලපෙන ක්රියාත්මක කිරීම් නොමැතිව.
ඒවා නිසි ලෙස භාවිතා කිරීම
- පන්තීන් අතර පැහැදිලි “is-a” සම්බන්ධතාවයක් පවතින විට
extendsභාවිතා කරන්න. - බහු පන්තීන් අතර පොදු හැසිරීමේ ගිවිසුම් ලබා දීමට අවශ්ය නම්
implementsභාවිතා කරන්න.
උදාහරණ:
- “බල්ලා සතුන් වේ” →
Dog extends Animal - “බල්ලා ඇවිදිය හැක සහ හඬා ගත හැක” →
Dog implements Walkable, Barkable
සාරාංශය
- පන්තියක් එක පියාමව් පන්තියක් පමණක් උරුම කර ගත හැක, නමුත් බහු අතුරුමුහුණත් ක්රියාත්මක කළ හැක.
- නිර්මාණයේ අදහස අනුව උරුමය හෝ අතුරුමුහුණත් තේරීම, පිරිසිදු, සවිස්තරවත්, නඩත්තු කළ හැකි කේතයක් ලබා දෙයි.
7. උරුමය භාවිතයේ හොඳ පුරුදු
උරුමය Java හි ශක්තිමත් වේ, නමුත් අනිසි ලෙස භාවිතා කිරීම වැඩසටහන තදබද සහ නඩත්තු කිරීම අමාරු කරයි. පහතදී උරුමය ආරක්ෂිතව සහ ප්රභාවශාලීව භාවිතා කිරීම සඳහා හොඳ පුරුදු සහ මාර්ගෝපදේශයන් ලබා දෙනු ලැබේ.
උරුමය භාවිතා කළ යුතු අවස්ථා — සහ එය වැළැක්විය යුතු අවස්ථා
- උරුමය භාවිතා කළ යුතු අවස්ථා:
- පැහැදිලි “is-a” සම්බන්ධතාවයක් පවතින විට (උදා: බල්ලා සතුන් වේ).
- පියාමව් පන්තියේ ක්රියාකාරිත්වය නැවත භාවිතා කර, එය දිගුවක් ලෙස ලබා දීමට අවශ්ය විට.
අතිරේක කේතය ඉවත් කර, පොදු තර්කයක් එකම ස්ථානයේ එකතු කිරීමට අවශ්ය විට.
උරුමය වැළැක්විය යුතු අවස්ථා:
- එය කේතය නැවත භාවිතා කිරීම සඳහා පමණක් භාවිතා කරන විට (මෙය අසාමාන්ය පන්තී නිර්මාණයට හේතු වේ).
- “has-a” සම්බන්ධතාවයක් වඩා සුදුසු වන විට — එවැනි අවස්ථා වල සංයෝජනය (composition) ගැන සිතන්න.
උරුමය සහ සංයෝජනය අතර තේරීම
- ඉන්හෙරිතා (
extends): is-a සම්බන්ධතාව - උදාහරණය:
Dog extends Animal - උප-ශ්රේණිය සත්යයෙන්ම මූල ශ්රේණියේ වර්ගයක් නියෝජනය කරන විට ප්රයෝජනවත් වේ.
- සංයෝජනය (has-a සම්බන්ධතාව)
- උදාහරණය: කාර් එකකට එන්ජින් එකක් ඇත
- වෙනත් පන්තියක උදාහරණයක් භාවිතා කර ක්රියාකාරිත්වය එක් කරයි.
- වඩාත් සවිස්තරාත්මක සහ අනාගත වෙනස්කම් සඳහා පහසුය.
ඉන්හෙරිතා අතිභාවය වැළැක්වීමට නිර්මාණ මාර්ගෝපදේශ
- ඉන්හෙරිතා ශ්රේණිගත කිරීම ඉතා ගැඹුරු නොකරන්න (මට්ටම් 3ක් හෝ අඩු තබන්න).
- බොහෝ උප-ශ්රේණි එකම මූල පන්තියෙන් ඉන්හෙරිතා කරන්නේ නම්, මූල පන්තියේ වගකීම් සුදුසුද යන්න නැවත සලකා බලන්න.
- මූල පන්තියේ වෙනස්කම් සියලු උප-ශ්රේණි වලට බලපාන අවදානම සැලකිල්ලට ගන්න.
- ඉන්හෙරිතා යෙදීමට පෙර, අතුරුමුහුණත් සහ සංයෝජනය වැනි විකල්ප සලකා බලන්න.
final සංශෝධකය සමඟ ඉන්හෙරිතා සීමා කිරීම
- පන්තියකට
finalඑකතු කිරීම එය ඉන්හෙරිතා වීමෙන් තහනම් කරයි. - ක්රමයකට
finalඑකතු කිරීම එය උප-ශ්රේණි මගින් අතිරේක නොකිරීමට තහනම් කරයි.final class Utility { // This class cannot be inherited } class Base { final void show() { System.out.println("オーバーライド禁止"); } }
ලේඛන සහ අදහස් වර්ධනය
- Javadoc හෝ අදහස් තුළ ඉන්හෙරිතා සම්බන්ධතා සහ පන්තිය නිර්මාණ අදහස් ලේඛනය කිරීම අනාගත නඩත්තු වැඩි පහසු කරයි.
සාරාංශය
ඉන්හෙරිතා පහසුය, නමුත් එය අදහස් පූර්වකව භාවිතා කළ යුතුය. සෑම විටම අසන්න, “මෙම පන්තිය සත්යයෙන්ම එහි මූල පන්තියේ වර්ගයක්ද?” ඔබට විශ්වාස නැත්නම්, සංයෝජනය හෝ අතුරුමුහුණත් විකල්ප ලෙස සලකා බලන්න.
8. සාරාංශය
මෙතෙක්, අපි Java ඉන්හෙරිතා සහ extends යතුර විස්තරාත්මකව පැහැදිළි කර ඇත—මූලික කරුණු සිට ප්රායෝගික භාවිතය දක්වා. පහත මෙම ලිපියේ ආවරණය කළ ප්රධාන කරුණු සාරාංශය වේ.
- Java ඉන්හෙරිතා උප-ශ්රේණියට මූල පන්තියේ දත්ත සහ ක්රියාකාරිත්වය ලබා දී, කාර්යක්ෂම සහ නැවත භාවිතා කළ හැකි වැඩසටහන් නිර්මාණය සලස්වයි.
extendsයතුර මූල පන්තිය සහ උප-පන්තිය අතර සම්බන්ධතාවය (“is-a සම්බන්ධතාව”) පැහැදිලි කරයි.- ක්රම අතිරේක කිරීම සහ
superයතුර ඉන්හෙරිතා වූ හැසිරීම විස්තාරණය හෝ අභිරුචිකරණය කිරීමට ඉඩ සලසයි. - ඉන්හෙරිතා කේත නැවත භාවිතය, විස්තාරණය, සහ පොලීමෝර්ෆිසම් සඳහා සහය වැනි වාසි බොහොමයක් ලබා දෙයි, නමුත් ගැඹුරු හෝ සංකීර්ණ ශ්රේණිගත කිරීම සහ පුළුල්-ආකාර වෙනස්කම් වැනි අවාසිද ඇත.
- ඉන්හෙරිතා, අතුරුමුහුණත්, සහ සංයෝජනය අතර වෙනස්කම් තේරුම් ගැනීම නිවැරදි නිර්මාණ ක්රමය තෝරා ගැනීමට අත්යවශ්ය වේ.
- ඉන්හෙරිතා අධිකව භාවිතා කිරීමෙන් වැළැක්විය යුතුය; නිර්මාණ අදහස සහ හේතුව සවිස්තරාත්මකව පැහැදිලි කර තබන්න.
ඉන්හෙරිතා Java හි වස්තු-ඝණිත වැඩසටහන් කිරීමේ මූලික සංකල්ප之一 වේ. නීති සහ හොඳ පුරුදු තේරුම් ගැනීමෙන්, ඔබට එය වාස්තුකලාවෙන් යථාර්ථයෙහි ප්රයෝගිකව භාවිතා කළ හැක.
9. නිතර අසන ප්රශ්න (FAQ)
Q1: Java හි පන්තියක් ඉන්හෙරිතා කරන විට මූල පන්තියේ ගොඩනැගීමක (constructor) කුමක් වේ?
A1: මූල පන්තියට පරාමිතියක් නොමැති (පෙරනිමි) ගොඩනැගීමක් තිබේ නම්, එය උප-පන්තියේ ගොඩනැගීමෙන් ස්වයංක්රීයව කැඳවයි. මූල පන්තියට පරාමිතියක් සමඟ ගොඩනැගීමක් පමණක් තිබේ නම්, උප-පන්තිය එය super(arguments) භාවිතා කර ගොඩනැගීමේ ආරම්භයේම පැහැදිලිව කැඳවිය යුතුය.
Q2: Java පන්තීන් සඳහා බහු-ඉන්හෙරිතා කළ හැදියිද?
A2: නැත. Java පන්තීන් සඳහා බහු-ඉන්හෙරිතා සහය නොදේ. පන්තියක් extends භාවිතා කර එකම මූල පන්තියක් පමණක් ඉන්හෙරිතා කළ හැක. නමුත්, පන්තියක් implements භාවිතා කර බහු අතුරුමුහුණත් ක්රියාත්මක කළ හැක.
Q3: ඉන්හෙරිතා සහ සංයෝජනය අතර වෙනස්කම් කුමක්ද?
A3: ඉන්හෙරිතා “is-a සම්බන්ධතාව” නියෝජනය කරයි, එහිදී උප-පන්තිය මූල පන්තියේ ක්රියාකාරිත්වය සහ දත්ත නැවත භාවිතා කරයි. සංයෝජනය “has-a සම්බන්ධතාව” නියෝජනය කරයි, එහිදී පන්තිය වෙනත් පන්තියේ උදාහරණයක් අඩංගු කරයි. සංයෝජනය බොහෝ විට වඩාත් සවිස්තරාත්මක වේ සහ අඩු සම්බන්ධතාවය හෝ අනාගත විස්තාරණය අවශ්ය වන බොහෝ අවස්ථා සඳහා වඩාත් සුදුසු වේ.
Q4: final සංශෝධකය උරුමය සහ අතිරේක කිරීම සීමා කරද?
A4: ඔව්. එක් පන්තියක් final ලෙස සලකුණු කර ඇත්නම්, එය උරුම කරගත නොහැක. එක් ක්රමයක් final ලෙස සලකුණු කර ඇත්නම්, උප පන්තියක එය අතිරේක කළ නොහැක. මෙය ස්ථාවර හැසිරීමක් සහතික කිරීම හෝ ආරක්ෂක අරමුණු සඳහා ප්රයෝජනවත් වේ.
Q5: මව් පන්තිය සහ දරුවන් පන්තිය එකම නාමයෙන් ක්ෂේත්ර හෝ ක්රම නිර්වචනය කරන්නේ නම් කුමක් වේ?
A5: එකම නාමයෙන් ක්ෂේත්රයක් දෙපාර්ශවයේම නිර්වචනය කර ඇත්නම්, දරුවන් පන්තියේ ක්ෂේත්රය මව් පන්තියේ ඒ ක්ෂේත්රය ආවරණය කරයි (සෙවණැලි). ක්රමයන් වෙනස් ලෙස ක්රියා කරයි: අත්සන් එකසේ නම්, දරුවන් ක්රමය මව් පන්තියේ ක්රමය අතිරේක කරයි. ක්ෂේත්රයන් අතිරේක කළ නොහැකි බව සලකන්න—එවා පමණක් ආවරණය කළ හැක.
Q6: උරුම ගැඹුරු බව ඉතා වැඩි වුවහොත් කුමක් වේ?
A6: ගැඹුරු උරුම ශ්රේණිගත කිරීම කේතය අවබෝධ කර ගැනීමට සහ නඩත්තු කිරීමට අමාරු කරයි. තර්කය කොතැනද නිර්වචනය කර ඇතිද යන්න හඹා යාම අභියෝගයක් වේ. නඩත්තු කළ හැකි නිර්මාණයක් සඳහා, උරුම ගැඹුරු බව අඩු තබා, භූමිකා පැහැදිලිව වෙන් කර තබන්න.
Q7: අතිරේක කිරීම (overriding) සහ අතිරේක කිරීම (overloading) අතර වෙනස කුමක්ද?
A7: අතිරේක කිරීම යනු මව් පන්තියේ ක්රමයක් දරුවන් පන්තියේ නැවත නිර්වචනය කිරීමයි. අතිරේක කිරීම (overloading) යනු එකම පන්තියේ එකම නාමයෙන්, නමුත් වෙනස් පරාමිතීන් වර්ග හෝ ගණන සමඟ බහු ක්රම නිර්වචනය කිරීමයි.
Q8: අබ්ස්ට්රාක්ට් පන්තීන් සහ අතුරුමුහුණත් (interfaces) වෙනස් ලෙස කෙසේ භාවිතා කළ යුතුද?
A8: අබ්ස්ට්රාක්ට් පන්තීන් සම්බන්ධිත පන්තීන් අතර හවුල් ක්රියාත්මක කිරීම හෝ ක්ෂේත්ර ලබා දීමට අවශ්ය වන විට භාවිතා කරයි. අතුරුමුහුණත් (interfaces) බහු පන්තීන් ක්රියාත්මක කළ හැකි හැසිරීම් ගිවිසුම් නිර්වචනය කිරීමට භාවිතා කරයි. හවුල් කේතයක් සඳහා අබ්ස්ට්රාක්ට් පන්තියක්, බහු වර්ග හෝ බහු “කාර්යයන්” අවශ්ය වන විට අතුරුමුහුණත් භාවිතා කරන්න.
