వియుక్త తరగతులు మరియు ఇంటర్‌ఫేస్‌ల మధ్య వ్యత్యాసం

హాయ్! ఈ పాఠంలో, ఇంటర్‌ఫేస్‌ల నుండి వియుక్త తరగతులు ఎలా విభిన్నంగా ఉంటాయో మరియు సాధారణ నైరూప్య తరగతులతో కొన్ని ఉదాహరణలను పరిశీలిస్తాము. మేము వియుక్త తరగతి మరియు ఇంటర్‌ఫేస్ మధ్య వ్యత్యాసాలకు ప్రత్యేక పాఠాన్ని కేటాయించాము, ఎందుకంటే ఈ అంశం చాలా ముఖ్యమైనది. భవిష్యత్తులో జరిగే 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();
   }
   

   మేము ఇంటర్‌ఫేస్ లోపల ప్రైవేట్ వేరియబుల్‌లను కూడా ప్రకటించలేము . ఎందుకు? ఎందుకంటే వినియోగదారు నుండి అమలును దాచడానికి ప్రైవేట్ మాడిఫైయర్ సృష్టించబడింది. మరియు ఇంటర్‌ఫేస్‌కు దాని లోపల ఎటువంటి అమలు లేదు: దాచడానికి ఏమీ లేదు.

   ఇంటర్‌ఫేస్ ప్రవర్తనను మాత్రమే వివరిస్తుంది. దీని ప్రకారం, మేము ఇంటర్‌ఫేస్ లోపల గెట్టర్‌లు మరియు సెట్టర్‌లను అమలు చేయలేము. ఇది ఇంటర్‌ఫేస్‌ల స్వభావం: అవి ప్రవర్తనతో పనిచేయడానికి అవసరం, స్థితిలో కాదు.

   Java 8 అమలును కలిగి ఉన్న ఇంటర్‌ఫేస్‌ల కోసం డిఫాల్ట్ పద్ధతులను ప్రవేశపెట్టింది. వాటి గురించి మీకు ఇప్పటికే తెలుసు, కాబట్టి మేము పునరావృతం చేయము.

2. ఒక వియుక్త తరగతి చాలా దగ్గరి సంబంధం ఉన్న తరగతులను కలుపుతుంది మరియు ఏకం చేస్తుంది. అదే సమయంలో, ఉమ్మడిగా ఏమీ లేని తరగతుల ద్వారా ఒకే ఇంటర్‌ఫేస్‌ను అమలు చేయవచ్చు.

   పక్షులతో మా ఉదాహరణకి తిరిగి వెళ్దాం.

   Birdఆ తరగతిపై ఆధారపడిన పక్షులను సృష్టించడానికి మా నైరూప్య తరగతి అవసరం. కేవలం పక్షులు మరియు మరేమీ లేవు! వాస్తవానికి, వివిధ రకాల పక్షులు ఉంటాయి.

   ఇంటర్‌ఫేస్‌తో CanFly, ప్రతి ఒక్కరూ వారి స్వంత మార్గంలో ఉంటారు. ఇది దాని పేరుతో అనుబంధించబడిన ప్రవర్తనను (ఎగిరే) మాత్రమే వివరిస్తుంది. అనేక సంబంధం లేని విషయాలు 'ఎగరగలవు'.

   ఈ 4 ఎంటిటీలు ఒకదానికొకటి సంబంధం కలిగి లేవు. వారంతా జీవించి ఉండరు. అయితే, అవన్నీ CanFly.

   మేము వాటిని వియుక్త తరగతిని ఉపయోగించి వివరించలేకపోయాము. వారు ఒకే స్థితిని లేదా ఒకే విధమైన ఫీల్డ్‌లను పంచుకోరు. విమానాన్ని నిర్వచించడానికి, మనకు మోడల్, ఉత్పత్తి సంవత్సరం మరియు గరిష్ట సంఖ్యలో ప్రయాణీకుల కోసం ఫీల్డ్‌లు అవసరం కావచ్చు. కార్ల్‌సన్ కోసం, అతను ఈరోజు తిన్న అన్ని స్వీట్‌ల కోసం ఫీల్డ్‌లు మరియు అతను తన చిన్న సోదరుడితో ఆడే ఆటల జాబితా అవసరం. ఒక దోమ కోసం, ... ఊ... నాకు కూడా తెలియదు... బహుశా, 'చిరాకు స్థాయి'? :)

   విషయమేమిటంటే, వాటిని వివరించడానికి మనం ఒక వియుక్త తరగతిని ఉపయోగించలేము. అవి చాలా భిన్నంగా ఉంటాయి. కానీ వారు భాగస్వామ్య ప్రవర్తనను కలిగి ఉంటారు: వారు ఎగరగలరు. ప్రపంచంలోని ఎగరగల, ఈత కొట్టగల, దూకగల లేదా కొన్ని ఇతర ప్రవర్తనలను ప్రదర్శించగల ప్రతిదాన్ని వివరించడానికి ఇంటర్‌ఫేస్ సరైనది.

