Pagkakaiba sa pagitan ng mga abstract na klase at mga interface

Kamusta! Sa panayam na ito ay pag-uusapan natin kung paano naiiba ang mga abstract na klase sa mga interface at titingnan ang mga halimbawa na may mga karaniwang abstract na klase. Nagtalaga kami ng isang hiwalay na panayam sa mga pagkakaiba sa pagitan ng abstract na klase at isang interface, dahil ang paksa ay napakahalaga. Tatanungin ka tungkol sa pagkakaiba ng mga konseptong ito sa 90% ng mga panayam sa hinaharap. Samakatuwid, siguraduhing maunawaan kung ano ang iyong binabasa, at kung hindi mo lubos na nauunawaan ang isang bagay, basahin ang mga karagdagang mapagkukunan. Kaya, alam natin kung ano ang abstract na klase at kung ano ang interface. Ngayon, dumaan tayo sa kanilang mga pagkakaiba.

1. Ang isang interface ay naglalarawan lamang ng pag-uugali. Wala siyang kapalaran. Ngunit ang isang abstract na klase ay may isang estado: inilalarawan nito ang pareho.

   Kumuha tayo ng abstract na klase Birdat interface bilang isang halimbawa 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;
      }
   }

   Gumawa tayo ng klase ng ibon Mockingjay(mockingjay) at magmana mula kay 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());
      }
   }

   Tulad ng nakikita mo, madali nating ma-access ang estado ng abstract na klase - ang mga variable nito species(uri) at age(edad).

   Ngunit kung susubukan naming gawin ang parehong sa interface, ang larawan ay magkakaiba. Maaari naming subukang magdagdag ng mga variable dito:

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

   Hindi rin kami makakagawa ng mga pribadong variable sa loob ng interface. Bakit? Dahil nilikha ang pribadong modifier upang itago ang pagpapatupad mula sa user. Ngunit walang pagpapatupad sa loob ng interface: walang dapat itago doon.

   Inilalarawan lamang ng interface ang pag-uugali. Alinsunod dito, hindi namin maipapatupad ang mga getter at setter sa loob ng interface. Iyan ang likas na katangian ng isang interface: ito ay sinadya upang harapin ang pag-uugali, hindi estado.

   Ipinakilala ng Java8 ang mga default na pamamaraan ng interface na may pagpapatupad. Alam mo na ang tungkol sa kanila, kaya hindi na namin uulitin.

2. Isang abstract na klase ang nagli-link at pinagsasama ang mga klase na may napakalapit na ugnayan. Kasabay nito, ang parehong interface ay maaaring ipatupad ng mga klase na walang anumang pagkakatulad.

   Bumalik tayo sa ating halimbawa sa mga ibon.

   Ang aming abstract na klase Birday kinakailangan upang lumikha ng mga ibon batay dito. Tanging mga ibon at wala nang iba! Syempre magkakaiba sila.

   Sa interface Flyablelahat ay iba. Inilalarawan lamang nito ang pag-uugali na naaayon sa pangalan nito - "lumilipad". Ang kahulugan ng "lumilipad", "may kakayahang lumipad" ay kinabibilangan ng maraming bagay na hindi nauugnay sa isa't isa.

   Ang 4 na entity na ito ay hindi nauugnay sa isa't isa sa anumang paraan. Ano ang masasabi ko, hindi naman lahat ay animate. Gayunpaman, lahat sila ay Flyablemay kakayahang lumipad.

   Hindi namin mailalarawan ang mga ito gamit ang abstract na klase. Wala silang karaniwang estado o magkaparehong mga field. Upang makilala ang isang sasakyang panghimpapawid, malamang na kakailanganin natin ang mga patlang na "modelo", "taon ng paggawa" at "maximum na bilang ng mga pasahero". Para kay Carlson, may mga field para sa lahat ng matamis na kinain niya ngayon, at isang listahan ng mga laro na paglalaruan niya kasama ang Kid. Para sa isang lamok...uh-uh...hindi nga natin alam... Baka “annoyance level”? :)

   Ang pangunahing bagay ay hindi natin mailarawan ang mga ito gamit ang isang abstract na klase. Masyado silang magkaiba. Ngunit mayroong isang karaniwang pag-uugali: maaari silang lumipad. Ang interface ay perpekto para sa paglalarawan ng lahat ng bagay sa mundo na maaaring lumipad, lumangoy, tumalon, o magkaroon ng ilang iba pang pag-uugali.

