ஜாவாவில் நமக்கு ஏன் இடைமுகங்கள் தேவை

வணக்கம்! இன்று நாம் ஜாவாவில் ஒரு முக்கியமான கருத்தைப் பற்றி பேசப் போகிறோம்: இடைமுகங்கள். இந்த வார்த்தை உங்களுக்கு நன்கு தெரிந்திருக்கலாம். எடுத்துக்காட்டாக, பெரும்பாலான கணினி நிரல்களும் கேம்களும் இடைமுகங்களைக் கொண்டுள்ளன. ஒரு பரந்த பொருளில், ஒரு இடைமுகம் என்பது ஒரு வகையான 'ரிமோட் கண்ட்ரோல்' ஆகும், இது இரண்டு ஊடாடும் கட்சிகளை இணைக்கிறது. அன்றாட வாழ்வில் இடைமுகத்தின் எளிய உதாரணம் டிவி ரிமோட் கண்ட்ரோல். இது ஒரு நபர் மற்றும் டிவி ஆகிய இரண்டு பொருளை இணைக்கிறது மற்றும் வெவ்வேறு பணிகளைச் செய்கிறது: ஒலியளவை அதிகரிக்கவும் அல்லது குறைக்கவும், சேனல்களை மாற்றவும் மற்றும் டிவியை இயக்கவும் அல்லது அணைக்கவும். ஒரு தரப்பினர் (நபர்) இடைமுகத்தை அணுக வேண்டும் (ரிமோட் கண்ட்ரோலில் ஒரு பொத்தானை அழுத்தவும்) இரண்டாவது தரப்பினர் செயலைச் செய்ய வேண்டும். எடுத்துக்காட்டாக, டிவியை அடுத்த சேனலுக்கு மாற்றுவதற்கு. மேலும் என்ன, பயனர் இல்லை' டிவி எவ்வாறு ஒழுங்கமைக்கப்பட்டுள்ளது அல்லது சேனல் மாற்றும் செயல்முறை உள்நாட்டில் எவ்வாறு செயல்படுத்தப்படுகிறது என்பதைத் தெரிந்து கொள்ள வேண்டும். பயனர் அணுகக்கூடிய ஒரே விஷயம் இடைமுகம். விரும்பிய முடிவைப் பெறுவதே முக்கிய நோக்கம். நிரலாக்கத்திற்கும் ஜாவாவிற்கும் என்ன சம்பந்தம்? எல்லாம் :) ஒரு இடைமுகத்தை உருவாக்குவது வழக்கமான வகுப்பை உருவாக்குவதைப் போன்றது, ஆனால் அதற்கு பதிலாக வார்த்தையைப் பயன்படுத்துகிறதுவர்க்கம் , நாம் சொல் இடைமுகத்தைக் குறிப்பிடுகிறோம் . எளிமையான ஜாவா இடைமுகத்தைப் பார்ப்போம், அது எப்படி வேலை செய்கிறது, ஏன் நமக்கு அது தேவை என்று பார்க்கலாம்:

public interface CanSwim {

     public void swim();
}

CanSwim இடைமுகத்தை உருவாக்கியுள்ளோம் . இது எங்கள் ரிமோட் கண்ட்ரோல் போன்றது, ஆனால் ஒரு 'பட்டன்': நீச்சல்() முறை. ஆனால் இந்த ரிமோட் கன்ட்ரோலரை எவ்வாறு பயன்படுத்துவது? இதைச் செய்ய, நாம் ஒரு முறையைச் செயல்படுத்த வேண்டும், அதாவது எங்கள் ரிமோட் கண்ட்ரோல் பட்டன். ஒரு இடைமுகத்தைப் பயன்படுத்த, எங்கள் திட்டத்தில் சில வகுப்புகள் அதன் முறைகளை செயல்படுத்த வேண்டும். 'நீந்தக்கூடிய' பொருள்களைக் கொண்ட ஒரு வகுப்பைக் கண்டுபிடிப்போம். எடுத்துக்காட்டாக, ஒரு வாத்து வகுப்பு பொருந்தும்:

public class Duck implements CanSwim {

    public void swim() {
        System.out.println("Duck, swim!");
    }

