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

سلام! هن ليڪچر ۾، اسان ان بابت ڳالهائينداسين ته ڪيئن خلاصي ڪلاس انٽرفيس کان مختلف آهن ۽ عام تجريدي طبقن سان مثالن کي ڏسو. اسان هڪ الڳ ليڪچر وقف ڪيو آهي هڪ خلاصي طبقي ۽ انٽرفيس جي وچ ۾ فرق، ڇو ته موضوع تمام اهم آهي. توھان کان پڇيو ويندو انھن تصورن جي وچ ۾ فرق بابت 90٪ مستقبل جي انٽرويو ۾. تنهن ڪري، پڪ ڪريو ته توهان ڇا پڙهي رهيا آهيو، ۽ جيڪڏهن توهان مڪمل طور تي ڪجهه نه سمجهي، اضافي ذريعن کي پڙهو. تنهن ڪري، اسان ڄاڻون ٿا ته هڪ خلاصو ڪلاس ڇا آهي ۽ هڪ انٽرفيس ڇا آهي. هاڻي اچو ته انهن جي اختلافن جي ذريعي وڃو.

1. هڪ انٽرفيس صرف رويي کي بيان ڪري ٿو. هن کي ڪا به قسمت ناهي. پر هڪ تجريدي طبقي ۾ هڪ رياست آهي: اهو ٻنهي کي بيان ڪري ٿو.

   اچو ته مثال طور هڪ خلاصو ڪلاس Bird۽ انٽرفيس وٺون Flyable:

   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, birdie!");
      }
   
      public static void main(String[] args) {
   
          Mockingjay someBird = new Mockingjay();
          someBird.setAge(19);
          System.out.println(someBird.getAge());
      }
   }

   جئين توهان ڏسي سگهو ٿا، اسان آساني سان خلاصي طبقي جي حالت تائين رسائي ڪري سگهون ٿا - ان جي متغير species(قسم) ۽ age(عمر).

   پر جيڪڏهن اسان انٽرفيس سان ساڳيو ڪم ڪرڻ جي ڪوشش ڪنداسين، تصوير مختلف ٿي ويندي. اسان ڪوشش ڪري سگھون ٿا ان ۾ متغير شامل ڪرڻ:

   public interface Flyable {
   
      String species = new String();
      int age = 10;
   
      public void fly();
   }
   
   public interface Flyable {
   
      private String species = new String(); // error
      private int age = 10; // also an error
   
      public void fly();
   }

   اسان انٽرفيس اندر نجي متغير ٺاهڻ جي قابل نه هوندا . ڇو؟ ڇو ته پرائيويٽ موڊيفائر ٺاهي وئي هئي ان عمل کي صارف کان لڪائڻ لاءِ. پر انٽرفيس اندر ڪو به عمل نه آهي: اتي لڪائڻ لاء ڪجھ به ناهي.

   انٽرفيس صرف رويي کي بيان ڪري ٿو. انهي جي مطابق، اسان انٽرفيس اندر حاصل ڪندڙن ۽ سيٽرن کي لاڳو ڪرڻ جي قابل نه هوندا. اها هڪ انٽرفيس جي فطرت آهي: اهو رويي سان معاملو ڪرڻ جو مطلب آهي، نه رياست.

   Java8 متعارف ڪرايو ڊفالٽ انٽرفيس طريقا جنهن تي عمل درآمد آهي. توھان انھن بابت اڳ ۾ ئي ڄاڻو ٿا، تنھنڪري اسين انھن کي ورجائي نه سگھندا.

2. هڪ خلاصو طبقو ڳنڍي ٿو ۽ طبقن کي متحد ڪري ٿو جن جو تمام گهڻو ويجهو تعلق آهي. ساڳئي وقت، ساڳئي انٽرفيس کي لاڳو ڪري سگهجي ٿو طبقن ۾ جيڪي ڪجھ به عام ۾ نه آهن.

   اچو ته پکين سان اسان جي مثال ڏانهن موٽون.

   اسان جي خلاصي طبقي Birdجي ضرورت آهي ته پکين کي بنياد بڻائي. رڳو پکي ۽ ٻيو ڪو نه! يقينا اهي مختلف هوندا.

   انٽرفيس سان Flyableهر شيء مختلف آهي. اهو صرف ان جي نالي سان لاڳاپيل رويي کي بيان ڪري ٿو - "پرواز". ”اُڏامڻ“، ”اُڏامڻ جي قابل“ جي تعريف ۾ ڪيتريون ئي شيون شامل آهن جيڪي هڪ ٻئي سان لاڳاپيل نه آهن.

   اهي 4 ادارا ڪنهن به طرح هڪ ٻئي سان لاڳاپيل نه آهن. مان ڇا ٿو چوان، نه ته اهي سڀئي متحرڪ آهن. بهرحال، اهي سڀئي Flyableپرواز ڪرڻ جي قابل آهن.

   اسان انهن کي تجريدي ڪلاس استعمال ڪندي بيان ڪرڻ جي قابل نه هوندا. انهن وٽ هڪ عام رياست يا هڪجهڙا شعبا نه آهن. جهاز جي خاصيت لاءِ، اسان کي شايد ”ماڊل“، ”ٺهيل جو سال“ ۽ ”مسافرن جو وڌ ۾ وڌ تعداد“ جي شعبن جي ضرورت پوندي. ڪارلسن لاءِ، اتي موجود سڀني مٺين لاءِ ميدان آهن جيڪي هن اڄ کائيندا هئا، ۽ راندين جي هڪ فهرست جيڪا هو ٻار سان کيڏندو. هڪ مڇر لاءِ... اوه... اسان کي به خبر ناهي... ٿي سگهي ٿو ”ناراضيءَ جي سطح“؟ :)

   بنيادي شيء اها آهي ته اسان انهن کي تجريدي طبقي استعمال ڪندي بيان نٿا ڪري سگهون. اهي تمام مختلف آهن. پر اتي ھڪڙو عام رويي آھي: اھي اڏامي سگھن ٿا. انٽرفيس دنيا جي هر شيءِ کي بيان ڪرڻ لاءِ مثالي آهي جيڪو اڏامي سگهي ٿو، ترڻ، ٽپو ڏئي سگهي ٿو، يا ڪجهه ٻيو رويو رکي ٿو.