3. Ang mga klase ay maaaring magpatupad ng maraming interface hangga't gusto nila, ngunit maaari lamang silang magmana mula sa isang klase.

   Napag-usapan na natin ito ng higit sa isang beses. Walang maraming mana sa Java, ngunit mayroong maraming pagpapatupad. Ang puntong ito ay bahagyang sumusunod mula sa nauna: ang isang interface ay nag-uugnay sa maraming iba't ibang mga klase na kadalasang walang pagkakatulad, at isang abstract na klase ay nilikha para sa isang pangkat ng mga klase na napakalapit sa isa't isa. Samakatuwid, lohikal na maaari kang magmana mula sa isang klase lamang. Inilalarawan ng abstract na klase ang "ay isang" relasyon.

Mga Karaniwang Interface ng InputStream at OutputStream

Napagdaanan na namin ang iba't ibang klase na responsable para sa streaming input at output. Tingnan natin InputStreamat OutputStream. Sa pangkalahatan, hindi ito mga interface, ngunit mga tunay na abstract na klase. Ngayon alam mo na kung ano ang mga ito, kaya ang pakikipagtulungan sa kanila ay magiging mas madali :) InputStream- ito ay isang abstract na klase na responsable para sa byte input. Ang Java ay may isang serye ng mga klase na nagmana mula sa InputStream. Ang bawat isa sa kanila ay naka-configure upang makatanggap ng data mula sa iba't ibang mga mapagkukunan. Dahil InputStreamisa itong magulang, nagbibigay ito ng ilang pamamaraan para sa maginhawang pagtatrabaho sa mga stream ng data. Ang bawat bata ay may mga pamamaraang ito InputStream:

• int available()ibinabalik ang bilang ng mga byte na magagamit para sa pagbabasa;
• close()isinasara ang input source;
• int read()nagbabalik ng integer na representasyon ng susunod na available na byte sa stream. Kung ang dulo ng stream ay naabot, ang numero -1 ay ibabalik;
• int read(byte[] buffer)sumusubok na basahin ang mga byte sa isang buffer, ibinabalik ang bilang ng mga byte na nabasa. Kapag ito ay umabot sa dulo ng file, ito ay nagbabalik -1;
• int read(byte[] buffer, int byteOffset, int byteCount)nagbabasa ng bahagi ng isang bloke ng mga byte. Ginagamit kapag may posibilidad na ang data block ay hindi ganap na napunan. Kapag naabot nito ang dulo ng file, nagbabalik -1;
• long skip(long byteCount)skips byteCount, isang byte ng input, ibinabalik ang bilang ng mga byte na hindi pinansin.

Pinapayuhan ko kayong pag-aralan ang buong listahan ng mga pamamaraan . Mayroong talagang higit sa isang dosenang mga kahalili na klase. Narito ang ilang halimbawa:

1. FileInputStream: ang pinakakaraniwang uri InputStream. Ginagamit upang basahin ang impormasyon mula sa isang file;
2. StringBufferInputStream: isa pang kapaki - pakinabang na uri InputStream. Ito ay nagiging isang string sa isang input stream ng data InputStream;
3. BufferedInputStream: buffered input stream. Ito ay kadalasang ginagamit upang mapabuti ang kahusayan.

Naaalala mo ba noong dumaan tayo BufferedReaderat sinabing hindi natin ito kailangang gamitin? Kapag sumulat tayo:

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