    public static void main(String[] args) {

        Duck duck = new Duck();
        duck.swim();
    }
}

"நாம் இங்கே என்ன பார்க்கிறோம்? டக் கிளாஸ் என்பது CanSwim இன்டர்ஃபேஸுடன் கருவிகளின் முக்கிய சொல்லால் 'தொடர்புடையது' . இரண்டு வகுப்புகளை பரம்பரை மூலம் இணைக்க நாங்கள் இதே போன்ற பொறிமுறையைப் பயன்படுத்தினோம் என்பது உங்களுக்கு நினைவிருக்கலாம், ஆனால் அந்த விஷயத்தில் நாங்கள் நீட்டிப்பு என்ற வார்த்தையைப் பயன்படுத்தினோம். முழுமையான தெளிவு, ' பொது வகுப்பு டக் கேன்ஸ்விம் செயல்படுத்துகிறது ' என்பதை நாம் மொழிபெயர்க்கலாம் : 'பொது டக் கிளாஸ் கேன்ஸ்விம் இடைமுகத்தை செயல்படுத்துகிறது '. இதன் பொருள் ஒரு இடைமுகத்துடன் தொடர்புடைய ஒரு வகுப்பு அதன் அனைத்து முறைகளையும் செயல்படுத்த வேண்டும். குறிப்பு: எங்கள் Duckவகுப்பு, அதைப் போலவே இடைமுகம் CanSwim, ஒரு swim()முறை உள்ளது, அது சில தர்க்கங்களைக் கொண்டுள்ளது. இது ஒரு கட்டாயத் தேவை. நாம் எழுதினால்public class Duck implements CanSwimswim()வகுப்பில் ஒரு முறையை உருவாக்காமல் Duck, கம்பைலர் நமக்கு ஒரு பிழையைக் கொடுக்கும்: வாத்து என்பது சுருக்கம் அல்ல மற்றும் CanSwim இல் சுருக்க முறை நீச்சல்() ஐ மீறாது ஏன்? இது ஏன் நடக்கிறது? டிவி உதாரணத்தைப் பயன்படுத்தி பிழையை விளக்கினால், சேனல்களை மாற்ற முடியாத 'சேனலை மாற்று' பட்டன் கொண்ட டிவி ரிமோட் கண்ட்ரோலை ஒருவரிடம் ஒப்படைப்பது போல் இருக்கும். நீங்கள் விரும்பியபடி பொத்தானை அழுத்தலாம், ஆனால் அது வேலை செய்யாது. ரிமோட் கண்ட்ரோல் சேனல்களை தானாகவே மாற்றாது: இது டிவிக்கு ஒரு சமிக்ஞையை மட்டுமே அனுப்புகிறது, இது சேனலை மாற்றும் சிக்கலான செயல்முறையை செயல்படுத்துகிறது. எங்கள் வாத்தும் அப்படித்தான்: அது நீந்தத் தெரிந்திருக்க வேண்டும், எனவே அதை CanSwimஇடைமுகத்தைப் பயன்படுத்தி அழைக்கலாம். அது எப்படி என்று தெரியவில்லை என்றால், திCanSwimஇடைமுகம் இரண்டு தரப்பினரையும் இணைக்கவில்லை - நபர் மற்றும் நிரல். நிரலுக்குள் நீந்துவதற்கு swim()அந்த நபரால் இந்த முறையைப் பயன்படுத்த முடியாது . Duckஇடைமுகங்கள் எதற்காக என்பதை இப்போது நீங்கள் தெளிவாக புரிந்துகொள்கிறீர்கள். இடைமுகத்தை செயல்படுத்தும் வகுப்புகள் இருக்க வேண்டிய நடத்தையை ஒரு இடைமுகம் விவரிக்கிறது. 'நடத்தை' என்பது முறைகளின் தொகுப்பாகும். நாம் பல தூதர்களை உருவாக்க விரும்பினால், ஒரு இடைமுகத்தை உருவாக்குவதே எளிதான விஷயம் Messenger. ஒவ்வொரு தூதருக்கும் என்ன தேவை? ஒரு அடிப்படை மட்டத்தில், அவர்கள் செய்திகளைப் பெறவும் அனுப்பவும் முடியும்.

