அணுகல் மாற்றிகள், முறை மேலெழுதுதல் மற்றும் சுருக்க முறைகளை செயல்படுத்துதல்

" அணுகல் மாற்றிகள் " பற்றி நான் உங்களுக்குச் சொல்லப் போகிறேன் . அவற்றைப் பற்றி முன்பு ஒருமுறை கூறினேன், ஆனால் திரும்பத் திரும்பச் சொல்வது கற்றலின் தூண்."

உங்கள் வகுப்பின் முறைகள் மற்றும் மாறிகளுக்கு மற்ற வகுப்புகள் வைத்திருக்கும் அணுகலை (தெரிவுத்தன்மை) நீங்கள் கட்டுப்படுத்தலாம். "இந்த முறை/மாறியை யார் அணுகலாம்?" என்ற கேள்விக்கு அணுகல் மாற்றியமைப்பாளர் பதிலளிக்கிறார். ஒவ்வொரு முறை அல்லது மாறிக்கும் ஒரே ஒரு மாற்றியை மட்டுமே நீங்கள் குறிப்பிட முடியும்.

1) " பொது " மாற்றி.

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

2) " தனியார் " மாற்றி.

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

3)  « இயல்புநிலை மாற்றி».

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

4) " பாதுகாக்கப்பட்ட " மாற்றி.

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

இந்த அட்டவணை அனைத்தையும் விளக்குகிறது:

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

"ஒரே தொகுப்பில் உள்ள வகுப்புகள் ஒரு குடும்பத்தின் ஒரு பகுதி என்று கற்பனை செய்வது போன்றது."

"மேற்கொள்ளும் முறைகள் பற்றிய சில சுவாரஸ்யமான நுணுக்கங்களையும் நான் உங்களுக்குச் சொல்ல விரும்புகிறேன்."

1) ஒரு சுருக்க முறையை மறைமுகமாக செயல்படுத்துதல்.

உங்களிடம் பின்வரும் குறியீடு உள்ளது என்று வைத்துக்கொள்வோம்:

class Cat
{
 public String getName()
 {
  return "Oscar";
 }
}

மேலும் இந்த வகுப்பை மரபுரிமையாகக் கொண்ட புலி வகுப்பை உருவாக்கவும், புதிய வகுப்பிற்கு இடைமுகத்தைச் சேர்க்கவும் முடிவு செய்தீர்கள்

class Cat
{
 public String getName()
 {
   return "Oscar";
 }
}

interface HasName
{
 String getName();
 int getWeight();
}

class Tiger extends Cat implements HasName
{
 public int getWeight()
 {
  return 115;
 }

}

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

டைகர் வகுப்பானது கேட்டிலிருந்து பெறப்பட்ட getName முறையைக் கொண்டுள்ளது, இது HasName இடைமுகத்திற்கான getName முறையை செயல்படுத்துவதாக எடுத்துக் கொள்ளப்படும்.

"நான் அதைப் பற்றி பயங்கரமான எதையும் பார்க்கவில்லை."

"இது மிகவும் மோசமாக இல்லை, இது தவறுகள் ஊடுருவக்கூடிய இடமாகும்."

ஆனால் அது இன்னும் மோசமாக இருக்கலாம்:

interface HasWeight
{
 int getValue();
}

interface HasSize
{
 int getValue();
}

class Tiger extends Cat implements HasWeight, HasSize
{
 public int getValue()
 {
  return 115;
 }
}

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

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

"ஆனால் ஒரு நல்ல செய்தி இருக்கிறது."

2) பார்வையை விரிவுபடுத்துதல். நீங்கள் ஒரு வகையைப் பெறும்போது, ​​ஒரு முறையின் தெரிவுநிலையை நீங்கள் விரிவாக்கலாம். இது எப்படி இருக்கிறது:

class Cat
{
 protected String getName()
 {
  return "Oscar";
 }
}

class Tiger extends Cat
{
 public String getName()
 {
  return "Oscar Tiggerman";
 }
}

public static void main(String[] args)
{
 Cat cat = new Cat();
 cat.getName();
}

public static void main(String[] args)
{
 Tiger tiger = new Tiger();
 tiger.getName();
}

public static void main(String[] args)
{
 Cat catTiger = new Tiger();
 catTiger.getName();
}

"நான் முழுமையாக புரிந்து கொண்டேன் என்று எனக்குத் தெரியவில்லை, ஆனால் இது சாத்தியம் என்பதை நான் நினைவில் கொள்கிறேன்."

3) திரும்பும் வகையை சுருக்கவும்.

மேலெழுதப்பட்ட முறையில், திரும்பும் வகையை குறுகலான குறிப்பு வகையாக மாற்றலாம்.

class Cat
{
 public Cat parent;
 public Cat getMyParent()
 {
  return this.parent;
 }
 public void setMyParent(Cat cat)
 {
  this.parent = cat;
 }
}

class Tiger extends Cat
{
 public Tiger getMyParent()
 {
  return (Tiger) this.parent;
 }
}

public static void main(String[] args)
{
 Cat parent = new Cat();

 Cat me = new Cat();
 me.setMyParent(parent);
 Cat myParent = me.getMyParent();
}

public static void main(String[] args)
{
 Tiger parent = new Tiger();

 Tiger me = new Tiger();
 me.setMyParent(parent);
 Tiger myParent = me.getMyParent();
}

public static void main(String[] args)
{
 Tiger parent = new Tiger();

 Cat me = new Tiger();
 me.setMyParent(parent);
 Cat myParent = me.getMyParent();
}

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

"சரியாக! அப்படியானால் பெரிய கேள்வி என்னவென்றால், ஒரு முறையை மேலெழுதும்போது, ​​திரும்பப்பெறும் மதிப்பின் வகையை ஏன் குறைக்க முடியாது?"

"இந்த வழக்கில் அடிப்படை வகுப்பில் உள்ள குறியீடு வேலை செய்வதை நிறுத்தும் என்பது வெளிப்படையானது:"

class Cat
{
 public Cat parent;
 public Cat getMyParent()
 {
  return this.parent;
 }
 public void setMyParent(Cat cat)
 {
  this.parent = cat;
 }
}

class Tiger extends Cat
{
 public Object getMyParent()
 {
  if (this.parent != null)
   return this.parent;
  else
   return "I'm an orphan";
 }
}

public static void main(String[] args)
{
 Tiger parent = new Tiger();

 Cat me = new Tiger();
 Cat myParent = me.getMyParent();
}

"அற்புதமான உதாரணம், அமிகோ!"

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

"ஐயோ. இப்ப தெரிஞ்சுது."