சார்பு தலைகீழ் கொள்கை பயன்படுத்தி செயல்படுத்தப்படுகிறது. சார்பு தலைகீழ்

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

ஒன்று). மேல்-நிலை தொகுதிகள் கீழ்-நிலை தொகுதிகளை சார்ந்து இருக்கக்கூடாது. இரண்டு நிலைகளிலும் உள்ள தொகுதிகள் சுருக்கங்களைச் சார்ந்திருக்க வேண்டும்.

2) சுருக்கங்கள் விவரங்களைச் சார்ந்து இருக்கக்கூடாது. விவரங்கள் சுருக்கங்களைப் பொறுத்து இருக்க வேண்டும்.

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

பொது வகுப்பு பார்ட் (தனியார் கிட்டார் கிட்டார்; பொது பார்ட் (கிட்டார் கிட்டார்) ( this.guitar = guitar; ) public void play() (guitar.play(); ) )

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

கோப்பு கருவி.ஜாவா:

பொது இடைமுகக் கருவி (வெற்று விளையாடு(); )

கோப்பு கிட்டார்.ஜாவா:

கிளாஸ் கிட்டார் கருவியை செயல்படுத்துகிறது( @Override public void play() ( System.out.println("Play Guitar!"); )

கோப்பு வீணை.ஜாவா:

பொது வகுப்பு வீணை கருவியை செயல்படுத்துகிறது( @Override public void play() ( System.out.println("Play Lute!"); )

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

பப்ளிக் கிளாஸ் பார்ட் (தனியார் கருவி கருவி; பொது பார்ட்() () பொது வெற்றிடத்தை விளையாடு () ( கருவி. நாடகம் (); ) பொது வெற்றிடத்தை அமைக்கும் கருவி (கருவி கருவி) (இது. கருவி = கருவி; ) )

2 பதில்கள்

நல்ல விஷயம் - தலைகீழ் வார்த்தை சற்றே ஆச்சரியமாக இருக்கிறது (டிஐபியைப் பயன்படுத்திய பிறகு, கீழ்-நிலை சார்புத் தொகுதி இப்போது உயர்-நிலை அழைப்பாளர் தொகுதியைச் சார்ந்து இல்லை: அழைப்பாளர் அல்லது சார்புடையவர் இப்போது கூடுதல் சுருக்கத்தின் மூலம் மிகவும் தளர்வாக இணைக்கப்பட்டுள்ளது. )

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

டிஐபியில் அங்கிள் பாப்பின் பேப்பரைப் படிக்கும்போது கவனிக்க வேண்டிய ஒரு விஷயம் என்னவென்றால், C++ க்கு இடைமுகங்கள் இல்லை (மற்றும் எழுதும் நேரத்தில், இல்லை), எனவே C++ இல் இந்த சுருக்கத்தை அடைவது பொதுவாக சுருக்க/தூய மெய்நிகர் அடிப்படை வகுப்பின் மூலம் அடையப்படுகிறது, அதேசமயம் ஜாவாவில் அல்லது C# இணைப்பினைத் தளர்த்துவதற்கான சுருக்கமானது, சார்புநிலையிலிருந்து இடைமுகத்தை சுருக்கி, உயர்நிலைத் தொகுதியை(களை) இடைமுகத்துடன் பிணைப்பதன் மூலம் பொதுவாக அவிழ்க்கப்படும்.

தொகுவிளக்குவதற்காக மட்டும்:

"சில இடங்களில் இது சார்பு தலைகீழ் என்று அழைக்கப்படுகிறது"

தலைகீழ்:பயன்பாட்டிலிருந்து கொள்கலனுக்கு சார்பு நிர்வாகத்தைத் தலைகீழாக மாற்றவும் (ஸ்பிரிங் போன்றவை).

சார்பு ஊசி:

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

கட்டுப்பாட்டின் தலைகீழ் (IoC) பற்றி என்ன?

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

ஒரு வடிவமைப்பு வழிகாட்டியாக கட்டுப்பாட்டின் தலைகீழ் பின்வரும் நோக்கங்களுக்காக உதவுகிறது:

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

மேலும் தகவலுக்கு பார்க்கவும்.

கடைசியாக புதுப்பிக்கப்பட்டது: 03/11/2016

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

மேல்-நிலை தொகுதிகள் கீழ்-நிலை தொகுதிகளை சார்ந்து இருக்கக்கூடாது. இரண்டும் சுருக்கங்களைச் சார்ந்திருக்க வேண்டும்.

சுருக்கங்கள் விவரங்களைச் சார்ந்து இருக்கக்கூடாது. விவரங்கள் சுருக்கங்களைப் பொறுத்து இருக்க வேண்டும்.

கொள்கையைப் புரிந்து கொள்ள, பின்வரும் உதாரணத்தைக் கவனியுங்கள்:

வகுப்பு புத்தகம் (பொது சரம் உரை (பெறு; அமை;) பொது கன்சோல் பிரிண்டர் அச்சுப்பொறி (பெறு; அமை;) பொது வெற்றிட அச்சு () (அச்சுப்பொறி.அச்சு(உரை);) ) வகுப்பு கன்சோல் பிரிண்டர் (பொது வெற்றிட அச்சு (சரம் உரை) (கன்சோல்.WriteLine (உரை);))

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

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

இடைமுகம் IPrinter ( void Print(string text); ) class Book ( public string Text ( get; set; ) public IPrinter Printer ( get; set; ) public Book(IPrinter printer) ( this.Printer = printer; ) public void Print( ) ( Printer.Print(Text); ) வகுப்பு ConsolePrinter: IPrinter ( public void Print(string text) ( Console.WriteLine("Print to Console"); ) class HtmlPrinter: IPrinter ( public void Print(string text) ( Console.WriteLine("htmlக்கு அச்சிடு"); ) )

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

புத்தக புத்தகம் = புதிய புத்தகம்(புதிய கன்சோல் பிரிண்டர்()); புத்தகம்.அச்சு(); book.Printer = புதிய HtmlPrinter(); புத்தகம்.அச்சு();

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

இந்த விளக்கம் ஜாவா மாணவர்களுடன் வகுப்புகளுக்கான தயாரிப்பில் விளாடிமிர் மத்வீவ் உடன் இணைந்து உருவாக்கப்பட்டது.

இந்தத் தொடரின் பிற கட்டுரைகள்:

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

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

பொது வகுப்பு A (சில முறை செல்லாது() (B b = புதிய B(); b.someMethodOfB(); ) )

இதேபோல், எடுத்துக்காட்டாக, வகுப்பு B என்பது கணினி வகுப்பின் நிலையான புலங்கள் மற்றும் முறைகளை வெளிப்படையாகக் குறிக்கிறது:

பப்ளிக் கிளாஸ் பி (சிஸ்டம்.அவுட்.பிரின்ட்ல்ன்("ஹலோ வேர்ல்ட்"); ) )

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

நேரடி சார்புகளில் என்ன தவறு? நேரடி சார்புகள் மோசமானவை, ஏனென்றால் ஒரு வர்க்கம் தனக்குள்ளேயே மற்றொரு வகுப்பை உருவாக்கிக் கொள்ளும் வர்க்கம் இந்த வகுப்போடு "இறுக்கமாக" பிணைக்கப்பட்டுள்ளது. அந்த. B = புதிய B() என்று வெளிப்படையாக எழுதப்பட்டிருந்தால்; , பின்னர் வகுப்பு A எப்போதும் B வகுப்புடன் வேலை செய்யும், வேறு எந்த வகுப்பும் இல்லை. அல்லது System.out.println("...") என்று சொன்னால்; பின்னர் வகுப்பு எப்போதும் System.out க்கு அவுட்புட் செய்யும், வேறு எங்கும் இல்லை.

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

ஒரு நேரடி சார்பு பின்வருமாறு வரைபடமாகக் காட்டப்படும்:

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

குறிப்பிட்ட சார்புகளிலிருந்து கிளாஸ் A ஐ துண்டிக்க, விண்ணப்பிக்கவும் சார்பு ஊசி. சார்பு ஊசி என்றால் என்ன? குறியீட்டில் விரும்பிய வகுப்பை வெளிப்படையாக உருவாக்குவதற்குப் பதிலாக, சார்புநிலைகள் கன்ஸ்ட்ரக்டர் மூலம் வகுப்பு Aக்கு அனுப்பப்படுகின்றன:

பொது வகுப்பு A (தனியார் இறுதி B b; பொது A(B b) ( this.b = b; ) பொது வெற்றிட சில முறை() (b.someMethodOfB(); ) )

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

B b = புதிய B(); A a = புதிய A(b); a.someMethod();

அனைத்து வகுப்புகளுக்கும் இதே நடைமுறை மீண்டும் மீண்டும் செய்யப்பட்டால், அதாவது. வகுப்பு D இன் நிகழ்வை வகுப்பு B இன் கட்டமைப்பாளருக்கு, D வகுப்பின் கட்டமைப்பாளருக்கு அனுப்பவும் - அதன் சார்புகள் E மற்றும் F, முதலியன, பின்னர் நீங்கள் குறியீட்டைப் பெறுவீர்கள், அதன் அனைத்து சார்புகளும் தலைகீழ் வரிசையில் உருவாக்கப்படுகின்றன:

ஜி ஜி = புதிய ஜி(); H h = புதிய H(); F f = புதிய (g,h); E e = புதிய E(); D d = புதிய D(e,f); B b = புதிய B(d); A a = புதிய A(b); a.someMethod();

வரைபட ரீதியாக, இதை இப்படிக் காட்டலாம்:

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

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

சார்பு ஊசியின் தீமையும் முதல் பார்வையில் தெரியும் - இந்த வடிவத்தைப் பயன்படுத்தி வடிவமைக்கப்பட்ட வகுப்புகளின் பொருள்கள் கட்டமைக்க கடினமாக உள்ளன. எனவே, சார்பு ஊசி (தலைகீழ்) பொதுவாக இந்த பணியை எளிதாக்க வடிவமைக்கப்பட்ட சில நூலகத்துடன் இணைந்து பயன்படுத்தப்படுகிறது. எடுத்துக்காட்டாக, Google Guice நூலகங்களில் ஒன்று. செ.மீ.