Un aide mémoire Java, Cheat Sheet of Java Programming

Ce document contient les notions les plus importantes du langage Java. C'est un résumé très efficace

Typology: Cheat Sheet

2020/2021
On special offer
30 Points
Discount

Limited-time offer


Uploaded on 05/28/2021

chaymae-bena
chaymae-bena 🇲🇦

1 document

1 / 4

Toggle sidebar

This page cannot be seen from the preview

Don't miss anything!

bg1
Variables et expressions
Déclarations de variables
Une variable stocke une valeur de type simple ou de type référence (vers un
tableau ou un objet). Elle doit être déclarée et peut être initialisée dans le même
temps. Plusieurs variables de même type peuvent être déclarées ensemble.
type nomVariable [= valeur];
type nomVar1 [=val], nomVar2 [=val] ... ;
Descriptions des principaux types simples
Type Description Formes des litéraux
int Entiers signés sur 32 bits 1, -3, -26, 2OO8975
double Nombres à virgule flottante double précision
Notation scientifique possible
123.4
-26.0
1.234e2
-2.6e1
boolean Booléen true, false
char Caractère ’a’, ’A’ ’\u0108’
Notations spécifiques pour certains caractères usuels
Code ’\n’ ’\t’ ’\\’ ’\’’ ’\”’ ’\b’
Valeur À la ligne Tabulation Antislash Apostrophe Guillemets Backspace
Expressions et opérateurs
Une expression est une suite d’opérations impliquant variables, littéraux et
appels de méthodes. Son type dépend des opérations et des opérandes.
Listes des opérateurs avec les types possibles des opérandes du résultat
Opérateurs Description Type Opérandes Type Resultat
Math
+, -, *, / Opérations arithmétiques int, double int, double
%Reste de la division int, double int, double
Logique
==, != Égalité, inégalité tout boolean
<, <=, >, >= Comparaison int, double, char boolean
&&, || Et, ou (logique) boolean boolean
!Non (logique) boolean boolean
Binaire
&, |, ^ Opérations bit à bit (et/ou/xor) int int
<<, >>, >>> Décalage de bit signé à gauche
et à droite et non signé à droite int int
^Complément bit à bit int int
Affectation et transtypage
L’affectation stocke le résultat de l’évaluation d’une expression dans une
variable en écrasant la précédente valeur.
nomVariable = expression ; Syntaxe de l’affectation
Le type de l’expression doit être le même que celui de la variable sinon il faut
un transtypage, c’est-à-dire une conversion de type. Dans de rares cas, il peut
être implicite.
(type) expression Syntaxe du transtypage
int i = (int)3.14 ; Exemple de transtypage explicite
double d = 3 ; Exemple de transtypage implicite
Notations raccourcies pour certaines affectations fréquentes
var += q;
c
var = var + q; var -= q;
c
var = var - q;
var *= q;
c
var = var * q; var /= q;
c
var = var / q;
var++;
c
var = var + 1; var--;
c
var = var - 1;
structures de contle
Blocs d’instructions
Description d’un bloc Syntaxe
Groupement d’instructions entouré d’accolades
dont les instructions sont indentées. La portée
(l’utilisation possible) d’une variable commence à
l’endroit où elle est déclarée et finit à la fin du bloc
contenant sa déclaration.
{
instruction;
...
}
Instructions Conditionnelles
Une instruction conditionnelle est un choix entre plusieurs blocs de code selon
une condition.
Description des instructions conditionnelles Syntaxe
if
Le premier bloc est exécuté si condition
est true, le second sinon. Plusieurs blocs
if peuvent être imbriqués. Le bloc else est
optionnel.
if(condition) {
instruction;
...
} else {
instruction;
...
}
switch
L’exécution du bloc commence à l’instruction
suivant le case dont la valeur correspond
à celle de variable et se termine au
premier break rencontré. Si aucun case ne
correspond à la valeur de variable, c’est
après le default que l’exécution commence.
Le type de variable est simple ou String.
switch(variable) {
case val1:
...
break;
case val2:val3:
...
default:
...
}
Boucles
Une boucle est l’exécution répétée (itération) d’un bloc de code selon une
condition. Le tableau suivant répertorie les quatre boucles de JAVA. Pour des
exemples, voir l’affichage des éléments d’un tableau à la page suivante.
Description des boucles Syntaxe
while
Exécution d’un bloc tant que condition est
true.
while(condition) {
instruction;
...
}
do while
Exécution d’un bloc une fois puis tant que
condition est true.
do {
instruction;
...
} while(condition);
for
Exécution d’un bloc tant que cond est true.
En général, la condition repose sur la variable
initialisée à l’entrée de la boucle (init) puis
mise à jour à chaque itération (maj).
for(init; cond; maj) {
instruction;
...
}
for each
Exécution d’un bloc pour chaque valeur
contenue dans iter (un tableau ou objet
implémentant l’interface Iterable). La
variable elt prend toutes les valeurs
contenues dans iter successivement.
for(type elt: iter) {
instruction;
...
}
Les instructions continue et break ne sont pas indispensables et leur
utilisation n’est pas recommandée. continue saute les instructions restantes
dans une itération et passe à la suivante. Les mises à jour de la boucle for sont
effectuées. break force la sortie d’un bloc (switch, for, while, do while).
aide MéMoire JaVa
Petit guide de survie à l’attention
des étudiants de Supélec.
Édition 2014
JAVA 7
Cécile Hardebolle
Christophe Jacquet
Marc-Antoine Weisser
pf3
pf4
Discount