public interface Messenger{

     public void sendMessage();

     public void getMessage();
}

இப்போது நாம் தொடர்புடைய இடைமுகத்தை செயல்படுத்தும் எங்கள் தூதர் வகுப்புகளை உருவாக்கலாம். கம்பைலரே நம் வகுப்புகளில் அவற்றைச் செயல்படுத்த நம்மை 'வற்புறுத்தும்'. தந்தி:

public class Telegram implements Messenger {

    public void sendMessage() {

        System.out.println("Sending a Telegram message!");
    }

     public void getMessage() {
         System.out.println("Receiving a Telegram message!");
     }
}

பகிரி:

public class WhatsApp implements Messenger {

    public void sendMessage() {

        System.out.println("Sending a WhatsApp message!");
    }

     public void getMessage() {
         System.out.println("Reading a WhatsApp message!");
     }
}

Viber:

public class Viber implements Messenger {

    public void sendMessage() {

        System.out.println("Sending a Viber message!");
    }

     public void getMessage() {
         System.out.println("Receiving a Viber message!");
     }
}

இது என்ன நன்மைகளை வழங்குகிறது? அவற்றில் முக்கியமானது தளர்வான இணைப்பு. கிளையன்ட் தரவைச் சேகரிக்கும் திட்டத்தை நாங்கள் வடிவமைக்கிறோம் என்று கற்பனை செய்து பாருங்கள். Clientகிளையன்ட் எந்த குறிப்பிட்ட தூதரைப் பயன்படுத்துகிறார் என்பதைக் குறிக்க வகுப்பிற்கு நிச்சயமாக ஒரு புலம் தேவை . இடைமுகங்கள் இல்லாமல், இது வித்தியாசமாக இருக்கும்:

public class Client {

    private WhatsApp whatsApp;
    private Telegram telegram;
    private Viber viber;
}

நாங்கள் மூன்று புலங்களை உருவாக்கினோம், ஆனால் ஒரு கிளையன்ட் ஒரே ஒரு தூதரை மட்டுமே வைத்திருக்க முடியும். எது என்று எங்களுக்குத் தெரியவில்லை. எனவே வாடிக்கையாளருடன் தொடர்பு கொள்ள ஒவ்வொரு சாத்தியத்தையும் வகுப்பில் சேர்க்க வேண்டும். nullஅவற்றில் ஒன்று அல்லது இரண்டு எப்போதும் நிரலுக்கு முற்றிலும் தேவையற்றதாக இருக்கும் என்று மாறிவிடும் . அதற்கு பதிலாக எங்கள் இடைமுகத்தைப் பயன்படுத்துவது நல்லது:

public class Client {

    private Messenger messenger;
}

தளர்வான இணைப்பிற்கு இது ஒரு எடுத்துக்காட்டு! வகுப்பில் ஒரு குறிப்பிட்ட தூதுவர் வகுப்பைக் குறிப்பிடுவதற்குப் பதிலாக Client, கிளையண்டிடம் ஒரு தூதர் இருப்பதைக் குறிப்பிடுகிறோம். நிரல் இயங்கும்போது எது சரியாகத் தீர்மானிக்கப்படும். ஆனால் இதற்கு ஏன் இடைமுகங்கள் தேவை? அவை ஏன் மொழியில் சேர்க்கப்பட்டன? இது ஒரு நல்ல கேள்வி - மற்றும் சரியான கேள்வி! சாதாரண பரம்பரையைப் பயன்படுத்தி அதே முடிவை அடைய முடியாதா? வகுப்பு Messengerபெற்றோராக, மற்றும் Viber, Telegram, மற்றும் WhatsAppகுழந்தைகளாக. உண்மையில், அது சாத்தியம். ஆனால் ஒரு தடுமாற்றம் இருக்கிறது. உங்களுக்கு ஏற்கனவே தெரியும், ஜாவாவிற்கு பல மரபுகள் இல்லை. ஆனால் பல இடைமுகங்களுக்கு ஆதரவு உள்ளது. ஒரு வகுப்பில் நீங்கள் விரும்பும் பல இடைமுகங்களை செயல்படுத்த முடியும். எங்களிடம் ஒரு Smartphoneவகுப்பு உள்ளது என்று கற்பனை செய்து பாருங்கள்Appபுலம், இது ஸ்மார்ட்போனில் நிறுவப்பட்ட பயன்பாட்டைக் குறிக்கிறது.

