Standaardmethoden in interfaces

Elke nieuwe versie van Java verschilt van de vorige. Hier is een voorbeeld van veranderingen in het materiaal dat we hebben behandeld: vóór Java 5 had de taal geen enums. Evenzo verschilt Java 8 aanzienlijk van Java 7. De meeste van onze lessen zijn geschreven voor de 7e versie van de taal, maar we zullen belangrijke innovaties natuurlijk niet negeren. Aangezien we het in deze les al over interfaces hebben, zullen we één update overwegen: standaardmethoden in interfaces . U weet al dat een interface geen gedrag implementeert . Het is zijn taak om het gedrag te beschrijven dat alle objecten die het implementeren, moeten hebben. Maar ontwikkelaars kwamen regelmatig situaties tegen waarin de implementatie van een methode in alle klassen hetzelfde is. Laten we eens kijken naar ons voorbeeld van een oude auto:

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

"Wat is volgens jou het grootste probleem met deze code? Je hebt waarschijnlijk gemerkt dat we een heleboel herhaalde code hebben geschreven! Dit probleem komt veel voor bij programmeren en je moet het vermijden. Het is een andere kwestie dat bepaalde oplossingen niet eerder bestonden. Java 8 is uitgebracht. Met deze versie kwam de mogelijkheid om standaardmethoden te specificeren en deze rechtstreeks in de interface te implementeren! Hier is hoe je dat doet:

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 zijn de methoden gas()en brake(), die voor alle auto's hetzelfde waren, verplaatst naar de interface. Er is geen herhaalde code nodig. Bovendien zijn de methoden in elke les beschikbaar!

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();
   }
}

Wat als er 100 klassen zijn met de gas()methode, maar slechts 99 daarvan hebben hetzelfde gedrag? Vernietigt dat alles en maakt dat de standaardmethode ongeschikt voor deze situatie? Natuurlijk niet :) Standaardmethoden in interfaces kunnen op dezelfde manier worden overschreven als gewone methoden.

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

Alle 99 andere soorten auto's zullen de standaardmethode implementeren, en deUnusualCarclass, wat een uitzondering is, zal het totaalbeeld niet bederven en definieert rustig zijn eigen gedrag. Meerdere overerving van interfaces. Zoals u al weet, ondersteunt Java geen meervoudige overerving. Daar zijn veel redenen voor. We zullen ze in detail bekijken in een aparte les. Andere talen, zoals C++, ondersteunen het wel. Zonder meervoudige overerving ontstaat een serieus probleem: één object kan meerdere verschillende kenmerken en 'gedragingen' hebben. Hier is een voorbeeld uit het leven: we zijn kinderen voor onze ouders, studenten voor onze leraren en patiënten voor onze artsen. In het leven nemen we verschillende rollen aan en gedragen we ons daarom anders: we zouden natuurlijk niet op dezelfde manier met leraren praten als met onze goede vrienden. Laten we proberen dit in code te vertalen. Stel je voor dat we twee klassen hebben: Vijver en volière. Voor de vijver hebben we watervogels nodig; voor de volière hebben we vliegende vogels nodig. Om dit te doen, hebben we twee basisklassen gemaakt:FlyingBirden Waterfowl.

public class Waterfowl {
}

public class FlyingBird {
}

Dienovereenkomstig sturen we vogels waarvan de klassen erven FlyingBirdnaar de volière, en we sturen vogels die erven Waterfowlnaar de vijver. Het lijkt allemaal heel eenvoudig. Maar waar sturen we een eend heen? Het zwemt en vliegt. En we hebben geen meervoudige erfenis. Gelukkig ondersteunt Java meerdere implementaties van interfaces. Hoewel een klasse niet meerdere ouders kan erven, kan het gemakkelijk meerdere interfaces implementeren! Onze eend kan zowel een vliegende vogel als een watervogel zijn :) We hoeven alleen maar interfaces te maken FlyingBirdin Waterfowlplaats van klassen om het gewenste resultaat te bereiken.

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

Dienovereenkomstig behoudt ons programma de flexibiliteit van klassen, en in combinatie met standaardmethoden wordt ons vermogen om het gedrag van objecten te definiëren bijna onbeperkt! :)