3. ڪلاس تمام گھڻا انٽرفيس لاڳو ڪري سگھن ٿا جيترا اھي چاھين، پر اھي صرف ھڪڙي طبقي مان ورثي ۾ حاصل ڪري سگھن ٿا.

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

معياري ان پٽ اسٽريم ۽ آئوٽ پٽ اسٽريم انٽرفيس

اسان اڳ ۾ ئي مختلف طبقن مان گذري چڪا آهيون ان پٽ ۽ آئوٽ اسٽريمنگ جا ذميوار. اچو ته ڏسو 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)skips 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 was read" + c);
           }
       } catch(Exception e) {

           e.printStackTrace();

       } finally {

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

هن مثال ۾، اسان هڪ فائل مان ڊيٽا پڙهي رهيا آهيون جيڪا ڪمپيوٽر تي "D:/Users/UserName/someFile.txt" پتي تي واقع آهي . اسان 2 شيون ٺاهيندا آهيون - FileInputStream۽ BufferedInputStreamان جي "ريپر" جي طور تي. ان کان پوء، اسان فائل مان بائيٽ پڙهي ۽ انهن کي اکرن ۾ تبديل ڪيو. ۽ ائين ئي فائل ختم ٿيڻ تائين. جئين توهان ڏسي سگهو ٿا، هتي ڪجھ به پيچيده ناهي. توهان هن ڪوڊ کي نقل ڪري سگهو ٿا ۽ ان کي هلائي سگهو ٿا ڪجهه حقيقي فائل تي جيڪو توهان جي ڪمپيوٽر تي ذخيرو ٿيل آهي :) هڪ ڪلاس OutputStreamهڪ خلاصو ڪلاس آهي جيڪو هڪ بائيٽ اسٽريم آئوٽ جي وضاحت ڪري ٿو. جيئن ته توهان اڳ ۾ ئي سمجهي رهيا آهيو، هي 'ا' جو ضد آهي InputStream. اهو ذميوار نه آهي ته ڪٿي ڊيٽا پڙهڻ لاء، پر ان لاء ڪٿي موڪليو وڃي . جهڙوڪ InputStream، هي خلاصو ڪلاس سڀني اولادن کي آسان ڪم لاءِ طريقن جي هڪ گروپ سان مهيا ڪري ٿو:

• int 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'a) ۾. معمولي ترتيب واري ڊيٽا جي رڪارڊنگ جي بدران، خاص "اسٽوريج" بفر ذريعي رڪارڊنگ استعمال ڪيو ويندو آهي. بفر استعمال ڪندي، توھان گھٽائي سگھوٿا گول سفرن جو تعداد ڊيٽا جي منزل ڏانھن ۽ اھڙي طرح ڪارڪردگي کي بھتر بڻائي.

   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 will convert this string into an array of bytes and write it to a file
   
          byte[] buffer = text.getBytes();
   
          bufferedStream.write(buffer, 0, buffer.length);
          bufferedStream.close();
      }
   }

   ٻيهر، توهان هن ڪوڊ سان پاڻ کي "راند" ڪري سگهو ٿا ۽ چيڪ ڪريو ته اهو توهان جي ڪمپيوٽر تي حقيقي فائلن تي ڪيئن ڪم ڪندو.

توھان پڻ مواد ۾ وارثن بابت پڙھي سگھو ٿا " InputStreamانپٽ / آئوٽ پُٽ سسٽم ". او ، ۽ اسان جو هڪ الڳ ليڪچر به هوندو، تنهنڪري پهرين واقفيت لاءِ انهن بابت ڪافي معلومات آهي. اهو ئي سڀ ڪجهه آهي! اسان کي اميد آهي ته توهان کي انٽرفيس ۽ تجريدي طبقن جي وچ ۾ فرق جي سٺي سمجھ آهي ۽ ڪنهن به سوال جو جواب ڏيڻ لاءِ تيار آهيو، جيتوڻيڪ هڪ مشڪل به :) OutputStreamFileInputStreamFileOutputStreamBufferedInputStream