public class Smartphone {

    private App app;
}

நிச்சயமாக, ஒரு பயன்பாடும் ஒரு தூதுவரும் ஒரே மாதிரியானவை, ஆனால் அவை இன்னும் வேறுபட்டவை. மெசஞ்சரின் மொபைல் மற்றும் டெஸ்க்டாப் பதிப்புகள் இருக்கலாம், ஆனால் ஆப் குறிப்பாக மொபைல் பயன்பாட்டைக் குறிக்கிறது. Telegramஇதோ ஒப்பந்தம் — நாம் மரபுரிமையைப் பயன்படுத்தினால், வகுப்பில் ஒரு பொருளைச் சேர்க்க முடியாது Smartphone. எல்லாவற்றிற்கும் மேலாக, Telegramவர்க்கம் ஒரே நேரத்தில் மரபுரிமை பெற முடியாது Appமற்றும் Messenger! நாங்கள் ஏற்கனவே அதை மரபுரிமையாக்கி Messengerவகுப்பில் சேர்த்துள்ளோம் Client. ஆனால் Telegramவகுப்பு இரண்டு இடைமுகங்களையும் எளிதாக செயல்படுத்த முடியும்! Clientஅதன்படி, வகுப்பிற்கு ஒரு Telegramபொருளை ஒரு பொருளாகக் கொடுக்கலாம் , அதை வகுப்பிற்கு ஒரு என Messengerவழங்கலாம் . நீங்கள் அதை எப்படி செய்வது என்பது இங்கே: SmartphoneApp

public class Telegram implements Application, Messenger {

    // ...methods
}

public class Client {

    private Messenger messenger;

    public Client() {
        this.messenger = new Telegram();
    }
}


public class Smartphone {

    private Application application;

    public Smartphone() {
        this.application = new Telegram();
    }
}

Telegramஇப்போது நாம் விரும்பும் வகுப்பைப் பயன்படுத்துகிறோம் . சில இடங்களில், இது ஒரு App. மற்ற இடங்களில், இது ஒரு Messenger. இடைமுக முறைகள் எப்போதும் 'காலியாக' இருப்பதை நீங்கள் நிச்சயமாக ஏற்கனவே கவனித்திருப்பீர்கள், அதாவது அவை செயல்படுத்தப்படவில்லை. இதற்கான காரணம் எளிதானது: இடைமுகம் நடத்தையை விவரிக்கிறது, ஆனால் அது அதை செயல்படுத்தவில்லை. 'இடைமுகத்தை செயல்படுத்தும் அனைத்து பொருட்களும் CanSwimநீந்தக்கூடியதாக இருக்க வேண்டும்': இடைமுகம் நமக்குச் சொல்வது அவ்வளவுதான். மீன், வாத்து மற்றும் குதிரைகள் நீந்துவதற்கான குறிப்பிட்ட வழி Fish, Duck, மற்றும்Horseவகுப்புகள், இடைமுகம் அல்ல. சேனலை மாற்றுவது போல டிவிக்கு ஒரு பணி. இதற்கான பட்டனை ரிமோட் உங்களுக்கு வழங்குகிறது. இருப்பினும், ஜாவா 8 இல் ஒரு சுவாரஸ்யமான சேர்த்தல் தோன்றியது - இயல்புநிலை முறைகள். எடுத்துக்காட்டாக, உங்கள் இடைமுகத்தில் 10 முறைகள் உள்ளன. அவற்றில் 9 வெவ்வேறு வகுப்புகளில் வெவ்வேறு செயலாக்கங்களைக் கொண்டுள்ளன, ஆனால் ஒன்று அனைவருக்கும் ஒரே மாதிரியாக செயல்படுத்தப்படுகிறது. முன்னதாக, ஜாவா 8 க்கு முன், இடைமுக முறைகள் எதுவும் செயல்படுத்தப்படவில்லை: கம்பைலர் உடனடியாக ஒரு பிழையைக் கொடுத்தது. இப்போது நீங்கள் இதைப் போன்ற ஒன்றைச் செய்யலாம்:

