Mga default na pamamaraan sa mga interface

Ang bawat bagong bersyon ng Java ay iba sa mga nauna. Narito ang isang halimbawa ng mga pagbabago mula sa materyal na aming tinalakay: Bago ang Java 5, walang enum's sa wika. Gayundin, ang Java 8 ay kapansin-pansing naiiba sa Java 7. Karamihan sa aming mga lektura ay nakasulat sa ika-7 na bersyon ng wika, ngunit, siyempre, hindi namin babalewalain ang mahahalagang inobasyon. Dahil pinag-uusapan natin ang tungkol sa mga interface sa lecture na ito, tingnan natin ang isang update - mga default na pamamaraan sa mga interface . Alam mo na na ang isang interface ay hindi nagpapatupad . Ang gawain nito ay ilarawan kung anong pag-uugali ang dapat taglayin ng lahat ng bagay na nagpapatupad nito . Ngunit madalas na ang mga developer ay nakatagpo ng mga sitwasyon kung saan ang pagpapatupad ng isang pamamaraan sa lahat ng mga klase ay pareho. Tingnan 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("Газ!");
   }

   @Override
   public void brake() {
       System.out.println("Тормоз!");
   }
}


public class Truck implements Car {

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

   @Override
   public void brake() {
       System.out.println("Тормоз!");
   }
}


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

   @Override
   public void brake() {
       System.out.println("Тормоз!");
   }
}

Ano sa palagay mo ang pangunahing problema sa code na ito? Marahil ay napansin mo na sumulat kami ng isang grupo ng parehong code! Ang problemang ito ay karaniwan sa programming at dapat na iwasan. Ang isa pang bagay ay bago ang paglabas ng Java 8 walang mga espesyal na pagpipilian sa solusyon. Nang lumabas ang bersyong ito, naging posible na tukuyin ang mga default na pamamaraan at ipatupad ang mga ito sa loob mismo ng interface! Narito kung paano ito ginagawa:

public interface Car {

   public default void gas() {
       System.out.println("Газ!");
   }

   public default void brake() {
       System.out.println("Тормоз!");
   }
}

public class Sedan implements Car {

}

public class Truck implements Car {

}

public class F1Car implements Car {

}

Ngayon ang mga pamamaraan gas()at brake(), na pareho para sa lahat ng mga makina, ay kasama sa interface, at hindi kailangan ang duplicate na code. Bukod dito, ang mga pamamaraan ay magagamit sa bawat isa sa mga 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 pamamaraan gas(), ngunit 99 lamang sa kanila ang may parehong pag-uugali? Sinisira nito ang lahat, at ang default na paraan ay hindi gagana sa kasong ito? Siyempre hindi :) Maaaring ma-override ang mga default na paraan ng mga interface.

public class UnusualCar implements Car {
   @Override
   public void gas() {
       System.out.println("Эта машина газует по-другому!");
   }

   @Override
   public void brake() {
       System.out.println("Эта машина тормозит по-другому!");
   }
}

Ang lahat ng iba pang 99 na uri ng mga makina ay magpapatupad ng default na pamamaraan, at ang klase UnusualCar- ang pagbubukod - ay hindi sisira sa pangkalahatang larawan at mahinahong matutukoy ang pag-uugali nito. Maramihang Pamana sa Mga Interface Tulad ng alam mo na, walang maramihang pamana sa Java. Mayroong maraming mga kadahilanan para dito; titingnan natin ang mga ito nang detalyado sa isang hiwalay na panayam. Sa ibang mga wika, halimbawa, sa C++, ito ay kabaligtaran. Kung walang maraming mana, isang seryosong problema ang lumitaw: ang parehong bagay ay maaaring magkaroon ng maraming magkakaibang katangian at "pag-uugali." Isang halimbawa mula sa buhay: para sa ating mga magulang tayo ay mga anak, para sa mga guro tayo ay mga estudyante, para sa mga doktor tayo ay mga pasyente. Sa buhay, lumilitaw tayo sa iba't ibang mga tungkulin at, nang naaayon, naiiba ang pag-uugali: malinaw naman na iba ang pakikipag-usap natin sa mga guro kaysa sa mga malalapit na kaibigan. Subukan nating isalin ang sitwasyong ito sa code. Isipin natin na mayroon tayong dalawang klase: Pond at Aviary. Para sa isang pond kailangan mo ng mga ibon na lumalangoy, at para sa isang aviary kailangan mo ng mga lumilipad. Upang gawin ito, lumikha kami ng dalawang baseng klase - FlyingBirdat Waterfowl.

public class Waterfowl {
}

public class FlyingBird {
}

Alinsunod dito, ipapadala namin sa aviary ang mga ibon na ang mga klase ay minana mula sa FlyingBird, at sa lawa - ang mga bumaba mula sa Waterfowl. Parang simple lang ang lahat. Ngunit ano ang gagawin natin kung kailangan nating kilalanin ang pato sa isang lugar? Pareho siyang lumalangoy at lumilipad. Pero wala kaming multiple inheritance. Sa kabutihang palad, ang Java ay nagbibigay ng maraming pagpapatupad ng mga interface. Kung ang isang klase ay hindi maaaring magmana mula sa ilang mga magulang, ang pagpapatupad ng ilang mga interface ay madali! Ang aming pato ay maaaring parehong lumilipad at lumalangoy :) Ito ay sapat na upang gumamit ng mga interface FlyingBirdsa halip Waterfowlna mga klase upang makamit ang nais na resulta.

public class Duck implements FlyingBird, Waterfowl {

   //методы обоих интерфейсов легко объединяются в одном классе

   @Override
   public void fly() {
       System.out.println("Летим!");
   }

   @Override
   public void swim() {

       System.out.println("Плывем!");
   }
}

Dahil dito, ang aming programa ay nagpapanatili ng kakayahang umangkop sa pamamahala ng klase, at kasabay ng pagpapatupad ng mga default na pamamaraan, ang aming kakayahang tukuyin ang pag-uugali ng mga bagay ay nagiging halos walang limitasyon! :)