On special offer

Partial preview of the text

Download Un aide mémoire Java and more Cheat Sheet Java Programming in PDF only on Docsity!

V ariables et expressions

Déclarations de variables

Une variable stocke une valeur de type simple ou de type référence (vers un

tableau ou un objet ). Elle doit être déclarée et peut être initialisée dans le même

temps. Plusieurs variables de même type peuvent être déclarées ensemble.

type nomVariable (^) [ = valeur ] ; type nomVar1 (^) [ = val ] , nomVar2 (^) [ = val ] ... ; Descriptions des principaux types simples Type Description Formes des litéraux int (^) Entiers signés sur 32 bits 1, -3, -26, 2OO double Nombres à virgule flottante double précision Notation scientifique possible^ 123.4 -26.0^ 1.234e2 -2.6e boolean (^) Booléen true, false char (^) Caractère ’a’, ’A’ ’\u0108’ Notations spécifiques pour certains caractères usuels Code ’\n’^ ’\t’^ ’\’^ ’\’’^ ’\”’^ ’\b’ Valeur À la ligne Tabulation Antislash Apostrophe Guillemets Backspace

Expressions et opérateurs

Une expression est une suite d’opérations impliquant variables, littéraux et

appels de méthodes. Son type dépend des opérations et des opérandes.

Listes des opérateurs avec les types possibles des opérandes du résultat Opérateurs Description Type Opérandes Type Resultat Math (^) +, -, *, / Opérations arithmétiques int, double int, double % (^) Reste de la division int, double int, double Logique ==, != (^) Égalité, inégalité tout boolean <, <=, >, >= (^) Comparaison int, double, char boolean &&, || (^) Et, ou (logique) boolean boolean ! (^) Non (logique) boolean boolean Binaire &,^ |,^ ^^ Opérations bit à bit (et/ou/xor) int^ int <<, >>, >>> Décalage de bit signé à gauche et à droite et non signé à droite int int ^ (^) Complément bit à bit int int

Affectation et transtypage

L’affectation stocke le résultat de l’évaluation d’une expression dans une

variable en écrasant la précédente valeur.

nomVariable = expression ; Syntaxe de l’affectation

Le type de l’expression doit être le même que celui de la variable sinon il faut

un transtypage , c’est-à-dire une conversion de type. Dans de rares cas, il peut

être implicite.

(type ) expression Syntaxe du transtypage int i = (int)3.14 ; Exemple de transtypage explicite double d = 3 ; Exemple de transtypage implicite Notations raccourcies pour certaines affectations fréquentes var += q;^ c var = var + q; var -= q;^ c var = var - q; var *= q;^ c var = var * q; var /= q;^ c var = var / q; var++;^ c var = var + 1; var--;^ c var = var - 1;

structures de contrôle

Blocs d’instructions

Description d’un bloc Syntaxe

Groupement d’instructions entouré d’accolades

dont les instructions sont indentées. La portée

