Coffee break #140. Mga abstract na klase at interface sa Java

Pinagmulan: InfoWorld Ngayon ay matututunan mo kung aling mga kaso ang isang developer ay dapat gumamit ng abstract na klase at kung aling mga kaso ang isang interface. Tutukuyin din natin ang mga pagkakaiba sa pagitan ng mga elementong ito ng wikang Java at kung paano gamitin ang mga ito sa mga programa. Ang mga abstract na klase at interface ay karaniwan sa Java code at maging sa Java Development Kit (JDK) mismo. Ang bawat isa sa mga elementong ito ay nagsisilbi ng ibang layunin:

• Ang isang interface ay isang konstruksyon sa wikang Java na tumutulong sa pagpapatupad ng mga abstract na pamamaraan at mga static na constant.
• Ang mga abstract na klase ay katulad ng mga regular na klase, maliban na maaari nilang isama ang mga abstract na pamamaraan, iyon ay, mga pamamaraan na walang katawan. Ang mga abstract na klase ay hindi maaaring gawin.

Maraming mga developer ang nag-iisip na ang mga interface at abstract na mga klase ay magkatulad, ngunit sa katotohanan ay hindi ito ganap na totoo. Tingnan natin ang mga pangunahing pagkakaiba sa pagitan nila.

Ano ang isang interface

Sa kaibuturan nito, ang isang interface ay isang kontrata, kaya depende ito sa pagpapatupad upang tukuyin ang layunin para sa paglikha nito. Ang interface ay hindi maaaring gumamit ng mga nababagong instance variable, maaari lamang itong gumamit ng mga panghuling variable.

Kailan gagamit ng mga interface

Ang mga interface ay lubhang kapaki-pakinabang para sa paghihiwalay ng code at pagpapatupad ng polymorphism. Makikita natin ito sa JDK na may interface ng Listahan :

public interface List<E> extends Collection<E> {

    int size();
    boolean isEmpty();
    boolean add(E e);
    E remove(int index);
    void clear();
}

Tulad ng malamang na napansin mo, ang code na ito, bagaman maikli, ay medyo naglalarawan. Madali nating makikita ang lagda ng pamamaraan na gagamitin upang ipatupad ang mga pamamaraan sa interface gamit ang kongkretong klase. Ang interface ng Listahan ay naglalaman ng isang kontrata na maaaring ipatupad ng ArrayList , Vector , LinkedList , at iba pang mga klase. Upang gumamit ng polymorphism, maaari lang nating ideklara ang uri ng ating variable gamit ang List at pagkatapos ay piliin ang alinman sa mga available na pagkakataon. Narito ang isa pang halimbawa:

List list = new ArrayList();
System.out.println(list.getClass());

 List list = new LinkedList();
 System.out.println(list.getClass());

Ang output ay: Sa kasong ito, iba ang mga paraan ng pagpapatupad para sa ArrayList , LinkedList , at Vector , na isang mahusay na senaryo para sa paggamit ng interface. Kung mapapansin mo na maraming klase ang nabibilang sa isang parent class na may parehong paraan ng pagkilos ngunit magkaibang pag-uugali. Sa ganitong mga sitwasyon, inirerekumenda na gamitin ang interface. Susunod, tingnan natin ang ilang mga opsyon para sa paggamit ng mga interface.

Pamamaraan ng Interface Overriding

Tulad ng alam na natin, ang interface ay isang uri ng kontrata na dapat ipatupad ng isang kongkretong klase. Ang mga pamamaraan ng interface ay implicitly abstract at nangangailangan ng isang kongkretong pagpapatupad ng klase. Narito ang isang halimbawa:

public class OverridingDemo {
  public static void main(String[] args) {
    Challenger challenger = new JavaChallenger();
    challenger.doChallenge();
  }
}

interface Challenger {
  void doChallenge();
}

class JavaChallenger implements Challenger {
  @Override
  public void doChallenge() {
    System.out.println("Challenge done!");
  }
}

Konklusyon: Tandaan na ang mga pamamaraan ng interface ay tahasang abstract. Nangangahulugan ito na hindi natin kailangang tahasang ideklara ang mga ito na abstract.

Mga Patuloy na Variable

Ang isa pang tuntunin na dapat tandaan ay ang isang interface ay maaari lamang maglaman ng mga pare-parehong variable. Narito ang isang halimbawa:

public class Challenger {

  int number = 7;
  String name = "Java Challenger";

}

Narito ang parehong mga variable ay implicit final at static . Nangangahulugan ito na ang mga ito ay pare-pareho, independyente sa instance, at hindi mababago. Ngayon ay susubukan naming baguhin ang mga variable sa interface ng Challenger , sabihin natin na ganito:

Challenger.number = 8;
Challenger.name = "Another Challenger";

Magdudulot ito ng error sa compilation:

Mga Default na Paraan

Kapag ang mga default na pamamaraan ay ipinakilala sa Java 8, naisip ng ilang mga developer na magiging pareho sila ng mga abstract na klase. Gayunpaman, hindi ito totoo dahil hindi maaaring magkaroon ng estado ang mga interface. Ang isang default na paraan ay maaaring may pagpapatupad, ngunit ang mga abstract na pamamaraan ay wala. Ang mga default na pamamaraan ay resulta ng mga inobasyon na may mga expression at stream ng lambda, ngunit dapat nating gamitin nang mabuti ang mga ito. Ang paraan sa JDK na gumagamit ng default na paraan ay forEach() , na bahagi ng Iterable interface . Sa halip na kopyahin ang code sa bawat Iterable na pagpapatupad , maaari lang nating gamitin muli ang paraang para sa bawat :

