Junior
რა არის ჩვეულებრივი და აბსტრაქტული კლასის მსგავსება და განსხვავება?
sobes.tech AI
პასუხი AI-სგან
Golang-да "සාමාන්ය පන්තිය" සහ "අබස්ත්රැක් පන්තිය" යන අදහස් Java හෝ C# වැනි වස්තු-කේන්ද්රිත භාෂා වල පවතින ආකාරයට නොමැත.
එහෙත්, ඒවාගේ කාර්ය සාධනය අනුකරණය කළ හැකි අතර, ඒ සඳහා ව්යුහ හා අතුරුමුහුණත් (interfaces) භාවිතා කළ හැකිය.
සමානතා (Golang හි ව්යුහ හා අතුරුමුහුණත් භාවිතා කරමින්):
- තත්වය (දත්ත): ව්යුහයක් සාමාන්ය පන්තියක් මෙන් ගුණාංග ගබඩා කරන ක්ෂේත්ර අඩංගු විය හැකිය.
- සංවර්ධනය (ක්රම): ව්යුහයට ක්රම සම්බන්ධ කළ හැකිය, ඒවා එහි හැසිරීම නියම කරයි, සාමාන්ය පන්තියක් මෙන්.
- සාමාන්ය ගිවිසුම (අබස්ත්රැක් පන්තිය හා අතුරුමුහුණත් සඳහා): Golang හි අතුරුමුහුණතක් යනු, එය අනුගමනය කළ ඕනෑම ව්යුහයක් අනුගමනය කළ යුතු ක්රම සෙට් එකක් නිර්වචනය කරයි. මෙය වෙනත් භාෂා වල අබස්ත්රැක් පන්තියක් හෝ අතුරුමුහුණතක් මෙන් ගිවිසුමක් සකස් කිරීමක් වේ.
වෙනස්කම් (Golang සන්දර්භයේ):
| ලක්ෂණය | "සාමාන්ය පන්තිය" (ක්රම සමඟ ව්යුහය) | "අබස්ත්රැක් පන්තිය" (අතුරුමුහුණත් + ව්යුහ) |
|---|---|---|
| සෘජු නිර්මාණය | ව්යුහයක නියමිතියක් නිර්මාණය කළ හැකිය. | අතුරුමුහුණතක් නියමිතියක් නිර්මාණය කළ නොහැක. |
| ක්රමයන්ගේ ක්රියාත්මක කිරීම | ව්යුහයට සම්බන්ධ සියලු ක්රමයන් ක්රියාත්මක වේ. | අතුරුමුහුණතක් පමණක් ක්රමයන් ප්රකාශ කරයි, ඒවායේ ක්රියාත්මක කිරීම නොමැත. |
| වංශානුකරණය | සාම්ප්රදායික වංශානුකරණයක් නොමැත. සංයෝජනය (ව්යුහ ඇතුළත් කිරීම) භාවිතා කළ හැකිය. | අතුරුමුහුණතක් වංශානුකරණය නොකරයි, ව්යුහයන් ඒ අනුගමනය කරයි. |
| අනිවාර්ය ක්රියාවලිය | නියමිත ක්රම සෙට් එකක් ක්රියාත්මක කිරීමට බලය නොමැත, ව්යුහයට සම්බන්ධිත ක්රමයන් හැර. | Golang හි අතුරුමුහුණතක් "අනුගමනය" කරන ව්යුහයක් සියලු ක්රමයන් සැපයිය යුතුය. |
| තත්වය (ක්ෂේත්ර) | ව්යුහය දත්ත ක්ෂේත්ර අඩංගු විය හැකිය. | අතුරුමුහුණත දත්ත ක්ෂේත්ර නොමැත. |
උදාහරණයක්:
// අතුරුමුහුණත, අබස්ත්රැක් පන්තියක් ලෙස අනුකරණය කරයි
type Shape interface {
Area() float64
Perimeter() float64
}
// ව්යුහයක්, සාමාන්ය පන්තියක් ලෙස අනුකරණය කරයි
type Circle struct {
Radius float64
}
// Circle සඳහා අතුරුමුහුණතේ ක්රමයන් ක්රියාත්මක කිරීම
func (c Circle) Area() float64 {
return 3.14 * c.Radius * c.Radius
}
func (c Circle) Perimeter() float64 {
return 2 * 3.14 * c.Radius
}
// තවත් ව්යුහයක්, අතුරුමුහුණත ක්රියාත්මක කරයි
type Rectangle struct {
Width, Height float64
}
func (r Rectangle) Area() float64 {
return r.Width * r.Height
}
func (r Rectangle) Perimeter() float64 {
return 2 * (r.Width + r.Height)
}
මෙහි Shape යනු ගිවිසුමක් (අබස්ත්රැක් පන්තියක් හෝ අතුරුමුහුණතක් මෙන්), Circle සහ Rectangle යනු විශේෂිත ක්රියාත්මක කිරීම් (සාමාන්ය පන්තියක් මෙන්). අපට Circle සහ Rectangle නියමිතියන් නිර්මාණය කළ හැකිය, නමුත් Shape නියමිතියක් සෘජුව නිර්මාණය කළ නොහැක. දෙකම ව්යුහයන් Area() සහ Perimeter() ක්රමයන් ක්රියාත්මක කළ යුතුය, එවිට ඒවා Shape අතුරුමුහුණත "අනුගමනය" කරයි.