Java - notions de bases pour développeur

Java
La syntaxe
Les aspects techniques
jd@olek.fr - Version du 22/10/13

mercredi 23 octobre 13

Rapide historique
• 1995 : sortie de la première version
• Rachat de Sun par Oracle en 2009
• Langage issu des concepts objets
• Plus mature que C++, Smalltalk...
• Portable sur plateformes hétérogènes
• Principe de virtualisation de l’exécution

Différentes versions
•
•
•

1996 : JDK 1.0 (211 classes)
1997 : JDK 1.1 (477 classes)
1998 : Java 2 (1 524 classes)

•
•
•

•
•
•
•
•

J2ME : Mobile Edition
J2SE : Reprise du Java “standard”
J2EE : Enterprise Edition (serveur)

2000 : J2SE 1.3 (1 840 classes)
2002 : J2SE 1.4 (2 723 classes)
2004 : J2SE 5.0 (3 270 classes)
2006 : Java SE 6 (3 777 classes)
2011 : Java SE 7 (8 000 classes)

Cycle de compilation
d’un langage ‘classique’
Compilateur
Code source
toto.c

Editeur de liens

Code objet
toto.o

•Fichier texte
•Fichier binaire
•Compatibilité si langage •Compatibilité CPU
normé

Code
exécutable
toto.exe

•Fichier binaire
•Compatibilité OS

Liaison avec des bibliothèques
faisant la liaison avec le système


Compilation/exécution
en Java
Compilateur
Code source
Toto.java

•Fichier texte
•Compatibilité totale

(norme gérée par Sun)

Exécution par la JVM
Bytecode
Toto.class

•Fichier binaire
•Compatibilité JVM

Code interprété
ou émulé

•Exécution directe en
mémoire
•Compatibilité OS

Liaison avec des bibliothèques
elles aussi en bytecode


Caractéristiques du
langage (1)
• Hétérogène
• Peut s’exécuter dans des environnements
très divers

• Pas de problème de compatibilité
• Même au niveau des types
• Même au niveau de l’interface graphique

langage (2)

• Objet
• Bénéﬁcie des retours d’expériences
d’avant 95

• Ce n’est pas une adaptation d’un langage
existant

• Tout est encapsulé dans des classes

• Simple
• La syntaxe est simpliﬁée et abordable

langage (3)

• Robuste
• La JVM détecte les erreurs et gère les
éventuelles fuites mémoire

• Orienté réseau
• Gestion native des threads
• Protocoles réseaux inclus en standard
• Informatique distribuée

langage (4)

• (relativement) ouvert sur l’extérieur
• Les interfaces JNI permettent de faire

passerelle avec les parties “natives” du
système (matériel, réseau, OS...)

• Très typé Web
• J2EE fournit un serveur d’application
complet pour le Web

• Tous les standards sont là : XML, Ajax...

Points faibles
• L’étape d’interprétation de la JVM entraine
bien sûr une plus grande lenteur et
lourdeur

• La syntaxe est simpliﬁée par rapport à
d’autres langages (C++...)

• En revanche, certaines subtilités

“techniques” ne sont pas possibles


Environnements de
développement
• L’ex Leader : Borland JBuilder
• Aujourd’hui : Eclipse / IBM Rational App Dev
• Base OpenSource donnée par IBM
• Extensions par Plugins
• Plugins OpenSource ou IBM
• Chez Sun : NetBeans

Les commandes de
base
• java : appel à la JVM
• javac : compilateur, produit des .class
• javap : désassembleur
• javadoc : génère la documentation
• jar : gestion des Java ARchives

Compilation manuelle
• Vériﬁer la présence des variables
d’environnement :

• JAVA_HOME : pointe sur le JDK
• PATH : doit intégrer $JAVA_HOME/bin
• CLASSPATH : doit intégrer

$JAVA_HOME/lib ainsi que vos propres
librairies (répertoires et .jar)


My ﬁrst class
• Et c’est parti ! Dans un ﬁchier texte Essai.java, on
tape :

public class Essai
{
public static void main(String args[])
{
System.out.println(“Goodbye cruel world !”);
}
}
http://fr.wikipedia.org/wiki/Hello_world