(l’utilisation possible) d’une variable commence à

l’endroit où elle est déclarée et finit à la fin du bloc

contenant sa déclaration.

instruction; ... }

Instructions Conditionnelles

Une instruction conditionnelle est un choix entre plusieurs blocs de code selon

une condition.

Description des instructions conditionnelles Syntaxe if

Le premier bloc est exécuté si condition

est true, le second sinon. Plusieurs blocs

if peuvent être imbriqués. Le bloc else est

optionnel.

if( condition ) { instruction; ... } else { instruction; ... } switch

L’exécution du bloc commence à l’instruction

suivant le case dont la valeur correspond

à celle de variable et se termine au

premier break rencontré. Si aucun case ne

correspond à la valeur de variable , c’est

après le default que l’exécution commence.

Le type de variable est simple ou String.

switch( variable ) { case val1 : ... break; case val2 :val3: ... default: ... }

Boucles

Une boucle est l’exécution répétée ( itération ) d’un bloc de code selon une

condition. Le tableau suivant répertorie les quatre boucles de JAVA. Pour des

exemples, voir l’affichage des éléments d’un tableau à la page suivante.

Description des boucles Syntaxe while

Exécution d’un bloc tant que condition est

true.

while( condition ) { instruction; ... } do while

Exécution d’un bloc une fois puis tant que

condition est true.

do { instruction; ... } while( condition ); for

Exécution d’un bloc tant que En général, la condition repose sur la variable^ cond^ est^ true.

initialisée à l’entrée de la boucle ( init ) puis

mise à jour à chaque itération (maj).

for( init ; cond ; maj ) { instruction; ... } for each

Exécution d’un bloc pour chaque valeur

contenue dans iter (un tableau ou objet

implémentant l’interface Iterable). La

variable elt prend toutes les valeurs

contenues dans iter successivement.

for( type elt : iter ) { instruction ; ... }

Les instructions continue et break ne sont pas indispensables et leur

utilisation n’est pas recommandée. continue saute les instructions restantes

dans une itération et passe à la suivante. Les mises à jour de la boucle for sont

effectuées. break force la sortie d’un bloc (switch, for, while, do while).

aide MéMoire JaVa

Petit guide de survie à l’attention des étudiants de Supélec. Édition 2014 JAVA 7 Cécile Hardebolle Christophe Jacquet Marc-Antoine Weisser

tableaux

Fonctionnement Général

Un tableau contient un nombre fixe de données de même type. Une variable

ne stocke jamais un tableau mais une référence vers un tableau. La création

d’un tableau s’effectue en deux étapes : déclaration d’une variable stockant

une référence puis allocation en mémoire d’un tableau (mot clef new). Deux

syntaxes existent pour la déclaration.

type [] tab ; Déclaration, syntaxe 1 type tab []; Déclaration, syntaxe 2 tab = new type [ taille ]; Allocation mémoire

Une case d’un tableau est une variable à laquelle on accède avec un indice. La

numérotation des cases commence à 0. La valeur length contient le nombre

de cases d’un tableau.

tab [0] = expression ; Affectation du premier élément tab [ tab .length-1] = expression ; Affectation du dernier élément

Il est possible d’allouer la mémoire et d’initialiser les éléments d’un tableau en

une seule instruction avec l’une des deux notations suivantes.

type [] tab = new type [] { val1, val2... }; type [] tab = { val1, val2... };

Tableau à plusieurs dimensions

Un tableau peut avoir plusieurs dimensions. Pour la déclaration et l’accès aux

cases, la syntaxe est similaire à celle des tableaux à une dimension. Exemple

pour un tableau à deux dimensions avec toutes les lignes de même taille :

type [][] tab = new type [ nbLignes ][ nbColonnes ]; tab [ i ][ j ] = expression ;

Un tableau à plusieurs dimensions est un tableau de tableaux. Il est donc

possible de déclarer un tableau ayant des lignes de tailles différentes. Exemple

d’un tableau triangulaire :

type [][] tab = new type [ nbLignes ][]; for(int i=0; i<tab.length; i++) { tab[i] = new type [i+1]; }

Affichage des éléments d’un tableau

Une variable ne stocke pas un tableau mais une référence dessus. L’instruction

“System.out.println( tab );“ affiche donc uniquement la référence et non

