anchor.diff:  	}
   }
   ----
  -Zoals te zien is kan LoggingAdder de `Default methods` van zowel Logger als Adder gebruiken. op deze manier is `Multiple inheritance` mogelijk gemaakt.
  +Zoals te zien is kan LoggingAdder de `Default methods` van zowel Logger als Adder gebruiken. op deze manier is `Multiple inheritance` mogelijk gemaakt. Dit zijn features die wij ook toe zouden kunnen en hopelijk op die manier onze, vaak zeer uitgebreide, class-hierarchy wat meer te structureren.
   
   === Multiple inheritance problem
   Met het mogelijk maken van multiple inheritance komt wel een volgend probleem om de hoek kijken. Het zogenaamde `Daimond problem`. Dit wil zeggen dat wanneer er meerdere interfaces met dezelfde default method worden geïmplementeerd, de compiler niet meer weet welke methode gebruikt moet worden. Dit kan opgelost worden door in die class de methode te overriden en dan expliciet aan te geven van welke interface de methode gebruikt moet worden. Dit ziet er dan alsvolgt uit.
  
positive.code: Een van de mooie zaken die je met CDI mooi op kunt lossen is dat je gemakkelijk één of meerdere instanties van een bepaalde interface kunt laten injecteren. 
  Dit bracht mij op het idee om eens goed te gaan kijken naar het type `interface`. + 
  
  De interface is toch één van de belangrijkste bouwstenen van Java. Buitengewoon handig bij het schrijven van een API, maar tot Java 8 ook wel een beetje beperkt. Wanneer je een implementatie van een interface methode wilde kunnen hergebruiken in meerdere classes, dan zat je alweer vaak vast aan een (abstracte) class, maar die past niet altijd in je class hierarchy. Dan moet je code gaan dupliceren of nog wat anders proberen. Gelukkig heeft Java 8 twee nieuwe features voor de interface toegevoegd.
  
  == Functional interfaces
  Er is een nieuw type interface toegevoegd in Java 8, de zogenaamde Functional Interface. Dit is een interface met maar één abstract method. Dit is te doen door de annotatie `@FunctionalInterface` aan de interface toe te voegen. Dit is geen vereiste. Elke interface met maar één abstract method is in principe een functional interface, echter wanneer de annotatie eraan toegevoegd is, wordt door de compiler ook gecheckt of er maar één abstact method is. +
  
  De reden dat dit type interface toegevoegd is, heeft te maken met een andere nieuwe toevoeging in Java 8, namelijk lambda's. Ook wel eens anonymous functions genoemd. Wat lambda's precies zijn en hoe je ze in kunt zetten, is wellicht iets voor een volgende blog.
  
  == Static methods
  Een andere toevoeging in Java 8 is de mogelijkheid om static methods toe te voegen aan interfaces. Voorheen was je genoodzaakt om static methods in de class zelf, in een (abstract) superclass of in een soort util-class toe te voegen. Dit had als nadeel dat je code die bij elkaar hoorde, niet altijd netjes bij elkaar kon plaatsen. Bijvoorbeeld bij enums die een interface implementeerde, aangezien inheritance bij enums niet is toegestaan. +
  
  Voorheen hadden we bijvoorbeeld 2 enums die een vrijwel identieke implementatie van een aantal methodes hadden. +
  `BPVStatus`
  
negative.code: Het bovenstaande voorbeeld is natuurlijk erg eenvoudig, helemaal omdat beide interfaces ook nog eens dezelfde functionaliteit bevatten. Het kiezen van de juiste interface zou wellicht ook at runtime kunnen en op die manier bijvoorbeeld een soort `feature toggles` mogelijk te maken. Dit heb ik echter niet getest, maar zal wellicht leuk zijn voor een volgende blog.
  
  == Conclusie
  Met de komst van Java 8 is er veel veranderd m.b.t. de interface. De toepassingen voor interface zijn met de komst van `static methods` en `default methods` alleen maar groter geworden. Code is in sommige gevallen beter te structureren en te groeperen. Je zou op die manier ook de functionaliteit van je class uit kunnen breiden, zonder de class-hierarchy te vergroten. Al met al kunnen de wijzigingen m.b.t. interfaces een grote impact hebben op onze codebase.
  
  