Utilisation de base des
commandes
• javac Essai.java
• Compile notre ﬁchier Essai.java
• On obtient un ﬁchier Essai.class
• java Essai
• Lance la classe contenue dans Essai.class

Notion de packages

• Les classes sont organisées en packages,
aﬁn de les organiser

• Les packages sont des répertoires
• On prend souvent le nom de domaine de la
société pour garantir un nom unique

• Dans le code, un package est représenté
sous la forme :

package fr.olek.cours.debutant;


Déclaration d’une
classe dans un package
package fr.olek.cours.repondeur;
public class Repondeur
{
...
}
Le ﬁchier se trouve dans :
/fr/ecoms/cours/repondeur/


Appel d’une classe dans
un package
• La syntaxe est plutôt lourde :
public class Essai
{
{
fr.olek.cours.repondeur.Repondeur r=
new fr.olek.cours.repondeur.Repondeur();
}
}

Utilisation de la clause
import

• Il vaut mieux l’importer :

import fr.olek.cours.repondeur.Repondeur;
public class Essai
{
{
Repondeur r=new Repondeur();
}
}

Divers usages d’import

• import n’importe pas “physiquement” les packages
mentionnés

• Simple indication à la JVM pour savoir où trouver
les classes utilisées

• Il est possible d’importer toutes les classes d’un
package d’un coup :

import fr.olek.cours.repondeur.*;

• Attention, ça n’inclue pas les sous-packages !
import fr.olek.*; // ne va pas importer “Repondeur”

Régler les ambiguités
• Dans certains cas, des classes portent le même
nom, dans des packages différents

import java.awt.*; // contient une classe “Point”
import fr.olek.geometrie.Point;
...
Point p=new Point(); // on utilise le nôtre


Imports statiques

• Nouveauté de Java 5.0
• Permet d’éviter la syntaxe classe.méthode
ou classe.attribut

• Exemple :
import static java.lang.Math;
...
aire=rayon*java.lang.Math.PI;
aire=rayon*Math.PI;
aire=rayon*PI;

Les commentaires

• Pour commenter une seule ligne :
// Ligne de commentaire

• Bloc de commentaire :
/* Début de bloc
....
Blabliblu */

• Bloc de commentaire de documentation
/** Début de bloc
....
Blabliblu */

Les types de données
• On les appelle “types scalaires”
• 3 grands types :
• Numériques
• Entiers
• Réels
• Booléens
• Caractères

Les types numériques
• Ils sont tous complètement normalisés !
• Quelque soit la plateforme, un même
type aura toujours la même
représentation

• Les entiers sont par défaut signés
• long et short sont des types à part entière

Les différents types
numériques disponibles
Type Taille mémoire
byte

1 octet

short

2 octets

int

4 octets

long

8 octets

• Par défaut, les nombres sont de type int
• Les sufﬁxes permettent de forcer un type : 1234L

Types réels
Type Taille mémoire
float

4 octets

double

8 octets

• Contrairement à C/C++, il existe une vraie
arithmétique en float

• Par défaut, un nombre à virgule est un double
• Suffixe pour un float : 12.24F

Type booléen

• Fini les réprésentations via des entiers 0 et 1
(ou 0 et -1, ou 1 et 2...)

• Java propose un type boolean à part entière
• 2 constantes particulières
• true
• false
• boolean est le seul type utilisé pour les tests
• Toute expression de test est donc booléenne

Exemple de test
booléen

Expression
booléenne

if(a==b) ....

• Pour tester un booléen :
boolean flag=false;
...
if(flag==true)
if(flag)

Expression
redondante

if(flag==false)
if(!flag)

Conditions
if(expression)
instruction1;
else
instruction2;
instruction3;


•Chaque expression est booléenne
•Chaque instruction peut être remplacée
par un bloc :

{

if(expression1)
instruction1;
else if(expression2) }
instruction2;
else if(expression3)
instruction3;
else
instruction4;

instruction 1;
...
instruction n;

Choix multiples

int choix;
switch(choix)
{
case 1: Exécuté si choix=1
i=3;
break;
Ordre de débranchement
case 2:
case 3:
i=4;
break;
Exécuté si choix=2 ou 3
default:
i=3;
Choix par défaut
}

switch/case ne
marche qu’avec
des types scalaires !
(=>pas de String)

