Implementy w Javie

Kiedy niektórzy mówią o paradygmacie dziedziczenia Java OOP, zwykle mają na myśli rozszerzenie klasy nadrzędnej o dziedzica, klasę podrzędną. Jednak gdy natkniesz się na słowo kluczowe Java implements, oznacza to, że przechodzimy na inny poziom abstrakcji i zaczynamy pracować z interfejsami w Javie. Porozmawiamy o tym, czym są interfejsy, do czego służą, jak przebiega implementacja.

Co to jest interfejs i implementacja

Prawdopodobnie wiele razy słyszałeś słowo „interfejs”. Na przykład komputer ma interfejs wejściowy (mysz i klawiatura), wiele programów ma interfejsy użytkownika. W najszerszym znaczeniu interfejs jest łącznikiem między dwiema współpracującymi ze sobą stronami. Na przykład ta sama klawiatura lub pilot do telewizora. W programowaniu, aw szczególności w Javie, interfejs to specyficzna umowa, która mówi, co zrobi klasa, która go implementuje. Interfejs definiuje tylko zachowanie. Nie mówi nic o obiekcie, który go zaimplementuje. Możesz zadeklarować interfejs w Javie w następujący sposób:

public interface MyInterface  {

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

Oto składnia Implements w Javie:

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

Interfejs opisuje zachowanie bez jego określania. Na przykład zachowanie takie jak „ruch” można zastosować do różnych typów obiektów: roweru, osoby, samochodu, wody w rzece i tak dalej. Zachowanie podczas pływania może być zachowaniem kaczki, statku lub ryby. Obiekty te nie mają ze sobą nic wspólnego poza tym, że mogą się poruszać lub pływać. Tak, a sam ruch z pływaniem są bardzo różne. Jednak w Javie możesz stworzyć klasy Duck , Boat , Fish i pozwolić im zaimplementować umiejętność pływania. W tym miejscu używane jest słowo kluczowe Java Implements .

Zaimplementuj słowo kluczowe Przykład

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

Jak widać, same metody nie są zaimplementowane. Ale zadeklarowaliśmy, że klasy, które implementują ten interfejs, muszą umieć pływać w linii prostej, a także skręcać w prawo i lewo. Stwórzmy klasy, które zaimplementują ten interfejs.

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

Wszystkie klasy, które implementują interfejs Swimmable , zgodnie z umową, muszą mieć możliwość pływania do przodu (implementacja metody moveForward() ), a także skrętu w prawo i w lewo. Wymagane jest wdrożenie tych metod. Kaczka i ryba pływają inaczej. Powiedzmy, że ryba ma dwie dodatkowe metody, które implementują jej zdolność pływania w górę iw dół. Interfejs Swimmable tego nie ma. Jeśli jednak stworzymy potomka klasy Ryba, np. Tuńczyka lub Łososia, to jak każda „Ryba” będą one mogły pływać w górę iw dół.

Wiele interfejsów w Javie

Jak zapewne już wiesz, Java nie obsługuje wielokrotnego dziedziczenia. Oznacza to, że jedna klasa może być dziedziczona tylko z jednej nadklasy. Jednak w pewnym sensie nadal możesz używać „wielokrotnego dziedziczenia” w Javie, ponieważ klasa może implementować wiele interfejsów.

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

Przykład wielu interfejsów

Pamiętaj, że kaczka potrafi nie tylko pływać, ale także latać. Napiszmy interfejs lotu i zaimplementujmy go w naszej kaczce.

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

}

I znowu, ważne jest, aby pamiętać, dlaczego piszemy interfejs. Powiedzmy, że jeśli zastosuje go ptak, samolot, skoczek spadochronowy i mniszek lekarski, ich loty będą zupełnie inne.