ஜாவாவில் இடைமுகங்கள்

1. இடைமுகங்களை அறிமுகப்படுத்துதல்

இன்று உங்கள் அறிவுக்கான நாள். மற்றொரு புதிய மற்றும் சுவாரஸ்யமான தலைப்பு இடைமுகங்கள்.

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

interface Feline
{
   void purr();
   void meow();
   void growl();
}

இடைமுகங்களைப் பற்றிய சில பயனுள்ள உண்மைகள் இங்கே:

1. ஒரு இடைமுகத்தை அறிவித்தல்

interface Drawable
{
   void draw();
}

interface HasValue
{
   int getValue();
}

1. முக்கிய வார்த்தைக்கு பதிலாக class, நாங்கள் எழுதுகிறோம் interface.
2. இதில் சுருக்க முறைகள் மட்டுமே உள்ளன (முக்கிய சொல்லை எழுத வேண்டாம் abstract)
3. உண்மையில், இடைமுகங்களில் அனைத்துpublic முறைகளும் உள்ளன

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

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

3. இடைமுகங்களிலிருந்து வகுப்புகளைப் பெறுதல்

ஒரு வர்க்கம் பல இடைமுகங்களை (ஒரு வகுப்பில் இருந்து மட்டுமே) பெற முடியும். இது முக்கிய சொல்லைப் பயன்படுத்தி செய்யப்படுகிறது implements. உதாரணமாக:

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;
   }
}

ChessItem வகுப்பு சுருக்கமாக அறிவிக்கப்படுகிறது: இது தவிர அனைத்து மரபுவழி முறைகளையும் செயல்படுத்துகிறது draw. வேறு வார்த்தைகளில் கூறுவதானால், ChessItemவகுப்பில் ஒரு சுருக்க முறை உள்ளது - draw().

extendsமற்றும் முக்கிய வார்த்தைகளின் தொழில்நுட்ப அர்த்தம் implementsஒன்றுதான்: இரண்டும் பரம்பரை. குறியீட்டின் வாசிப்புத்திறனை மேம்படுத்துவதற்காக இந்த வேறுபாடு செய்யப்பட்டது. வகுப்புகள் மரபுரிமையாக (வழியாக extends) மற்றும் இடைமுகங்கள் செயல்படுத்தப்படுகின்றன (வழியாக implements)

4. மாறிகள்

இங்கே மிக முக்கியமான விஷயம்: சாதாரண மாறிகளை இடைமுகங்களில் அறிவிக்க முடியாது (நிலையானவை என்றாலும்).

ஆனால் நமக்கு ஏன் இடைமுகங்கள் தேவை? அவை எப்போது பயன்படுத்தப்படுகின்றன? வகுப்புகளை விட இடைமுகங்கள் இரண்டு வலுவான நன்மைகளைக் கொண்டுள்ளன:

2. "முறைகளின் விளக்கத்தை" அவற்றின் செயலாக்கத்திலிருந்து பிரித்தல்.

உங்கள் வகுப்பின் முறைகளை மற்ற வகுப்புகளில் இருந்து அழைக்க நீங்கள் அனுமதிக்க விரும்பினால், உங்கள் முறைகளை முக்கிய சொல்லைக் கொண்டு குறிக்க வேண்டும் என்று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இடைமுகத்தின் இரண்டு வெவ்வேறு செயலாக்கங்கள் List.

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

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

3. பல பரம்பரை

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

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

அவர்கள் ஏன் வகுப்புகளின் பல மரபுகளை தடை செய்தார்கள் ஆனால் இடைமுகங்களின் பல பரம்பரையை அனுமதித்தார்கள்? வைர மரபுரிமை பிரச்சனை என்று அழைக்கப்படுவதால் :

B வகுப்பு A வகுப்பைப் பெறும்போது, ​​அது C மற்றும் D வகுப்புகளைப் பற்றி எதுவும் தெரியாது. எனவே இது A வகுப்பின் மாறிகளை அது பொருத்தமாகப் பயன்படுத்துகிறது. C வகுப்பும் அதையே செய்கிறது: இது A வகுப்பின் மாறிகளைப் பயன்படுத்துகிறது, ஆனால் வேறு வழியில். இவை அனைத்தும் டி வகுப்பில் மோதலை ஏற்படுத்துகின்றன.

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

class Data
{
   protected int value;
}

class XCoordinate extends Data
{
   public void setX (int x) { value = x;}
   public int getX () { return value;}
}

class YCoordinate extends Data
{
   public void setY (int y) { value = y;}
   public int getY () { return value; }
}

தரவு வகுப்பு valueமாறியை சேமிக்கிறது. அதன் XCoordinate வம்சாவளி வர்க்கமானது மதிப்பைச் சேமிக்க அந்த மாறியைப் பயன்படுத்துகிறது x, மேலும் மதிப்பைச் YCoordinateசேமிக்க சந்ததி வகுப்பு அதைப் பயன்படுத்துகிறது y.

அது வேலை செய்கிறது. தனித்தனியாக. XCoordinateஆனால் XYCoordinates வகுப்பு மற்றும் வகுப்புகள் இரண்டையும் பெற வேண்டுமெனில் YCoordinate, உடைந்த குறியீட்டைப் பெறுவோம். இந்த வகுப்பில் அதன் மூதாதையர் வகுப்புகளின் முறைகள் இருக்கும், ஆனால் அவை சரியாக வேலை செய்யாது, ஏனென்றால் அவை ஒரே மாதிரியானவை value variable.

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