Boucles

• La boucle type en Java est while :
while(condition)
{
instruction1;
}
Exécuté au
moins une fois


do
{
instruction1;
} while(condition)

Boucle for

• Héritée du langage C
• En fait, un condensé d’une boucle while
avec incrémentation

for(exp_init;
exp_test;
exp_maj)
{
instruction1;
}

exp_init;
while(exp_test)
{
instruction1;
exp_maj;
}

Exemple : for(int i=0;i<10;i++) ...

Caractères
•
•
•
•


Particularité de Java : tout caractère est au format
UNICODE sur 16 bits
Saisie d’une constante caractère :
char
char
char
char

c1=’A’;
c2=’t’;
c3=’060’;
c4=’u0030’;

//
//
//
//
//

Caractère en dur
Séquence d’échappement classique du C
Exactement 3 chiffres en octal
Exactement 4 chiffres en hexadécimal
pour une constante UNICODE

Attention aux caractères Français accentués
Unicode conseillé...

•

char eacute=’u00E9’;

// le caractère « é »

char est de toute manière peu utilisé
On préférera utiliser la classe String

•

Chaîne de caractères
• Fini les bidouilles de tableau de caractères
• On utilise une classe à part entière
String s=new String(“bonjour les amis”);

• ou plutôt :
String s=”bonjour les amis”;


Concaténation
String nom=”Paul”;
String phrase=”Bonjour,”+nom+”, comment va ?”;

• On peut également concaténer des éléments autres
que “String”

• Ils seront automatiquement convertis
int age=10;
String phrase=”Tu as “+age+” ans”;


Concaténation par
buffer

• La concaténation classique de String implique une
reconstruction systématique

String s=”Bonjour”;
s=s+” les amis”; // s est une nouvelle instance

• La classe StringBuffer résoud ce problème d’efﬁcacité
StringBuffer sb=new StringBuffer();
sb.append(“Bonjour”);
sb.append(“ les amis”);
String s=sb.toString();

Comparaison de
chaînes de caractères
• La comparaison directe va comparer les
pointeurs, pas le contenu :
if(s1==s2) ...

• La comparaison de contenu nécessite
l’utilisation de la méthode equals() :
if(s1.equals(s2)) ...


Intérêt d’une classe
• Rappel : une classe =
• des informations (attributs)
• des actions pour manipuler ces
informations (méthodes)

• Ici, chaque instance de String rassemble :
• La chaîne de caractères
• De quoi retravailler cette chaîne

Encapsulation dans une
chaîne de caractères
Avant :
La chaîne :
char[50]
Les outils :
(répartis dans
diverses librairies)
strcmp
strstr
strpos
...

Après :

String
chaine
substr(int,int)
size()
equals(String)
...

Méthode vs Fonction
• Taille d’une chaîne en PHP via la fonction
strlen :

$taille=strlen($chaine);

• Equivalent en Java :

Un outil auquel on fournit
la donnée

int taille=chaine.length();
Une donnée encapsulant ses
outils

Méthodes utiles de
String
trim()
Supprime les espaces
toLowerCase()
Force en minuscules
toUpperCase()
Force en majuscule
subString(int,int)
Retourne une sous-chaîne
indexOf(String) Retourne la position d’une sous chaine
charAt(int)
Renvoie le caractère à la position donnée
length()
Renvoie la longueur de chaîne
...
...


Utilisation de la Javadoc


临河而羡鱼，不如归家织网


临河而羡鱼，不如归家织网
Si tu donnes un poisson à un homme, il mangera un jour.
Si tu lui apprend à pêcher, il mangera toujours.


Liste des
packages

Index des
méthodes
Package
Héritage

Liste des
classes


Clic pour voir le
détail

Regarder le
type de sortie pour
choisir une bonne
méthode

Méthode
statique

Transtypage / Casting
• Le transtypage permet de gérer les
conversions d’un type à un autre

• Différents cas se présentent :
• D’un type scalaire à un autre
• D’une classe à une autre
• Entre classes et types scalaires

Casting entre types
scalaires
• Tout est possible, mais attention aux pertes
de précision

int i=10;
double d=10.1;
d=i; // interdit
d=(double)i; // autorisé
i=(int)d; // autorisé, mais perte de précision


