Arnaud Labourel
4 novembre 2019
String get(String[] source, int index) {
// Teste si l'index est dans les limites du tableau.
if (index < 0 || index >= source.length)
return null;
return source[index];
}
Si un commentaire semble nécessaire, le remplacer par une méthode :
Les commentaires se désynchronisent souvent du code :
risque de devenir un jour :
Commentaires inutiles = répétition
Des commentaires qui peuvent sembler utiles :
/* une méthode qui retourne que les carrés : */
List<Rectangle> get(List<Rectangle> list) {
/* le résultat sera stocké dans cette liste : */
List<Rectangle> list2 = new ArrayList<Rectangle>();
for (Rectangle x : list)
if (x.w == x.h /* un carré ? */)
list2.add(x);
return list2;
}
class Rectangle {
public int w; /* largeur */
public int h; /* hauteur */
}
On peut se passer de commentaire en rajoutant une méthode et en nommant correctement les éléments du code.
List<Rectangle> findSquares(List<Rectangle> rectangles) {
List<Rectangle> squares = new ArrayList<Rectangle>();
for (Rectangle rectangle : rectangles)
if (rectangle.isSquare())
squares.add(rectangle);
return squares;
}
class Rectangle {
private int width, height;
boolean isSquare() {
return width == height;
}
}
Documentation ou spécification du comportement d’une méthode :
/**
* Returns <tt>true</tt> if this list contains the
* specified element. More formally, returns
* <tt>true</tt> if and only if this list contains
* at least one element <tt>e</tt> such that
* <tt>(o==null ? e==null : o.equals(e))</tt>.
*
* @param o element whose presence in this list is
* to be tested
* @return <tt>true</tt> if this list
* contains the specified element
*/
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
JavaDoc permet de générer automatiquement une documentation du code à partir de commentaires associés aux classes, méthodes, propriétés, …
La documentation contient :
Un bloc de commentaire Java commençant par /**
deviendra un bloc de commentaire Javadoc qui sera inclus dans la documentation du code source.
Tag | Description |
---|---|
@author | pour préciser l’auteur de la fonctionnalité |
@deprecated | indique que l’attribut, la méthode ou la classe |
est dépréciée | |
@return | pour décrire la valeur de retour |
{@code literal } |
Formate literal en code |
{@link reference } |
permet de créer un lien |
Tools → generate Javadoc
/**
* The {@code Byte} class wraps a value of primitive
* type {@code byte} in an object. An object of type
* {@code Byte} contains a single field whose type is
* {@code byte}.
*
* <p>In addition, this class provides several methods
* for converting a {@code byte} to a {@code String}
* and a {@code String} to a {@code byte}, as well as
* other constants and methods useful when dealing
* with a {@code byte}.
*
* @author Nakul Saraiya
* @author Joseph D. Darcy
*/
En Java, un projet peut être découpé en paquets (package
).
Les paquets permettent de :
Un paquet (package
) :
Java utilise l’arborescence de fichier pour retrouver les fichiers .class
.class
Les .class
du paquet com.univ_amu
doivent :
ClassPath
Le ClassPath
inclut :
-classpath path
)Le mot-clé package
permet de préciser le paquet des classes ou interfaces définies dans le fichier :
Java utilise l’arborescence pour retrouver le code des classes ou interfaces :
MyClass
est cherchée dans le fichier MyClass.java
MyClass.java
est cherché dans le dossier associé au paquet de MyClass
Dans l’exemple précédent, il est donc conseillé que le fichier :
MyClass.java
com/univ_amu
(Par défaut, la compilation crée MyClass.class
dans com/univ_amu
)Accessibilité :
On peut désigner une classe qui se trouve dans un autre paquet :
Vous pouvez également importer une classe :
package com.my_project;
import com.univ_amu.MyClass;
public class Main {
public static void main(String[] args) {
MyClass myClass = new MyClass();
}
}
Deux classes de deux paquets différents peuvent avoir le même nom :
java.util.List
et java.awt.List
Vous pouvez également importer toutes les classes d’un paquet :
package com.my_project;
import com.univ_amu.*;
public class Main {
public static void main(String[] args) {
MyClass myClass = new MyClass();
}
}
Remarques :
java.lang
est importé par défautDepuis Java 5, il est possible d’importer directement des méthodes ou attributs de classes (static
).
La syntaxe est la suivante :
Exemple :
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!");
System.out.println(
"A circle with a diameter of 5 cm has");
System.out.println("a circumference of "
+ (Math.PI * 5) + " cm");
System.out.println("and an area of "
+ (Math.PI * Math.pow(2.5, 2))
+ " sq. cm");
}
}
import static java.lang.Math.PI;
import static java.lang.Math.pow;
import static java.lang.System.out;
public class HelloWorld {
public static void main(String[] args) {
out.println("Hello World!");
out.println(
"A circle with a diameter of 5 cm has");
out.println("a circumference of "
+ (PI * 5) + " cm");
out.println("and an area of "
+ (PI * pow(2.5, 2)) + " sq. cm");
}
}
Le fichier com/univ_amu/HelloWorld.java
:
package com.univ_amu;
public class HelloWorld {
public static void main(String[] arg) {
System.out.println("Hello world ! ");
}
}
$ javac com/univ_amu/HelloWorld.java
$ ls com/univ_amu
HelloWorld.java HelloWorld.class
$ java com.univ_amu.HelloWorld
Hello world !
Nommage des paquets :
com.google.gson
, com.oracle.jdbc
com.univ_amu
Fichier JAR (Java Archive) :
ClassPath
jar
) ou avec un IDEIl est possible de définir une classe à l’intérieur d’une autre (classe imbriquée ou nested class) :
public class LinkedList {
public static class Node {
private String data; private Node next;
public Node(String data, Node next) {
this.data = data; this.next = next;
}
}
}
Il est possible d’instancier la classe interne sans qu’une instance de LinkedList
existe car elle est statique :
Une classe non-imbriquée publique (public
) doit être dans un fichier portant son nom.
Fichier LinkedList.java
⇒ erreur à la compilation :
Une classe imbriquée peut être publique et accessible depuis l’extérieur.
Il est également possible de la rendre privée à la classe LinkedList
:
public class LinkedList {
private static class Node {
private String data;
private /*LinkedList.*/Node next;
public Node(String data, Node next) {
this.data = data;
this.next = next;
}
}
}
Dans ce cas, seules les méthodes de LinkedList
pourront l’utiliser. Notez que des méthodes statiques définies dans LinkedList
peuvent également utiliser cette classe interne du fait qu’elle soit statique.
Exemple d’implémentation de méthodes dans la classe LinkedList
:
Exemple d’utilisation de la classe précédente :
Cet exemple produit la sortie suivante :
[c][b][a]
Une classe imbriquée statique ne peut accéder qu’aux attributs et méthodes statiques de la classe qui la contient :
En revanche, si la classe interne n’est pas statique, elle peut accéder aux champs de classe qui la contient :
Java insère dans l’instance de Node
une référence vers l’instance de LinkedList
qui a permis de la créer :
Il est possible d’utiliser la méthode isFirst
dans LinkedList
:
Exemple d’utilisation de la classe précédente :
Cet exemple produit la sortie suivante :
[c,true][b,false][a,false]