இடைமுகங்கள்

"வணக்கம், அமிகோ! இன்று நீங்கள் சில கண்டுபிடிப்புகளைச் செய்யப் போகிறீர்கள். இன்றைய தலைப்பு - டிரம் ரோல், தயவுசெய்து - இடைமுகங்கள். "

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

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

interface Drawable
{
void draw();
}
interface HasValue
{
int getValue();
}

interface Element extends Drawable, HasValue
{
int getX();
int getY();
}

abstract class ChessItem implements Drawable, HasValue
{
private int x, y, value;

public int getValue()
{
return value;
}

public int getX()
{
return x;
}

public int getY()
{
return y;
}

}

"சுவாரஸ்யமானது. ஆனால் நமக்கு ஏன் இடைமுகங்கள் தேவை? அவை எப்போது பயன்படுத்தப்படுகின்றன?"

"வகுப்புகளை விட இடைமுகங்கள் இரண்டு வலுவான நன்மைகளைக் கொண்டுள்ளன:"

1) முறை செயல்படுத்தல்களில் இருந்து "முறை வரையறைகளை" பிரித்தல்.

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

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

class Student
{
 private String name;

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

 public String getName()
 {
  return this.name;
 }

 private void setName(String name)
 {
  this.name = name;
 }

interface Student
{
 public String getName();
}

class StudentImpl implements Student
{
 private String name;
 public StudentImpl(String name)
 {
  this.name = name;
 }
 public String getName()
 {
  return this.name;
 }
 private void setName(String name)
 {
  this.name = name;
 }
}

public static void main(String[] args)
{
 Student student =
               new Student("Alibaba");
 System.out.println(student.getName());
}

public static void main(String[] args)
{
 Student student =
               new StudentImpl("Ali");
 System.out.println(student.getName());
}

எங்கள் வகுப்பை இரண்டு பகுதிகளாகப் பிரிக்கிறோம்: ஒரு இடைமுகம் மற்றும் இடைமுகத்தை செயல்படுத்தும் ஒரு வகுப்பு.

"அதனால் என்ன நன்மை?"

"ஒரே இடைமுகத்தை வெவ்வேறு வகுப்புகளால் (மரபுரிமையாக) செயல்படுத்த முடியும். மேலும் ஒவ்வொரு வகுப்பிற்கும் அதன் சொந்த நடத்தை இருக்கும். ArrayList மற்றும் LinkedList போன்றவை பட்டியல் இடைமுகத்தின் இரண்டு வெவ்வேறு செயலாக்கங்களாகும். "

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

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

2) பல பரம்பரை.

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

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