les éléments du tableau. Pour afficher les éléments, on peut utiliser une boucle

ou la méthode toString de la classe Arrays permettant la conversion d’un

tableau en String.

Affichage avec une boucle for Affichage avec une boucle while String s=””; for(int i=0; i<tab.length; i++) { s = s+tab[i].toString()+” ”; } System.out.println(s); String s=””; int i=0; while(i<tab.length) { s = s+tab[i].toString()+” ”; i++; } System.out.println(s); Affichage avec une boucle for-each Affichage par Arrays String s=”” ; for(Object t: tab ) { s = s+t.toString()+” ”; } System.out.println(s); String s=Arrays.toString(tab); System.out.println(s); prograMMation obJet

Généralité sur les classes et objets

Une classe est un moule permettant de créer des objets ( instances ) dont le

type est une classe. Elle inclut la déclaration d’ attributs , de constructeurs et de

méthodes. Les modificateurs précèdant le mot clef class sont des propriétées.

La visibilité restreint l’accès et final rend la classe non dérivable (voir héritage).

[ visibilité ] [ final ] class^ NomClasse^ { ... } Visibilité Classe, attribut ou méthode accessible depuis private la classe uniquement (autorisé uniquement pour les classes de haut niveau, les attributs et les méthodes) non spécifiée toutes classes du package (dit «package-private») protected (^) toutes classes du package et sous-classes public (^) toutes classes

Attributs

Un attribut est une caractéristique d’un objet. Il est déclaré en début de classe.

[ visibilité ] [ static ] [ final ] type^ nomAttribut^ ; Modificateur Propriété de l’attribut final (^) Attribut constant static Un attribut alors une valeur commune pour tous les objets de la classe.^ static^ est associé à la classe plutôt qu’aux objets. Il a

Méthodes

Une méthode est un bloc d’instructions ( corps d’une méthode ) destiné à

réaliser une opération. Elle peut recevoir des paramètres et renvoyer une valeur

de retour. Son nom et le type de ses paramètres forment sa signature. Le type

de la valeur de retour est void si la méthode ne renvoie rien.

[ visibilité ] [ static ] [ final ] type^ nomMethode ( [ type^ param... ] ){ instructions ; } Modificateur Propriété de la méthode final (^) Méthode non surchargeable (voir héritage) static (^) Méthode de classe. Elle ne peut utilser que des attributs static.

Le mot clef return met fin à l’exécution de la méthode. Si une valeur de retour

est attendue, elle doit être indiquée après return.

L’appel d’une méthode de classe (static) est préfixé par le nom de la classe.

NomClasse.nomMethode( val1 , val2... ) ;

L’appel d’une méthode d’instance (abscence du modificateur static) est

préfixé par un objet. Dans le corps de celle-ci, cet objet est désigné par this.

nomObjet.nomMethode( val1 , val2... ) ;

Méthode Main

Une classe est exécutable si elle inclut une méthode main. C’est le point

d’entrée du programme. Les arguments donnés au programme lors de son

lancement sont transmis, sous forme d’un tableau de String, en paramètre

de la méthode main.

public static void main( String[] args ) { ... } prograMMation obJet ( suite )

Constructeur et instanciation

Un constructeur permet d’initialiser des instances. C’est une méthode portant

le nom de la classe et ne renvoyant rien (pas de void). Sa première instruction

peut être super(...) pour appeler un constructeur d’une classe mère (voir

héritage) ou this(...) pour appeler un autre constructeur de la classe.

[ visibilité ] NomClasse (^ type^ param...^ )^ { [ super(...) | this(...) ] instruction ; ... }

Pour créer un objet ( instanciation ), on utilise new suivi du constructeur choisi

pour l’initialisation. La référence sur l’objet peut être stockée dans une variable.

NomClasse variable = new NomClasse ( param1, param2... ) ;

Référence et égalité entre objets

L’opérateur d’égalité “==” teste si deux expressions sont égales. Pour les objets

on teste donc si deux références désignent (physiquement) le même objet.

Pour l’égalité logique, on utilise la méthode equals de la classe Object. Sa

surcharge définit le mode de comparaison des instances d’une classe.

public boolean equals(Object obj) { ... }

Exemple de classe

