சுருக்க வகுப்புகள் மற்றும் இடைமுகங்களுக்கு இடையிலான வேறுபாடு

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

1. ஒரு இடைமுகம் நடத்தையை மட்டுமே விவரிக்கிறது. அதற்கு மாநிலம் இல்லை. ஆனால் ஒரு சுருக்க வகுப்பில் நிலை அடங்கும்: இது இரண்டையும் விவரிக்கிறது.

   எடுத்துக்காட்டாக, Birdசுருக்க வகுப்பு மற்றும் CanFlyஇடைமுகத்தை எடுத்துக் கொள்ளுங்கள்:

   
   public abstract class Bird {
      private String species;
      private int age;
   
      public abstract void fly();
   
      public String getSpecies() {
          return species;
      }
   
      public void setSpecies(String species) {
          this.species = species;
      }
   
      public int getAge() {
          return age;
      }
   
      public void setAge(int age) {
          this.age = age;
      }
   }
   

   பறவை வகுப்பை உருவாக்கி MockingJayஅதை மரபுரிமையாக்குவோம் Bird:

   
   public class MockingJay extends Bird {
   
      @Override
      public void fly() {
          System.out.println("Fly, bird!");
      }
   
      public static void main(String[] args) {
   
          MockingJay someBird = new MockingJay();
          someBird.setAge(19);
          System.out.println(someBird.getAge());
      }
   }
   

   நீங்கள் பார்க்கிறபடி, சுருக்க வகுப்பின் நிலையை - அதன் speciesமற்றும் ageமாறிகளை நாம் எளிதாக அணுகலாம்.

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

   
   public interface CanFly {
   
      String species = new String();
      int age = 10;
   
      public void fly();
   }
   
   public interface CanFly {
   
      private String species = new String(); // Error
      private int age = 10; // Another error
   
      public void fly();
   }
   

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

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

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

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

   பறவைகளுடன் நமது உதாரணத்திற்கு திரும்புவோம்.

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

   இடைமுகத்துடன் CanFly, ஒவ்வொருவரும் தங்கள் சொந்த வழியில் செல்கிறார்கள். இது அதன் பெயருடன் தொடர்புடைய நடத்தை (பறத்தல்) மட்டுமே விவரிக்கிறது. தொடர்பில்லாத பல விஷயங்கள் 'பறக்க முடியும்'.

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

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

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

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

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

நிலையான இடைமுகங்கள்: InputStream மற்றும் OutputStream

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

• int available()படிக்க கிடைக்கும் பைட்டுகளின் எண்ணிக்கையை வழங்குகிறது;
• close()உள்ளீட்டு ஸ்ட்ரீமை மூடுகிறது;
• int read()ஸ்ட்ரீமில் கிடைக்கும் அடுத்த பைட்டின் முழு எண் பிரதிநிதித்துவத்தை வழங்குகிறது. நீரோடையின் முடிவை அடைந்துவிட்டால், -1 திரும்பப் பெறப்படும்;
• int read(byte[] buffer)பைட்டுகளை இடையகமாகப் படிக்க முயற்சிக்கிறது, மேலும் படித்த பைட்டுகளின் எண்ணிக்கையை வழங்குகிறது. கோப்பின் முடிவை அடையும் போது, ​​அது -1ஐத் தருகிறது;
• int read(byte[] buffer, int byteOffset, int byteCount)பைட்டுகளின் தொகுதியின் ஒரு பகுதியை எழுதுகிறது. பைட் வரிசை முழுவதுமாக நிரப்பப்படாமல் இருக்கும் போது இது பயன்படுத்தப்படுகிறது. கோப்பின் முடிவை அடையும் போது, ​​அது -1ஐத் தருகிறது;
• long skip(long byteCount)உள்ளீட்டு ஸ்ட்ரீமில் byteCount பைட்டுகளைத் தவிர்த்து, புறக்கணிக்கப்பட்ட பைட்டுகளின் எண்ணிக்கையை வழங்கும்.

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

