خلاصو طبقن ۽ انٽرفيس جي وچ ۾ فرق

سلام هن سبق ۾، اسين ڳالهائينداسين ته ڪيئن تجريدي طبقن انٽرفيس کان مختلف آهن ۽ ڪجهه مثالن تي غور ڪنداسين عام تجريدي طبقن سان. اسان هڪ الڳ سبق وقف ڪيو آهي هڪ خلاصي طبقي ۽ هڪ انٽرفيس جي وچ ۾ فرق، ڇاڪاڻ ته هي موضوع تمام اهم آهي. توھان کان پڇيو ويندو انھن تصورن جي وچ ۾ فرق بابت 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. ڪلاس تمام گھڻا انٽرفيس لاڳو ڪري سگھن ٿا جيئن توھان چاھيو، پر اھي صرف ھڪڙي طبقي کي وارث ڪري سگھن ٿا.

   اسان اڳ ۾ ئي هن جو ذڪر ڪيو آهي هڪ کان وڌيڪ ڀيرا. جاوا وٽ طبقن جي گهڻن ورثي نه آهي، پر اهو انٽرفيس جي ڪيترن ئي ورثي کي سپورٽ ڪري ٿو. ھي نقطو پوئين ھڪڙي جي ھڪڙي حصي ۾ ھيٺ ڏنل آھي: ھڪڙو انٽرفيس ڪيترن ئي مختلف طبقن کي ڳنڍيندو آھي جن ۾ عام طور تي ٻيو ڪجھ به نه ھوندو آھي، جڏھن ته ھڪڙو خلاصو ڪلاس تمام ويجھي لاڳاپيل طبقن جي ھڪڙي گروپ لاءِ ٺاھيو ويندو آھي. تنهن ڪري، اهو احساس آهي ته توهان صرف هڪ اهڙي طبقي جي وارث ڪري سگهو ٿا. هڪ خلاصو طبقو هڪ 'آهي-هڪ' تعلق بيان ڪري ٿو.

معياري انٽرفيس: 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، تنهنڪري اها پهرين واقفيت لاءِ ڪافي معلومات آهي. بس اهو آهي! اسان کي اميد آهي ته توهان انٽرفيس ۽ تجريدي طبقن جي وچ ۾ فرق سمجهي رهيا آهيو ۽ ڪنهن به سوال جو جواب ڏيڻ لاءِ تيار آهيو، سوالن کي به ٽوڪ ڪريو :)