... BufferedReaderhindi na kailangang gamitin ito: InputStreamReadergagawin nito ang trabaho. Ngunit BufferedReaderginagawa nito nang mas mahusay at, bukod dito, makakapagbasa ng data sa buong linya, sa halip na mga indibidwal na character. Ang lahat BufferedInputStreamay pareho! Ang klase ay nag-iipon ng data ng input sa isang espesyal na buffer nang hindi patuloy na ina-access ang input device. Tingnan natin ang isang halimbawa:

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

Sa halimbawang ito, nagbabasa kami ng data mula sa isang file na matatagpuan sa computer sa address na "D:/Users/UserName/someFile.txt" . Lumilikha kami ng 2 bagay - FileInputStreamat BufferedInputStreambilang "wrapper" nito. Pagkatapos nito, binabasa namin ang mga byte mula sa file at i-convert ang mga ito sa mga character. At iba pa hanggang sa matapos ang file. Tulad ng nakikita mo, walang kumplikado dito. Maaari mong kopyahin ang code na ito at patakbuhin ito sa ilang totoong file na nakaimbak sa iyong computer :) Ang isang klase OutputStreamay isang abstract na klase na tumutukoy sa isang byte stream na output. Tulad ng naiintindihan mo na, ito ang antipode ng InputStream'a. Ito ay hindi responsable para sa kung saan magbabasa ng data, ngunit para sa kung saan ito ipapadala . Tulad ng InputStream, ang abstract class na ito ay nagbibigay sa lahat ng mga inapo ng isang pangkat ng mga pamamaraan para sa maginhawang trabaho:

• int close()isinasara ang output stream;
• void flush()nililimas ang lahat ng buffer ng output;
• abstract void write (int oneByte)nagsusulat ng 1 byte sa output stream;
• void write (byte[] buffer)nagsusulat ng isang hanay ng mga byte sa output stream;
• void write (byte[] buffer, int offset, int count)nagsusulat ng isang hanay ng mga count byte mula sa array, simula sa posisyon offset.

Narito ang ilan sa mga inapo ng klase OutputStream:

1. DataOutputStream. Isang output stream na may kasamang mga pamamaraan para sa pagsusulat ng mga karaniwang uri ng data ng Java.

   Isang napakasimpleng klase para sa pagsulat ng mga primitive na uri at string ng Java. Tiyak na mauunawaan mo ang nakasulat na code kahit na walang paliwanag:

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

   Mayroon itong magkakahiwalay na pamamaraan para sa bawat uri - writeDouble(), writeLong(), writeShort()at iba pa.

2. Klase FileOutputStream . Nagpapatupad ng mekanismo para sa pagpapadala ng data sa isang file sa disk. Siyanga pala, ginamit na natin ito sa nakaraang halimbawa, napansin mo ba? Ipinasa namin ito sa loob ng DataOutputStream, na nagsilbing "wrapper".

3. BufferedOutputStream. Naka-buffer na stream ng output. Wala ring kumplikado, ang kakanyahan ay pareho sa BufferedInputStream(o BufferedReader'a). Sa halip na ang karaniwang sunud-sunod na pag-record ng data, ang pagre-record sa pamamagitan ng isang espesyal na "storage" buffer ay ginagamit. Sa pamamagitan ng paggamit ng buffer, maaari mong bawasan ang bilang ng mga round trip sa patutunguhan ng data at sa gayon ay mapabuti ang kahusayan.

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

   Muli, maaari kang "maglaro" gamit ang code na ito at suriin kung paano ito gagana sa mga totoong file sa iyong computer.

Maaari mo ring basahin ang tungkol sa mga tagapagmana sa materyal na " InputStreamInput / Output System ". Oh , at magkakaroon din tayo ng hiwalay na lecture, kaya may sapat na impormasyon tungkol sa kanila para sa unang kakilala. Iyon lang! Umaasa kami na mayroon kang isang mahusay na pag-unawa sa mga pagkakaiba sa pagitan ng mga interface at abstract na mga klase at handang sagutin ang anumang tanong, kahit na isang nakakalito :) OutputStreamFileInputStreamFileOutputStreamBufferedInputStream