1. FileInputStream: மிகவும் பொதுவான வகை InputStream. ஒரு கோப்பிலிருந்து தகவல்களைப் படிக்க இது பயன்படுகிறது;
2. StringBufferInputStream: மற்றொரு பயனுள்ள வகை InputStream. இது ஒரு சரத்தை ஒரு சரமாக மாற்றுகிறது InputStream;
3. BufferedInputStream: ஒரு இடையக உள்ளீட்டு ஸ்ட்ரீம். செயல்திறனை அதிகரிக்க இது பெரும்பாலும் பயன்படுத்தப்படுகிறது.

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

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))

…நீங்கள் பயன்படுத்த வேண்டியதில்லை BufferedReader: ஒரு InputStreamReaderவேலையைச் செய்ய முடியும். ஆனால் BufferedReaderசெயல்திறனை மேம்படுத்துகிறது மற்றும் தனிப்பட்ட எழுத்துக்களைக் காட்டிலும் தரவுகளின் முழு வரிகளையும் படிக்க முடியும். அதே விஷயம் பொருந்தும் BufferedInputStream! உள்ளீட்டு சாதனத்தை தொடர்ந்து அணுகாமல் ஒரு சிறப்பு இடையகத்தில் உள்ளீட்டு தரவை வகுப்பு குவிக்கிறது. ஒரு உதாரணத்தைக் கருத்தில் கொள்வோம்:

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.InputStream;

public class BufferedInputExample {

   public static void main(String[] args) throws Exception {
       InputStream inputStream = null;
       BufferedInputStream buffer = null;

       try {

           inputStream = new FileInputStream("D:/Users/UserName/someFile.txt");

           buffer = new BufferedInputStream(inputStream);

           while(buffer.available()>0) {

               char c = (char)buffer.read();

                System.out.println("Character read: " + c);
           }
       } catch(Exception e) {

           e.printStackTrace();

       } finally {

           inputStream.close();
           buffer.close();
       }
   }
}

இந்த எடுத்துக்காட்டில், ' D:/Users/UserName/someFile.txt ' இல் கணினியில் உள்ள ஒரு கோப்பிலிருந்து தரவைப் படிக்கிறோம் . நாம் 2 பொருட்களை உருவாக்குகிறோம் - a FileInputStreamமற்றும் a BufferedInputStreamஅதை 'மறைக்கும்'. பின்னர் கோப்பிலிருந்து பைட்டுகளைப் படித்து அவற்றை எழுத்துகளாக மாற்றுவோம். கோப்பு முடியும் வரை நாங்கள் அதை செய்கிறோம். நீங்கள் பார்க்க முடியும் என, இங்கே சிக்கலான எதுவும் இல்லை. நீங்கள் இந்தக் குறியீட்டை நகலெடுத்து உங்கள் கணினியில் உள்ள உண்மையான கோப்பில் இயக்கலாம் :) வகுப்பு OutputStreamஎன்பது பைட்டுகளின் வெளியீட்டு ஸ்ட்ரீமைக் குறிக்கும் ஒரு சுருக்க வகுப்பாகும். உங்களுக்கு ஏற்கனவே தெரியும், இது ஒரு க்கு எதிரானது InputStream. எங்கிருந்தாவது தரவைப் படிப்பதற்கு இது பொறுப்பல்ல, மாறாக எங்காவது தரவை அனுப்புவதற்குப் பொறுப்பாகும் . , இந்த சுருக்க வகுப்பு அதன் அனைத்து InputStreamசந்ததியினருக்கும் வசதியான முறைகளின் தொகுப்பை வழங்குகிறது:

• void close()வெளியீட்டு ஸ்ட்ரீமை மூடுகிறது;
• void flush()அனைத்து வெளியீட்டு இடையகங்களையும் அழிக்கிறது;
• abstract void write(int oneByte)வெளியீட்டு ஸ்ட்ரீமில் 1 பைட் எழுதுகிறது;
• void write(byte[] buffer)வெளியீட்டு ஸ்ட்ரீமில் ஒரு பைட் வரிசையை எழுதுகிறது;
• void write(byte[] buffer, int offset, int count)ஒரு வரிசையில் இருந்து எண்ணிக்கை பைட்டுகளின் வரம்பை எழுதுகிறது, இது ஆஃப்செட் நிலையில் இருந்து தொடங்குகிறது.