3. తరగతులు మీకు కావలసినన్ని ఇంటర్‌ఫేస్‌లను అమలు చేయగలవు, కానీ అవి ఒక తరగతిని మాత్రమే వారసత్వంగా పొందగలవు.

   మేము దీన్ని ఇప్పటికే ఒకటి కంటే ఎక్కువసార్లు ప్రస్తావించాము. జావాకు బహుళ వారసత్వ తరగతులు లేవు, కానీ ఇది ఇంటర్‌ఫేస్‌ల బహుళ వారసత్వానికి మద్దతు ఇస్తుంది. ఈ పాయింట్ మునుపటి నుండి కొంత భాగాన్ని అనుసరిస్తుంది: ఇంటర్‌ఫేస్ అనేక విభిన్న తరగతులను కలుపుతుంది, అవి తరచుగా ఉమ్మడిగా ఏమీ ఉండవు, అయితే చాలా దగ్గరి సంబంధం ఉన్న తరగతుల సమూహం కోసం ఒక వియుక్త తరగతి సృష్టించబడుతుంది. అందువల్ల, మీరు అటువంటి తరగతిని మాత్రమే వారసత్వంగా పొందగలరని అర్ధమే. ఒక వియుక్త తరగతి 'is-a' సంబంధాన్ని వివరిస్తుంది.

ప్రామాణిక ఇంటర్‌ఫేస్‌లు: ఇన్‌పుట్ స్ట్రీమ్ మరియు అవుట్‌పుట్ స్ట్రీమ్

మేము ఇప్పటికే ఇన్‌పుట్ మరియు అవుట్‌పుట్ స్ట్రీమ్‌లకు బాధ్యత వహించే వివిధ తరగతులను అధిగమించాము. పరిశీలిద్దాం 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)ఇన్‌పుట్ స్ట్రీమ్‌లో బైట్‌కౌంట్ బైట్‌లను దాటవేస్తుంది మరియు విస్మరించబడిన బైట్‌ల సంఖ్యను అందిస్తుంది.

మీరు పద్ధతుల యొక్క పూర్తి జాబితాను అధ్యయనం చేయాలని నేను సిఫార్సు చేస్తున్నాను . వాస్తవానికి పది కంటే ఎక్కువ పిల్లల తరగతులు ఉన్నాయి. ఉదాహరణకు, ఇక్కడ కొన్ని ఉన్నాయి:

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, కాబట్టి ఇది మొదటి పరిచయానికి తగినంత సమాచారం. అంతే! మీరు ఇంటర్‌ఫేస్‌లు మరియు నైరూప్య తరగతుల మధ్య తేడాలను అర్థం చేసుకున్నారని మరియు ఏదైనా ప్రశ్నకు సమాధానం ఇవ్వడానికి సిద్ధంగా ఉన్నారని మేము ఆశిస్తున్నాము :)