Perte de précisions
dans les calculs
• Exemple :
int i=4;
int j=3;
double result=i/j;

i/j est une expression
donnant un entier

• Pour limiter la perte, il faut :
double result=i/(double)j;
ou
double result=(double)i/j;

int / double est un
double

Cast entre classes :
downcasting
Livre livre=new Livre(...);
Produit prod;
prod=(Produit) livre; // autorisé
prod=livre; // autorisé, car un livre EST un produit


Cast entre classes :
upcasting
Produit prod=new Livre(...); // autorisé (downcast)
Livre livre;
livre=prod; // interdit
livre=(Livre)prod; // autorisé, mais risqué


Cast entre classes et
types scalaires
• Ex : passer un String en int, ou inversement
• Ce n’est pas possible directement
• Deux notions totalement différentes
• On passe par un intermédiaire
• Les class wrappers (enrobeurs)

Les class Wrappers
• Ce sont des classes encapsulant des types
scalaires

• Ex : Integer iWrap=new Integer(12);

• Permet de faire bénéﬁcier ses types
scalaires des atouts d’une classe :

• Fournir la donnée avec ses outils

Class Wrappers
disponibles
Type primitif
boolean
byte
double
short
int
long
ﬂoat
char


Wrapper
Boolean
Byte
Double
Short
Integer
Long
Float
Character

Conversion d’un String
en int

Javadoc du class Wrap Integer :

String s=”12”;
Integer iWrap=new Integer(s);

int val=iWrap.intValue();

Conversion String/int avec
une méthode statique
Javadoc du class Wrap Integer :

String s=”12”;
int val=Integer.parseInt(s);
Syntaxe
classe.méthode()


Conversion int en String

• On utilise encore le classwrap Integer :
int val=12;
Integer iWrap=new Integer(val);
String s=iWrap.toString();

• Il existe aussi une méthode statique dans String :
String s=String.valueOf(val);

• Autre méthode, plus “douteuse” :
String s=””+val;

Autoboxing de Java5

• Dans certains cas, l’encapsulation de types
dans des classwrap est automatique en
Java>5

• Exemple :
Avant :
List l=new ArrayList();
int val=100;
l.add(new Integer(val));

Après :
List l=new
ArrayList<Integer>();
int val=100;
l.add(val);

Conversion
implicite

Listes dynamiques
• Classes héritant de la structure List :
• ArrayList : redimensionnement auto d’un
tableau

• LinkedList : véritable liste chaînée
• Chaque classe a ses atouts en termes
d’efﬁcacité

• Mais l’utilisation est la même

Exploitation d’une liste
• Création :
ArrayList liste=new ArrayList();

• Remplissage :
liste.add(element);

• Récupération d’un élément :
Voiture v=(Voiture)liste.get(i);


Typage de listes en
Java >5
• Avant : upcasting risqué
Voiture v=(Voiture)liste.get(i);

• Après : listes typées et typage implicite
ArrayList<Voiture> liste=new ArrayList<Voiture>();
...
Voiture v=liste.get(i);


Parcours de liste par
boucle for
...
for(int i=0;i<liste.size();i++)
{
size() détermine
Voiture v=liste.get(i); le nb d’éléments
...
}


itérateur
...
Iterator<Voiture> it=liste.iterator();
while(it.hasNext())
{
Voiture v=it.next();
...
}


itérateur implicite (Java5)
...
for(Voiture v: liste)
{
v.accelere();
Il s’agit en fait d’un «foreach»
...
}


Expression d’une
instance en String

• Par défaut, Java ne sait pas comment “afﬁcher”
une instance

Voiture v=new Voiture();
System.out.println(v);

➡Voiture@2a18bdf

• Cet afﬁchage est en fait effectué par une
méthode toString() de la classe Object

• Rappel : toutes les classes héritent d’Object

Surcharge de toString()

• Surcharger cette méthode permet de

personnaliser l’afﬁchage de l’instance
public class Voiture
{
...
public String toString()
{
return “Je suis la voiture “
+this.nom;
Voiture v=new Voiture();
}
System.out.println(v);
}
Je suis la voiture XXX

➡


Intérêts de la méthode
toString()
• Le concept d’instance “autodescriptive” est
très intéressant pour le debug