public class Complexe { private double rho, theta ; public static final Complexe UN = new Complexe(1,0); public static final Complexe I = new Complexe(1,Math.PI/2); public Complexe(double rho, double theta){ this.rho = rho; this.theta = theta; } public double imag(){ return this.rhoMath.sin(this.theta);} public double reel(){ return this.rhoMath.cos(this.theta);} public Complexe division( Complexe c ){ return new Complexe(this.rho/c.rho, this.theta-c.theta); } public String toString(){ return ”<”+this.reel()+”, ”+this.imag()+”>”; } public boolean equals(Object o){ if( !(o instanceof Complexe) ) { return false; } Complexe c=(Complexe)o; return c.rho==this.rho && c.theta==this.theta; } } public class TestComplexe { public static void main( String[] args ) { if( !Complexe.I.equals( Complexe.UN ) ) { System.out.println( ”1 et i sont différents” ); } Complexe u = new Complexe( 1, Math.PI/6 ) ; System.out.println(”u/i : ” + u.division( Complexe.I )); } }

structures de données aVancées

Collection, List et Set

L’interface java.util.Collection regroupe les méthodes génériques

pour la gestion de structures de données. Elle hérite de Iterable. Les

structures l’implémentant peuvent être parcourues avec une boucle for each.

Les interfaces List et Set héritent de Collection. Les classes qui les

implémentent sont respectivement des listes et des ensembles.

Liste (non exaustive) des méthodes définies dans Collection et List Méthode Description Collection boolean add(E e) boolean addAll(Collection c) Insère e (ou les élements de c) et renvoie true si la structure a été modifiée void clear( ) (^) Vide la Collection boolean contains(Object o) boolean containsAll(Collection c) Renvoie true si o ou l’ensemble des éléments de c sont dans la structure boolean isEmpty( ) (^) Renvoie true si la liste est vide boolean remove(Object o) boolean removeAll(Collection c) Supprime une occurrence de o ou de chaque élément de c. Renvoie true si chaque occurrence a été supprimée. int size() (^) Renvoie le nombre d’éléments Object[] toArray() (^) Renvoie un tableau des éléments List boolean void add(^ add(Eint ie), E e) Insère^ e^ en fin de liste. Renvoie^ true Insère e à l’indice i E get(int i) (^) Renvoie l’élément contenu à l’indice i boolean remove(int i) (^) Supprime l’élément à l’indice i List subList(int from, int to) (^) Renvoie la sous liste entre from et to Set boolean add(E e) Insère e s’il n’existe pas d’élément f vérifiant e.quals(f). Renvoie true si le Set a changé.

ArrayList est une implémentation de List construite sur des tableaux.

L’accès aux éléments est rapide à partir de leur indice. Suppression et Insertion

sont plus coûteuses.

HashSet est une implémentation de Set construite sur une table de

hachage. Accès, insertion et suppression sont en temps constant.

Map

L’interface java.util.Map<K,V> est utilisée pour les tableaux d’association

clef-valeur ( dictionnaires ). On insère dans la table une valeur en l’associant à

une clef. Une clef ne peut être associée qu’à une seule valeur. Pour retrouver

une valeur on utilise la clef. La principale implémentation est HashMap<K,V>.

Liste de certaines méthodes définies dans Map Méthode Description void clear() (^) Supprime toutes les associations d’une table boolean containsKey(Object k) (^) Renvoie true si la table contient la clef k boolean containsValue(Object v) (^) Renvoie true si la table contient la valeur v V get(Object k) (^) Renvoie la valeur associé à la clef k ou null boolean isEmpty( ) (^) Renvoie true si la liste est vide Set keySet() (^) Renvoie un ensemble contenant les clefs V put(K k, V v) Insère l’association de la clef k et de la valeur v. Renvoie la précédente valeur associée à k ou null. V remove(Object k) Supprime l’association avec la clef la valeur qui lui était associée ou null^ k. Renvoie int size() (^) Renvoie le nombre d’associations Collection values() (^) Renvoie une collection des valeurs exceptions

Attraper les exceptions

Les exceptions sont des objets héritant de throwable et utililisées pour gérer

les cas d’erreurs d’un programme. Un bloc protégé peut attraper les exceptions

lancées (déclenchées) par les instructions du bloc et les gérer.

