Bases du langage
Syntaxe
* Langage "C-like"
* Pour la partie procédurale, syntaxe similaire au C
* Instructions terminées par ";"
* Commentaires
* "//" pour une seule ligne
* "/*...*/" pour plusieurs lignes
* Opérateurs identiques
* Structures de contrôle identiques
* Sensible à la casse
* Variables fortement typées
* Pour la partie objet, similitudes avec C++
Variables
* Deux types de variables
* Variables primitives
* Représentent une valeur d'un type primitif: int, char, double...
* Variables objets
* Représentent un objet d'une classe donnée
* Toutes les classes héritent de la super-classe "Object"
* Sémantique des variables primitives identique à C / C++
* En revanche, les variables objets sont différentes
* Les variables sont des "références" sur des objets
* Terme "référence" en Java ? terme "référence" en C++
Types primitifs
Equivalence classes et types primitifs (1/2)
* Variable primitive non reconnue comme objet
* Parfois, nécessaire qu'un primitif soit un objet
* Par exemple, un conteneur générique
* Mettre un primitif dans un conteneur d'"Object"
* Il existe une classe équivalente à chaque type primitif
* Exemple: type "int" ? classe "Integer"
* Création d'un objet à partir d'un primitif
* Integer i = new Integer(4);
* Création d'un primitif à partir d'un objet
* int j = i.intValue();
* Création d'un primitif à partir d'une chaîne
* int i = Integer.parseInt("4");
* Remarque: en Java, accès à une méthode de classe par "."
Equivalence classes et types primitifs (2/2)
Référence ou pointeur ? (1/3)
* Passage d'argument par valeur / copie
* Par défaut pour les types primitifs en Java
* Par défaut en C++ (primitif ou objet)
* Exemple C++ / Java
* void f(char x) { x = 12; }
x = 3; f(x);
==> x vaut toujours 3
* Passage d'argument par pointeur
* N'existe pas en Java
* Impossible d'obtenir l'adresse d'une variable
* Possible en C++ (primitif ou objet)
* Exemple C++
* void f(char * x) { *x = 12; }
x = 3; f(&x);
==> x vaut maintenant 12
Référence ou pointeur ? (2/3)
* Passage d'argument par référence
* Par défaut pour les variables objets en Java
* N'existe pas pour les types primitifs
* Possible en C++ (primitif ou objet)
* Exemple C++
* void f(MonObjet & x) { x.setVal(12); }
x.setVal(3); f(x);
==> x.getVal() vaut maintenant 12
* Exemple Java
* void f(MonObjet x) { x.setVal(12); }
x.setVal(3); f(x);
==> x.getVal() vaut maintenant 12
Référence ou pointeur ? (3/3)
* "Référence" en Java = pointeur "caché" au sens C++
* Exemple
* void f(MonObjet x) { x = new MonObjet(12); }
x = new MonObjet(3); f(x);
==> x est toujours l'objet construit avec 3
* Passage par copie des "pointeurs" !
* Preuve qu'il s'agit de pointeurs au sens C++
* Mais pas d'accès possible à l'adresse
Tableaux (1/2)
* En Java, un tableau = un objet
* Impossible de donner la taille à la déclaration
* int [] t;
* int t[];
* Taille fournie au moment de la création
* t = new int[10];
* Comme en C++, "new" crée un objet
* Possibilité de créer un tableau initialisé à sa déclaration
* int t[] = { 1,2,3 };
* Pour connaître la taille du tableau
* int taille = t.length;
Tableaux (2/2)
* Numérotation des éléments à partir de 0
* Seul l'opérateur "[]" permet l'accès à un élément
* Contrairement à C/C++, pas d'arithmétique de pointeur
* Exemple de tableau à deux dimensions
String m[][] = new String[3][4];
int i = 0;
int j;
while (i < 3) {
j = 0;
while (j < 4) {
m[i][j] = new String("case " + i + ";" + j);
++j;
}
++i;
}
Tableaux multidimensionnels
* Tableau à plusieurs dimensions = tableau de tableaux
* Dimensions pouvant être différentes entre sous-tableaux
* Exemple
int m[][] = new int[3][];
int i = 0;
while (i < 3) {
m[i] = new int[5*(i+1)];
j = 0;
while (j < 5*(i+1)) {
m[i][j] = i+j;
++j;
}
++i;
}
Chaînes de caractères (1/2)
* Chaîne statique: classe "String"
* Chaîne dynamique: classe "StringBuffer"
* Création d'une chaîne
* String s = new String("bonjour");
* String t = "bonjour";
* Taille d'une chaîne
* int taille = s.length();
* En Java, une chaîne n'est pas un tableau
* Pas d'opérateur "[]"
* Accès à un caractère
* char c = s.charAt(3);
Chaînes de caractères (2/2)
* Concaténation de chaînes
* String s = t + " toi";
* t += " toi";
* Comparaison de deux chaînes
* Opérateur "==" compare les références des objets
* Méthode "equals" compare les chaînes
* if (s.equals("bonjour")) ...
* Recherche d'une sous-chaîne
* int position = s.indexOf("toi");
* Extraction d'une sous-chaîne
* String toi = s.substring(position,position+3);
Exécution d'une classe
* Exécution classe = exécution de sa méthode "main"
* public static void main(String args[]) { ... }
* Doit être statique, publique et recevoir un tableau de chaînes
* Tableau = arguments de la ligne de commande
* Valeur retournée par le programme: System.exit(?);
* Exemple
public static void main(String args[]) {
for (int x = 0; x < args.length; ++x)
System.out.println("Argument " + x + " " + args[x]);
}
* Exécution
* Ligne de commande: java Exemple a b
* Résultat
Argument 0 = a
Argument 1 = b