Implementeert in Java

Als sommigen het hebben over het Java OOP-paradigma van overerving, bedoelen ze meestal het uitbreiden van een bovenliggende klasse met een overerfbare klasse, een onderliggende klasse. Wanneer u echter het trefwoord Java-implementaties tegenkomt, betekent dit dat we naar een ander abstractieniveau gaan en gaan werken met interfaces in Java. We gaan het hebben over wat interfaces zijn, waar ze voor zijn, hoe implementatie plaatsvindt.

Wat is interface en implementatie

Je hebt het woord "interface" waarschijnlijk al vaak gehoord. Zo heeft een computer een invoerinterface (muis en toetsenbord), veel programma's hebben gebruikersinterfaces. In de breedste zin is een interface een schakel tussen twee op elkaar inwerkende partijen. Bijvoorbeeld hetzelfde toetsenbord of de afstandsbediening van de tv. Bij programmeren, en in Java in het bijzonder, is een interface een specifiek contract dat zegt wat de klasse die het implementeert zal doen. Een interface definieert alleen gedrag. Het zegt niets over het object dat het zal implementeren. U kunt een interface in Java als volgt declareren:

public interface MyInterface  {

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

Hier is een syntax van Implements in Java:

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

Een interface beschrijft gedrag zonder het te specificeren. Een gedrag zoals 'beweging' kan bijvoorbeeld worden toegepast op verschillende soorten objecten: een fiets, een persoon, een auto, water in een rivier, enzovoort. Het gedrag van zwemmen kan het gedrag zijn van een eend, een schip of een vis. Deze objecten hebben niets anders met elkaar gemeen dan dat ze kunnen bewegen of zwemmen. Ja, en juist de beweging met zwemmen is heel anders. In Java kun je echter Duck- , Boat- en Fish- klassen maken en ze de mogelijkheid om te zwemmen laten implementeren. Hier wordt het sleutelwoord Java Implements gebruikt.

Trefwoord Voorbeeld implementeren

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

Zoals u kunt zien, zijn de methoden zelf niet geïmplementeerd. Maar we hebben verklaard dat de klassen die deze interface implementeren, in een rechte lijn moeten kunnen zwemmen en zowel naar rechts als naar links moeten kunnen draaien. Laten we klassen maken die deze interface zullen implementeren.

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...");
   }
}

Alle klassen die de Swimmable -interface implementeren, moeten volgens het contract vooruit kunnen zwemmen (implementeer de methode moveForward() ), en ook rechts en links kunnen draaien. Implementatie van deze methoden is vereist. Een eend en een vis zwemmen anders. Laten we zeggen dat een vis twee extra methoden heeft die zijn vermogen om op en neer te zwemmen implementeren. De Swimmable-interface heeft dit niet. Als we echter een kind van de visklasse maken, bijvoorbeeld tonijn of zalm, kunnen ze, net als elke "vis", op en neer zwemmen.

Meerdere interfaces in Java

Zoals u waarschijnlijk al weet, ondersteunt Java geen meervoudige overerving. Dat betekent dat één klasse slechts van één superklasse kan worden geërfd. In zekere zin kunt u echter nog steeds "meervoudige overerving" in Java gebruiken, omdat een klasse meerdere interfaces kan implementeren.

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
   }
}

Voorbeeld van meerdere interfaces

Vergeet niet dat een eend niet alleen kan zwemmen, maar ook kan vliegen. Laten we de vluchtinterface schrijven en deze in onze duck implementeren.

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!!!");
   }

}

En nogmaals, het is belangrijk om te onthouden waarom we de interface schrijven. Laten we zeggen dat als het wordt geïmplementeerd door een vogel, een vliegtuig, een skydiver en een paardenbloem, hun vluchten compleet anders zullen zijn.