• Il est possible d’utiliser des appels à
toString() en cascade :

• Ex : ArrayList possède une méthode

toString() qui va appeler le toString() de
chacun de ses éléments


Exceptions
• Une exception représente soit :
• Une erreur (système)
• Une erreur (de votre application)
• Un cas alternatif

Section de code
critique
• Le code potentiellement source d’erreur
sera encadré par un bloc try :

try
{
FileReader f=new FileReader(“unﬁc.txt”);
}


Capture des erreurs
• Chaque bloc try est suivi d’un ou plusieurs
blocs catch

• Si une erreur apparaît, l’exécution de try

est stoppée, et le bloc catch apparaît à la
place


Enchaînement try/catch
try
{
...
}
catch(IOException ioe)
{
.... gestion de l’erreur de type IO
}
catch(Exception e)
{ ... gestion des autres erreurs }

.......
try
{
...
instruction à problème
.....
}
{
.... gestion de l’erreur de type IO
}
......

Que faire en cas
d’erreur ?
• L’erreur peut se réparer localement ?
• On fait un try/catch
• L’erreur est grave, il faut sortir de la
méthode

• On relance l’exception via un throws

Avant la remontée
d’erreur
void uneMethode()
{
....
instructionAProbleme
...
}

{
....
inst.uneMethode();
...
}


Remontée d’erreur
void uneMethode()
throws IOException
{
....
instructionAProbleme
...
}

{
....
Cet appel
est devenu section
try
de code critique
{
inst.uneMethode();
}
{ ... }
...
}


Différentes exceptions
• Celles héritant de Exception
• “checked exceptions”, les plus connues
• Celles héritant de Error
• Erreurs système graves
• Celles héritant de RuntimeException
• “unchecked exceptions”, n’obligeant pas
un try/catch pour les gérer


Le bloc ﬁnally
•

Est exécuté qu’il y
aie une erreur ou
non

• Finalement presque

identique au bloc de
données après le
catch

• Mais est exécuté

même en cas de
sortie anticipée de la
fonction


try
{
.....
}
catch(Exception e)
{
.... ; return;
}
ﬁnally
{
.. // est exécuté avant le return
}

Générer ses propres
exceptions
1) Déﬁnir l’exception

• Il s’agit d’une classe héritant de Exception

public class QINegatifException extends Exception
{
public QINegatifException(String nom)
{
super(“Attention, “+nom+” a un QI d’huitre !”);
}
Appel
constructeur classe
}
mère


exceptions
2) Lancer l’exception

• Lorsque celà vous parait utile, vous lancez l’exception
{
...
if(qi<0)
throw new QINegatifException(“bob”);
...
}

exceptions
3) Déﬁnir le code critique

• La méthode où vous avez lancé l’exception devient
section de code critique

void ajoutLofteur(Lofteur l) throws QINegatifException
{
Ne pas confondre
...
avec throw (sans S)
if(l.getQi()<0)
throw new QINegatifException(l.getNom());
...
}

exceptions
4) Lever l’exception

• On gère l’appel au code critique comme à l’accoutumée
try
L’utilisateur de la
{
classe est obligé par le
compilateur de gérer l’exception
...
‘proprement’
loft.ajoutLofteur(l);
...
}
catch(QINegatifException qie) { ... }

Comment gérer
l’erreur ?

• Le plus souvent, on se contente d’afﬁcher l’erreur
• System.err.println(e.getMessage());
• e.printStackTrace();
• Autant que possible, effectuer un traitement
adéquat

• Le plus souvent, tout ce joue dans ce qu’on va
mettre dans le try / en dehors du try


Lire un ﬁchier de
propriétés
• La plupart des applis Java stockent leurs

paramètres dans un ﬁchier texte de type :
machin.properties

• Il existe une petite classe permettant de
faciliter l’accès à ces propriétés


Utilisation de la classe
Properties

Fichier
monappli.properties

import java.util.Properties;

monappli.url=http://www.olek.fr
monappli.chemin=/usr/local/appli

Properties prop = new Properties();
// Lecture du ﬁchier contenant les données de conﬁguration
FileInputStream in = new FileInputStream("monappli.properties");
prop.load(in);
in.close();
// Extraction des propriétés
String url = prop.getProperty("monappli.url");
String user = prop.getProperty("monappli.chemin");


