Jó példa az interfészek használatára?

Ahelyett, hogy nagyon csúnya származtatási fát adsz, egyszerűen hozzápasszolsz egy interfészt és abból a szempontból a különböző osztályokat együtt kezelheted. pl

Object->Fogyasztható dolog->Kaja leszármazásod van és szeretnéd ár szerint növekvően rendezni a kajáidat.

Ha arraylist-be rakod, van egy tök jó beépített függvény rá:

Collection.sort(listám)

Ekkor a listában szereplő minden elemre kritérium, hogy valósítsák meg a Comparable interfészt, ami csak egy compareTo fv-t tartalmaz. Ez megmondja, melyik kaja "nagyobb a másiknál". Ezt megvalósítod, pl a drágább kaja hátrébb kerül, vagy a jobb minőségű előrébb, akár a kettő együtt.

Miután megvan ez a függvény, a sort már képes rendezni.

Ebben az a jó, hogy magát a sort-ot, mikor írták, nem érdekelték őket, hogy mi alapján rendezed, csak elmondták, tessék itt a comparable, ennek a visszatérési értéke megadja, melyik értékesebb a másiknál. Én csak eszerint írok egy frankó rendezést.

És így nem kell beiktatnod még egy származtatást:

Object->Comparable->Fogyasztható dolog->Kaja, hanem egyszerűen implementálják. Sőt így egyszerre több intefészt is adhatsz egy classnak, míg csak osztályokkal nem lehetne annyi féle öröklést létrehozni.

Röviden:

Vannak a világban különféle dolgok. Van nekünk szélerőművünk, hőerőművünk, atomerőművünk. Ezek a dolgok biztosítanak nekünk valamit, amit más dolgok, például egy mikrosütő, használhatnak. A lényeg, hogy engem nem érdekel, hogyan áll elő az áram, csak az érdekel, hogy legyen áram. Vagy nem érdekel, hogy a kocsi motorja hogyan működik, az érdekel, hogy menjen a kocsi.

A mikrosütőnek kell egy áramforrás, ezt így tudjuk megadni:

class mikrosütő {

public Atomerőmű a;

}

Azért valljuk be, elég szar tervezés, hogy a mikró csak atomerőműben előállított árammal tud dolgozni. Ugyanakkor ha belegondolsz, van az erőművekben valami közös - áramot állítanak elő. Ezentúl két út áll előtted:

- Minden erőműnek közös ősosztálya lesz, ezzel megoldva a problémát

- Írsz egy interfészt

A kettő közt nagy különbség van. Ha az első lehetőséget választod, akkor a közös ősosztály, mint tárgy, megjelenik a világodban, ráadásul Java nyelvben egyszeres öröklődés van, így más ősosztálya nem is lehet az erőműveknek. Az interfész pedig csak egy egyszerű megszorítást ír le, mégpedig minden olyan tárgynak a világban, amely ezzel a megszorítással rendelkezik, ezt meg ezt kell biztosítania - jelen esetben áramot.

Szóval az ősosztályos verzió úgy működik, hogy a világban van egy tárgyad. Ebből te új tárgyat akarsz létrehozni, némileg több tudással felvértezve, így ez osztályok közti viszony.

class Erőmű {}

class Atomerőmű extends Erőmű {}

Mindkét tárgy létezik a világban.

Míg interfész esetében nem jön létre új tárgy a világodban, hanem az egyes tárgyakra megszorításokat róhatsz ki. Minden olyan tárgynak, amely egy adott interfésszel rendelkezik, kötelessége biztosítani az interfészben leírtakat.

interface Áramforrás {}

class Atomerőmű implements Áramforrás {}

class Hőerőmű implements Áramforrás {}

Így már menni fog a mikrónk mindennel:

class mikró {

public Áramforrás a;

}

mikró m = new mikró();

Atomerőmű a = new Atomerőmű;

m.a = a;