Megvalósítások Java nyelven

Amikor egyesek a Java OOP öröklődés paradigmájáról beszélnek, általában azt jelentik, hogy a szülő osztályt kiterjesztik egy örökössel, egy gyermek osztállyal. Ha azonban a Java implements kulcsszóval találkozik, az azt jelenti, hogy az absztrakció egy másik szintjére lépünk, és elkezdünk dolgozni a Java interfészeivel. Arról fogunk beszélni, hogy mik azok az interfészek, mire valók, hogyan történik a megvalósítás.

Mi az interfész és a megvalósítás

Valószínűleg sokszor hallottad már az „interfész” szót. Például egy számítógépnek van beviteli felülete (egér és billentyűzet), sok programnak van felhasználói felülete. A legtágabb értelemben az interfész egy kapcsolat két interakcióban lévő fél között. Például ugyanaz a billentyűzet vagy a TV távirányítója. A programozásban és különösen a Java-ban az interfész egy konkrét szerződés, amely megmondja, hogy az azt megvalósító osztály mit fog csinálni. Az interfész csak a viselkedést határozza meg. Nem mond semmit az objektumról, amely megvalósítja. Java-ban egy interfészt így deklarálhat:

public interface MyInterface  {

     // constants declaration 
     // methods without implementation
     // static methods
     // default methods (default)
     // private methods
}

Íme a Java implementációk szintaxisa :

public class MyClass implements MyInterface{
//implementing the methods of MyInterface 
//Other code
} 

Egy interfész leírása nélkül írja le a viselkedést. Például egy olyan viselkedés, mint a „mozgás”, különböző típusú tárgyakra alkalmazható: kerékpár, személy, autó, víz a folyóban stb. Az úszás viselkedése lehet egy kacsa, egy hajó vagy egy hal viselkedése. Ezekben a tárgyakban semmi közös nincs azon kívül, hogy tudnak mozogni vagy úszni. Igen, és a mozgás az úszással nagyon különbözik. A Java nyelven azonban létrehozhat Duck , Boat , Fish osztályokat, és hagyhatja, hogy megvalósítsák az úszás képességét. Itt használatos a Java Implements kulcsszó.

Példa kulcsszó megvalósítása

public interface Swimmable {
  
   void moveForward();
   void TurnRight();
   void TurnLeft();
  
}

Mint látható, maguk a módszerek nem valósulnak meg. De kijelentettük, hogy az ezt az interfészt megvalósító osztályoknak tudniuk kell egyenes vonalban úszni, valamint jobbra-balra kanyarodni. Hozzunk létre osztályokat, amelyek megvalósítják ezt a felületet.

public class Duck implements Swimmable {
//implementing the methods
   public void moveForward() {
       System.out.println(" Quack, I am moving forward...");
   }

   public void TurnRight(){
       System.out.println("I am turning right...");
   }
   public void TurnLeft(){
       System.out.println("I am turning left...");

   }

   public void Stop() {
       System.out.println("Quack. I am relaxing on the surface of the water...");
   }

}

public class Fish implements Swimmable {

   public void moveForward() {
       System.out.println("I am moving forward...");
   }

   public void TurnRight(){
       System.out.println("I am turning right...");
   }
   public void TurnLeft() {
       System.out.println("I am turning left...");
   }

   public void turnUp(){
       System.out.println("I am turning up...");
   }

   public void turnDown(){
       System.out.println("I am turning down...");
   }

   public void Stop() {
       System.out.println("I am relaxing somewhere under the water surface...");
   }
}

Minden osztálynak, amely a szerződés szerint megvalósítja az Swimmable interfészt, képesnek kell lennie előreúszni (megvalósítani a moveForward() metódust), valamint jobbra-balra kanyarodni. Ezen módszerek végrehajtása szükséges. A kacsa és a hal másképp úszik. Tegyük fel, hogy egy halnak két további módszere is van, amelyek megvalósítják a fel és le úszás képességét. Az úszható felületen ez nem található. Ha azonban létrehozunk egy hal osztály gyermekét, például tonhalat vagy lazacot, akkor ezek, mint minden „hal”, fel-alá úszhatnak.

Több interfész Java-ban

Amint valószínűleg már tudja, a Java nem támogatja a többszörös öröklődést. Ez azt jelenti, hogy egy osztály csak egy szuperosztályból örökölhető. Azonban bizonyos módon továbbra is használhatja a „többszörös öröklést” a Java-ban, mivel egy osztály több interfészt is megvalósíthat.

To implement multiple interfaces, use the next syntax: 
interface MyFirstInterface {
   public void myMethod();
}
interface MySecondInterface {
   public void myOtherMethod();
}

// MyClass implements both MyFirstInterface and MySecondInterface
class MyClass implements MyFirstInterface, MySecondInterface {
   public void myMethod() {
      //method implementation
   }
   public void myOtherMethod() {
     //method implementation
   }
}

Példa több interfészre

Ne feledje, hogy a kacsa nem csak úszni, hanem repülni is tud. Írjuk meg a repülési felületet, és implementáljuk a kacsánkban.

public interface Flyable {
   double startAge = 0.1;
   void fly();
}

public class Duck implements Swimmable, Flyable {

   public void moveForward() {
       System.out.println(" Quack, I am moving forward...");
   }

   public void TurnRight(){
       System.out.println("I am turning right...");
   }
   public void TurnLeft(){
       System.out.println("I am turning left...");

   }

   public void Stop() {
       System.out.println("Quack. I am relaxing on the surface of the water...");
   }

   public void fly(){
       System.out.println("I am flying!!!");
   }

}

És ismét fontos megjegyezni, miért írjuk a felületet. Mondjuk, ha egy madár, egy repülőgép, egy ejtőernyős és egy pitypang valósítja meg, akkor teljesen más lesz a repülésük.