Marshalling XML
• Objectif : sauvegarder une trace de ses
données sous forme d’un fichier XML

• Exemple : fichier de configuration
• On peut utiliser :
• Des outils complets de marshalling
(CastorXML, par ex)

• Les classes standards de Java
• XStream (http://xstream.codehaus.org)

Avec Java standard
• Depuis la v1.4, on dispose de classes
XMLEncoder et XMLDecoder

• Usage :
XMLEncoder e = new XMLEncoder(
new BufferedOutputStream(
new FileOutputStream("Test.xml")));
e.writeObject(instanceASerialiser);
e.close();


Limitation de ces
classes

• Utilisation impérative de beans

(constructeur sans paramètre et get/set
systématiques)

• Code XML généré lourd
• On voit les objets ArrayList, etc...
• A réserver à l’archivage de petites classes
isolées

• Par ex, classe de conﬁguration

Avec XStream

XStream xstream = new XStream(new DomDriver());

// écriture du XML à partir d’une instance de classe
xstream.toXML(inst, new BufferedOutputStream(
new FileOutputStream("Test.xml")));
// lecture du XML et récupération de l’instance
MaClasse inst=(MaClasse)
xstream.fromXML(new BufferedInputStream(
new FileInputStream("Test.xml")));

• On peut également gérer des “mappings”

permettant de préciser les noms utilisés au
ﬁnal dans le XML


Sérialisation
• Va prendre une “image “ d’une instance
telle qu’elle est présente en mémoire

• Et la transforme en suite d’octets que l’on
peut manipuler directement

• Pour transfert via le réseau
• Pour stockage dans un ﬁchier ou une
base (dans un blob)


Mise en place
• Les classes à stocker doivent implémenter
l’interface Serializable

• Cette interface est vide, aucune méthode à
implémenter

• Elle joue simplement le rôle de marqueur

• On utilise ensuite les outils

ObjectOutputStream et ObjectInputStream


ObjectOutputStream
• Exemple de stockage dans un ﬁchier :
! FileOutputStream fos = new FileOutputStream("t.tmp");
! ObjectOutputStream oos = new ObjectOutputStream(fos);
! oos.writeObject(moninstance);
! oos.close();
fos.close();


ObjectInputStream
• Relecture de l’objet à partir du fichier
! FileInputStream fis = new FileInputStream("t.tmp");
! ObjectInputStream ois = new ObjectInputStream(fis);
! MaClasse instanceRecup=(MaClasse)ois.readObject();
! oos.close();
fos.close();


Qu’est ce qui est
sérialisé ?

• Données ET méthodes
• Vraie encapsulation
• Sérialisation en cascade
• Si des attributs pointent vers d’autres

objets, ils sont sérialisés (même les listes)

• Pour ignorer un attribut : transient

Gestion des logs
• Objectif : remplacer les bêtes “println” qui
parsement nos programmes

• Pourquoi ?
• Pouvoir les rediriger où l’on veut
(ﬁchier...)

• Gérer différents niveaux d’afﬁchage
• Debug, erreurs...

L’outil Log4J d’Apache
• Autre possibilité : java.util.logging
• Permet la gestion de différents niveaux d’erreur
• DEBUG >WARN>INFO>ERROR
• Ainsi que le reroutage sur divers périphériques
• CONSOLE, LOGFILE...
• Possibilité de gérer des roulements de
ﬁchiers


Utilisation de Log4J


// récup du fichier de configuration
PropertyConfigurator.configure("log4j.properties");
//initialisation du Logger
Logger log=Logger.getLogger(Essai.class);
// émission de messages
log.debug("debug!!");
log.warn("warn !");
log.fatal("fatal !");
log.info("info !");

Fichier de conﬁguration
# Set root category priority to INFO and its only appender to
CONSOLE.
log4j.rootCategory=INFO, CONSOLE
#log4j.rootCategory=INFO, CONSOLE, LOGFILE
# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.Threshold=INFO
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=[%t] %-5p %c - %m%n


Java - notions de bases pour développeur

Contenu connexe

Tendances

En vedette

Similaire à Java - notions de bases pour développeur

Java - notions de bases pour développeur