ජාවා එනුම් පුද්ගලික සම්පාදකයින් සහ පොදු ස්ථිතික සාමාජිකයන් සමඟ පන්තිවලට සම්පාදනය කර ඇති බව මම දනිමි. දී ඇති enum හි සාමාජිකයන් දෙදෙනෙකු සංසන්දනය කිරීමේදී, මම සෑම විටම භාවිතා කර ඇත .equals(), උදා

public useEnums(SomeEnum a)
{
    if(a.equals(SomeEnum.SOME_ENUM_VALUE))
    {
        ...
    }
    ...
}

කෙසේ වෙතත්, ==.equals () වෙනුවට සමාන ක්‍රියාකරු භාවිතා කරන කේතයක් මට හමු විය :

public useEnums2(SomeEnum a)
{
    if(a == SomeEnum.SOME_ENUM_VALUE)
    {
        ...
    }
    ...
}

මා භාවිතා කළ යුත්තේ කුමන ක්‍රියාකරුද?

දෙකම තාක්ෂණික වශයෙන් නිවැරදි ය. ඔබ සඳහා ප්‍රභව කේතය දෙස බැලුවහොත් .equals(), එය සරලවම කල් දමයි ==.

==කෙසේ වෙතත්, එය ශුන්‍ය ආරක්ෂිත වනු ඇති බැවින් මම භාවිතා කරමි .

හැකි ==මත භාවිතා කල enum?

ඔව්: සිද්ධි ==සංසන්දනය කිරීම සඳහා භාවිතා කිරීමට ඉඩ සලසන තද නිදර්ශන පාලක එනූම්ස් සතුව ඇත . භාෂා පිරිවිතරයෙන් සපයන සහතිකය මෙන්න (මා අවධාරණය කිරීම):

JLS 8.9 එනූම්ස්

එනූම් වර්ගයට එහි එනුම් නියතයන් මගින් අර්ථ දක්වා ඇති අවස්ථා හැර වෙනත් අවස්ථා නොමැත.

එනූම් වර්ගයක් පැහැදිලිව ක්ෂණිකව තහවුරු කිරීමට උත්සාහ කිරීම සම්පාදක කාල දෝෂයකි. මෙම final cloneපාලන ක්රමය Enumබව සහතික enumනියත කවදාවත් කරගත යුතු වේ, හා අනු අවස්ථා කවදාවත් deserialization ප්රතිඵලයක් ලෙස නිර්මාණය වී ඇති serialization යාන්ත්රණයක් බවටද සහතික විසින් විශේෂ ප්රතිකාර ලබා ඇත. එනූම් වර්ග පරාවර්තකව ස්ථාපනය කිරීම තහනම්ය. මෙම කරුණු හතරම එක්ව නියතයන් enumවිසින් නිර්වචනය කර ඇති ප්‍රමාණය ඉක්මවා කිසිදු ආකාරයක අවස්ථාවක් නොපවතින බව සහතික කරයි enum.

එක් එක් උදාහරණයක් පමණක් ඇති නිසා enumනියතය එය භාවිතා කිරීමට අවසර නොදෙනු ==ඇති වෙනුවට ක්රියාකරු equalsක්රමය එය ඔවුන් අවම වශයෙන් එක් වූ අදහස් කළ බව කවුරුත් හොඳින් දන්නා කාරණයකි නම් වස්තුව පද දෙකක් සාපේක්ෂව enumනියත . ( equalsක්‍රමවේදය Enumයනු finalහුදෙක් super.equalsඑහි තර්කයට ආයාචනා කර ප්‍රති result ලය ලබා දෙන අතර එමඟින් අනන්‍යතා සංසන්දනයක් සිදු කරයි.)

මෙම සහතිකය ජොෂ් බ්ලොච් නිර්දේශ කරන තරමට ශක්තිමත් වන අතර, ඔබ සිංගල්ටන් රටාව භාවිතා කිරීමට බල කරන්නේ නම්, එය ක්‍රියාත්මක කිරීමට ඇති හොඳම ක්‍රමය තනි මූලද්‍රව්‍යයක් භාවිතා කිරීමයි enum(බලන්න: Java ලදායී ජාවා 2 වන සංස්කරණය, අයිතමය 3: සිංගල්ටන් දේපල a සමඟ බලාත්මක කරන්න පුද්ගලික ඉදිකිරීම්කරු හෝ එනුම් වර්ගයක් ; සිංගල්ටන් හි නූල් ආරක්ෂාව )

