Auteur: Ivo Woltring is Software Architect en Codesmith bij Ordina JTech

Ik zal maar meteen met de deur in huis vallen en mijn conclusie geven. Iedere Java developer dient dit boek te lezen! Als je al jaren ervaring hebt in het programmeren met Java zal je nog steeds iets leren van bijna elk item in dit boek. Als je je programmeerkennis en kunde wilt verbeteren en wilt leren hoe de taal bedoeld is om effectief gebruikt te worden, dan is dit boek een must read!

Joshua Bloch heeft zijn geweldige boek Effective Java second edition een upgrade gegeven en geüpdate naar Java 9. Hij heeft meegeschreven aan essentiële delen van de Java taal, dus je krijgt advies van een van de grote meesters in dit vak. Iemand die weet hoe de taal bedoeld is en hoe je deze zou moeten gebruiken.

Doelgroep

Het is echter geen boek voor de beginnende Java programmeur, die nog bezig is om de basis van de taal onder de knie te krijgen. Als je echter de basisprincipes beheerst en je jezelf wilt verbeteren, dan is dit hét boek voor je. Ook voor zeer ervaren programmeurs zit het boek boordevol leermomenten. Vraag je jezelf wel eens af of je Java oplossing wel de goede oplossing was? Zo ja, lees dan dit boek. Joshua Bloch doet geweldig werk met het uitleggen van best practices en gaat uitgebreid in op de fijnere details van de Java-taal.

Er zijn veel boeken over programmeren in Java te vinden, die je goede uitleg geven en je leren de taal te gebruiken. Zoals de meeste ervaren programmeurs echter weten, is dit pas de eerste stap in het leerproces. Er is een groot verschil tussen het kennen van een methode en het begrijpen wanneer en hoe het te gebruiken om een ​​efficiënte en onderhoudbare applicatie te bouwen. Dit boek helpt je daarbij.

Opzet boek

Ik heb zelf het boek van voor tot achter doorgelezen, omdat ik deze review wilde schrijven en omdat ik alle Items weer eens tot me wilde nemen. Joshua geeft echter zelf aan dat dit niet de originele opzet is van het boek. Het boek bestaat uit 90 Items. Elk item staat op zichzelf en beschrijft een best practice. Elk item beslaat maar een paar pagina’s. Items refereren wel vaak naar andere Items, waardoor je toch al snel meer dan een paar pagina’s aan het lezen bent. Achter in het boek is een uitgebreide index te vinden waar je op trefwoord naar het juiste Item kan zoeken. De items zijn ook losjes gegroepeerd in 11 hoofdstukken.

  1. Creating and destroying objects
  2. Methods common to all objects
  3. Classes and interfaces
  4. Generics
  5. Enums and annotations
  6. Lambdas and Streams
  7. Methods
  8. General programming
  9. Exceptions
  10. Concurrency
  11. Serialization

Deze structuur maakt het boek gemakkelijk te gebruiken en uiterst nuttig in het dagelijkse werk.

Second edition

Voor hen die de tweede editie van dit boek ook gelezen hebben, is het nog steeds de moeite waard om over te gaan naar de derde editie. Er is veel gebeurd tussen de versies Java 5 en Java 9. Sommige Items zijn met pensioen gegaan, omdat ze niet meer relevant zijn en een aantal Items hebben een stevige upgrade gehad. Denk aan dependency injection, try-with-resources en nog vele anderen. Wil je de discussie over Optionals eindelijk beslechten….

Ook is er een nieuw hoofdstuk over Lambdas en Streams toegevoegd.

Er zijn ook Items onveranderd gebleven. In de Appendix is een handige lijst gepubliceerd om de vergelijking tussen de tweede en derde editie gemakkelijker te maken.

Voorbeelden

Dit artikel gaat zeker niet in op alle Items van het boek, maar ik wil er twee even de revue laten passeren.

Item 17 – Minimize mutability

In Item 17 wordt ingegaan op de muteerbaarheid van de instanties van een class. Er wordt uitgelegd waarom het immutable maken van een class een goed idee is.

