FAQ Langage JavaConsultez toutes les FAQ

Une classe est constituée :

• de données, ce qu'on appelle des attributs ou membres ;
• de procédures et/ou des fonctions, ce qu'on appelle des méthodes.
  

• ayant même structure (même ensemble d'attributs) ;
• ayant même comportement (mêmes méthodes) ;
• ayant une sémantique commune.
  

• une classe permet généralement d'instancier (créer) plusieurs objets ;
• chaque objet est instance d'une classe et une seule.
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Voiture { 
  
	private int puissance; 
	private boolean estDemarree; 
	private double vitesse; 
  
	public int deQuellePuissance() { 
		return puissance; 
	}		 
  
	public void demarre() { 
		estDemarree = true; 
	} 
  
	public void accelere(double v) { 
		if (estDemarree) { 
			vitesse = vitesse + v 
		} 
	} 
}

Un package ou paquetage est un moyen d'organiser les classes de votre code. Cette unité organisationnelle est à rapprocher du mécanisme des espaces de nommage (naming space) qui existe dans d'autres langages même si les packages fonctionnent un peu différemment.

En Java, un package correspond toujours à un ou plusieurs répertoires ayant exactement le même nom, situés sur le disque, dans une ou plusieurs archives JAR ou plus généralement sur le CLASSPATH. Les classes qui sont déclarées comme appartenant à ce package doivent être physiquement situées dans un de ces répertoires.

Un package est identifié par son nom court (le nom du répertoire lui-même) mais c'est surtout son nom long qui le rend unique. Le nom long ou nom complet est constitué du cheminement complet des noms de tous les packages intermédiaires depuis la racine du CLASSPATH jusqu'au répertoire final, séparés par des points (.). Par exemple, si nous avons un répertoire d situé dans l’arborescence suivante :

1
2
3
4
a 
 ∟ b 
   ∟ c 
     ∟ d

package <nom long du package>;

1
2
3
4
5
package a.b.c.d; 
  
public class Voiture { 
    // Déclaration du reste de la classe. 
    [...]

• les packages dont l'arborescence commence par java sont réservés à l’implémentation de l'API standard dans la JVM (ce qui inclut les classes de base, les collections, AWT, etc.) ;
• les packages dont l'arborescence commence par javax sont réservés au mécanisme des extensions standard de l'API Java (ce qui inclut Swing, l'API d'impression, l'API XML, etc.) ;
• les packages dont l'arborescence commence par javafx sont réservés au toolkit JavaFX.
  

• il suffit d’écrire le nom complet (ou nom long) de la classe à chaque endroit où ce type est utilisé. Par exemple :
  
  

  Code Java :

  Sélectionner tout

  a.b.c.d.Voiture maVoiture = new a.b.c.d.Voiture();

• on peut utiliser une directive import pour que le compilateur accepte d'utiliser le nom court de la classe. Par exemple  :
  
  

  Code Java :

  Sélectionner tout

  1
  2
  3
  4
  5
  import a.b.c.d.Voiture; 
    
  [...] 
    
  Voiture maVoiture = new Voiture();

  
  Il est également possible d’utiliser la syntaxe large (wildcard) en utilisant le caractère étoile (*). Par exemple :
  
  

  Code Java :

  Sélectionner tout

  1
  2
  3
  4
  5
  import a.b.c.d.*; 
    
  [...] 
    
  Voiture maVoiture = new Voiture();

  
  Cela permet, non seulement d'utiliser le nom court de la classe Voiture, mais également celui de toutes les autres classes disponibles dans le package a.b.c.d. À la compilation, le compilateur cherchera à remplacer les noms courts par les noms longs appropriés. Des erreurs seront générées en cas d’ambigüité.
  

1
2
3
4
5
import java.lang.System; 
  
[...] 
  
System.out.println("Salut !");

java.lang.System.out.println("Salut !");

System.out.println("Salut !");

1
2
java.util.Date uneDateJava = [...] 
java.sql.Date uneDateSQL = [...]

1
2
3
4
import a; 
import a.b; 
import a.b.c; 
import a.b.c.d;

L'héritage est un des principaux concepts de la programmation orientée objet. L'héritage permet de définir une relation de « filiation » entre classes. Ainsi une classe fille (ou sous-classe) étend une classe mère (ou super-classe). L'héritage permet en général de spécialiser une classe.

Pour indiquer qu'une classe hérite d'une autre, il faut utiliser le mot-clé extends :

1
2
3
public class Fille extends Mere{ 
   // Ici, le code spécifique de la classe fille. 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class Couleur(){ 
    String nom; 
  
    public Couleur(String nom){ 
        this.nom = nom; 
    } 
} 
  
public class Rouge extends Couleur{ 
    public Rouge(){ 
        super("rouge"); 
    } 
} 
  
public class AutreClasse(){ 
  
    public void setCouleur(Couleur uneCouleur){ 
        [...] 
    } 
  
    public static void main(String[] args){ 
        AutreClasse ac = new AutreClasse(); 
        ac.setCouleur(new Couleur("vert")); 
        ac.setCouleur(new Rouge()); 
    } 
}

Une classe abstraite est une classe incomplète. Elle regroupe un ensemble de variables et de méthodes, mais certaines de ses méthodes ne contiennent pas d'instruction, elles devront être définies dans une classe héritant de cette classe abstraite. Une classe abstraite doit être marquée du mot-clé abstract.

Toute méthode déclarée abstraite, doit également être marquée du mot-clé abstract et ne doit pas avoir de corps. L’implémentation de ces méthodes est laissée aux soins des classes filles de cette classe.

Une classe qui contient au moins une méthode abstraite ou qui hérite d'une classe abstraite et n’implémente aucune des méthodes abstraites de sa classe mère doit obligatoirement être elle-même marquée du mot-clé abstract.

À quoi ça sert ?
En général, cela sert à définir les grandes lignes du comportement d'une classe d'objets sans forcer l'implémentation des détails de l'algorithme. Prenons l'exemple d'une chaîne de montage automobile, laquelle sort un modèle de voiture particulier. On peut choisir de faire une nouvelle chaîne de montage pour le modèle à pare-chocs métallisés, une pour le modèle à pare-chocs en plastique, etc. Ou on peut décider de faire une chaîne de montage générique, de laquelle sortiront des véhicules non finis, que l'on terminera sur d'autres petites chaînes.

Comment ça marche ?
Comme indiqué ci-dessus, une classe abstraite est incomplète, elle ne peut donc pas être instanciée et doit être héritée. Certaines classes abstraites disposeront de méthodes abstraites (que les classes enfants devront implémenter). Voici un exemple de déclaration :

1
2
3
4
5
6
7
8
9
10
/** La classe abstraite employée : */ 
public abstract class Employe { 
  
    [...] 
  
    /** définition d'une méthode abstraite 
     * on notera qu'il n'y a pas d'instruction et un point-virgule à la fin 
     */ 
    public abstract void licencier(); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Class Ouvrier 
public class Ouvrier extends Employe { 
    // définition du code de licencier 
    @Override 
    public void licencier() { 
        // On définit le code. 
        System.out.println("Dehors !"); 
    }  
}  
  
// Class Patron  
public class Patron extends Employe { 
    // Définition du code de la méthode licencier. 
    @Override 
    public void licencier() { 
        System.out.println("Veuillez comprendre que dans la conjoncture actuelle ... !"); 
    }  
}

1
2
3
4
5
6
Employe bob = new Employe() { 
    @Override 
    public void licencier() { 
        System.out.println("Cherche un nouveau boulot."); 
    } 
};

Une classe interne (ou nested class) est une classe déclarée à l'intérieur d'une autre classe. Elle possède les mêmes possibilités qu'une autre classe, mais elle est toujours dépendante de sa classe conteneur et ne peut être utilisée que par la classe conteneur.

Classe interne
Par exemple :

1
2
3
4
class Outer { 
    class Inner { 
    } 
}

1
2
3
4
5
6
7
class Outer{ 
    int i = 100; 
  
    class Inner { 
	int k = i; 
    } 
}

1
2
3
4
class Outer { 
    static class Inner { 
    } 
}

1
2
3
4
5
6
7
class Outer { 
    static int i = 100; 
  
    static class Inner { 
        int k = i; 
    } 
}

Une classe interne est une classe qui est déclarée à l'intérieur d'une autre classe. Le principal avantage des classes internes vient du fait qu'elles ont accès à tous les membres de leur classe conteneur quel que soit le niveau de visibilité. Ainsi les membres private de la classe conteneur sont visibles par toutes ses classes internes.

Note : en réalité le compilateur générera implicitement une méthode d'accès synthétique de visibilité package-private.

On distingue toutefois quatre grands types de classes internes :

• les classes internes statiques (static nested classes), qui correspondent à de simples classes déclarées à l'intérieur d'une autre classe ;
• les classes internes (inner classes), qui conservent un lien fort avec une instance de la classe conteneur ;
• les classes locales, déclarées dans une méthode, et qui ne sont valides qu'à l'intérieur de ce bloc.
• les classes anonymes, déclarées en ligne dans le code.
  

1
2
3
4
5
6
7
8
9
10
public class TopLevelClass { 
    private String privateField; 
  
    public static class StaticNestedClassComparator implements Comparator<TopLevelClass> { 
        public int compare(TopLevelClass o1, TopLevelClass o2) { 
            // On accède directement aux champs privés : 
            return o1.privateField.compareTo(o2.privateField); 
        } 
    } 
}

TopLevelClass.StaticNestedClassComparator instance = new TopLevelClass.StaticNestedClassComparator();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class TopLevelClass { 
    private String privateField; 
  
    public class InnerClassRunnable implements Runnable { 
        public void run() { 
            // On peut accéder directement aux champs privés de l'instance lié : 
            System.out.println(TopLevelClass.this.privateField); 
        } 
    } 
  
    public InnerClassRunnable create() { 
        // On crée une instance de l'inner-class qui sera liée avec l'instance courante (this) 
	return new InnerClassRunnable(); 
    } 
}

1
2
TopLevelClass topLevelInstance = new TopLevelClass(); 
TopLevelClass.InnerClassRunnable innerInstance = topLevelInstance.new InnerClassRunnable();

1
2
3
4
5
6
7
8
9
10
11
12
public class InnerClassRunnable implements Runnable { 
    final TopLevelClass topLevelClass; 
  
    public InnerClassRunnable(TopLevelClass topLevelClass) { 
        this.topLevelClass = topLevelClass; 
    } 
  
    public void run() { 
        // On peut accéder directement aux champs privés de l'instance liée : 
        System.out.println(topLevelClass.privateField); 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void main(final String[] args) throws Exception { 
    // Déclaration de la classe au sein d'une méthode : 
    class LocalClass { 
        public void sayHello() { 
            System.out.println("Hello World"); 
        } 
    } 
  
    LocalClass c1 = new LocalClass(); 
    LocalClass c2 = new LocalClass(); 
  
    c1.sayHello(); 
    c2.sayHello(); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static void main(final String[] args) throws Exception { 
  
    // Implémentation d'une interface : 
    Runnable task = new Runnable() { 
        public void run() { 
            System.out.println("Hello World"); 
        } 
    }; 
  
    // Héritage d'une classe : 
    Thread thread = new Thread() { 
        public void run() { 
            System.out.println("Hello World"); 
        } 
    }; 
  
    thread.start(); 
    new Thread(task).start(); 
}

Une interface représente un contrat passé entre plusieurs classes (polymorphisme). En général mais pas toujours, l'interface porte un nom de type adjectif compose autour du suffixe able qui signifie « capable de », ce qui permet de préciser les aptitudes complémentaires d'une classe. Par exemple :

• Runnable = capable d'être exécuté  ;
• Drawable = capable de s'afficher.
  

• découper, de manière à la fois élégante et très puissante, l'aptitude (contrat) de l'implémentation.
  
  Par exemple l'interface Enumeration permet de parcourir un ensemble d'objets d'un bout à l'autre sans se préoccuper de l'implémentation sous-jacente (un tableau, une table de hachage, une collection, etc.). En effet il suffit de faire une boucle :
  
  

  Code Java :

  Sélectionner tout

  1
  2
  3
  4
  while (Enumeration e = ...; e.hasNextElement(); ) { 
          MonObjet o = (MonObjet)e.next(); 
          // Faire qqc avec o 
  }

• de bien séparer les activités, et d'améliorer ainsi la lecture du code.
  
  En effet, la seule lecture de la déclaration de la classe nous permet de prendre connaissance de l'intégralité des activités de celle-ci. Par exemple une classe, disons Ensemble qui implémente l'interface Sortable nous renseigne dès sa déclaration sur la notion d'aptitude au tri qui lui a été attribuée.
  

1
2
3
public interface Sortable { 
    void sort(); 
}

1
2
3
4
5
6
public class MaListe implements Sortable { 
    @Override 
    public void sort() { 
        // Code du tri ici. 
    } 
}

1
2
3
4
5
6
Sortable monSortable = new Sortable() { 
    @Override 
    public void sort() { 
        // Code du tri ici. 
    } 
}

1
2
3
public interface Constants { 
    public static final double PI2 = 2*Math.PI; 
}

1
2
3
4
5
6
7
public interface Localizable { 
    String getDisplayName(Locale locale); 
  
    default String getDisplayName() { 
        return getDisplayName(Locale.getDefault()); 
    } 
}

• Pour en savoir plus sur la notion d'interface, outre les tutoriels Java, il est conseillé de chercher de l'information autour des design patterns.
• Pour mieux comprendre la notion de séparation des activités, il peut être intéressant de lire les documentations concernant jakarta-avalon .
  

Java permet de sauvegarder l'état d'un objet à un instant donné dans un flux d'octets. On dirigera généralement ce flux dans un fichier pour effectuer une sauvegarde. Le principal avantage de la sérialisation, c'est d'être complètement intégré à l'API Java et donc de ne nécessiter presque aucun code supplémentaire.

Lorsqu'on redéfinit une méthode d'une classe parente, ou lors de l'implémentation d'une méthode d'une classe abstraite ou d'une interface, on doit obligatoirement conserver la signature exacte de la méthode d'origine : c'est le contrat que l'on doit respecter. Toutefois, il n'est pas figé et il est donc possible de modifier certains éléments. Pour cela, nous allons prendre la déclaration de la méthode suivante en exemple :

protected Number getValue(int value) throws IOException;

1. La portée de la méthode : il est en effet possible de changer la portée de la méthode, à condition de l'élargir. Ainsi, une méthode protected peut devenir public alors qu'une méthode sans modificateur (visibilité limitée au package) pourra devenir protected ou public... Cela est possible, car le contrat de la méthode originale est respecté (on se contente d'étendre l'accès à la méthode).
   
   Par contre, l'inverse reste interdit ! Il est impossible de passer une méthode public en protected ou private par exemple.
   
   Ainsi, la méthode ci-dessous est tout à fait valable :
   
   

   Code Java :

   Sélectionner tout

   public Number getValue(int index) throws IOException;

2. Les Exceptions retournées : il est possible de modifier la déclaration des exceptions renvoyées par la méthode, tant que l'on respecte celle de la méthode parente. Il est donc possible de :
   
   
   • supprimer l'exception : en effet, en ne renvoyant pas d'exception, on respecte le contrat original, car le mot-clé throw signifie « la méthode peut renvoyer une exception », mais ce n'est pas une obligation ;
   • spécialiser le type de l'exception : en indiquant par exemple une exception qui hérite de celle définie dans la signature de la méthode parente.
     
   
   Ainsi, les deux méthodes suivantes sont valables (puisque FileNotFoundException et ZipException héritent de IOException) :
   
   

   Code Java :

   Sélectionner tout

   protected Number getValue(int value);

   Code Java :

   Sélectionner tout

   protected Number getValue(int value) throws FileNotFoundException, ZipException;

3. La covariance du type de retour : depuis la version 5.0, Java apporte une nouvelle possibilité : on peut désormais modifier le type de retour de la méthode. Toutefois, il faut que le nouveau type hérite du type de retour d'origine afin de ne pas rompre le contrat.
   
   Ainsi, notre méthode pourrait retourner un Long (puisque Long hérite de Number) :
   
   

   Code Java :

   Sélectionner tout

   protected Long getValue(int value) throws IOException;

1
2
3
4
5
public Double getValue(int value); 
  
protected Long getValue(int value) throws FileNotFoundException, ZipException; 
  
[...]

La surcharge (ou encore overload) est le fait de déclarer plusieurs méthodes avec le même nom, mais avec des paramètres et/ou types de retour différents.

Une méthode qui surcharge une autre doit obligatoirement :

• avoir le même nom de la méthode surchargée ;
• être déclarée dans la même classe ou dans une classe fille ;
• avoir une signature différente : paramètres différents en nombre, en types ou en ordre de ceux de la méthode surchargée.
  

1
2
3
4
5
6
7
8
9
public class Salutation { 
    public void disBonjour() { 
        System.out.println("Bonjour inconnu !"); 
    } 
  
    public void disBonjour(String nom) { 
        System.out.println("Bonjour "+nom+" !"); 
    } 
}

1
2
3
Salutation salutation = new Salutation(); 
salutation.disBonjour(); 
salutation.disBonjour("Développeur");

1
2
Bonjour inconnu ! 
Bonjour Développeur !

Un getter (du verbe anglais to get signifiant obtenir) est le surnom d'une méthode en accès public qui permet de récupérer la valeur d’un membre ou d'une propriété private ou protected d'un objet. Le but d'un getter est d'encapsuler l’accès à ce membre ou propriété, par exemple en cachant le fait que le résultat peut provenir d'un appel à une autre méthode ou même d'un sous-objet plutôt que d'un membre ou en s'assurant qu'on retourne un objet en lecture seule ou une copie lorsque la valeur de retour est de type complexe de manière à ne pas pouvoir permettre les effets de bord.

Cette méthode n'a généralement pas de paramètre d'entrée et retourne une valeur du même type que le membre. Selon la convention, ces méthodes sont écrites sous la forme get<Nom de la propriété avec la première lettre en majuscule>() ou, pour les valeurs booléennes, is<Nom de la propriété avec la première lettre en majuscule>().

Par exemple :

• boolean isEnabled() - retourne le statut « activé » du contrôle ;
• int getChildCount() - retourne le nombre d’éléments enfants ;
• String getPhoneNumber() - retourne le numéro de téléphone ;
• etc.
  

Un setter (du verbe anglais to set signifiant définir) est le surnom d'une méthode en accès public qui permet de spécifier la valeur d’un membre ou d'une propriété private ou protected d'un objet. Le but d'un setter est d'encapsuler l’accès direct à ce membre ou propriété, et de permettre de faire, par exemple, des vérifications sur la validité des valeurs qui sont affectées à la propriété, de pouvoir positionner des valeurs par défaut lorsque des valeurs non viables sont passées en paramètre ou de pouvoir générer des exceptions si besoin. Cela permet également de lancer une action dans l'objet lui-même suite au changement de valeur ou même de lancer une notification de modification à tout observateur intéressé en utilisant l'API d’évènements.

Cette méthode n'a pas de valeur de sortie et prend en argument en général un seul paramètre du même type que le membre. Selon la convention, ces méthodes sont écrites sous la forme set<Nom de la propriété avec la première lettre en majuscule>().

Par exemple :

• void setEnabled(boolean value) - définit si le contrôle est activé ;
• void setChildCount(int value) - définit le nombre d’éléments enfants ;
• void setPhoneNumber(String valeur) - définit le numéro de téléphone ;
• etc.
  

Les Generics (ou types paramétrés) permettent de s'abstraire du type réel des objets lors de la conception d'une classe ou d'une méthode tout en conservant un code sécurisé. En effet, contrairement au polymorphisme tel qu'il était utilisé jusque là dans Java, les Generics permettent de définir le type réel des objets lors de leurs utilisations, et permettent ainsi de s'affranchir des multiples cast peu pratiques et dangereux en cas de mauvaise utilisation. Ainsi, les Generics augmentent la sécurité en reportant à la compilation des erreurs qui survenaient à l'exécution...

Prenons pour exemple l'utilisation des collections de Java, avec une méthode qui permet de calculer la moyenne d'une List de Float :

1
2
3
4
5
6
7
8
9
public float moyenne (List listNote) { 
    float moyenne = 0.f; 
    Iterator iterator = listNote.iterator(); 
    while (iterator.hasNext()) { 
        Float note = (Float) iterator.next(); 
        moyenne += note.floatValue(); 
    } 
    return moyenne/listNote.size(); 
}

1
2
3
4
5
6
7
8
9
public float moyenne (List<Float> listNote) { 
    float moyenne = 0.f; 
    Iterator<Float> iterator = listNote.iterator(); 
    while (iterator.hasNext()) { 
        Float note = iterator.next(); 
        moyenne += note.floatValue(); 
    } 
    return moyenne/listNote.size(); 
}

1
2
3
4
5
6
7
public float moyenne (List<Float> listNote) { 
    float moyenne = 0.f; 
    for (float note : listNote) { 
        moyenne += note; 
    } 
    return moyenne/listNote.size(); 
}

L'auto-boxing gère la transformation des types primitifs (boolean, byte, char, short, int, long, float, double) vers la classe wrapper correspondante (Boolean, Byte, Character, Short, Integer, Long, Float, Double) et inversement pour l'auto-unboxing.

Tout est transparent, il n'y a donc plus aucune conversion explicite. Ainsi, le code suivant est tout à fait correct :

1
2
3
4
5
6
7
8
9
10
Integer integer = 0;// Integer integer = new Integer(0); 
int j = integer;// int j = integer.intValue(); 
  
Map map = new HashMap(); 
map.put ( 2.1, "Valeur" );// map.put (new Double(2.1), "Valeur"); 
  
List list = new ArrayList(); 
list.add (true);// list.add (new Boolean(true)); 
  
[...]

1
2
Integer value = null; 
int i = value; // Génère une NullPointerException.

Les annotations permettent de poser des « marqueurs » sur divers éléments du langage. Elles peuvent ensuite être utilisées par le compilateur ou d'autres outils de gestions des sources afin d'automatiser certaines tâches, voire directement pendant l'exécution de l'application...

Dans le code source, les annotations se distinguent par la présence d'une arobase (@) devant leur nom (à l'instar des tags Javadoc), et elles se déclarent avec le mot-clé @interface :

1
2
public @interface SimpleAnnotation { 
}

1
2
3
4
public @interface AttributAnnotation { 
    String value(); 
    int count(); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@SimpleAnnotation 
public class MaClasse { 
  
@SimpleAnnotation 
protected String name; 
  
@SimpleAnnotation protected int value; 
  
@AttributAnnotation(value="info", count=3); 
public MaClasse () { 
} 
  
@SimpleAnnotation 
@AttributAnnotation(value="m", count=1); 
public void method () { 
}

• @Deprecated - qui permet d'indiquer qu'un élément est déprécié et ne devrait plus être utilisé ;
• @Override - à placer devant une méthode permet d'indiquer qu'elle surcharge une méthode héritée de la classe parent ;
• @SuppressWarnings - permet d'ignorer certains warnings lors de la compilation.
  

• @Documented - permet d'indiquer que l'annotation doit figurer dans la documentation générée par javadoc ;
• @Inherited - indique que l'annotation doit être héritée par les classes filles ;
• @Retention - spécifie de quelle manière l'annotation doit être conservée par le compilateur et la JVM ;
• @Target - permet de limiter les éléments du langage qui peuvent prendre cette annotation.
  

Une enum représente un type énuméré, c'est-à-dire un type qui n'accepte qu'un ensemble fini d'éléments. Ce type permet donc de créer simplement des énumérations.

Utilisation
Dans sa forme la plus basique, une enum contient simplement la liste des valeurs possibles qu'elle peut prendre. Elle se déclare comme une classe, mis à part que l'on utilise le mot-clé enum, par exemple :

1
2
3
public enum Season { 
    spring, summer, automn, winter; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public enum Season { 
    spring("Printemps"), summer("Eté"), automn("Automne"), winter("Hiver"); 
  
    protected String label; 
  
    /** Constructeur */ 
    Season(String pLabel) { 
        this.label = pLabel; 
    } 
  
    public String getLabel() { 
        return this.label; 
    } 
}

1
2
Season season = Season.winter; 
System.out.println(season.getLabel());

Season s = new Season("Hiver"); // Code invalide, ne compile pas.

• values() - cette méthode retournera un tableau du type de l'enum avec toutes les valeurs définies dans cette dernière. Par exemple :
  

  Code Java :

  Sélectionner tout

  Season[] seasons = Season.values();

• valueOf(String) - cette méthode retournera la valeur de l'enum dont le nom est passé en paramètre. Par exemple :
  

  Code Java :

  Sélectionner tout

  Season season = Season.valueOf("spring") //Retournera Season.spring.

  
  Attention : une exception de type IllegalArgumentException sera générée si la valeur passée en paramètre ne correspond pas à une valeur définie dans l'enum.
  

• ordinal() - cette méthode retournera l'index auquel cette valeur de l'enum a été déclarée dans le code. Il s'agit également de l'index de cette valeur dans le tableau retourné par la méthode statique values(). Par exemple :
  

  Code Java :

  Sélectionner tout

  1
  2
  3
  4
  int springIndex = Season.spring.ordinal(); // Vaut 0. 
  int summerIndex = Season.summer.ordinal(); // Vaut 1. 
  int automnIndex = Season.automn.ordinal(); // Vaut 2. 
  int winterIndex = Season.winter.ordinal(); // Vaut 3.

  Attention : ces valeurs sont valides tant que l'ordre originel de déclaration est préservé dans l'enum.
• name() - cette méthode renvoie la valeur de l'enum sous forme de String. Par exemple :
  

  Code Java :

  Sélectionner tout

  1
  2
  3
  4
  String springName = Season.spring.name(); // Vaut "spring". 
  String summerName = Season.summer.name(); // Vaut "summer". 
  String automnName = Season.automn.name(); // Vaut "automn". 
  String winterName = Season.winter.name(); // Vaut "winter".

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public void method (Season season) { 
    switch (season) { 
        case spring: 
            System.out.println("Les arbres sont en fleurs !!!"); 
            break; 
        case summer: 
            System.out.println("Il fait chaud !!!"); 
            break; 
        case automn: 
            System.out.println("Les feuilles tombent..."); 
            break; 
        case winter: 
            System.out.println("Il neige !!!"); 
            break; 
    } 
}

Une constante est un attribut static final qui respecte certaines conditions :

• il doit correspondre à un type primitif (boolean, byte, char, int, long, float ou double) ou au type spécial String ;
• sa valeur doit être directement affectée en ligne à la déclaration de l'attribut ;
• sa valeur doit pouvoir être évaluée par le compilateur, c'est-à-dire qu'elle ne doit pas comporter de code dynamique (appel de méthode ou utilisation de variables), mais de simples opérations sur des constantes.
  

1
2
3
4
5
6
public static final char CHAR = 'C'; 
public static final double RAYON = 15.0; 
public static final double AIRE = Math.PI * RAYON * RAYON; 
  
public static final String HELLO = "Hello"; 
public static final String HELLO_WORLD = HELLO + " World";

1
2
3
4
5
6
7
8
9
10
11
12
public static final char CHAR = Character.valueOf('C'); // Appel d'une méthode. 
public static final double RANDOM = Math.random(); // Appel d'une méthode. 
public static final Object OBJECT = "Object"; // Type incorrect (Object). 
  
public static final String HELLO = new String("Hello"); // Utilisation d'un constructeur. 
public static final String HELLO_WORLD = HELLO + " World"; // HELLO n'est pas une constante. 
  
public static final String  VALUE; // Pas d'initialisation. 
  
static { 
    VALUE = "Value"; 
}

System.out.println(Constante.HELLO + " World");

System.out.println("Hello" + " World");

System.out.println("Hello World");

Les membres d'une classe (c'est-à-dire ses attributs, constructeurs ou méthodes) peuvent être marqués en tant que « synthetic » par le compilateur pour indiquer qu'il s'agit d'un élément qui a été introduit par le compilateur et qui n'est donc pas directement présent dans le code source original de la classe.

La plupart du temps les membres synthetic sont générés lors de l'utilisation de classes internes, par exemple :

• une classe interne non static se verra ajouter un attribut référençant l'instance de la classe parente avec laquelle elle est liée ;
• lorsqu'une classe interne accède à une méthode ou un attribut privé de la classe parente, le compilateur ajoutera et utilisera en réalité une méthode d'accès de visibilité « package-only » dans la classe parente ;
• lorsqu'une classe interne accède à un constructeur privé de la classe parente, le compilateur génèrera en fait un autre constructeur de visibilité « package-only ».
  

Les méthodes bridges sont des méthodes « synthetics » générées par le compilateur sous certaines conditions lors de l'implémentation ou la redéfinition de méthodes paramétrées par les Generics, et que l'on spécifie un type particulier.

Prenons l'exemple d'une classe qui implémente l'interface Comparator<T> en utilisant le type String :

1
2
3
4
5
public class StringIgnoreCaseComparator implements Comparator<String> { 
    public int compare(String o1, String o2) { 
        return o1.compareToIgnoreCase(o2); 
    } 
}

1
2
3
4
5
6
7
8
9
10
public class StringIgnoreCaseComparator implements Comparator<String> { 
    public int compare(String o1, String o2) { 
        return o1.compareToIgnoreCase(o2); 
    } 
  
    // Méthode bridge créée par le compilateur : 
    public int compare(Object o1, Object o2) { 
        return compare((String)o1, (String)o2); 
    } 
}

Dans le langage, on ne peut spécifier qu'un type pour un paramètre. Ainsi, si une méthode doit utiliser des objets qui implémentent deux interfaces, on ne peut en utiliser qu'un seul dans la définition de la méthode, ce qui oblige à un cast potentiellement dangereux à l'exécution :

1
2
3
4
5
public void method(Serializable data) { 
    Comparable cData = (Comparable) data; // throw ClassCastException 
    // Traitement ici 
    [...] 
}

1
2
3
4
5
public <T extends Serializable & Comparable<T>> void method(T data) { 
    // 'data' implémente les interfaces Serializable et Comparable 
    // Traitement ici 
    [...] 
}

Connues précédemment sous le nom de Single Abstract Method interfaces (SAM Interfaces), les interfaces fonctionnelles introduisent les interfaces qui possèdent uniquement une seule méthode d’instance abstraite. Les plus connues sont java.lang.Runnable, java.awt.event.ActionListener, java.util.Comparator. Dès lors qu'une interface possède une seule méthode d’instance abstraite, elle est désignée comme interface fonctionnelle.

Il est aussi possible d'annoter l'interface par @FunctionalInterface. Si une interface est annotée ainsi et possède plus d'une méthode d’instance abstraite, une erreur de compilation sera produite. C'est un peu le même principe qu'avec l'annotation @Override.

L'interface ci-dessous, Runnable possède une méthode et est annotée @FunctionalInterface :

1
2
3
4
@FunctionalInterface 
public interface Runnable { 
    void run(); 
}

Les lambdas ont été introduits dans la version 8 de Java. Décrite depuis la JSR 335, cette fonctionnalité permet d'apporter la puissance de la programmation fonctionnelle dans Java. Une expression lambda peut être assimilée à une fonction anonyme, ayant potentiellement accès au contexte (variables locales et/ou d'instance) du code appelant. Ces « fonctions anonymes » peuvent être affectées dans une interface fonctionnelle. Le code de l’expression lambda servira ainsi d’implémentation pour la méthode abstraite de l’interface. On peut donc les utiliser avec n'importe quel code Java utilisant une telle interface, à condition que la signature de la méthode corresponde à celle de l’expression lambda.

La syntaxe utilisée est la suivante : (paramètres) -> code ou (paramètres) -> { code } quand il y a plus d'une instruction.

Prenons l'exemple du tri des éléments d'une collection.

1
2
3
4
5
6
Arrays.sort(testStrings, new Comparator<String>() { 
    @Override 
    public int compare(String s1, String s2) { 
        return(s1.length() - s2.length()); 
    } 
});

1
2
3
4
5
6
7
8
9
// Forme longue : 
Arrays.sort(testStrings, (String s1, String s2) -> { return s1.length() – s2.length(); }); 
  
// Forme courte (possible uniquement s’il n’y a qu’une instruction) : 
Arrays.sort(testStrings, (String s1, String s2) -> s1.length() – s2.length()); 
  
// Forme courte avec type implicite des paramètres 
// (le type est déduit par le compilateur via l’inférence) 
Arrays.sort(testStrings, (s1, s2) -> s1.length() – s2.length());

Runnable r1 = () -> System.out.println("My Runnable");

Une référence de méthode est utilisée pour définir une méthode en tant qu’implémentation de la méthode abstraite d’une interface fonctionnelle. La notation utilise le nom de la classe ou une instance de la classe, suivi de l'opérateur :: et du nom de la méthode à référencer. Le type des paramètres sera déduit du contexte selon l’interface fonctionnelle vers laquelle on affecte la référence.

On peut distinguer quatre types de méthodes références :

• les références vers une méthode statique, qui s’utilisent toujours avec le nom de la classe en préfixe. La signature de la référence correspond alors à la signature de la méthode.
  

  Code Java :

  Sélectionner tout

  1
  2
  Supplier<Double> random = Math::random; 
  double result = random.get(); // Math.random();

• les références vers une méthode d’instance, liées à une instance spécifique, qui s’utilisent toujours avec l’instance en préfixe. Ici également, la signature de la référence correspond à la signature de la méthode, et tous les appels s’appliqueront sur l’instance définie dans la référence de méthode :
  

  Code Java :

  Sélectionner tout

  1
  2
  3
  Random r = new Random(); 
  Supplier<Double> random2 = r::nextDouble; 
  double result2 = random2.get(); // r.nextDouble();

• les références vers une méthode d’instance, mais sans lien avec une instance précise. Comme pour les méthodes statiques, on utilisera comme préfixe le nom de la classe. La signature de la référence correspond alors à la signature de la méthode, précédée par un argument du type de la classe, qui correspondra à l’instance sur laquelle on appellera la méthode :
  

  Code Java :

  Sélectionner tout

  1
  2
  3
  4
  5
  6
  7
  Function<Random,Double> random3 = Random::nextDouble; 
  Random r1 = new Random(); 
  Random r2 = new Random(); 
  Random r3 = new Random(); 
  double result1 = random3.apply(r1); // r1.nextDouble(); 
  double result2 = random3.apply(r2); // r2.nextDouble(); 
  double result3 = random3.apply(r3); // r2.nextDouble();

• enfin, il est possible de référencer un constructeur en utilisant le mot-clé new comme nom de méthode. Très pratique pour créer une fabrique :
  

  Code Java :

  Sélectionner tout

  1
  2
  Function<String, Thread> factory = Thread::new; 
  Thread t = factory.apply("name"); // new Thread("name");

1
2
3
4
5
6
7
8
9
10
11
Random r = new Random(); 
  
Supplier<Double> random = Math::random; 
Supplier<Double> random2 = r::nextDouble; 
Function<Random,Double> random3 = Random::nextDouble; 
Function<String, Thread> factory = Thread::new; 
  
Supplier<Double> random = () -> Math.random(); 
Supplier<Double> random2 = () -> r->nextDouble(); 
Function<Random,Double> random3 = (Random random) -> random.nextDouble(); 
Function<String, Thread> factory = (String name) -> new Thread(name);

Une méthode par défaut (Defender Methods) permet de proposer une implémentation dite « par défaut » aux méthodes déclarées dans les interfaces. Par conséquent, depuis Java 8, une interface Java contient du code. L'avantage est de pouvoir faire évoluer les interfaces sans avoir à tout casser.

Dans l'exemple ci-dessous, une interface Person déclare deux méthodes. La méthode sayHello() est dite par défaut via le mot-clé default. Toute implémentation de Person imposera que la méthode sayGoodBye() soit implémentée. Pour sayHello(), l'implémentation ne sera pas obligatoire, même si elle reste bien sûr possible.

1
2
3
4
5
6
7
8
interface Person { 
  
    void sayGoodBye(); 
  
    default void sayHello() { 
        System.out.println("Hello there!"); 
    } 
}

Un objet immuable est un objet dont on ne peut plus modifier l'état une fois l'instance créée.

La classe String est l'exemple le plus utilisé d'objet immuable : il n'est pas possible de modifier une chaine de caractères. Toutes les méthodes de la classe ou même l'opérateur + qui lui sont appliqués retournent en fait une nouvelle chaine distincte de la première.

Prenons, par exemple, le code suivant :

1
2
3
String maChaine = "Test par Moi"; 
maChaine.toUpperCase(); 
System.out.println(maChaine);

1
2
3
String maChaine = "Test par Moi"; 
maChaine = maChaine.toUpperCase(); 
System.out.println(maChaine);

En informatique, et en représentation binaire, on groupe les bits par paquet de 8 (un octet ou byte). On note traditionnellement les bits de poids fort (ceux avec la plus grande puissance de 2) sur la gauche et les bits de poids faible (ceux avec la plus faible puissance de 2) sur la droite.

Par exemple :

2726252423222120

00000011 ↔ 21 + 20 ↔ 2 + 1 ↔ 3

• sur les architectures IBM, Cray, Sun, etc., on a tendance à agencer les bits de la manière suivante :
  
  

  Code Console :

  Sélectionner tout

  231230229228227226225224 223222221220219218217216 2152142132122112102928 2726252423222120

  
  Soit :
  
  

  Code :

  Sélectionner tout

  Octet31-24 Octet23-16 Octet15-8 Octet7-0

  Ici, les octets de poids fort sont à gauche, tandis que les octets de poids faible sont à droite.
• tandis que, sur les architectures Intel, on a tendance à agencer les bits de la manière suivante :
  
  

  Code Console :

  Sélectionner tout

  2726252423222120 2152142132122112102928 223222221220219218217216 231230229228227226225224

  
  Soit :
  
  

  Code :

  Sélectionner tout

  Octet7-0 Octet15-8 Octet23-16 Octet31-24

  Ici, les octets de poids faible sont à gauche, tandis que les octets de poids fort sont à droite.
  

• Big-Endian (gros-boutiste ou grand-boutien) - les octets de poids fort sont à gauche : architecture IBM, CRAY, Sun, etc. ;
• Little-Endian (petit-boutiste ou petit-boutien) - les octets de poids faible sont à gauche : architecture Intel.
  

1
2
3 sur une machine gros-boutiste  ↔ 00000000 00000000 00000000 00000011 ↔ 50331648 sur une machine petit-boutiste. 
3 sur une machine petit-boutiste ↔ 00000011 00000000 00000000 00000000 ↔ 50331648 sur une machine gros-boutiste.

Un singleton est un objet qui ne peut être instancié qu'une seule et unique fois dans le programme.
Pour transformer une classe en singleton, il faut passer les constructeurs en accès private et ajouter au code une instance et un accesseur statiques :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Singleton { 
  
    private static Singleton instance = new Singleton(); 
  
    public static Singleton getInstance() { 
        return instance; 
    } 
  
    private Singleton() { 
        //constructeur 
    } 
  
    //reste de la classe 
  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Singleton { 
  
    private static Singleton instance = null; 
  
    public static Singleton getInstance() { 
        if(instance == null) 
            instance = new Singleton(); 
        return instance; 
    } 
  
    private Singleton() { 
        //constructeur 
    } 
  
    //reste de la classe 
  
}

Singleton s = Singleton.getInstance();

1
2
3
4
5
6
7
8
9
10
11
12
public class Something { 
     private Something() { 
     } 
  
     private static class LazyHolder { 
         private static final Something something = new Something(); 
     } 
  
     public static Something getInstance(){ 
         return LazyHolder.something; 
     } 
}

La méthode equals() permet d'indiquer qu'un objet est égal à un autre. L'implémentation par défaut hérité de Object se contente de renvoyer true lorsqu'il s'agit du même objet en mémoire et ne vérifie pas les valeurs des attributs de la classe (donc x.equals(y) équivaut à x==y).

Dès lors que l'on a besoin de tester l'égalité des instances d'une classe, il faut que cette dernière redéfinisse la méthode equals(). C'est également une condition pour le bon fonctionnement de certaines méthodes des Collections de Java.

La méthode equals() doit donc renvoyer true lorsque deux objets sont identiques, et false dans le cas inverse. Enfin il faut noter que cette méthode ne devrait pas renvoyer d'exception, même si son paramètre vaut null.

En général la méthode equals() se décompose en trois étapes :

• vérification de l'égalité des références : il est inutile de comparer les valeurs si les références sont identiques ;
• vérification du type du paramètre : on ne peut pas comparer n'importe quel type ;
• vérification des valeurs des attributs utiles des deux objets (c'est-à-dire des attributs représentatifs de la valeur de l'objet).
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class TestClass { 
    private int attribut1; 
    private String attribut2; 
    private boolean visible; // Attribut non représentatif et donc ignoré 
  
    @Override 
    public boolean equals(Object obj) { 
        // Vérification de l'égalité des références 
        if (obj==this) { 
            return true; 
        } 
  
        // Vérification du type du paramètre 
        if (obj instanceof TestClass) { 
            // Vérification des valeurs des attributs 
            TestClass other = (TestClass) obj; 
  
            // Pour les attributs de type primitif 
            // on compare directement les valeurs : 
            if (this.attribut1 != other.attribut1) { 
                return false; // les attributs sont différents  
            } 
  
            // Pour les attributs de type objet  
            // on compare dans un premier temps les références  
            if (this.attribut2 != other.attribut2) { 
                // Si les références ne sont pas identiques 
                // on doit en plus utiliser equals() 
                if (this.attribut2 == null || !this.attribut2.equals(other.attribut2)) { 
                    return false; // les attributs sont différents  
                } 
            } 
  
            // Si on arrive ici c'est que tous les attributs sont égaux : 
            return true; 
        } 
  
        return false; 
    } 
}

• Réflection: x.equals(x) devrait toujours retourner true ;
• Symétrie: Si x.equals(y) retourne true,alors y.equals(x) retournera true. ;
• Transitivité: Si x.equals(y) retourne trueet y.equals(z) retourne true,alors x.equals(z) retourne true. ;
• Consistance: Pour deux références x ety, tous les appels à la méthode x.equals(y)devront toujours donner le même résultat.
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public boolean equals(Object obj) { 
    // Vérification de l'égalité des références 
    if (obj==this) { 
        return true; 
    } 
  
    // Vérification du type du paramètre 
    if (obj instanceof TestClass) { 
  
        // Vérification des valeurs des attributs 
        TestClass other = (TestClass) obj; 
  
        return new EqualsBuilder() 
            .append(this.attribut1, other.attribut1) 
            .append(this.attribut2, other.attribut2) 
            .isEquals(); 
    } 
  
    return false; 
}

La méthode hashCode() a pour objectif de fournir un code de hashage, afin d'optimiser le traitement des collections de type Map, qui se basent sur ce hashCode pour classer les données. Il est ainsi nécessaire de redéfinir la méthode hashCode() dès que l'on souhaite utiliser un objet en tant que clé d'une Map.

Mais plus généralement, il est souhaitable de redéfinir la méthode hashCode() lorsque l'on redéfinit la méthode equals(), afin de conserver une certaine cohérence.

En effet, ces deux méthodes sont très liées, puisque les hashCode de deux objets égaux doivent être égaux, ainsi l'on doit vérifier la condition suivante :

Si x.equals(y), alors x.hashCode() == y.hashCode()

Par contre l'inverse n'est pas forcément vrai. Ainsi deux objets différents peuvent avoir le même hashCode(). Toutefois ceci est à éviter dans la mesure du possible, car cela peut détériorer les performances des Map.

Mais le calcul du hashCode() doit rester raisonnable et peu complexe, afin d'éviter des temps de calcul trop importants.

La solution la plus courante est de calculer un hashCode() selon la valeur des attributs utilisés dans la méthode equals() afin de conserver la cohérence entre les deux méthodes.

Pour le calcul du hashCode(), on peut raisonnablement suivre la règle suivante.

• On choisit deux nombres impairs différents de zéro. Un de ces nombres servira comme valeur de départ pour le calcul du hashCode. Le second servira de « multiplieur » à chaque « ajout » du hashCode d'un attribut. Il est préférable d'utiliser des nombres premiers par sécurité.
  

h(x)=[x(1)*B^(l-1) + x(2)*B^(l-2)....+x(l)] mod N

h(x)=x(l) mod N

• Calcul du hashCode de chaque attribut utile (ceux utilisés dans la méthode equals()), ce qui revient à faire (soit 'a' l'attribut) :
  

• Pour un boolean, renvoyer 0 ou 1

  Code java :

  Sélectionner tout

  (a ? 0 : 1)

• Pour type entier (byte, char, short ou int) il suffit de prendre la valeur entière (avec un cast éventuel) :

  Code java :

  Sélectionner tout

  (int)a;

• Pour un type long, le convertir en int en déplaçant les bits :

  Code java :

  Sélectionner tout

  (int) (a^(a>>>32))

• Pour le type float, on le convertit en int avec la méthode Float.floatToIntBits(a).
• Pour le type double, on le convertit en long avec la méthode Double.doubleToLongBits(a), puis on effectue le même traitement que pour les long.
• Pour les objets, on se contentera d'utiliser la méthode hashCode(), ou d'utiliser zéro si la référence est null :

  Code java :

  Sélectionner tout

  (object==null ? 0, object.hashCode())

• Pour un tableau, on traitera tous les éléments de ce dernier en respectant les règles ci-dessus.
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public int hashCode() { 
    // On choisit les deux nombres impairs 
    int result = 7; 
    final int multiplier = 17; 
  
    // Pour chaque attribut, on calcule le hashcode 
    // que l'on ajoute au résultat après l'avoir multiplié 
    // par le nombre "multiplieur" : 
    result = multiplier*result + attribut1; 
    result = multiplier*result + (attribut2==null ? 0 : attribut2.hashCode()); 
  
    // On retourne le résultat : 
    return result; 
}

1
2
3
4
5
6
public int hashCode() { 
    return new HashCodeBuilder(17, 37) 
        .append(this.attribut1) 
        .append(this.attribut2) 
        .toHashCode(); 
}

Un POJO ou Plain Old Java Object (un bon vieil objet Java) est un objet Java tout simple qui ne suit (presque) aucun concept de design ou framework particulier dans sa conception. Ce terme a été inventé par Martin Fowler, Rebecca Parsons et Josh MacKenzie en septembre 2000 alors qu'ils s’étonnaient de l'opposition apparente à l'utilisation d'objets à la conception très simple dans le code et en concluaient, avec humour, que cela venait probablement du fait que de tels objets ne disposaient pas d'une désignation « cool ». Ils sont à mettre en opposition à des objets « lourds » et complexes tels que les Entrerprise Java Beans par exemple.

Donc, pour résumer, un POJO :

• n’hérite pas d'objet préspécifié ;
• n’implémente pas des interfaces préspécifiées ;
• n'utilise pas d'annotation préspécifiée.
  

Pour copier un objet, deux manières de faire s'offrent à vous.

Copie manuelle
Vous pouvez effectuer une copie manuelle de l'objet dans une nouvelle instance, par exemple en le passant dans un constructeur spécialisé (aussi appelé constructeur de copie) de cette classe ou via une méthode de fabrique chargée de dupliquer l'objet. Par exemple ;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Article { 
    private int prix; 
    private int quantite; 
    private String nom; 
  
    /** 
     * Constructeur normal. 
     */ 
    public Article(String nom, int prix, int quantite) { 
        this.prix = prix; 
        this.quantite = quantite; 
        this.nom = nom; 
    } 
  
    /** 
     * Constructeur de copie. 
     */ 
    public Article(Article source) { 
        Objects.requiresNonNull(source); 
        this.prix = source.prix; 
        this.quantite = source.quantite; 
        this.nom = source.nom; 
    }  
}

1
2
Article source = [...] 
Article copie = new Article(source);

1
2
3
4
5
6
7
8
9
public class ArticleDeMarque extends Article { 
  
    private String marque; 
  
    public ArticleDeMarque(String nom, int prix, int quantite, String marque) { 
        super(nom, prix, quantite); 
        this.marque = marque; 
    } 
}

1
2
3
4
5
6
7
Article source = [...] 
Article copie = null; 
if (source instanceof ArticleDeMarque) { 
    copie = new ArticleDeMarque((ArticleDeMarque) source); 
} else { 
    copie = new Article(source); 
}

La méthode clone() est définie directement dans la classe java.lang.Object et est donc accessible depuis n'importe quel objet en Java. Cependant, elle est définie en visibilité protected. De plus, si vous tentez de l'invoquer directement, votre code provoquera une exception de type java.lang.CloneNotSupportedException.

Lorsque vous créez une nouvelle classe que vous désirez pouvoir cloner, vous devez lui faire étendre l'interface de marquage java.lang.Cloneable ; cela permet d’éviter la génération de l'exception. Ensuite vous pouvez surcharger la méthode clone() pour lui donner une visibilité public ce qui permettra de l'invoquer depuis du code externe. Enfin, la covariance permet également de spécifier un type de retour approprié pour la méthode. Par exemple :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Article implements Cloneable { 
  
    private int prix; 
    private int quantite; 
    private String nom; 
  
    public Article(String nom, int prix, int quantite) { 
        this.prix = prix; 
        this.quantite = quantite; 
        this.nom = nom; 
    } 
  
    @Override 
    public Article clone() throws CloneNotSupportedException { 
        // Cet appel créera l'instance de la copie, 
        // et recopiera les valeurs de tous les membres dans cette nouvelle instance. 
        Article copie = (Article) super.clone(); 
        return copie; 
    } 
}

1
2
Article source = [...]; 
Article copie = source.clone();

1
2
Article source = new ArticleDeMarque([...]); 
Article copie = source.clone();

Par défaut, le clonage se contente de recopier les valeurs des membres des types primitifs et des références. Ainsi si notre classe contient une référence vers un objet complexe, c'est la référence de l'objet qui est copiée et non pas l'objet lui-même et donc le clone obtenu détiendra une référence vers la même instance de cet objet. Par exemple :

1
2
3
4
5
6
public class Article implements Cloneable {  
  
    [...] 
  
    private List<Integer> encheres = new LinkedList(); 
}

1
2
Article source = [...] 
article copie =  source.clone();

1
2
3
4
5
6
7
8
@Override  
public Article clone() throws CloneNotSupportedException {  
    Article copie = (Article) super.clone();  
    // On crée une nouvelle liste qui est la copie de la liste source. 
    // Noter que LinkedList utilise un constructeur de copie. 
    copie.encheres = new LinkedList(this.encheres); 
    return copie;  
}