Mots réservés

Certains mots seulement ne sont pas commentés. abstract
boolean
break
byte
byvalue
case
cast
catch
char
class
const
continue
default
do
double
else(if-else pour l'instruction conditionnelle)
enum
extends
false
final
finally
float
for
future
generic
goto
if (if-else pour l'instruction conditionnelle)
implements
import
inner
instanceof
int
interface
long
native
new
null
operator
outer
package
private
protected
public
rest
return
short
static
super
switch
synchronized
this
throw
throws
transient
true
try
var
void
volatile
while

• sortir d'une boucle ; le flux d'exécution continue alors avec l'instruction qui suit la boucle. On aura généralement, dans la boucle, une instruction du type :
      if (condition) break;
• pour sortir d'une instruction par cas (définie avec switch) ; le flux d'exécution continue alors avec l'instruction qui suit l'instruction par cas.

try {
 instructions effectuées;
 instruction ou méthode pouvant
 lancer une exception de la classe MyException;
 instructions effectuées si l'exception n'a pas été lancée;
}
catch(MyException e) {
 instructions effectuées si une instance de
 MyException, a été lancée et donc attrapée;
}

do {
 suite d'instructions
}while (condition);

Une interface peut aussi étendre (grâce à extends) une autre ou plusieurs autres interfaces.
Exemple :
interface Dessinable extends Coloriable, Tracable
{
...
}
Dessinable hérite de toutes les constantes et méthodes abstraites contenues dans Coloriable et Tracable.

• Pour une classe, final indique que la classe ne peut pas être étendue.
• Pour une méthode, final indique que la méthode ne peut pas être redéfinie. Une méthode qui est déclarée static ou private est automatiquement final.
• Pour une donnée, final indique qu'il s'agit d'une constante, d'instance s'il n'y a pas simultanément le modificateur static, et de classe si la donnée est final static. Une donnée final ne pourra être affectée qu'une seule fois.

• soit un "bloc try"
• soit un "bloc try" suivi d'un "bloc catch"

Premier type
Cette boucle suit le schéma suivant :

for (instruction1; condition; instruction2) {
 suite d'instructions
}:

Second type
Cette boucle s'utilise avec un tableau ou bien avec une collection (du type d'une classe qui implémente l'interface java.util.collection, ou une sous-interface de ce type : ArrayList, Vector...). Si T est un tableau d'int, on peut écrire :

for (int t : T) {
 suite d'instructions
} 

Si T est un tableau d'objets d'un type nommé Compte, on peut écrire :

for (Compte c : T) {
 suite d'instructions
} 

Si liste est un ArrayList ou un Vector..., contenant des objets d'un type nommé Compte (ArrayList<Compte> ou Vector<Compte>...), on peut écrire :

for (Compte c : liste) {
 suite d'instructions
} 

Les mots réservés if et else servent à définir une instruction conditionnelle

class MaClasse extends AutreClasse 
 implements UneInterface, UneAutreInterface 

Premier exemple :

coursJava.monPaquet.DansPaquetage UneInstance= 
 new coursJava.monPaquet.DansPaquetage();

DansPaquetage UneInstance= new DansPaquetage();

• regrouper des constantes
• permettre qu'un ensemble de classes, étendant éventuellement d'autres classes, puissent implémenter une même interface. Cela ne serait pas utile si java permettait l'héritage multiple (possibilité d'étendre plusieurs classes à la fois). Un nom d'interface peut être utilisé comme un nom de classe. On pourra donc mettre dans une variable dont le type est une interface n'importe quel objet implémentant l'interface en question. Quelque soit l'objet référencé par la variable, on pourra lui appliquer une méthode déclarée dans l'interface.

Pour créer un nouvel objet, le mot new doit être suivi d'une méthode qui soit un constructeur.
Par exemple, on pourra avoir :

Pour créer un nouveau tableau, on peut par exemple écrire :

• Un attribut déclaré static existe dès que sa classe est évoquée, en dehors et indépendamment de toute instanciation. Quelque soit le nombre d'instanciation de la classe (0, 1, ou plus) un attribut de classe, i.e. statique, existe en un et un seul exemplaire. Un tel attribut sera utilisé un peu comme une variable globale d'un programme non objet.
• Une méthode, pour être de classe (i.e. static) ne doit pas manipuler, directement ou indirectement, des attributs non statiques de sa classe. En conséquence, une méthode de classe ne peut utiliser directement dans son code aucun attribut ou aucune méthode non statique de sa classe ; une erreur serait détectée à la compilation. Autrement dit, une méthode qui utilise (en lecture ou en en écriture) des attributs d'instance ne peut être statique, et est donc nécessairement une méthode d'instance.

synchronized(identificateur)
{
 instruction1;
 instruction2;
 ...
}

class Cercle {
 int x,y, rayon;
 Cercle(int x, int y, int rayon) {
 this.x=x;
 this.y=y;
 this.rayon=rayon;
 }

 Cercle(int x, int y) {
 this(x,y,10);
 }
}

• suivi d'un "bloc finally", les instructions du "bloc finally" sont exécut&eacut;s et la propagation se poursuit ;
• suivi d'un "bloc catch" attrapant les exceptions de la classe de l'exception qui se propage, les instructions du "bloc catch" sont exécutés puis l'exécution reprend son cours normal avec l'instruction qui suit le "bloc finally".

void maMethode throws NumberFormatException, myException {
 ...
 instruction pouvant lancer une erreur de la classe
 NumberFormatException ou myException;
 ...
}

while (condition) {
 suite d'instructions
}

©Irène Charon, Télécom ParisTech 2011