Java Tutorial

Write Once, Run Anywhere

Java - General
 Java est :
 un langage de programmation indépendant
de la plate-forme
 similaire à C++ au niveau de la syntaxe
 similaire à Smalltalk dans le paradigme
mental
 Avantages : également omniprésent sur le
net
 Inconvénients : interprété et encore en
développement (cible mouvante)
Java - General
 Java possède quelques caractéristiques
intéressantes :
 vérification automatique des types,
 garbage collection automatique,
 simplifie les pointeurs ; pas de pointeur directement
accessible à la mémoire,
 accès simplifié au réseau,
 multithreading !
 Comment ça marche... !
Compile-time Environment Compile-time Environment

Chargeur de
classes Java
Bytecode Class
Libraries
Vérificateur
Java
Source
(.java)
Juste à
Java
temps
Java Interpreter
Bytecodes e
Compilate Java
se déplacer localement ur Virtual
ou par l'intermédiaire d'un
réseau machine
Java
Compiler
Système d'exécution

Java
Bytecod Système d'exploitation
e
(.class )
Matériel
Comment ça marche... !
 Java n'est indépendant que pour une
seule raison :
 Il ne dépend que de la machine virtuelle
Java (JVM),
 Le code Java est compilé en bytecode,
qui est interprété par la JVM résidente,
 Les compilateurs JIT (just in time)
tentent d'augmenter la vitesse.
Java - Sécurité
 Refus de pointeurs - réduit les chances que des
programmes virulents corrompent l'hôte,
 Les applets sont encore plus limités -
 Ne peuvent pas
 exécuter des exécutables locaux,
 lire ou écrire dans le système de fichiers local
 communiquer avec tout autre serveur que le serveur
d'origine.
Orienté objet

 Java supporte l'OOD

 Polymorphisme
 Héritage
 Encapsulation
 Les programmes Java ne contiennent
rien d'autre que des définitions et des
instanciations de classes.
 Tout est encapsulé dans une classe !
Avantages de Java
 Portable - écrire une fois, exécuter n'importe où
 La sécurité a été bien pensée
 Gestion robuste de la mémoire
 Conçu pour la programmation en réseau
 Multithreading (plusieurs tâches simultanées)
 Dynamique et extensible (nombreuses bibliothèques)
 Classes stockées dans des fichiers séparés
 Chargées uniquement en cas de besoin
Syntaxe de base de Java
 Types Primitive et Variables
 booléen, char, byte, short, int, long, float, double, etc.
 Ces types de base (ou primitifs) sont les seuls à ne
pas être des objets (pour des raisons de
performance).
 Cela signifie que vous n'utilisez pas l'opérateur new
pour créer une variable primitive.
 Déclaration de variables primitives :
 float initVal ;
 int retVal, index = 2 ;
 double gamma = 1.2, luminosité
 boolean valueOk = false ;
Initialisation
 Si aucune valeur n'est attribuée avant l'utilisation, le
compilateur émet une erreur.
 Java définit les variables primitives à zéro ou à false
dans le cas d'une variable booléenne.
 Toutes les références d'objets sont initialement
définies comme nulles
 Un tableau de n'importe quoi est un objet
 Défini à null lors de la déclaration
 Les éléments sont mis à zéro, faux ou nul lors de la
création
Declarations
int index = 1.2 ; // erreur de compilation
boolean retOk = 1 ; // erreur de compilation
double fiveFourths = 5 / 4 ; // pas d'erreur !
float ratio = 5.8f ; // correct
double fiveFourths = 5.0 / 4.0 ; // correct

1,2f est une valeur flottante précise à 7

décimales près.
1,2 est une valeur double précise à 15 décimales
près.
Attribution
 Toutes les affectations Java sont associatives à droite
 int a = 1, b = 2, c = 5
 a=b=c
 System.out.print(
 "a= " + a + "b= " + b + "c= " + c)

 Quelle est la valeur de a, b et c ?

 De droite à gauche : a = (b = c) ;
Opérateurs mathématiques de base

 * / % + - sont les opérateurs

mathématiques
 * / % ont une priorité plus élevée
que + ou -
 double myVal = a + b % d - c * d /
b ;
 C'est la même chose que :
 double myVal = (a + (b % d)) -
 ((c * d) / b) ;
Déclarations et blocs
 Une instruction simple est une commande
terminée par un point-virgule :
 nom = "Fred" ;
 Un bloc est une instruction composée entourée
