Noms a Java

CamelCase: pràctica d’escriure frases o paraules compostes eliminant espais i posant en majúscula la primera lletra de cada paraula.

Pot ser UpperCamelCase o lowerCamelCase.

Es recomanable evitar caràcters que no siguin lletres o números.

• Classes (i Interfaces): noms en UpperCamelCase
• Mètodes: verbs en lowerCamelCase
• Variables: en lowerCamelCase. Han de ser mnemònics i evitar variables d’una lletra, excepte per temporals: i,j,k,m,n (sencers) i c,d,e (caràcters)
• Constants: paraules en majúscules separades per subratllat (underscore)
• Paquets (packages): paraules en minúscules separades per punts. Solen tenir format de domini invertit (com.domain.subdomain). S’ha d’evitar el default package (sense nom)

Valors inicials de les variables

• Each class variable, instance variable, or array component is initialized with a default value when it is created:
  • For type byte, the default value is zero, that is, the value of (byte)0.
  • For type short, the default value is zero, that is, the value of (short)0.
  • For type int, the default value is zero, that is, 0.
  • For type long, the default value is zero, that is, 0L.
  • For type float, the default value is positive zero, that is, 0.0f.
  • For type double, the default value is positive zero, that is, 0.0d.
  • For type char, the default value is the null character, that is, '\u0000'.
  • For type boolean, the default value is false.
  • For all reference types, the default value is null.
• Each method parameter is initialized to the corresponding argument value provided by the invoker of the method.
• Each constructor parameter is initialized to the corresponding argument value provided by a class instance creation expression or explicit constructor invocation.
• An exception parameter is initialized to the thrown object representing the exception.
• A local variable must be explicitly given a value before it is used, by either initialization or assignment, in a way that can be verified using the rules for definite assignment.

Expressions i conversió de tipus

Ordre de les expressions

A Java, les expressions s'avaluen d'esquerra a dreta.

Java no executarà parts de l'expressió quan no sigui necessari. En particular:

• Si tenim expressions AND i el resultat d'una a l'esquerra és false, ja no es continua avaluant a la dreta.
• Si tenim expressions OR i el resultat d'una a l'esquerra és true, ja no es continua avaluant a la dreta.

Tipus primitius

Quan diversos tipus intervenen en una expressió, tots es converteixen al mateix tipus mitjançant unes normes de promoció. Per començar, tots els char / byte / short es promouen a int. Si hi ha algun long, a long. Si hi ha algun float, a float. I si hi ha algun double, a double.

La conversió només es pot fer amb tipus numèrics (exclou el boolean). Hi ha de dos tipus:

• Widening: cap a un tipus més ample, no cal utilitzar cap notació.
• Narrowing: cap a un tipus més estret, cal utilitzar el cast: ( tipus ). La conversió pot perdre informació.

També tenim el boxing / unboxing, que permet convertir automàticament entre els tipus primitius i les classes embolcall.

Objectes

Tenim dos tipus:

• Upcasting: quan volem passar el tipus d'un objecte des de la subclasse a una superclasse.
• Downcasting: quan volem passar el tipus d'un objecte des d'una superclasse a una subclasse.

L'operació de downcasting sol venir precedida de l'ús de l'operador instanceof. Aquest operador retorna true si la classe és del tipus que es pregunta, si és una subclasse o si implementa la interfície.

Emmagatzematge de variables

Precedència d'operadors

Local vs Instance vs Class variables

Checked versus unchecked exceptions

Unchecked exceptions:

• represent defects in the program (bugs) - often invalid arguments passed to a non-private method. To quote from The Java Programming Language, by Gosling, Arnold, and Holmes: "Unchecked runtime exceptions represent conditions that, generally speaking, reflect errors in your program's logic and cannot be reasonably recovered from at run time."
• are subclasses of RuntimeException, and are usually implemented using IllegalArgumentException, NullPointerException, or IllegalStateException
• a method is not obliged to establish a policy for the unchecked exceptions thrown by its implementation (and they almost always do not do so)

Checked exceptions:

• represent invalid conditions in areas outside the immediate control of the program (invalid user input, database problems, network outages, absent files)
• are subclasses of Exception
• a method is obliged to establish a policy for all checked exceptions thrown by its implementation (either pass the checked exception further up the stack, or handle it somehow)

Interpretació de les excepcions

Hem vist que podem tenir excepcions Checked (subclasses de Exception) i Unchecked (subclasses de RuntimeException).

Si mirem la jerarquia de classes, totes extenen Throwable, la classe pare de totes:

• java.lang.Throwable
  • java.lang.Error
  • java.lang.Exception
    • java.lang.RuntimeException

Els tres mètodes més importants de Throwable són:

• public String getMessage(): conté el missatge d'excepció.
• public StackTraceElement[] getStackTrace(): conté la traça de la pila de l'excepció.
• public Throwable getCause(): opcionalment, conté una referència a l'excepció que ha causat aquesta. Pot ser una cadena de diverses excepcions.

