Implementer i Java

Når nogle taler om Java OOP-paradigmet for arv, betyder de normalt at udvide en forældreklasse med en arvtager, en børneklasse. Men når du støder på Java implements nøgleordet, betyder det, at vi flytter til et andet abstraktionsniveau og begynder at arbejde med grænseflader i Java. Vi skal tale om, hvad grænseflader er, hvad de er til, hvordan implementering sker.

Hvad er interface og implementering

Du har sikkert hørt ordet "interface" mange gange. For eksempel har en computer en inputgrænseflade (mus og tastatur), mange programmer har brugergrænseflader. I bredeste forstand er en grænseflade et bindeled mellem to interagerende parter. For eksempel det samme tastatur eller tv-fjernbetjening. I programmering, og i Java i særdeleshed, er en grænseflade en specifik kontrakt, der siger, hvad klassen, der implementerer den, vil gøre. En grænseflade definerer kun adfærd. Det siger ikke noget om objektet, der skal implementere det. Du kan erklære en grænseflade i Java som denne:

public interface MyInterface  {

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

Her er en syntaks af Implementer i Java:

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

En grænseflade beskriver adfærd uden at specificere den. For eksempel kan en adfærd som "bevægelse" anvendes på forskellige typer objekter: en cykel, en person, en bil, vand i en flod og så videre. Svømningsadfærden kan være en ands, et skibs eller en fisks adfærd. Disse genstande har intet tilfælles andet end at de kan bevæge sig eller svømme. Ja, og selve bevægelsen med svømning de er meget forskellige. Men i Java kan du oprette Duck , Boat , Fish- klasser og lade dem implementere evnen til at svømme. Det er her Java Implements nøgleordet bruges.

Implementer søgeordseksempel

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

Som du kan se, er selve metoderne ikke implementeret. Men vi erklærede, at de klasser, der implementerer denne grænseflade, skal være i stand til at svømme i en lige linje, samt dreje til højre og venstre. Lad os oprette klasser, der implementerer denne grænseflade.

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 klasser, der implementerer Swimmable- grænsefladen, skal ifølge kontrakten kunne svømme fremad (implementere moveForward()- metoden), samt dreje til højre og venstre. Implementering af disse metoder er påkrævet. En and og en fisk svømmer forskelligt. Lad os sige, at en fisk har to yderligere metoder, der implementerer dens evne til at svømme op og ned. Den Swimmable-grænseflade har ikke dette. Men hvis vi opretter et barn i Fiskeklassen, for eksempel tun eller laks, vil de, ligesom alle "fisk", være i stand til at svømme op og ned.

Flere grænseflader i Java

Som du sikkert allerede ved, understøtter Java ikke multipel nedarvning. Det betyder, at én klasse kun kan arves fra én superklasse. Men på en måde kan du stadig bruge "multiple inheritance" i Java, fordi en klasse kan implementere flere grænseflader.

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

Eksempel på flere grænseflader

Husk, at en and ikke kun kan svømme, men også flyve. Lad os skrive flyvegrænsefladen og implementere den i vores and.

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

}

Og igen er det vigtigt at huske, hvorfor vi skriver grænsefladen. Lad os sige, at hvis det implementeres af en fugl, et fly, en faldskærmsudspringer og en mælkebøtte, vil deres flyvninger være helt anderledes.