Description Syntaxe des exceptions

try{...} : code protégé

catch( Excep1 e ){...} : si le bloc

protégé lève une exception de type

Excep1, elle est stockée dans e et le

bloc associé est exécuté.

catch( Excep2 |...| ExcepN e ){...} :

idem, plusieurs types d’exception.

finally {...} : bloc de code exécuté

quoi qu’il arrive (exception ou non).

try { instructions ; ... } catch( Excep1 e ) { instructions ; ... } catch( Excep2 |...| ExcepN e ) { instructions; ... } finally { ... }

Certains objets (comme les flux) doivent être refermés après leur utilisation.

Lever une exception peut interompre le code qui était destiné à les refermer.

Il est possible de refermer automatiquement les objets implémentant

AutoCloseable en les déclarant entre paranthèses juste après try.

try( AutoCloseableClass a=...) { ... } catch ...

Plutôt que traiter localement une exception, il est possible de déléguer cette

tâche à la méthode appelant la méthode courante. On déclare la méthode

courante comme succeptible de lever certains types d’exceptions. Si le cas

se présente, l’exception levée est relayée à la méthode appelante. La méthode

courante prend fin.

type methode (...) throws Excep1, Excep2, ... { ... }

Créer des exceptions

Une exception est un objet d’une classe héritant de Throwable. Lancer une

exception se fait avec le mot clef throw.

throw new MonException ( ) ;

Lorsqu’une méthode succeptible de lancer une exception n’est pas dans un

bloc protégé, le compilateur engendre une erreur. Dans le cas des exceptions

héritant de Error ou RunTimeException, le bloc n’est pas nécessaire.

Exceptions courantes

Exception Cause NullPointerException Accès à une méthode ou à un attribut depuis une variable référençant null. IndexOutOfBoundException (^) Accès à une case n’existant pas dans un tableau. ClassCastException Transtypage d’un objet dans un type auquel il n’appartient pas.

Quitter un programme

La méthode exit permet de terminer l’exécution d’un programme. Elle

prend en paramètre un statut qui sera renvoyé au système d’exploitation. Par

convention, toute valeur non nulle indique une terminaison anormale.

System.exit( status ) coMMentaires et J aVadoc

Commentaires

Deux syntaxes sont possibles pour les commentaires. La première permet des

commentaire sur une ligne, la seconde sur plusieurs lignes.

// Commentaire d’une ligne /* Commentaire de plusieurs lignes... */

Javadoc

Javadoc est un programme qui permet d’extraire la documentation d’une

bibliothèque (API) depuis les commentaires d’un programme. Il est nécessaire

d’utiliser une syntaxe précise dans les commentaires.

Le fonctionnement est le suivant : on fait précéder chaque déclaration de classe,

d’attribut et de méthode d’un commentaire sur plusieurs lignes débutant par

“/**”. Ce commentaire peut inclure des balises donnant des précisions.

/** Constructeur d’un nombre complexe @param rho valeur du module @param theta valeur de l’angle (en radian) */ public Complexe(double rho, double theta){ this.rho = rho; this.theta = theta; } Liste des balises Javadoc Tags Description @param nom description (^) Description d’un paramètre d’une méthode @return description (^) Description de la valeur de retour d’une méthode @throws type (^) Indique les types d’exceptions pouvant être levés @author nom (^) Nom de l’auteur @version numéro (^) Numero de la version @see reference (^) Renvoie vers une méthode, classe, ... @since date (^) Date d’apparition @deprecated commentaire (^) Indique de ne plus utiliser cet élément et un commentaire À propos

Memento JAVA, version 3, septembre 2014.

Ce memento est un outil d’aide à la programmation. Il tente de regrouper la

syntaxe des principaux concepts de JAVA. Il n’a pas vocation à remplacer un

cours.

La syntaxe utilisée pour décrire les éléments du langage est la suivante :

  • Le code utilise une police particulière : System.exit(0);
  • Les mots clefs de JAVA sont en rouge : int, void, for, public.
  • Les élements optionels sont entourés de grande paranthèses : (^) [ abstract ]
  • Les éléments en italique représentent des noms dépendant du

programmeur : nomVariable , nomClasse , instruction ...

Merci à tous les relecteurs.