Je krijgt 5 regels uitgelegd hoe je classes immutable kunt maken:

  1. Geef de class geen methoden om de state te wijzigen (mutators).
  2. Zorg ervoor dat de class niet extended kan worden. Op deze manier kunnen kwaadwillende subclass instanties de muteerbaarheid niet in gevaar brengen.
  3. Maak alle velden final. Door velden final te maken, laat je duidelijk je intentie zien op een manier dat ook door het systeem bekrachtigd wordt. Het bevordert ook threat safety.
  4. Maak alle velden private.
  5. Zorg voor exclusieve toegang tot muteerbare componenten.

Zie Listing 1 om een uitgewerkt voorbeeld te zien van een immutable class.

Waarom moet je een object immutable maken?

  • Ze zijn makkelijker te ontwerpen, bouwen en onderhouden dan muteerbare classes.
  • Dit maakt ze minder foutgevoelig.
  • Ze zijn veiliger in gebruik. Immutable classen zijn thread-safe (geen synchronize nodig).
  • Immutable objecten kunnen gedeeld worden.
  • Het zijn goede bouwblokken voor andere objecten.
  • Fouten zijn makkelijker te vinden. Er is bij immutable objecten geen kans op tijdelijke inconsistentie.

Een nadeel: voor elke unieke waarde van het object is een nieuw object nodig.

Concluderend vertelt Joshua ons dat het minimaliseren van muteerbaarheid een goed idee is, tenzij er een goede reden is voor het muteerbaar maken van een object. Zelfs dan is het minimaliseren van muteerbaarheid “zoveel als mogelijk” nog steeds een goed idee.

Dit Item vertelt nog veel meer over dit onderwerp en gaat in detail in op elk punt hier genoemd, maar dat zou teveel worden om allemaal in dit artikel te verwerken..

 

//Listing 1
package effectivejava.chapter4.item17;

// Immutable complex number class (Pages 81-82)
public final class Complex {
   private final double re;
   private final double im;

   public static final Complex ZERO = new Complex(0, 0);
   public static final Complex ONE  = new Complex(1, 0);
   public static final Complex I    = new Complex(0, 1);

   public Complex(double re, double im) {
       this.re = re;
       this.im = im;
   }

   public double realPart()      { return re; }
   public double imaginaryPart() { return im; }

   public Complex plus(Complex c) {
       return new Complex(re + c.re, im + c.im);
   }

   // Static factory, used in conjunction with private constructor (Page 85)
   public static Complex valueOf(double re, double im) {
       return new Complex(re, im);
   }

   public Complex minus(Complex c) {
       return new Complex(re - c.re, im - c.im);
   }

   public Complex times(Complex c) {
       return new Complex(re * c.re - im * c.im, re * c.im + im * c.re);
   }

   public Complex dividedBy(Complex c) {
       double tmp = c.re * c.re + c.im * c.im;
       return new Complex((re * c.re + im * c.im) / tmp, (im * c.re - re * c.im) / tmp);
   }

   @Override public boolean equals(Object o) {
       if (o == this) return true;
       if (!(o instanceof Complex))  return false;
       Complex c = (Complex) o;
       // See page 47 to find out why we use compare instead of ==
       return Double.compare(c.re, re) == 0
               && Double.compare(c.im, im) == 0;
   }
   @Override public int hashCode() {
       return 31 * Double.hashCode(re) + Double.hashCode(im);
   }

   @Override public String toString() {
       return "(" + re + " + " + im + "i)";
   }
}

Item 18: Favor composition over inheritance

Ik ga dit Item niet verder uitwerken, maar de titel doet al wel suggereren dat hier wat aparte dingen gezegd gaan worden. Hoezo geen inheritance? Inheritance is toch een van de drie pijlers van Object Oriented programmeren? Dit Item gaat daar uitgebreid op in.

Conclusie

Dit boek is een klassieker dat al jaren van goede programmeurs nog betere programmeurs maakt. Met deze upgrade is het er weer helemaal klaar voor om dat te blijven doen. Het is echt aan te raden om regelmatig weer even een Item door te nemen. Net als de vorige editie zal dit boek een van mijn favoriete referenties worden. Zorg dat je een exemplaar te pakken krijgt.

 

Referentie

Titel: Effective Java Third Edition

Auteur: Joshua Bloch

ISBN: 978-0-13-468599-1

Uitgever: Addison-Wesley

https://github.com/jbloch/effective-java-3e-source-code

 

 

Dit boek is een klassieker dat al jaren van goede programmeurs nog betere programmeurs maakt.