Mga default na pamamaraan sa mga interface

Ang bawat bagong bersyon ng Java ay naiiba sa mga nauna. Narito ang isang halimbawa ng mga pagbabago sa materyal na aming nasaklaw: bago ang Java 5, ang wika ay walang enums. Katulad nito, ang Java 8 ay kapansin-pansing naiiba sa Java 7. Karamihan sa aming mga aralin ay isinulat para sa ika-7 bersyon ng wika, ngunit siyempre hindi namin babalewalain ang mahahalagang pagbabago. Dahil pinag-uusapan na natin ang tungkol sa mga interface sa araling ito, isasaalang-alang natin ang isang update — mga default na pamamaraan sa mga interface . Alam mo na na ang isang interface ay hindi nagpapatupad ng gawi . Ang gawain nito ay ilarawan ang pag-uugali na dapat mayroon ang lahat ng bagay na nagpapatupad nito. Ngunit ang mga developer ay madalas na nakatagpo ng mga sitwasyon kung saan ang pagpapatupad ng isang pamamaraan ay pareho sa lahat ng mga klase. Isaalang-alang natin ang aming lumang halimbawa ng kotse:

public interface Car {

   public void gas();

   public void brake();
}
public class Sedan implements Car {

   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class Truck implements Car {

   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class F1Car implements Car {
   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}

"Sa iyong opinyon, ano ang pangunahing problema sa code na ito? Marahil ay napansin mo na sumulat kami ng isang grupo ng mga paulit-ulit na code! Ang problemang ito ay karaniwan sa programming, at kailangan mong iwasan ito. Ito ay isa pang usapin na ang mga partikular na solusyon ay hindi umiiral noon. Inilabas ang Java 8. Sa bersyong ito ay dumating ang kakayahang tukuyin ang mga default na pamamaraan at ipatupad ang mga ito sa loob mismo ng interface! Narito kung paano mo ito gagawin:

public interface Car {

   public default void gas() {
       System.out.println("Gas!");
   }

   public default void brake() {
       System.out.println("Brake!");
   }
}

public class Sedan implements Car {

}

public class Truck implements Car {

}

public class F1Car implements Car {

}

Ngayon ang gas()at brake()mga pamamaraan, na pareho para sa lahat ng mga kotse, ay inilipat sa interface. Walang kinakailangang paulit-ulit na code. Higit pa rito, ang mga pamamaraan ay magagamit sa bawat klase!

public class Main {

   public static void main(String[] args) {

       F1Car f1Car = new F1Car();
       Sedan sedan = new Sedan();
       Truck truck = new Truck();
       truck.gas();
       sedan.gas();
       f1Car.brake();
   }
}

Paano kung mayroong 100 klase na may gas()pamamaraan, ngunit 99 lamang sa kanila ang may parehong pag-uugali? Sinisira ba nito ang lahat at ginagawang hindi angkop ang default na pamamaraan para sa sitwasyong ito? Siyempre, hindi :) Ang mga default na pamamaraan sa mga interface ay maaaring ma-override sa parehong paraan tulad ng mga ordinaryong.

public class UnusualCar implements Car {
   @Override
   public void gas() {
       System.out.println("This car accelerates differently!");
   }

   @Override
   public void brake() {
       System.out.println("This car decelerates differently!");
   }
}

Ang lahat ng 99 na iba pang uri ng mga kotse ay magpapatupad ng default na paraan, at angUnusualCarclass, na kung saan ay isang exception, ay hindi palayawin ang pangkalahatang larawan at mahinahon na tumutukoy sa sarili nitong pag-uugali. Maramihang pamana ng mga interface. Tulad ng alam mo na, hindi sinusuportahan ng Java ang maramihang pamana. Maraming dahilan para dito. Titingnan natin ang mga ito nang detalyado sa isang hiwalay na aralin. Sinusuportahan ito ng ibang mga wika, gaya ng C++. Kung walang maraming pamana, isang seryosong problema ang lumitaw: ang isang bagay ay maaaring magkaroon ng ilang magkakaibang katangian at 'pag-uugali'. Narito ang isang halimbawa mula sa buhay: tayo ay mga anak sa ating mga magulang, mga estudyante sa ating mga guro, at mga pasyente sa ating mga doktor. Sa buhay, iba't ibang tungkulin ang ginagampanan natin at, nang naaayon, iba ang pag-uugali: malinaw naman, hindi tayo makikipag-usap sa mga guro sa parehong paraan ng pakikipag-usap natin sa ating malalapit na kaibigan. Subukan nating isalin ito sa code. Isipin na mayroon tayong dalawang klase: Pond at Aviary. Para sa pond, kailangan namin ng water fowl; para sa aviary, kailangan natin ng mga lumilipad na ibon. Upang gawin ito, lumikha kami ng dalawang baseng klase:FlyingBirdat Waterfowl.

public class Waterfowl {
}

public class FlyingBird {
}

Alinsunod dito, magpapadala kami ng mga ibon na ang mga klase ay namamana FlyingBirdsa aviary, at magpapadala kami ng mga ibon na nagmana Waterfowlsa lawa. Parang napakasimple ng lahat. Ngunit saan tayo magpapadala ng pato? Lumalangoy ito at lumilipad. At wala kaming multiple inheritance. Sa kabutihang palad, sinusuportahan ng Java ang maramihang pagpapatupad ng mga interface. Kahit na ang isang klase ay hindi maaaring magmana ng ilang mga magulang, maaari itong madaling ipatupad ang ilang mga interface! Ang aming pato ay maaaring parehong lumilipad na ibon at isang waterfowl :) Kailangan lang naming gumawa FlyingBirdat Waterfowlmag-interface kaysa sa mga klase upang makamit ang ninanais na resulta.

public class Duck implements FlyingBird, Waterfowl {

   // The methods of both interfaces can be easily combined into one class

   @Override
   public void fly() {
       System.out.println("Fly!");
   }

   @Override
   public void swim() {

       System.out.println("Swim!");
   }
}

Alinsunod dito, pinapanatili ng aming programa ang kakayahang umangkop ng mga klase, at, kasama ng mga default na pamamaraan, ang aming kakayahang tukuyin ang pag-uugali ng mga bagay ay nagiging halos walang limitasyon! :)