==සහ අතර ඇති වෙනස්කම් equalsමොනවාද?

මතක් කිරීමක් ලෙස, එය සාමාන්‍යයෙන් ==ශක්‍ය විකල්පයක් නොවන බව පැවසිය යුතුය equals. කෙසේ වෙතත්, (සමඟ වැනි enum) සලකා බැලිය යුතු වැදගත් වෙනස්කම් දෙකක් තිබේ:

== කවදාවත් විසි කරන්නේ නැහැ NullPointerException

enum Color { BLACK, WHITE };

Color nothing = null;
if (nothing == Color.BLACK);      // runs fine
if (nothing.equals(Color.BLACK)); // throws NullPointerException

== සම්පාදනය කරන වේලාවේදී අනුකූලතා පරීක්ෂාවට යටත් වේ

enum Color { BLACK, WHITE };
enum Chiral { LEFT, RIGHT };

if (Color.BLACK.equals(Chiral.LEFT)); // compiles fine
if (Color.BLACK == Chiral.LEFT);      // DOESN'T COMPILE!!! Incompatible types!

==අදාළ වන විට භාවිතා කළ යුතුද ?

ඔවුන්ගේ අවස්ථා පිළිබඳ නිසි පාලනයක් ඇති වෙනස් කළ නොහැකි පංති ==භාවිතා කළ හැකි තම සේවාදායකයින්ට සහතික කළ හැකි බව බ්ලොච් විශේෂයෙන් සඳහන් කරයි . enumනිදර්ශනය කිරීම සඳහා විශේෂයෙන් සඳහන් කර ඇත.

අයිතමය 1: ඉදිකිරීම්කරුවන් වෙනුවට ස්ථිතික කර්මාන්තශාලා ක්‍රම සලකා බලන්න

[...] එය සමාන අවස්ථා දෙකක් නොපවතින බවට සහතිකයක් ලබා දීමට වෙනස් කළ නොහැකි පන්තියකට ඉඩ දෙයි: a.equals(b)තිබේ නම් සහ එසේ නම් පමණි a==b. පංතියක් මෙම සහතිකය ලබා දෙන්නේ නම්, එහි සේවාදායකයින්ට ක්‍රමවේදය ==වෙනුවට ක්‍රියාකරු භාවිතා කළ හැකි equals(Object)අතර එමඟින් කාර්ය සාධනය වැඩි දියුණු විය හැකිය. එනුම් වර්ග මෙම සහතිකය සපයයි.

සාරාංශගත කිරීම සඳහා, භාවිතා ==කිරීම සඳහා වන තර්ක enum:

• එය වැඩ කරනවා.
• එය වේගවත් ය.
• ධාවන වේලාවේදී එය ආරක්ෂිතයි.
• සම්පාදනය කරන වේලාවේදී එය ආරක්ෂිතයි.

==එක් එක් එනූම් නියතයට එක් වස්තුවක් පමණක් ඇති බැවින්, එනුම් අගයන් දෙකක් සංසන්දනය කිරීම භාවිතා කරයි.

පැති සටහනක, ඇත්ත වශයෙන්ම ==ඔබ මේ ආකාරයට ලියන්නේ නම්, ශුන්‍ය-ආරක්ෂිත කේත ලිවීමට භාවිතා කිරීමේ අවශ්‍යතාවයක් නොමැත equals():

public useEnums(final SomeEnum a) {
    if (SomeEnum.SOME_ENUM_VALUE.equals(a)) {
        …
    }
    …
}

මෙය ඔබ අනිවාර්යයෙන්ම අනුගමනය කළ යුතු වමේ සිට නියතයන් සංසන්දනය කිරීම ලෙස හැඳින්වෙන හොඳම භාවිතයකි .