Stacktrace

Un stacktrace no ha de ser necessàriament un error. Es pot obtenir el valor actual mitjançant aquest codi:

public class TestStackTrace {

    public static void one() {

        two();

    }

    public static void two() {

        three();

    }

    public static void three() {

        StackTraceElement[] trace = Thread.currentThread().getStackTrace();

        for (StackTraceElement elem : trace) {

            System.out.println(elem);

        }

    }

    public static void main(String[] args) {

        one();

    }

}

Cause

Si pots, guarda la causa quan facis throw d'una excepció més específica.

try {

  doSomething();

} catch (NumberFormatException e) {

  throw new MyBusinessException(e, ErrorCode.CONFIGURATION_ERROR);

} catch (IllegalArgumentException e) {

  throw new MyBusinessException(e, ErrorCode.UNEXPECTED);

}

Estructura típica

paquet.NomDeLaException: missatge que explica la excepció al getMessage()

at paquet.Classe.metode(Classe.java:XXX)

at paquet.Classe.metode(Classe.java:XXX)

...

Caused by: paquet.NomDeLaException: missatge que explica la excepció al getMessage()

at paquet.Classe.metode(Classe.java:XXX)

at paquet.Classe.metode(Classe.java:XXX)

...

Exemple

A continuació veiem una excepció amb les causes encadenades (Caused by). Els punts suspensius expressen la repetició de les línies respecte de l'excepció pare.

Genèrics

Mètodes genèrics

• Totes les declaracions genèriques del mètode tenen una secció de paràmetre tipus delimitada per claudàtors d'angle (<i>) que precedeix el tipus de retorn del mètode (<E> en el següent exemple).
• Cada secció de paràmetres de tipus conté un o més paràmetres de tipus separats per comes. Un paràmetre tipus, també conegut com a variable de tipus, és un identificador que especifica un nom de tipus genèric.
• Els paràmetres de tipus es poden utilitzar per declarar el tipus de devolució i actuar com a marcadors per als tipus d’arguments passats al mètode genèric, que es coneixen com a arguments de tipus reals.
• El cos d'un mètode genèric es declara com el de qualsevol altre mètode. Tingueu en compte que els paràmetres de tipus només poden representar tipus de referència, no tipus primitius (com int, double i char).

public static <E> void printArray( E[] inputArray ) {

    // Display array elements

    for(E element : inputArray) {

       System.out.printf("%s ", element);

    }

    System.out.println();

}

Paràmetres de tipus delimitat

Hi pot haver moments en què voldreu restringir els tipus de tipus que es permeten passar a un tipus de paràmetre. Per exemple, un mètode que opera sobre números només pot voler acceptar instàncies de Number o de les seves subclasses. Per a què serveixen els paràmetres del tipus de límit.

Per declarar un paràmetre de tipus delimitat, enumereu el nom del paràmetre del tipus, seguit de la paraula clau extends, seguit tipus delimitant.

public static <T extends Comparable<T>> T maximum(T x, T y, T z) {

   T max = x;   // assume x is initially the largest

   if(y.compareTo(max) > 0) {

      max = y;   // y is the largest so far

   }

   if(z.compareTo(max) > 0) {

      max = z;   // z is the largest now                 

   }

   return max;   // returns the largest object   

}

Classes genèriques

Una declaració de classe genèrica sembla una declaració de classe no genèrica, tret que el nom de classe sigui seguit per una secció de paràmetre tipus.

Com en els mètodes genèrics, la secció de paràmetres de tipus d'una classe genèrica pot tenir un o més paràmetres de tipus separats per comes. Aquestes classes es coneixen com a classes parametrizades o tipus parametrizats perquè accepten un o més paràmetres.

public class Box<T> {

   private T t;

   public void add(T t) {

      this.t = t;

   }

   public T get() {

      return t;

   }

}

Utilitats

Llegir propietats

Properties props = new Properties();

props.load(inputStream);

String value = props.getProperty("nom.propietat"); // null, si no existeix

InputStream inputStream;

// possibles valors d'inputStream:

inputStream = new FileInputStream("/path/nom.properties");

inputStream = NomClasse.class.getResourceAsStream("/package1/package2/nom.properties");

inputStream = objecte.getClass().getResourceAsStream("/package1/package2/nom.properties");

Quan s'utilitza getResourceAsStream(), podem també utilitzar path relatiu a la classe (NomClasse o classe de l'objecte), però cal que l'arxiu es copiï a la carpeta del classpath (bin o com es digui).

Referències

• Java™ Platform, Standard Edition 8 API Specification
• Java. The Complete Reference (Ninth Edition). Herbert Schildt
  • Capítol 20: Input/Output: Exploring java.io.
• Oracle Java SE Support Roadmap
• Infografia de conceptes POO
• Composition vs. Inheritance: How to Choose?
• Difference between Association, Aggregation and Composition in UML, Java and Object Oriented Programming
• Practical Test Pyramid (Martin Fowler)