default void forEach(Consumer<? super T> action) {
  // Code implementation here...

Maaaring gamitin ng anumang Iterable na pagpapatupad ang paraang forEach() nang hindi nangangailangan ng bagong pagpapatupad ng pamamaraan. Pagkatapos ay maaari nating gamitin muli ang code gamit ang default na paraan. Gumawa tayo ng sarili nating default na paraan:

public class DefaultMethodExample {

  public static void main(String[] args) {
    Challenger challenger = new JavaChallenger();
    challenger.doChallenge();
  }

}

class JavaChallenger implements Challenger { }

interface Challenger {

  default void doChallenge() {
    System.out.println("Challenger doing a challenge!");
  }
}

Resulta: Tungkol sa mga default na pamamaraan, mahalagang tandaan na ang bawat naturang pamamaraan ay kailangang ipatupad. Ang default na paraan ay hindi maaaring static. Ngayon ay lumipat tayo sa mga abstract na klase.

Ang kakanyahan ng isang abstract na klase

Ang mga abstract na klase ay maaaring magkaroon ng estado na may mga variable na halimbawa. Nangangahulugan ito na ang variable ng instance ay maaaring gamitin at mabago. Narito ang isang halimbawa:

public abstract class AbstractClassMutation {

  private String name = "challenger";

  public static void main(String[] args) {
    AbstractClassMutation abstractClassMutation = new AbstractClassImpl();
    abstractClassMutation.name = "mutated challenger";
    System.out.println(abstractClassMutation.name);
  }

}

class AbstractClassImpl extends AbstractClassMutation { }

Konklusyon:

Mga abstract na pamamaraan sa abstract na mga klase

Tulad ng mga interface, ang mga abstract na klase ay maaaring magkaroon ng mga abstract na pamamaraan. Ang abstract na pamamaraan ay isang paraan na walang katawan. Hindi tulad ng mga interface, ang mga abstract na pamamaraan sa mga abstract na klase ay dapat na tahasang ideklarang abstract. Narito ang isang halimbawa:

public abstract class AbstractMethods {

  abstract void doSomething();

}

At narito ang isang pagtatangka na magdeklara ng isang pamamaraan nang walang pagpapatupad at walang abstract na keyword :

public abstract class AbstractMethods {
   void doSomethingElse();
}

Sa kasamaang palad, nagreresulta ito sa isang error sa compilation:

Kailan gagamit ng mga abstract na klase

Inirerekomenda ang abstract na klase kapag kailangan mong ipatupad ang nababagong estado. Halimbawa, ang Java Collections Framework ay may kasamang AbstractList na klase na gumagamit ng estado ng mga variable. Sa mga kaso kung saan hindi mo kailangang panatilihin ang estado ng klase, kadalasan ay mas mahusay na gumamit ng isang interface.

Mga pagkakaiba sa pagitan ng mga abstract na klase at mga interface

Mula sa isang object-oriented programming perspective, ang pangunahing pagkakaiba sa pagitan ng isang interface at isang abstract na klase ay ang isang interface ay hindi maaaring magkaroon ng estado, samantalang ang isang abstract na klase ay maaaring magkaroon ng estado na may mga variable na halimbawa. Ang isa pang pangunahing pagkakaiba ay ang mga klase ay maaaring magpatupad ng higit sa isang interface, ngunit maaari lamang nilang pahabain ang isang abstract na klase. Ang solusyon na ito ay batay sa katotohanan na ang maramihang mana (pagpapalawak ng higit sa isang klase) ay maaaring humantong sa deadlock ng code. Nagpasya ang mga nag-develop ng wikang Java na iwasan ito. Ang isa pang pagkakaiba ay ang mga interface ay maaaring ipatupad ng mga klase o pinalawig ng mga interface, ngunit ang mga klase ay maaari lamang palawigin. Mahalagang tandaan na ang mga expression ng lambda ay maaari lamang gamitin sa isang functional na interface (ibig sabihin ay isang interface na may isang paraan lamang), habang ang mga abstract na klase na may isang abstract na paraan lamang ay hindi maaaring gumamit ng mga lambda expression. Narito ang ilan pang pagkakaiba sa pagitan ng mga abstract na klase at mga interface. Interface:

• Maaari lamang magkaroon ng mga panghuling static na variable. Hindi kailanman mababago ng isang interface ang sarili nitong estado.
• Ang isang klase ay maaaring magpatupad ng maramihang mga interface.
• Maaaring ipatupad gamit ang implements na keyword. Maaaring pahabain ng isang interface ang isa pang interface.
• Ang mga pamamaraan ay maaari lamang gumamit ng mga static na huling field, parameter, o lokal na variable.
• Ang mga functional na interface lamang ang maaaring gumamit ng lambda function sa Java.
• Hindi maaaring magkaroon ng constructor.
• Maaaring may mga abstract na pamamaraan.
• Maaaring magkaroon ng mga default at static na pamamaraan (ipinakilala sa Java 8).
• Maaaring magkaroon ng mga pribadong pamamaraan na may pagpapatupad (ipinakilala sa Java 9).

Mga abstract na klase:

• Maaaring magkaroon ng anumang instance o static na variable, nababago o hindi nababago.
• Ang isang klase ay maaari lamang mag-extend ng isang abstract na klase.
• Maaaring may instance ng mga nababagong field, parameter, o lokal na variable.
• Ang mga abstract na klase na may isang abstract na paraan lamang ay hindi maaaring gumamit ng mga expression ng lambda.
• Maaaring may constructor.
• Maaaring magkaroon ng anumang pamamaraan.