de crochets :
 {
 nom1 = "Fred" ; nom2 = "Bill" ;
 }
 Les blocs peuvent contenir d'autres blocs
Flux de contrôle
 Java exécute les instructions les unes après
les autres dans l'ordre où elles sont écrites
 De nombreuses instructions Java sont des
instructions de contrôle de flux :
 Alternance : if, if else, switch
 Boucle : for, while, do while
 Échappatoires : break, continue, return
If - L'énoncé conditionnel
 L'instruction if évalue une expression et si cette
évaluation est vraie, l'action spécifiée est exécutée.
 if ( x < 10 ) x = 10 ;
 Si la valeur de x est inférieure à 10, rendre x égal à
10
 On aurait pu écrire
 if ( x < 10 )
 x = 10 ;
 Ou, alternativement :
 if ( x < 10 ) { x = 10 ; }
Opérateurs relationnels
== Égal (attention)
!= Pas égal
>= Supérieur ou égal
<= Inférieur ou égal
> Plus grand que
< Inférieur à
If… else
 L'instruction if ... else évalue une expression et
effectue une action si cette évaluation est vraie ou
une action différente si elle est fausse.
 if (x != oldx) {
 System.out.print("x a été modifié") ;
 }
 else {
 System.out.print("x est inchangé") ;
 }
Nested if … else
if ( myVal > 100 ) {
if ( remainderOn == true) {
myVal = mVal % 100 ;
}
else {
myVal = myVal / 100.0 ;
}
}
else
{
System.out.print("myVal is in range") ;
}
 else if
 Utile pour choisir entre plusieurs solutions :
 if ( n == 1 ) {
 // exécuter le bloc de code #1
 }
 else if ( j == 2 ) {
 // exécuter le bloc de code #2
 }
 else {
 // si tous les tests précédents ont échoué,
exécuter le bloc de code #3
 }