අනෙක් අය පවසා ඇති පරිදි, දෙකම ==සහ .equals()බොහෝ අවස්ථාවන්හි වැඩ කරයි. ඔබ වෙනත් අය විසින් පෙන්වා දී ඇති සම්පූර්ණයෙන්ම වෙනස් වස්තු සංසන්දනය නොකරන කාල නියමය වලංගු හා ප්‍රයෝජනවත් වේ, කෙසේ වෙතත් විවිධ සංයුක්ත කාල වර්ග දෙකක වස්තු සංසන්දනය කිරීමේ විශේෂිත දෝෂය ද FindBugs විසින් සොයා ගනු ඇත (සහ බොහෝ විට Eclipse / IntelliJ විසින් කාල පරීක්ෂාවන් සම්පාදනය කරයි), එබැවින් එය සොයා ගන්නා ජාවා සම්පාදකයාට එතරම් අමතර ආරක්ෂාවක් එක් නොවේ.

කෙසේවෙතත්:

1. බව ==මගේ සිතේ NPE අවුලට කවදාවත් වේ අවාසිය පිළිබඳ ==. ඔබට enumවර්ග ප්‍රකාශ කිරීමේ අවශ්‍යතාවයක් කිසිසේත්ම තිබිය යුතු නැත null, මන්ද ඔබට ප්‍රකාශ කිරීමට අවශ්‍ය ඕනෑම අමතර තත්වයක් අතිරේක අවස්ථාවක් ලෙස nullඑකතු කළ හැකි බැවිනි enum. එය අනපේක්ෂිත ලෙස නම් null, නිහ ly ==ව අසත්‍යය තක්සේරු කරනවාට වඩා මට NPE එකක් තිබිය යුතුය . එබැවින් ධාවන කාල මතයට වඩා ආරක්ෂිත යැයි මම එකඟ නොවෙමි ; කිසි විටෙකත් enumසාරධර්මවලට ඉඩ නොදීමට පුරුද්දට පිවිසීම හොඳය @Nullable.
2. ඇතැයි යන තර්කය ==වන්නේ වේගවත් ද ව්යාජ වේ. බොහෝ අවස්ථාවල දී ඔබ කතා කරන්නම් .equals()කාගේ බැදීමකට වර්ගය නිඛිල පන්තිය බවත්, එවැනි අවස්ථාවන්හිදී සම්පාදකවරයා මෙම සමාන බව දැන හැකි විචල්ය මත ==(බැවින් enumගේ equals()ක්රමය ඉක්මවනු විය හැක) මෙම උත්සවයට ඇමතුමක් උපරිම ඵල හැකි ඉවතට. සම්පාදකයා දැනට මෙය කරන්නේ දැයි මට විශ්වාස නැත, නමුත් එය එසේ නොවන්නේ නම් සහ සමස්තයක් වශයෙන් ජාවා හි කාර්ය සාධන ගැටලුවක් බවට පත්වේ නම්, ජාවා ක්‍රමලේඛකයින් 100,000 ක් ඔවුන්ගේ ක්‍රමලේඛන විලාසය ගැලපෙන පරිදි වෙනස් කරනවාට වඩා මම සම්පාදකය නිවැරදි කරමි. විශේෂිත සම්පාදක අනුවාදයක කාර්ය සාධන ලක්ෂණ.
3. enumsවස්තු වේ. අනෙක් සියලුම වස්තු වර්ග සඳහා සම්මත සංසන්දනය .equals()නොවේ ==. ව්‍යතිරේකයක් කිරීම භයානක යැයි මම සිතන්නේ enumsඔබ ==ඒ වෙනුවට අහම්බෙන් වස්තු සංසන්දනය කිරීම නිසා විය හැකිය equals(), විශේෂයෙන් ඔබ එනුම් enumනොවන පන්තියකට ප්‍රතිනිර්මාණය කරන්නේ නම් . එවැනි ප්‍රතිචක්‍රීකරණයකදී, එය ඉහළින් ක්‍රියාත්මක වන ස්ථානය වැරදිය. භාවිතයක් ==නිවැරදි බව ඔබට ඒත්තු ගැන්වීමට , ප්‍රශ්නයේ වටිනාකම enumප්‍රාථමිකද නැතිනම් ප්‍රාථමිකද යන්න පරීක්ෂා කර බැලිය යුතුය ; එය enumපංතියක් නොවන නම් , එය වැරදියි, නමුත් එය මඟ හැරීම පහසුය, මන්ද කේතය තවමත් සම්පාදනය වනු ඇත. භාවිතා කරන විට ඇති එකම අවස්ථාව.equals()වැරදියි යනු ප්‍රශ්නයේ අගයන් ප්‍රාථමික නම්; එවැනි අවස්ථාවකදී, කේතය සම්පාදනය නොවන බැවින් එය මග හැරීමට වඩා අපහසු වේ. එබැවින් .equals()නිවැරදි යැයි හඳුනා ගැනීම වඩා පහසු වන අතර අනාගත ප්‍රතිචක්‍රීකරණයන්ට එරෙහිව එය ආරක්ෂිත වේ.