வகுப்பின் சில சந்ததியினர் இங்கே OutputStream:

1. DataOutputStream. நிலையான ஜாவா தரவு வகைகளை எழுதுவதற்கான முறைகளை உள்ளடக்கிய வெளியீட்டு ஸ்ட்ரீம்.

   பழமையான ஜாவா தரவு வகைகள் மற்றும் சரங்களை எழுதுவதற்கான மிக எளிய வகுப்பு. விளக்கம் இல்லாமல் கூட பின்வரும் குறியீட்டை நீங்கள் புரிந்துகொள்வீர்கள்:

   
   import java.io.*;
   
   public class DataOutputStreamExample {
   
      public static void main(String[] args) throws IOException {
   
          DataOutputStream dos = new DataOutputStream(new FileOutputStream("testFile.txt"));
   
          dos.writeUTF("SomeString");
          dos.writeInt(22);
          dos.writeDouble(1.21323);
          dos.writeBoolean(true);
   
      }
   }
   

   ஒவ்வொரு வகைக்கும் தனித்தனி முறைகள் உள்ளன - writeDouble(), writeLong(), writeShort(), மற்றும் பல.



2. FileOutputStream. இந்த வகுப்பு வட்டில் உள்ள ஒரு கோப்பிற்கு தரவை அனுப்புவதற்கான ஒரு பொறிமுறையை செயல்படுத்துகிறது. மூலம், நாங்கள் ஏற்கனவே கடைசி எடுத்துக்காட்டில் பயன்படுத்தினோம். நீ கவனித்தாயா? நாங்கள் அதை DataOutputStream க்கு அனுப்பினோம், அது 'ரேப்பராக' செயல்பட்டது.


3. BufferedOutputStream. ஒரு இடையக வெளியீடு ஸ்ட்ரீம். மேலும் இங்கே சிக்கலான எதுவும் இல்லை. BufferedInputStreamஇதன் நோக்கம் (அல்லது ) போன்றது BufferedReader. தரவுகளின் வழக்கமான தொடர் வாசிப்புக்குப் பதிலாக, இது ஒரு சிறப்பு 'ஒட்டுமொத்த' இடையகத்தைப் பயன்படுத்தி தரவை எழுதுகிறது. டேட்டா சிங்க் அணுகப்படும் முறைகளின் எண்ணிக்கையைக் குறைப்பதைத் தாங்கல் சாத்தியமாக்குகிறது, இதனால் செயல்திறனை அதிகரிக்கிறது.

   
   import java.io.*;
   
   public class DataOutputStreamExample {
   
        public static void main(String[] args) throws IOException {
   
              FileOutputStream outputStream = new FileOutputStream("D:/Users/Username/someFile.txt");
              BufferedOutputStream bufferedStream = new BufferedOutputStream(outputStream);
   
              String text = "I love Java!"; // We'll convert this string to a byte array and write it to a file
   
              byte[] buffer = text.getBytes();
   
              bufferedStream.write(buffer, 0, buffer.length);
        }
   }
   

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

எங்களிடம் ஒரு தனி பாடம் இருக்கும் FileInputStream, FileOutputStreamமற்றும் BuffreredInputStream, முதல் அறிமுகத்திற்கு இது போதுமான தகவல். அவ்வளவுதான்! இடைமுகங்கள் மற்றும் சுருக்க வகுப்புகளுக்கு இடையிலான வேறுபாடுகளை நீங்கள் புரிந்துகொள்வீர்கள் என்று நம்புகிறோம் மற்றும் எந்த கேள்விக்கும், தந்திரமான கேள்விகளுக்கும் கூட பதிலளிக்க தயாராக உள்ளீர்கள் :)