public interface CanSwim {

   public default void swim() {
       System.out.println("Swim!");
   }

   public void eat();

   public void run();
}

முக்கிய சொல்லைப் பயன்படுத்தி default, இயல்புநிலை செயலாக்கத்துடன் ஒரு இடைமுக முறையை உருவாக்கியுள்ளோம். செயல்படுத்தும் அனைத்து வகுப்புகளிலும் - eat()மற்றும் - மற்ற இரண்டு முறைகளுக்கு எங்கள் சொந்த செயலாக்கத்தை வழங்க வேண்டும் . இந்த முறையை நாங்கள் செய்ய வேண்டியதில்லை : ஒவ்வொரு வகுப்பிலும் செயல்படுத்தல் ஒரே மாதிரியாக இருக்கும். மூலம், நீங்கள் ஏற்கனவே கடந்த பணிகளில் இடைமுகங்களைக் கண்டிருக்கிறீர்கள், நீங்கள் கவனிக்காவிட்டாலும் கூட :) இங்கே ஒரு தெளிவான உதாரணம்: நீங்கள் மற்றும் இடைமுகங்களுடன் பணிபுரிந்தீர்கள்! இன்னும் துல்லியமாக, நீங்கள் அவற்றின் செயலாக்கங்களுடன் பணிபுரிந்துள்ளீர்கள் - , , , முதலியன. ஒரே வரைபடத்தில் ஒரு வகுப்பு ஒரே நேரத்தில் பல இடைமுகங்களைச் செயல்படுத்தும் உதாரணத்தை தெளிவாகத் தருகிறது. எடுத்துக்காட்டாக, மற்றும் செயல்படுத்துகிறதுrun()CanSwimswim()ListSetArrayListLinkedListHashSetLinkedListListDeque(இரட்டை முனை வரிசை) இடைமுகங்கள். நீங்கள் இடைமுகத்தை நன்கு அறிந்திருக்கிறீர்கள் Map, அல்லது அதைச் HashMapசெயல்படுத்துவது. மூலம், இந்த வரைபடம் ஒரு அம்சத்தை விளக்குகிறது: இடைமுகங்கள் பிற இடைமுகங்களைப் பெறலாம். இடைமுகம் SortedMapமரபுரிமை பெறுகிறது Map, அதே சமயம் Dequeமரபுரிமையாகும் Queue. ஒரு இடைமுகம் மற்றொன்றின் விரிவாக்கப்பட்ட பதிப்பாக இருக்கும் இடைமுகங்களுக்கிடையேயான தொடர்பை நீங்கள் காட்ட விரும்பினால் இது அவசியம். இடைமுகத்துடன் ஒரு உதாரணத்தைக் கருத்தில் கொள்வோம் Queue. நாங்கள் இன்னும் மதிப்பாய்வு செய்யவில்லைQueues, ஆனால் இது மிகவும் எளிமையானது மற்றும் ஒரு கடையில் ஒரு சாதாரண வரிசை அல்லது வரி போல் வேலை செய்கிறது. நீங்கள் வரிசையின் முடிவில் பொருட்களை மட்டுமே சேர்க்க முடியும், மேலும் அவற்றை ஆரம்பத்தில் இருந்து மட்டுமே எடுக்க முடியும். ஒரு கட்டத்தில், இரண்டு முனைகளிலும் பொருட்களைச் சேர்க்க மற்றும் எடுக்க டெவலப்பர்களுக்கு வரிசையின் மேம்படுத்தப்பட்ட பதிப்பு தேவைப்பட்டது. எனவே அவர்கள் ஒரு Dequeஇடைமுகத்தை உருவாக்கினர், இது இரட்டை முனை வரிசை. இது ஒரு சாதாரண வரிசையின் அனைத்து முறைகளையும் கொண்டுள்ளது. எல்லாவற்றிற்கும் மேலாக, இது இரட்டை முனை வரிசையின் பெற்றோர், ஆனால் இது புதிய முறைகளையும் சேர்க்கிறது.