OOP இன் கோட்பாடுகள்

ஜாவா ஒரு பொருள் சார்ந்த மொழி. இதன் பொருள் நீங்கள் ஒரு பொருள் சார்ந்த முன்னுதாரணத்தைப் பயன்படுத்தி ஜாவா நிரல்களை எழுத வேண்டும். இந்த முன்னுதாரணம் உங்கள் நிரல்களில் பொருள்கள் மற்றும் வகுப்புகளைப் பயன்படுத்துகிறது. வகுப்புகள் மற்றும் பொருள்கள் என்றால் என்ன என்பதையும், நடைமுறையில் அடிப்படை OOP கொள்கைகளை (சுருக்கம், பரம்பரை, பாலிமார்பிசம் மற்றும் இணைத்தல்) எவ்வாறு பயன்படுத்துவது என்பதைப் புரிந்துகொள்ள எடுத்துக்காட்டுகளைப் பயன்படுத்த முயற்சிப்போம்.

ஒரு பொருள் என்ன?

நாம் வாழும் உலகம் பொருள்களால் ஆனது. சுற்றிப் பார்த்தால், வீடுகள், மரங்கள், கார்கள், தளபாடங்கள், பாத்திரங்கள் மற்றும் கணினிகளால் நாம் சூழப்பட்டிருப்பதைக் காணலாம். இவை அனைத்தும் பொருள்கள், மேலும் அவை ஒவ்வொன்றும் குறிப்பிட்ட பண்புகள், நடத்தைகள் மற்றும் நோக்கங்களின் தொகுப்பைக் கொண்டுள்ளன. நாம் பொருள்களுடன் பழக்கமாகிவிட்டோம், அவற்றை எப்போதும் குறிப்பிட்ட நோக்கங்களுக்காகப் பயன்படுத்துகிறோம். உதாரணமாக, நாம் வேலைக்குச் செல்ல வேண்டும் என்றால், நாங்கள் ஒரு காரைப் பயன்படுத்துகிறோம். நாம் சாப்பிட விரும்பினால், நாங்கள் உணவுகளைப் பயன்படுத்துகிறோம். நாங்கள் ஓய்வெடுக்க விரும்பினால், ஒரு வசதியான சோபாவைக் காணலாம். மனிதர்கள் அன்றாட வாழ்வில் பிரச்சனைகளைத் தீர்க்க பொருள்களின் அடிப்படையில் சிந்திக்கப் பழகிவிட்டனர். நிரலாக்கத்தில் பொருள்கள் பயன்படுத்தப்படுவதற்கு இதுவும் ஒரு காரணம். இந்த அணுகுமுறை பொருள் சார்ந்த நிரலாக்கம் என்று அழைக்கப்படுகிறது. ஒரு உதாரணம் தருவோம். நீங்கள் ஒரு புதிய ஃபோனை உருவாக்கிவிட்டீர்கள் மற்றும் வெகுஜன உற்பத்தியைத் தொடங்க விரும்புகிறீர்கள் என்று கற்பனை செய்து பாருங்கள். ஃபோனின் டெவலப்பராக, அது எதற்காக என்று உங்களுக்குத் தெரியும், இது எவ்வாறு செயல்படுகிறது மற்றும் அதன் பாகங்கள் என்ன (உடல், மைக்ரோஃபோன், ஸ்பீக்கர், கம்பிகள், பொத்தான்கள் போன்றவை). மேலும், இந்த பகுதிகளை எவ்வாறு இணைப்பது என்பது உங்களுக்கு மட்டுமே தெரியும். ஆனால் நீங்கள் தனிப்பட்ட முறையில் ஃபோன்களை உருவாக்கத் திட்டமிடவில்லை - இதைச் செய்ய உங்களுக்கு ஒரு முழுத் தொழிலாளர்கள் குழு உள்ளது. தொலைபேசியின் பாகங்களை எவ்வாறு இணைப்பது என்பதை மீண்டும் மீண்டும் விளக்க வேண்டிய அவசியத்தை நீக்குவதற்கும், எல்லா ஃபோன்களும் ஒரே மாதிரியாகத் தயாரிக்கப்படுவதை உறுதி செய்வதற்கும், அவற்றைத் தயாரிக்கத் தொடங்குவதற்கு முன், தொலைபேசி எவ்வாறு ஒழுங்கமைக்கப்பட்டுள்ளது என்பதை விவரிக்கும் ஒரு வரைபடத்தை நீங்கள் உருவாக்க வேண்டும். OOP இல், அத்தகைய விளக்கம், வரைதல், வரைபடம் அல்லது டெம்ப்ளேட்டை வகுப்பு என்று அழைக்கிறோம். நிரல் இயங்கும் போது பொருட்களை உருவாக்கும் அடிப்படையை இது உருவாக்குகிறது. ஒரு கிளாஸ் என்பது குறிப்பிட்ட வகை பொருள்களின் விளக்கமாகும் - புலங்கள், முறைகள் மற்றும் கட்டமைப்பாளரைக் கொண்ட பொதுவான டெம்ப்ளேட் போன்றது. ஒரு பொருள் என்பது ஒரு வகுப்பின் உதாரணம்.