මම ඇත්ත වශයෙන්ම සිතන්නේ ජාවා භාෂාව වම් අතෙහි අගය මත .equals () ඇමතීමට සහ වස්තු අනන්‍යතාවය සඳහා වෙනම ක්‍රියාකරුවෙකු හඳුන්වා දීමට වස්තු මත අර්ථ දැක්විය යුතු නමුත් ජාවා අර්ථ දක්වා ඇත්තේ එලෙස නොවේ.

සාරාංශයක් ලෙස, මම තවමත් සිතන්නේ තර්ක වර්ග .equals()සඳහා භාවිතා කිරීමට පක්ෂව සිටින enumබවයි.

මම ==ඒ වෙනුවට භාවිතා කිරීමට කැමැත්තෙමි equals:

වෙනත් හේතුවක් නම්, මෙහි දැනටමත් සාකච්ඡා කර ඇති අනෙක් ඒවාට අමතරව, ඔබට එය නොදැන දෝෂයක් හඳුන්වා දිය හැකිද? ඔබට මෙම එනූම්ස් හරියටම සමාන නමුත් වෙන්වූ පැකේජ වල තිබේ යැයි සිතමු (එය පොදු නොවේ, නමුත් එය සිදුවිය හැකිය):

පළමු enum :

package first.pckg

public enum Category {
    JAZZ,
    ROCK,
    POP,
    POP_ROCK
}

දෙවන enum:

package second.pckg

public enum Category {
    JAZZ,
    ROCK,
    POP,
    POP_ROCK
}

එවිට ඔබ තුළ මෙන් තැනෙන්නේ භාවිතා සිතමු item.categoryවන first.pckg.Categoryනමුත්, ඔබ දෙවන නිඛිල (ආනයනය second.pckg.Categoryඑය සාක්ෂාත් නොමැතිව පළමු වෙනුවට):

import second.pckg.Category;
...

Category.JAZZ.equals(item.getCategory())

ඒ නිසා ඔබට falseසත්‍යය අපේක්ෂා කළත් ඔබට ලැබිය යුතු දේ වෙනස් item.getCategory()වේ JAZZ. එය බැලීමට ටිකක් අපහසු විය හැකිය.

එබැවින්, ඔබ ඒ වෙනුවට ක්‍රියාකරු භාවිතා කරන්නේ නම් ඔබට ==සම්පාදක දෝෂයක් ඇත:

operator == "second.pckg.Category", "first.pckg.Category" වෙත යෙදිය නොහැක.

import second.pckg.Category; 
...

Category.JAZZ == item.getCategory() 

මේ දෙක සංසන්දනය කිරීම සඳහා ගොරහැඩි කාල පරීක්ෂණයක් මෙන්න:

import java.util.Date;

public class EnumCompareSpeedTest {

    static enum TestEnum {ONE, TWO, THREE }

    public static void main(String [] args) {

        Date before = new Date();
        int c = 0;

        for(int y=0;y<5;++y) {
            for(int x=0;x<Integer.MAX_VALUE;++x) {
                if(TestEnum.ONE.equals(TestEnum.TWO)) {++c;}
                if(TestEnum.ONE == TestEnum.TWO){++c;}              
            }
        }

        System.out.println(new Date().getTime() - before.getTime());
    }   

}

වරකට IFs ගැන අදහස් දක්වන්න. විසුරුවා හරින ලද බයිට් කේතයෙන් ඉහළින් සැසඳීම් දෙක මෙන්න:

 21  getstatic EnumCompareSpeedTest$TestEnum.ONE : EnumCompareSpeedTest.TestEnum [19]
 24  getstatic EnumCompareSpeedTest$TestEnum.TWO : EnumCompareSpeedTest.TestEnum [25]
 27  invokevirtual EnumCompareSpeedTest$TestEnum.equals(java.lang.Object) : boolean [28]
 30  ifeq 36

 36  getstatic EnumCompareSpeedTest$TestEnum.ONE : EnumCompareSpeedTest.TestEnum [19]
 39  getstatic EnumCompareSpeedTest$TestEnum.TWO : EnumCompareSpeedTest.TestEnum [25]
 42  if_acmpne 48