Avertissement...
FAUX
CORRECT
! !
si(if(
i ==
i ==
j )j ) {
si si
( j( ==
j ==
k )k )
System.out.print(
System.out.print(
"i "i
estest
égal
égal
à k")
à k"); ;
else
}
else
System.out.print(
System.out.print("i
"i n'est pas égaln'est
à j")pas
; égal à
j") ; // Correct !
The switch Statement
switch ( n ) {
case 1 :
// exécution du bloc de code n°
1
break ;
case 2 :
// exécuter le bloc de code #2
break ;
default :
// si tous les tests précédents
échouent alors //exécute le bloc de
code #4
break ;
}
The for loop
 Loop n times
 for ( i = 0 ; i < n ; n++ ) {
 // ce corps de code sera exécuté n fois
 // de 0 à n-1
 }
 Nested for:
 for ( j = 0 ; j < 10 ; j++ ) {
 for ( i = 0 ; i < 20 ; i++ ){
 // ce corps de code sera exécuté 200 fois
 }
 }
while loops
while(response == 1) {
System.out.print( “ID =” +
userID[n]);
n++;
response = readInt( “Enter “);
}

Quel est le nombre minimum d'exécutions de la

loop ?
Quel est le nombre maximal d'exécutions ?
do {… } while loops
do {
System.out.print( “ID =” + userID[n] );
n++;
response = readInt( “Enter ” );
}while (response == 1);

Quel est le nombre minimum d'exécutions de la

boucle ?
Quel est le nombre maximal d'exécutions ?
Break
 Une instruction break entraîne la sortie de
l'instruction while, do, for ou switch la plus proche.
 for ( int i = 0 ; i < maxID, i++ ) {
 if ( userID[i] == targetID ) {
 index = i ;
 break ;
 }
 } // le programme saute ici après la pause
Continue
 Ne peut être utilisée qu'avec while, do ou for.
 L'instruction continue permet à la boucle la plus
proche de commencer immédiatement l'itération
suivante
 for ( int i = 0 ; i < maxID ; i++ ) {
 si ( userID[i] != -1 ) continue ;
 System.out.print("ID utilisateur " + i + " :" + ID
utilisateur) ;
 }
Arrays
 Un array est une liste de choses similaires
 Un array a un nom fixe :
 nom
 type
 longueur
 Ces éléments doivent être déclarés lors de la
création du tableau.
 La taille d’un array ne peut pas être modifiée pendant
l'exécution du code.
myArray = 3 6 3 1 6 3 4 1
0 1 2 3 4 5 6 7

myArray peut contenir 8 éléments

les éléments sont accessibles par leur indice
en Java, les indices des tableaux
commencent à 0
Déclaration des Arrays

int myArray[];
déclare que myArray est un array d'entiers
myArray = new int[8];
crée 8 espaces de taille entière en mémoire,
labelled myArray[0] to myArray[7]
int myArray[] = new int[8];
combine les deux déclarations en une seule
ligne
Attribution de valeurs
 faire référence aux éléments de l’array par leur index
pour y stocker des valeurs.
 monTableau[0] = 3 ;
 monTableau[1] = 6 ;
 monTableau[2] = 3 ; ...
 peut créer et initialiser en une seule étape :
 int myArray[] = {3, 6, 3, 1, 6, 3, 4, 1} ;
Iterating Through Arrays
 for loops sont utiles lorsqu'il s'agit des arrays :

for (int i = 0; i <

myArray.length; i++) {
myArray[i] = getsomevalue();
}
Arrays des Objects
 Jusqu'à présent, nous avons étudié array de types
primitifs.
 entiers
 on peut aussi utiliser des doubles, des flottants, des
caractères...
 Souvent, nous voulons avoir un array d'objets
 Étudiants, livres, prêts ......
 Il faut suivre 3 étapes.
Déclaration d’unArray
1. Déclarez un array:
private Student studentList[] ;
ceci déclare la liste des élèves
2. créer l’array
studentList = new Student[10] ;
cela crée 10 espaces en mémoire pouvant
contenir des références à des objets Étudiant.
3. Créer des objets Étudiant et les ajouter au
tableau : studentList[0] = new
Student("Cathy", "Computing") ;
Méthodes et classes en Java
Les classes sont des définitions d'objets

 OOP - programmation orientée objet

 code construit à partir d'objets
 En Java, ces objets sont appelés
classes.
 Chaque définition de classe est
codée dans un fichier .java distinct
 Le nom de l'objet doit correspondre
au nom de la classe ou de l'objet.
Les trois principes du OOP
 Encapsulation
 Les objets cachent leurs
fonctions (méthodes) et
leurs données (variables
d'instance).
 Héritage car Super class
 Chaque sous-classe hérite
de toutes les variables de sa
auto-
superclasse. manual
matic Subclasses
 Polymorphisme
 Interface identique malgré
des types de données draw()
différents draw()
Classe et méthode simples
Class Fruit{
int grams;
int cals_per_gram;

int total_calories() {
return(grams*cals_per_gram);
}
}
Methods
 Une méthode est une séquence de code nommée
qui peut être invoquée par d'autres codes Java.
 Une méthode prend certains paramètres, effectue
certains calculs et renvoie éventuellement une valeur
(ou un objet).
 Les méthodes peuvent être utilisées dans le cadre
d'une déclaration d'expression.

 public float convertCelsius(float tempC) {
 return((tempC * 9.0f) / 5.0f) + 32.0 ) ;
 }
Signatures de la méthode
 La signature d'une méthode spécifie
 le nom de la méthode
 Le type et le nom de chaque paramètre.
 le type de la valeur (ou de l'objet) renvoyée par la méthode
 Les exceptions vérifiées lancées par la méthode.
 Les différents modificateurs de méthode.
 modificateurs type nom ( liste des paramètres ) [lance des
exceptions ]
public float convertCelsius (float tCelsius ) {}
public boolean setUserInfo ( int i, int j, String name ) throws
IndexOutOfBoundsException {}
Public/private
 Les méthodes/données peuvent être
déclarées publiques ou privées, ce qui
signifie qu'elles peuvent ou non être
accessibles par le code d'autres
classes ...
 Bonne pratique :
 garder les données privées
 garder la plupart des méthodes privées
 interface bien définie entre les classes -
aide à éliminer les erreurs
Utilisation d'objets
 Ici, le code d'une classe crée une instance
d'une autre classe et fait quelque chose avec
elle …
Fruit plum=new Fruit();
int cals;
cals = plum.total_calories();

 Dot operator permet d'accéder à des

données/méthodes (publiques) à l'intérieur de
la classe Fruit
Constructors
 La ligne
plum = new Fruit();
 invoque une méthode de construction qui
permet de définir les données initiales d'un
objet.
 Vous pouvez choisir plusieurs types de
constructeurs avec différentes listes
d'arguments.
eg Fruit(), Fruit(a) ...
Overloading

 Il peut y avoir plusieurs versions d'une

méthode dans la classe avec différents
types/nombre d'arguments.
Fruit() {grams=50;}
Fruit(a,b) { grams=a; cals_per_gram=b;}

 En examinant les arguments, Java

décide de la version à utiliser
Java Development Kit

 javac - Le compilateur Java

 java - L'interprète Java
 jdb - Le débogueur Java
 appletviewer - Outil pour exécuter les
applets
 javap - pour imprimer les bytecodes Java
 javaprof - Profileur Java
 javadoc - générateur de documentation
 javah - crée des fichiers d'en-tête C
Manipulation des flux de données
Streams et I/O
 classes de base pour les fichiers IO
– FileInputStream, pour la lecture d'un fichier
– FileOutputStream, pour écrire dans un fichier
 Example:
Ouvrir un fichier "myfile.txt" for reading
FileInputStream fis = new FileInputStream("myfile.txt");

Ouvrir un fichier "outfile.txt" for writing

FileOutputStream fos = new FileOutputStream ("myfile.txt");

48
Afficher le contenu du fichier
import java.io.*;
public class FileToOut1 {
public static void main(String args[]) {
try {
FileInputStream infile = new FileInputStream("testfile.txt");
byte buffer[] = new byte[50];
int nBytesRead;
do {
nBytesRead = infile.read(buffer);
System.out.write(buffer, 0, nBytesRead);
} while (nBytesRead == buffer.length);
}
catch (FileNotFoundException e) {
System.err.println("File not found");
}
catch (IOException e) { System.err.println("Read failed"); }
}
} 49
Filters

• Une fois qu'un flux (par exemple, un fichier) a

été ouvert, nous pouvons y attacher des filtres
• Les filtres rendent la lecture et l'écriture plus
efficaces
• Filtres les plus populaires :
• For basic types:
• DataInputStream, DataOutputStream
• For objects:
• ObjectInputStream, ObjectOutputStream

50
Écriture de données dans un fichier à l'aide de filtres
import java.io.*;
public class GenerateData {
public static void main(String args[]) {
try {
FileOutputStream fos = new FileOutputStream("stuff.dat");
DataOutputStream dos = new DataOutputStream(fos);
dos.writeInt(2);
dos.writeDouble(2.7182818284590451);
dos.writeDouble(3.1415926535);
dos.close(); fos.close();
}
catch (FileNotFoundException e) {
System.err.println("File not found");
}
catch (IOException e) {
System.err.println("Read or write failed");
}
} 51
}
Lecture de données à partir d'un fichier à l'aide de
filtres
import java.io.*;
public class ReadData {
public static void main(String args[]) {
try {
FileInputStream fis = new FileInputStream("stuff.dat");
DataInputStream dis = new DataInputStream(fis);
int n = dis.readInt();
System.out.println(n);
for( int i = 0; i < n; i++ ) { System.out.println(dis.readDouble());
}
dis.close(); fis.close();
}
catch (FileNotFoundException e) {
System.err.println("File not found");
}
catch (IOException e) { System.err.println("Read or write failed");
}
} 52
}
Sérialisation des objets

Écrire des objets dans un fichier, au lieu d'écrire

des types primitifs.

Use the ObjectInputStream, ObjectOutputStream

classes, the same way that filters are used.

53
Écrire un objet dans un fichier
import java.io.*;
import java.util.*;
public class WriteDate {
public WriteDate () {
Date d = new Date();
try {
FileOutputStream f = new FileOutputStream("date.ser");
ObjectOutputStream s = new ObjectOutputStream (f);
s.writeObject (d);
s.close ();
}
catch (IOException e) { e.printStackTrace(); }

public static void main (String args[]) {

new WriteDate ();
}
} 54
Lire un objet dans un fichier
import java.util.*;
public class ReadDate {
public ReadDate () {
Date d = null;
ObjectInputStream s = null;
try { FileInputStream f = new FileInputStream ("date.ser");
s = new ObjectInputStream (f);
} catch (IOException e) { e.printStackTrace(); }
try { d = (Date)s.readObject (); }
catch (ClassNotFoundException e) { e.printStackTrace(); }
catch (InvalidClassException e) { e.printStackTrace(); }
catch (StreamCorruptedException e) { e.printStackTrace(); }
catch (OptionalDataException e) { e.printStackTrace(); }
catch (IOException e) { e.printStackTrace(); }
System.out.println ("Date serialized at: "+ d);
}
public static void main (String args[]) { new ReadDate (); } 55
}