சுருக்கம்

நிஜ உலகில் உள்ள ஒரு பொருளில் இருந்து ஒரு நிரலில் உள்ள ஒரு பொருளுக்கு நாம் எவ்வாறு நகரலாம் என்பதைப் பற்றி இப்போது சிந்திப்போம். தொலைபேசியை உதாரணமாகப் பயன்படுத்துவோம். இந்த தகவல் தொடர்பு சாதனம் 100 ஆண்டுகளுக்கும் மேலான வரலாற்றைக் கொண்டுள்ளது. நவீன தொலைபேசி அதன் 19 ஆம் நூற்றாண்டின் முன்னோடியை விட மிகவும் சிக்கலான சாதனமாகும். தொலைபேசியைப் பயன்படுத்தும் போது, ​​அதன் அமைப்பு மற்றும் அதன் உள்ளே நிகழும் செயல்முறைகளைப் பற்றி நாம் சிந்திக்க மாட்டோம். தொலைபேசியின் டெவலப்பர்கள் வழங்கிய செயல்பாடுகளை நாங்கள் பயன்படுத்துகிறோம்: பொத்தான்கள் அல்லது தொடுதிரை தொலைபேசி எண்ணை உள்ளிட்டு அழைப்புகளைச் செய்ய. முதல் ஃபோன் இடைமுகங்களில் ஒன்று, அழைப்பைச் செய்ய சுழற்ற வேண்டிய கிராங்க் ஆகும். நிச்சயமாக, இது மிகவும் வசதியாக இல்லை. ஆனால் அது அதன் செயல்பாட்டை குறைபாடற்ற முறையில் நிறைவேற்றியது. நீங்கள் மிகவும் நவீன மற்றும் முதல் தொலைபேசிகளை ஒப்பிட்டுப் பார்த்தால், 19 ஆம் நூற்றாண்டின் பிற்பகுதியில் சாதனம் மற்றும் நவீன ஸ்மார்ட்போனுக்கான மிக முக்கியமான செயல்பாடுகளை நீங்கள் உடனடியாக அடையாளம் காணலாம். அவை அழைப்புகளைச் செய்யும் திறன் மற்றும் அழைப்புகளைப் பெறும் திறன். உண்மையில், இதுவே ஃபோனை ஃபோன் ஆக்குகிறது, வேறு ஒன்று அல்ல. இப்போது OOP இன் கொள்கையைப் பயன்படுத்துங்கள்: ஒரு பொருளின் மிக முக்கியமான பண்புகள் மற்றும் தகவலை அடையாளம் காணவும். இந்த கொள்கை சுருக்கம் என்று அழைக்கப்படுகிறது. OOP இல், ஒரு நிரலில் உள்ள பொருள்களாக நிஜ-உலகப் பணியின் கூறுகளைக் குறிக்கும் முறையாகவும் சுருக்கத்தை வரையறுக்கலாம். சுருக்கம் எப்போதும் ஒரு பொருளின் சில பண்புகளின் பொதுமைப்படுத்தலுடன் தொடர்புடையது, எனவே முக்கிய விஷயம் என்னவென்றால், பணியின் சூழலில் முக்கியமற்றவற்றிலிருந்து அர்த்தமுள்ள தகவலைப் பிரிப்பதாகும். கூடுதலாக, சுருக்கத்தின் பல நிலைகள் இருக்கலாம். நாம் எங்கள் தொலைபேசிகளில் சுருக்கக் கொள்கையைப் பயன்படுத்த முயற்சிக்கவும். தொடங்குவதற்கு, நாங்கள் மிகவும் பொதுவான வகை ஃபோன்களை அடையாளம் காண்போம் - முதல் ஃபோன்கள் முதல் இன்றைய ஃபோன்கள் வரை. எடுத்துக்காட்டாக, படம் 1 இல் உள்ள வரைபடத்தின் வடிவத்தில் அவற்றைக் குறிப்பிடலாம். சுருக்கத்தைப் பயன்படுத்தி, இந்த பொருளின் படிநிலையில் உள்ள பொதுவான தகவலை நாம் இப்போது அடையாளம் காணலாம்: பொதுவான சுருக்க பொருள் (தொலைபேசி), தொலைபேசியின் பொதுவான பண்புகள் (எ.கா. உருவாக்கப்பட்ட ஆண்டு) மற்றும் பொதுவான இடைமுகம் (அனைத்து தொலைபேசிகளும் அழைப்புகளைப் பெறலாம் மற்றும் செய்யலாம்). ஜாவாவில் இது எப்படி இருக்கிறது என்பது இங்கே:

public abstract class AbstractPhone {
    private int year;

    public AbstractPhone(int year) {
        this.year = year;
    }
    public abstract void call(int outgoingNumber);
    public abstract void ring(int incomingNumber);
}

ஒரு திட்டத்தில், இந்த சுருக்க வகுப்பைப் பயன்படுத்தி புதிய வகையான ஃபோன்களை உருவாக்கலாம் மற்றும் OOP இன் பிற அடிப்படைக் கொள்கைகளைப் பயன்படுத்தலாம், அதை நாங்கள் கீழே ஆராய்வோம்.

அடைப்பு

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

இணைத்தல் மற்றும் அணுகல் கட்டுப்பாடு

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

public class SomePhone {

    private int year;
    private String company;
    public SomePhone(int year, String company) {
        this.year = year;
        this.company = company;
    }
private void openConnection(){
    // findSwitch
    // openNewConnection...
}
public void call() {
    openConnection();
    System.out.println("Calling");
}

public void ring() {
    System.out.println("Ring-ring");
}

 }

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

பரம்பரை

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

public abstract class CordlessPhone extends AbstractPhone {

    private int hour;

    public CordlessPhone (int year, int hour) {
        super(year);
        this.hour = hour;
    }
    }

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

public class CellPhone extends CordlessPhone {
    public CellPhone(int year, int hour) {
        super(year, hour);
    }

    @Override
    public void call(int outgoingNumber) {
        System.out.println("Calling " + outgoingNumber);
    }

    @Override
    public void ring(int incomingNumber) {
        System.out.println("Incoming call from " + incomingNumber);
    }
}

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

public class Smartphone extends CellPhone {

    private String operationSystem;

    public Smartphone(int year, int hour, String operationSystem) {
        super(year, hour);
        this.operationSystem = operationSystem;
    }
public void install(String program) {
    System.out.println("Installing " + program + " for " + operationSystem);
}

}

நீங்கள் பார்க்க முடியும் என, ஸ்மார்ட்போன் வகுப்பை விவரிக்க புதிய குறியீட்டை நாங்கள் உருவாக்கினோம் , ஆனால் புதிய செயல்பாட்டுடன் புதிய வகுப்பைப் பெற்றுள்ளோம். OOP இன் இந்தக் கொள்கையானது தேவையான ஜாவா குறியீட்டின் அளவைக் கணிசமாகக் குறைக்க உதவுகிறது, இதனால் புரோகிராமருக்கு வாழ்க்கையை எளிதாக்குகிறது.

பாலிமார்பிசம்

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

public class User {
    private String name;

    public User(String name) {
        this.name = name;
            }

    public void callAnotherUser(int number, AbstractPhone phone){
// And here's polymorphism: using the AbstractPhone type in the code!
        phone.call(number);
    }
}
 }

இப்போது நாம் பல வகையான தொலைபேசிகளை விவரிப்போம். முதல் தொலைபேசிகளில் ஒன்று:

public class ThomasEdisonPhone extends AbstractPhone {

public ThomasEdisonPhone(int year) {
    super(year);
}
    @Override
    public void call(int outgoingNumber) {
        System.out.println("Crank the handle");
        System.out.println("What number would you like to connect to?");
    }

    @Override
    public void ring(int incomingNumber) {
        System.out.println("The phone is ringing");
    }
}

ஒரு சாதாரண லேண்ட்லைன் தொலைபேசி:

public class Phone extends AbstractPhone {

    public Phone(int year) {
        super(year);
    }

    @Override
    public void call(int outgoingNumber) {
        System.out.println("Calling " + outgoingNumber);
    }

    @Override
    public void ring(int incomingNumber) {
        System.out.println("The phone is ringing");
    }
}

இறுதியாக, ஒரு சிறந்த வீடியோ ஃபோன்:

public class VideoPhone extends AbstractPhone {

    public VideoPhone(int year) {
        super(year);
    }
    @Override
    public void call(int outgoingNumber) {
        System.out.println("Connecting video call to " + outgoingNumber);
    }
    @Override
    public void ring(int incomingNumber) {
        System.out.println("Incoming video call from " + incomingNumber);
    }
  }

பிரதான() முறையில் பொருட்களை உருவாக்கி , callAnotherUser() முறையைச் சோதிப்போம்:

AbstractPhone firstPhone = new ThomasEdisonPhone(1879);
AbstractPhone phone = new Phone(1984);
AbstractPhone videoPhone=new VideoPhone(2018);
User user = new User("Jason");
user.callAnotherUser(224466, firstPhone);
// Crank the handle
// What number would you like to connect to?
user.callAnotherUser(224466, phone);
// Calling 224466
user.callAnotherUser(224466, videoPhone);
// Connecting video call to 224466

பயனர் பொருளில் அதே முறையை அழைப்பது வெவ்வேறு முடிவுகளை உருவாக்குகிறது. நிரல் இயங்கும் போது அனுப்பப்பட்ட குறிப்பிட்ட வகைப் பொருளின் அடிப்படையில் அழைப்பு முறையின் ஒரு குறிப்பிட்ட செயலாக்கமானது callAnotherUser() முறையில் மாறும் வகையில் தேர்ந்தெடுக்கப்படுகிறது . இது பாலிமார்பிஸத்தின் முக்கிய நன்மை - இயக்க நேரத்தில் செயல்படுத்தலைத் தேர்ந்தெடுக்கும் திறன். மேலே கொடுக்கப்பட்ட ஃபோன் வகுப்புகளின் எடுத்துக்காட்டுகளில், நாங்கள் முறை மேலெழுதலைப் பயன்படுத்தினோம் - ஒரு தந்திரம், அடிப்படை வகுப்பில் வரையறுக்கப்பட்ட முறையின் செயலாக்கத்தை முறை கையொப்பத்தை மாற்றாமல் மாற்றுவோம். இது அடிப்படையில் முறையை மாற்றுகிறது: துணைப்பிரிவில் வரையறுக்கப்பட்ட புதிய முறை நிரல் செயல்படுத்தப்படும் போது அழைக்கப்படுகிறது. வழக்கமாக, நாம் ஒரு முறையை மேலெழுதும்போது, ​​@Overrideசிறுகுறிப்பு பயன்படுத்தப்படுகிறது. இது மேலெழுதப்பட்ட மற்றும் மேலெழுதப்பட்ட முறைகளின் கையொப்பங்களைச் சரிபார்க்க கம்பைலரிடம் கூறுகிறது. இறுதியாக, உங்கள் ஜாவா புரோகிராம்கள் OOP இன் கொள்கைகளுடன் ஒத்துப்போவதை உறுதிசெய்ய, இந்த உதவிக்குறிப்புகளைப் பின்பற்றவும்:

• ஒரு பொருளின் முக்கிய பண்புகளை அடையாளம் காணுதல்;
• பொதுவான பண்புகள் மற்றும் நடத்தை அடையாளம் மற்றும் வகுப்புகளை உருவாக்கும் போது பரம்பரை பயன்படுத்த;
• பொருள்களை விவரிக்க சுருக்க வகைகளைப் பயன்படுத்தவும்;
• வகுப்பின் உள் செயலாக்கம் தொடர்பான முறைகள் மற்றும் புலங்களை எப்போதும் மறைக்க முயற்சிக்கவும்.