පළමු (සමාන) අථත්‍ය ඇමතුමක් සිදු කරන අතර තොගයේ සිට ආපසු එන බූලියන් පරීක්ෂා කරයි. දෙවැන්න (==) වස්තු ලිපින සෘජුවම තොගයෙන් සංසන්දනය කරයි. පළමු අවස්ථාවේ දී වැඩි ක්රියාකාරිත්වයක් ඇත.

මම එකවරම IFs දෙකම සමඟ මෙම පරීක්ෂණය කිහිප වතාවක්ම ධාවනය කළෙමි. "==" සෑම විටම තරමක් වේගවත් වේ.

එනුම් නම් දෙකම නිවැරදි සහ හරි !!

tl; dr

තවත් විකල්පයක් වන්නේ Objects.equalsඋපයෝගිතා ක්‍රමයයි.

Objects.equals( thisEnum , thatEnum )

Objects.equals ශුන්‍ය ආරක්ෂාව සඳහා

.equals () වෙනුවට ක්‍රියාකරු == සමාන වේ

මා භාවිතා කළ යුත්තේ කුමන ක්‍රියාකරුද?

තෙවන විකල්පය වන්නේ ජාවා 7 සහ ඊට පසුව එකතුequals කරන ලද Objectsඋපයෝගිතා පන්තියේ ස්ථිතික ක්‍රමයයි .

උදාහරණයක්

මෙන්න Monthenum භාවිතා කරන උදාහරණයක් .

boolean areEqual = Objects.equals( Month.FEBRUARY , Month.JUNE ) ;  // Returns `false`.

ප්‍රතිලාභ

මෙම ක්‍රමයට ප්‍රතිලාභ කිහිපයක් මම සොයා ගතිමි:

• ශුන්‍ය ආරක්ෂාව
  • දෙකම ශුන්‍ය true
  • එක්කෝ ශුන්‍ය false
  • විසි කිරීමේ අවදානමක් නැත NullPointerException
• සංයුක්ත, කියවිය හැකි

එය ක්‍රියාත්මක වන ආකාරය

භාවිතා කරන තර්කනය Objects.equalsකුමක්ද?

සිට, ඔබම බලන්න ජාවා 10 මූල කේතය පිළිබඳ OpenJDK :

return (a == b) || (a != null && a.equals(b));

==එනුම් නියතයන් සංසන්දනය කිරීම හැර වෙනත් දෙයක් භාවිතා කිරීම විකාරයකි. එය වස්තූන් සමඟ සංසන්දනය කිරීමක්classequals වැනිය - එය නොකරන්න!

කෙසේ වෙතත්, සන් ජේඩීකේ 6u10 සහ ඊට පෙර අප්රසන්න දෝෂයක් (බග් අයිඩ් 6277781 ) ඇති අතර එය මීට පෙර historical තිහාසික හේතූන් මත සිත්ගන්නා සුළු විය හැකිය. මෙම දෝෂය නිසා ==ඩෙසරීකරණය කළ එනූම් නිසි ලෙස භාවිතා කිරීම වලක්වනු ලැබීය .

එනුම් යනු පංති යනු එක් එක් ගණන් කිරීමේ නියතය සඳහා (නිශ්චල නොවන) ප්‍රකාශිත එක් අවස්ථාවක් (සිංගල්ටන් වැනි) ලබා දෙන අතර public static final fieldඑමඟින් ක්‍රමවේදය ==භාවිතා කරනවාට වඩා ඔවුන්ගේ සමානාත්මතාවය පරීක්ෂා කිරීමට ක්‍රියාකරුට හැකි equals()වේ.

Enums == සමඟ පහසුවෙන් ක්‍රියා කිරීමට හේතුව වන්නේ එක් එක් නිර්වචනය කළ අවස්ථාව ද තනි පුද්ගලයෙකි. එබැවින් == භාවිතා කරමින් අනන්‍යතා සංසන්දනය සැමවිටම ක්‍රියාත්මක වේ.

