Standardmetoder i gränssnitt

Varje ny version av Java skiljer sig från de som kom tidigare. Här är ett exempel på ändringar i material som vi har täckt: före Java 5 hade språket inte enums. På liknande sätt skiljer sig Java 8 markant från Java 7. De flesta av våra lektioner skrevs för den 7:e versionen av språket, men vi kommer naturligtvis inte att ignorera viktiga innovationer. Eftersom vi redan pratar om gränssnitt i den här lektionen kommer vi att överväga en uppdatering — standardmetoder i gränssnitt . Du vet redan att ett gränssnitt inte implementerar beteende . Dess uppgift är att beskriva beteendet som alla objekt som implementerar det måste ha. Men utvecklare stötte ofta på situationer där en metods implementering är densamma i alla klasser. Låt oss betrakta vårt gamla bilexempel:

public interface Car {

   public void gas();

   public void brake();
}
public class Sedan implements Car {

   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class Truck implements Car {

   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class F1Car implements Car {
   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}

"Vad är enligt din åsikt huvudproblemet med den här koden? Du har säkert märkt att vi skrev en massa upprepad kod! Det här problemet är vanligt i programmering, och du måste undvika det. Det är en annan sak att vissa lösningar inte fanns tidigare Java 8 släpptes. Med den här versionen kom möjligheten att specificera standardmetoder och implementera dem direkt i gränssnittet! Så här gör du:

public interface Car {

   public default void gas() {
       System.out.println("Gas!");
   }

   public default void brake() {
       System.out.println("Brake!");
   }
}

public class Sedan implements Car {

}

public class Truck implements Car {

}

public class F1Car implements Car {

}

Nu har metoderna gas()och brake(), som var desamma för alla bilar, flyttats till gränssnittet. Ingen upprepad kod behövs. Dessutom finns metoderna tillgängliga i varje klass!

public class Main {

   public static void main(String[] args) {

       F1Car f1Car = new F1Car();
       Sedan sedan = new Sedan();
       Truck truck = new Truck();
       truck.gas();
       sedan.gas();
       f1Car.brake();
   }
}

Tänk om det finns 100 klasser med gas()metoden, men bara 99 av dem har samma beteende? Förstör det allt och gör standardmetoden olämplig för den här situationen? Naturligtvis inte :) Standardmetoder i gränssnitt kan åsidosättas på samma sätt som vanliga.

public class UnusualCar implements Car {
   @Override
   public void gas() {
       System.out.println("This car accelerates differently!");
   }

   @Override
   public void brake() {
       System.out.println("This car decelerates differently!");
   }
}

Alla de 99 andra typerna av bilar kommer att implementera standardmetoden, ochUnusualCarklass, vilket är ett undantag, kommer inte att förstöra helhetsbilden och definierar lugnt sitt eget beteende. Flera arv av gränssnitt. Som du redan vet stöder Java inte multipelt arv. Det finns många anledningar till detta. Vi kommer att titta på dem i detalj i en separat lektion. Andra språk, som C++, stöder det. Utan multipelt arv uppstår ett allvarligt problem: ett objekt kan ha flera olika egenskaper och "beteenden". Här är ett exempel från livet: vi är barn för våra föräldrar, studenter för våra lärare och patienter för våra läkare. I livet tar vi på oss olika roller och beter oss därför annorlunda: uppenbarligen skulle vi inte prata med lärare på samma sätt som vi pratar med våra nära vänner. Låt oss försöka översätta detta till kod. Föreställ dig att vi har två klasser: Damm och voljär. Till dammen behöver vi vattenfåglar; till voljären behöver vi flygande fåglar. För att göra detta har vi skapat två basklasser:FlyingBirdoch Waterfowl.

public class Waterfowl {
}

public class FlyingBird {
}

Följaktligen skickar vi fåglar vars klasser ärver FlyingBirdtill voljären, och vi skickar fåglar som ärver Waterfowltill dammen. Det hela verkar väldigt enkelt. Men vart skickar vi en anka? Den simmar och flyger. Och vi har inte flera arv. Lyckligtvis stöder Java flera implementeringar av gränssnitt. Även om en klass inte kan ärva flera föräldrar, kan den enkelt implementera flera gränssnitt! Vår anka kan vara både en flygande fågel och en sjöfågel :) Vi behöver helt enkelt göra FlyingBirdoch Waterfowlgränssnitt snarare än klasser för att uppnå önskat resultat.

public class Duck implements FlyingBird, Waterfowl {

   // The methods of both interfaces can be easily combined into one class

   @Override
   public void fly() {
       System.out.println("Fly!");
   }

   @Override
   public void swim() {

       System.out.println("Swim!");
   }
}

Följaktligen behåller vårt program klassernas flexibilitet, och i kombination med standardmetoder blir vår förmåga att definiera objekts beteende nästan obegränsad! :)