Java - notions de bases pour développeur

JavaLa syntaxe

Les aspects techniques

[email protected] - Version du 22/10/13

mercredi 23 octobre 13

mailto:[email protected]

mailto:[email protected]

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)mercredi 23 octobre 13

Cycle de compilationd’un langage ‘classique’

Code sourcetoto.c

Code objettoto.o

Code exécutabletoto.exe

Compilateur Editeur de liens

•Fichier texte•Compatibilité si langage normé

•Fichier binaire•Compatibilité CPU

•Fichier binaire•Compatibilité OS

Liaison avec des bibliothèquesfaisant la liaison avec le système


Compilation/exécution en Java

Code sourceToto.java

BytecodeToto.class

Code interprétéou émulé

Compilateur Exécution par la JVM

•Fichier texte•Compatibilité totale(norme gérée par Sun)

•Fichier binaire•Compatibilité JVM

•Exécution directe enmémoire•Compatibilité OS

Liaison avec des bibliothèqueselles 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



• Objet

• Bénéficie 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 simplifiée et abordable



• 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



• (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 simplifié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érifier 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 first class• Et c’est parti ! Dans un fichier 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 fichier Essai.java

• On obtient un fichier Essai.class

• java Essai

• Lance la classe contenue dans Essai.class


Notion de packages• Les classes sont organisées en packages,

afin 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 fichier se trouve dans :

/fr/ecoms/cours/repondeur/


Appel d’une classe dans un package

• La syntaxe est plutôt lourde :

public class Essai{ public static void main(String args[]) { 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{ public static void main(String args[]) { 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”mercredi 23 octobre 13

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

• Par défaut, les nombres sont de type int

• Les suffixes permettent de forcer un type : 1234L

Type Taille mémoire

byte 1 octet

short 2 octets

int 4 octets

long 8 octets


Types réels

• 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 Taille mémoire

float 4 octets

double 8 octets


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

if(a==b) ....

• Pour tester un booléen :

boolean flag=false;...if(flag==true)

if(flag)

Expression booléenne

Expression redondante

if(flag==false)

if(!flag)


Conditionsif(expression) instruction1;else instruction2;instruction3;

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

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

instruction 1; ... instruction n;}


Choix multiplesint choix;switch(choix){ case 1: i=3; break; case 2: case 3: i=4; break; default: i=3;}

Ordre de débranchement

Exécuté si choix=2 ou 3

Choix par défaut

Exécuté si choix=1 switch/case ne marche qu’avecdes types scalaires !(=>pas de String)


Boucles• La boucle type en Java est while :

while(condition){ instruction1;}

do{ instruction1;} while(condition)Exécuté au

moins une fois


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;}

for(int i=0;i<10;i++) ...Exemple :mercredi 23 octobre 13

Caractères

• Particularité de Java : tout caractère est au format UNICODE sur 16 bits

• Saisie d’une constante caractère :

char c1=’A’; // Caractère en dur char c2=’\t’; // Séquence d’échappement classique du C char c3=’\060’; // Exactement 3 chiffres en octal char c4=’\u0030’; // 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énationString 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’efficacité

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)strcmpstrstrstrpos...

String

chaine

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

Après :


Méthode vs Fonction

• Taille d’une chaîne en PHP via la fonction strlen :

$taille=strlen($chaine);

• Equivalent en Java :

int taille=chaine.length();

Une donnée encapsulant ses outils

Un outil auquel on fournit la donnée


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

Liste des classes

Index des méthodes

Héritage

Package


Regarder le type de sortie pour choisir une bonne

méthode

Méthode statique

Clic pour voir le détail


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; // interditd=(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;

• Pour limiter la perte, il faut :

double result=i/(double)j;oudouble result=(double)i/j;

int / double est un double

i/j est une expression donnant un entier


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; // interditlivre=(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éficier ses types scalaires des atouts d’une classe :

• Fournir la donnée avec ses outils


Class Wrappers disponibles

Type primitif Wrapper

boolean Boolean

byte Byte

double Double

short Short

int Integer

long Long

float Float

char 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’efficacité

• 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

ArrayList<Voiture> liste=new ArrayList<Voiture>();...for(int i=0;i<liste.size();i++){ Voiture v=liste.get(i); ...}

size() détermine le nb d’éléments


Parcours de liste par itérateur

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


Parcours de liste par itérateur implicite (Java5)ArrayList<Voiture> liste=new ArrayList<Voiture>();...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 “afficher” une instance

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

➡Voiture@2a18bdf

• Cet affichage 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’affichage de l’instancepublic class Voiture{ ... public String toString() { return “Je suis la voiture “ +this.nom; }}

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

➡Je suis la voiture XXXmercredi 23 octobre 13

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(“unfic.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/catchtry{ ...}catch(IOException ioe){ .... gestion de l’erreur de type IO}catch(Exception e){ ... gestion des autres erreurs }


.......try{ ... instruction à problème .....}catch(IOException ioe){ .... 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’erreurvoid uneMethode()

{ .... instructionAProbleme ...} {

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


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

{ .... try { inst.uneMethode(); } catch(IOException ioe) { ... } ...}

Cet appel est devenu section de code critique


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 finally• 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;}finally{.. // est exécuté avant le return}


Générer ses propres exceptions

1) Définir l’exception

• Il s’agit d’une classe héritant de Exceptionpublic class QINegatifException extends Exception{ public QINegatifException(String nom) { super(“Attention, “+nom+” a un QI d’huitre !”); }}

Appel constructeur classe

mère



2) Lancer l’exception

• Lorsque celà vous parait utile, vous lancez l’exception

{ ... if(qi<0) throw new QINegatifException(“bob”); ...}



3) Définir le code critique

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

void ajoutLofteur(Lofteur l) throws QINegatifException{ ... if(l.getQi()<0) throw new QINegatifException(l.getNom()); ...}

Ne pas confondre avec throw (sans S)



4) Lever l’exception

• On gère l’appel au code critique comme à l’accoutumée

try{ ... loft.ajoutLofteur(l); ...}catch(QINegatifException qie) { ... }

L’utilisateur de la classe est obligé par le

compilateur de gérer l’exception ‘proprement’


Comment gérer l’erreur ?

• Le plus souvent, on se contente d’afficher 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 fichier de propriétés

• La plupart des applis Java stockent leurs paramètres dans un fichier 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

import java.util.Properties; Properties prop = new Properties(); // Lecture du fichier contenant les données de configuration 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");

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

Fichier monappli.properties


http://www.ecoms.fr

http://www.ecoms.fr

http://www.ecoms.fr

http://www.ecoms.fr

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 configuration


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

// écriture du XML à partir d’une instance de classexstream.toXML(inst, new BufferedOutputStream( new FileOutputStream("Test.xml")));

// lecture du XML et récupération de l’instanceMaClasse 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 final 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 fichier 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 fichier :! 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 (fichier...)

• Gérer différents niveaux d’affichage

• 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 fichiers


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 configuration

# 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.ConsoleAppenderlog4j.appender.CONSOLE.Threshold=INFOlog4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayoutlog4j.appender.CONSOLE.layout.ConversionPattern=[%t] %-5p %c - %m%n


Technology

Java - notions de bases pour développeur