නමුත් == භාවිතා කිරීම එය එනූම්ස් සමඟ ක්‍රියා කරන නිසා ඔබේ කේත සියල්ලම එම එනූම් භාවිතය සමඟ තදින් බැඳී ඇත.

උදාහරණයක් ලෙස: එනූම්ස් හට අතුරු මුහුණතක් ක්‍රියාත්මක කළ හැකිය. ඔබ දැනට භාවිතා කරන්නේ ඉන්ටර්ෆේස් 1 ක්‍රියාත්මක කරන එනූම් එකක් යැයි සිතමු. පසුකාලීනව, යමෙකු එය වෙනස් කිරීම හෝ එකම අතුරු මුහුණතක් ක්‍රියාත්මක කිරීමක් ලෙස නව පන්තියේ Impl1 හඳුන්වා දෙයි. ඉන්පසුව, ඔබ Impl1 හි නිදසුන් භාවිතා කිරීමට පටන් ගන්නේ නම්, පෙර භාවිතා කළ == නිසා වෙනස් කිරීමට සහ පරීක්ෂා කිරීමට ඔබට කේත රාශියක් ඇත.

එබැවින් සාධාරණ ප්‍රතිලාභයක් නොමැති නම් හොඳ පුරුද්දක් ලෙස සලකන දේ අනුගමනය කිරීම වඩාත් සුදුසුය.

සෝනාර් නීති වලින් එකක් Enum values should be compared with "==". හේතු පහත පරිදි වේ:

equals()එනමූම් වස්තුවක් වන නිසාත්, සෑම ජාවා සංවර්ධකයෙකුම දන්නා වස්තුවක ==අන්තර්ගතය සංසන්දනය කිරීම සඳහා භාවිතා නොකළ යුතු නිසාත්, එනුම් අගය සමඟ සමානාත්මතාවය පරීක්ෂා කිරීම පරිපූර්ණ ලෙස වලංගු වේ . ඒ සමගම, ==enums භාවිතා කිරීම:

• අපේක්ෂිත සංසන්දනය (අන්තර්ගතය) සපයයි equals()

• වඩා ශුන්‍ය-ආරක්ෂිතයි equals()

• ධාවන කාල පරීක්ෂාවට වඩා සම්පාදක-කාල (ස්ථිතික) පරීක්ෂාව සපයයි

මෙම හේතු නිසා, භාවිතය ==වඩාත් කැමති විය යුතුය equals().

අවසාන වශයෙන් නොව, ==එනූම්ස් මත වාදයට වඩා කියවිය හැකි (අඩු වාචික) equals().

කෙටියෙන් කිවහොත්, දෙදෙනාම වාසි සහ අවාසි ඇත.

එක් අතකින්, ==අනෙක් පිළිතුරු වල විස්තර කර ඇති පරිදි එය භාවිතා කිරීමට වාසි ඇත .

අනෙක් අතට, ඔබ කිසියම් හේතුවක් නිසා එනූම්ස් වෙනුවට වෙනත් ප්‍රවේශයකින් (සාමාන්‍ය පන්ති අවස්ථා) ආදේශ කරන්නේ නම්, ඔබ ==දෂ්ට කරයි. (BTDT.)

මට බහු අවයවික පිළිතුරු සම්පුර්ණ කිරීමට අවශ්‍යයි:

මම පෞද්ගලිකව සමාන () වලට කැමතියි. නමුත් එය වර්ගයේ ගැළපුම පරීක්ෂා කරයි. එය වැදගත් සීමාවක් යැයි මම සිතමි.

සම්පාදනය කරන වේලාවේදී වර්ගීකරණ අනුකූලතා පරීක්‍ෂණයක් කිරීමට, ඔබේ එනූම් හි අභිරුචි ශ්‍රිතයක් ප්‍රකාශ කර භාවිතා කරන්න.

public boolean isEquals(enumVariable) // compare constant from left
public static boolean areEqual(enumVariable, enumVariable2) // compare two variable

මේ සමඟ, ඔබට විසඳුම් දෙකේම සියලු වාසි ලැබුණි: එන්පීඊ ආරක්ෂාව, කේත කියවීමට පහසු සහ සම්පාදක වේලාවේදී අනුකූලතා පරීක්ෂාව ටයිප් කරන්න.

එනුම් සඳහා නිර්වචනය නොකළ අගයක් එක් කිරීමට ද මම නිර්දේශ කරමි.