f. voisin : introduction à java 1 introduction à java frédéric voisin fiifo - « remise à...

F. Voisin : Introduction à Java 1

Introduction à Java

Frédéric VOISIN

FIIFO - « Remise à Niveau »


Bref Historique des Langages à Objets

SIMULA (1967) : ancêtre des langages à objets Smalltalk (72-76-80) : le premier « vrai » langage à objets

original, voire déroutant (syntaxe) très « dynamique » (tout est redéfinissable dans le langage) environnements de programmation, prototypage, …

C++ (~ 1985) : Langage « orienté objet », issu du langage C et de SIMULA performant, puissant (trop ! Difficile à maîtriser) plutôt « statique », orienté « Génie Logiciel »

Java (~1996, Sun): emprunte à Smalltalk et à C++ C# (2001, Microsoft) : simplification de C++, concurrent de Java Autres acteurs:

Ada 95: puissant, mais beaucoup le trouvent trop lourd divers dialectes de Pascal : Delphi Les « langages Microsoft » VBA, Visual C++, J++


Le Marketing Java

Moderne : objet, modulaire, typé Largement disponible : « gratuit », « propriétaire » mais pas trop Portable : multi-plateformes (O.S.), Internationalisation (Unicode) Orienté WEB:

chargement dynamique de code « appliquettes » (applets) associées aux navigateurs modèles de sécurité pour le téléchargement de code

(« bac à sable », vérification du bytecode, authentification, téléchargement du code autorisé ou non selon la source)

Fiabilité: vérifications dynamiques à l’exécution; « ramasse-miettes » Support des « processus légers » (threads) Orienté systèmes distribués et ouverts: invocation à distance (RMI), API

CORBA, JDBC, Réseaux, … Multi-usages: de la « machine à laver » aux « composants métiers », en

passant par les applications audio/vidéo et la JavaCard ;-)


Le Marketing Java (fin)

Au centre d’un effort de normalisation Norme J2EE (« Java 2 Enterprise Edition »): 13 services pour environnements

ouverts (annuaires, gestion de messages, de transactions, …):JDBC, RMI, JSP/servlet, JNDI, JTS, JMS, EJB ...

EJB (« Enterprise Java Beans »): développement orienté composants JSP/Servlet (Java Server Page/ Server Applets): WEB dynamique avec code

Java exécuté du côté serveur et non pas client

;-| Réaction Microsoft : .NET (évolution de COM+, IIS,...) autour de C#

Les acronymes à connaître: JVM: la « machine virtuelle Java » (le « moteur » d’exécution) J2RE : (« runtime » : les librairies mais pas le compilateur…) J2EE (Enterprise Edition), J2SE (Standard Edition) J2ME: (Mobile Edition)

très « mode » actuellement : développement « multi plateformes » (PCs, Internet/Intranet, PDA, PocketPC, mobiles,….)


Bref Historique de Java

JDK (« Java Development Kit ») : Java 1.0.2: version de tous les navigateurs Web Java 1.1.5: 1997

504 classes, 23 paquetages Abstract Window Toolkit (awt) : interface graphique

Java 1.2 (dit encore Java 2 !) : 1998 1520 classes, 59 paquetages Swing (IHM), Drag and Drop, amélioration audio, amélioration I/O

Java 1.3: amélioration des « collections » notamment (2130 classes !) Java 1.4 (2001/2002): la version courante : cryptographie, modèles de sécurité…

(2738 classes…) Java 1.5 (fin septembre 2004 ?): classes « génériques » (à la C++/C# ?)

compatibilité ascendante en gros (« deprecated » features)


Java: la portabilité

portabilité du code compilé et pas seulement du source (via la bonne JVM) ! Basé sur le portage de la « Java Virtual Machine »: interpréteur de « code

intermédiaire » et du « Java Runtime Environment » ce sont la JVM et le JRE qui sont réécrits pour chaque O.S. !

1. on (pré-)compile le code source dans le code de cette JVM (bytecode),

2. à l’exécution la JVM interprète le code produit spécification publique de cette JVM, l’aspect « propriétaire » du langage permet

d’éviter les dérives comme il y en a eu avec les extensions à html…

le même code compilé peut tourner sous Solaris, Windows, Linux, MacOS,… facile à distribuer compatible avec les environnements des utilisateurs


Write once, run everywhere !

bytecode

(.class)

Source java(.java)

javac

(sun)

javac

(Mac)

javac

(windows)

SunJava (JVM)

SunJava (JVM)

MacJava (JVM)

MacJava (JVM)

WindowsJava (JVM)

WindowsJava (JVM)

NavigateurJava (JVM)

NavigateurJava (JVM)

bytecode

(.class)

bytecode

(.class)

…

Archive(.jar)

Source java(.java)

Source java(.java)


Java: les principaux outils

java : la JVM = l’interprète de « bytecode »

javac : le compilateur

appletviewer : JVM pour l’exécution des appliquettes

jar : le gestionnaire d’archives java (multi-fichiers, compressé)

javadoc : le générateur de documentation

commentaires « normalisés » --> document html

la documentation reste en phase avec le source, à moindres efforts !

Il existe de nombreux environnements de développement dont ECLIPSE


Compilation / Exécution

Unité de base Java = la classe

public class MaClasse { // public = indication de visibilité

définition de « variables d’instances »

définition de « méthodes » (fonctions/procédures)

} Un fichier peut contenir plusieurs classes, une seule d’entre elles doit avoir

l’attribut public. Les autres sont des classes auxiliaires.

Un fichier peut débuter par une déclaration de « paquetage » et/ou des

importations de classes (venant d’autres paquetages)

Correspondances entre classes (publiques) et fichiers

correspondance entre la structure de paquetages et l’organisation du code

source en fichiers/répertoires (détails vus ultérieurement)


Compilation / Exécution (suite)

public class Accueil { // un nom de classe débute par une Majuscule public static void main (String[] args) {

System.out.println("Bienvenue chez Java");}

} La classe doit être contenue dans un fichier de nom Accueil.java

Compilation: javac Accueil.java // javac nom-fichiercrée dans les bons cas Accueil.class

Variable d’environnement CLASSPATH pour localiser les classes nécessaires:une liste ordonnée de répertoires ou d’archives (.jar) séparés par ':'

Remarques:public = visible par tout le mondestatic = la méthode n’est pas associée à un objet particulier mais à la classe en tant que telle.


Compilation / Exécution (fin)

Exécution: java Accueil paramètres-optionnels // java Nom-Classe

La valeur de CLASSPATH doit permettre d’accéder au fichier Accueil.class

la JVM recherche dans Accueil.class une méthode de profil

public static void main (String[] args)et l’exécute

Si une telle méthode n’existe pas = erreur au lancement !Exception … in java.lang.NoSuchMethodError: main

Causes possibles d’erreur :

Le fichier Accueil.class n’est pas accessible via la variable CLASSPATH la classe Accueil et la méthode main doivent être public la méthode main doit être static


Un autre exemple simple

public class Echo { public static void main (String[] args) {

for(int i = 0; i < args.length; i++)System.out.println(args[i] + " " + args[i]);// out est un un objet défini comme attribut de la classe System// println est une méthode appliquée à l’objet System.out// l’opérateur + représente ici la concaténation de chaînes

} //length est un attribut prédéfini des tableaux}

javac Echo.javajava Echo Bonjour les RN

Bonjour Bonjourles lesRN RN


Java: les bases

Syntaxe des instructions très proche de celle de C, la sémantique pas toujours

on distingue « types primitifs » et « objets » (instances des classes) types primitifs :

boolean

char, byte

short, int, long

float, double

void Classes java : mot-clef class; Instances créées par le mot-clef new

pas de type « entier » non signé (unsigned du langage C)

promotion automatique vers le type le plus fort


Types de données primitifs


Java: les références aux instances

on manipule toujours les objets par le biais de « références » (pointeurs) C monC; // monC est une « référence » sur une instance de C

// qui ne référence rien pour l’instant (i.e. null) monC = new C(); : // allocation + mémorisation de la référence dans monC C monC = new C(); // déclaration avec initialisation C[] maTableDeC = new C[10];

// maTableDeC référence un tableau de 10 références à des instances de C

// mais maTableDeC[0] … maTableDeC[9] sont toujours null ! for(int i = 0; i < maTableDeC.length; i++)

maTableDeC[i] = new C();

une fois allouée, les références sont transparentes: maTableDeC[3].val = 12; // en supposant un attribut val dans C !

la désallocation est gérée par le système (« ramasse-miettes »)


Il existe des abréviations:

C maTableDeC[] = { new C(), new C(), new C() };

String[] matieres; // ou String matieres[];!!

matieres = new String[3];

matiere[0] = new String("java"); //ou matiere[0]="java" ?

matiere[1] = new String("ACSI");

matiere[2] = new String("BD");

for(int i = 0; i < matieres.length; i++)

System.out.println(matiere[i]);

int[] table = { 1, 3, 5 }; // en déduit new int[3] tout seul

// int table[3] est syntaxiquement incorrect !


Java: les références aux instances (suite)

Que veulent dire « affectation » et « égalité » des références ??C monC1 = new C();C monC2 = new C();int t1[] = { 1, 2, 3};int t2[] = { 4, 5, 6, 7, 8};...monC1 = monC2; // ?? Coréférence (partage) !t1 = t2; // C’est comme du C, vous avez dit ??? NON !!if (monC1 == monC2)… // teste l’égalité des références !

On aura souvent besoin d’une autre «égalité » (ou équivalence, plutôt !) : if (monC1.equals(monC2))… // quelle méthode equals pour C ?

Même problème pour la copie : affectation "=" ou clone() ?Si on clone, quel type de clonage ?


Des types primitifs aux classes et inversement

Il existe des contextes dans lesquels on veut des objets et non pas des valeurs de type primitif (ex: les « conteneurs » ou « collection » d’objets)ArrayList a = new ArrayList();a.add(1); // KO. ‘1’ n’est pas une instanceif ('a'.equals('b'))… // KOif (1.equals(x)) … // KO

Il existe des « wrappers » (enveloppes) pour faire la correspondance Boolean Character, Byte // new Character('c') Short, Integer, Long // new Integer(3) Float, Double Void // non instanciable !!

a.add(Integer(1)); // OK !


Les wrappers (suite)

Integer Y = Integer(1); Integer X = Integer(3);

Il existe des méthodes de conversion inverse:

intValue() // X.intValue() + 3

les classes « wrapper » définissent des méthodes d’instance : Y.equals(X),Y.compareTo(X),Y.toString(), …

elles définissent aussi des méthodes ou attributs « statiques »Integer.MAX_VALUEInteger.MIN_VALUEInteger.parseInt(String) // retourne une valeurInteger.valueOf(String) // retourne un IntegerInteger.toString(int) // retourne une String


Exercice

Faire la somme d’une suite d’entiers passés sur la ligne de commande !

On prend deux entiers n1, n2 sur la ligne de commande on crée un tableau de n1 int, initialisé avec les entiers de 0 à n1 on crée un tableau de n2 instances de Integer initialisé avec les enveloppes

des entiers de 0 à n2 -1 on calcule la somme des entiers stockés dans les deux tableaux et on l’imprime.


Quelques classes importantes

Object : equals(Object), toString(), getClass(), clone()

String : les chaînes de caractères (ont le statut de constantes !)

charAt, compareTo, equals, concat, indexOf, length

Attention : les String ne sont pas des tableaux de caractères !String char[] byte[]

StringBuffer: les chaînes de caractères modifiables

charAt, delete, reverse, append,

Math: que des méthodes et attributs statiques (cos, sqrt, pi, …)

Random: générateur de nombres aléatoires avec des méthodes telles que

nextInt(), nextInt(int), nextBoolean(),…


Quelques classes importantes (suite)

Les diverses collections (conteneur d’instances) :ArrayList

boolean add(Object) // ajout à la fin !void add(int, Object) // ajout à une place précise !int size()int indexOf(Object) // indice de la première occurrence !Object get(int) // Object ???Iterator iterator()

TreeSet: collection « triée » d’éléments « comparables » (satisfaisant l’interface Comparable, c.à.d. munis de int compareTo(Object))

Les itérateurs (Iterator): ils savent parcourir les collectionsboolean hasNext()Object next()void remove() // comportement pas toujours défini.


Opérateurs, Priorité et Associativité


Les Concepts Objets

Classe : une description d’un ensemble d’objets avec leurs comportements définit la structure des instances de la classe (attributs) + les actions qu’ils

peuvent effectuer (méthodes) sert à créer les instances: new MaClasse() sert à typer : MaClasse C; // C référencera une instance de MaClasse définit aussi ce qui est visible (champs, méthodes) et par qui (autres classes)

4 niveaux: public, protected, paquetage, private définit ce qui est attaché à la classe en tant que telle (static) et ce qui est

attaché à une instance particulière définit ce qui ne peut pas être modifié (final) et ce qui peut l’être

Objets (instances) : les individus qui appartiennent à la classe


Un exemple simple

public class Point2D { private double x = 0.0; // La structure des instances est cachée private double y = 0.0;

// Point2D: « Constructeur » : sert à initialiser les instances nouvellement crééespublic Point2D(double monX, double monY) { x = monX; y = monY; }public Point2D() // un autre constructeur « par défaut » { x = 0.0; y = 0.0; }

public void move(double dx, double dy) { x += dx; y += dy; } // modifie l’instance courante

public String toString() // crée une String « au vol » { return "(" + x + ", " + y + ")" ; }public Point2D symetrique() // crée une nouvelle instance { return new Point2D(-x, -y); }

}


Une classe de test simple

public class TestPoint2D {

public static void main(String[] args) {

Point2D p = new Point2D(12.0, 23.0);

System.out.println(p.toString());

p1.move(-5.0, 2.0);


System.out.println(p.symetrique().toString());


}}

Remarque 1: Plutôt que de définir une classe de test, on aurait pu définir dans Point2D une

méthode main de test (unitaire) de la classe.

Remarque 2: on ne dit pas d’où vient Point2D !

Il faudrait aussi une méthode clone() et une méthode equals() !


public class Employe { private String nom; // on pourrait ajouter l’adresse, le prénom, l’âge... private float sal; private int id; // chaque employé a un numéro de badge unique

private static int dernierId = 0; // pour produire des « id » distincts

private static Employe[] listeEmployes = new Employe[50] ;// on se limite à 50 employés

// à suivre ...

Un exemple plus complet


Exemple (suite)

public Employe(String nom, float sal) { // constructeur ! this.nom = nom; this.sal = sal; this.id = Employe.newId(this); } //ou dans ce dernier cas: id = newId(this)

private static int newId(Employe e) { listeEmployes[dernierId] = e; return dernierId++ ; }

public String toString(){ // abréviation possible ci-dessous return nom + " " + (new Integer(id)).toString()

+ " " + (new Float(sal)).toString(); }

public static void listingEmployes() { for(int i = 0; i < Employe.dernierId; i++) System.out.println(listeEmployes[i].toString());

}} // fin de la classe Employe


Exemple (fin)

public class TestEmploye {

public static void main(String[] args) {

Employe e1 = new Employe("Dupont", 100.23F);

Employe e2 = new Employe("Albert", 112.23F);

Employe e3 = new Employe("Valentine", 500F);

Employe.listingEmployes();

}

}

Attention: dans cette version, on ne peut avoir de facto qu’une seule entreprise (celle-ci est implicite, à cause de la liste des employées qui est une variable « statique »)


import java.util.ArrayList; // pour la classe ArrayList ci-dessous

public class Employe { // sans changement: attributs nom, sal, id et dernierId

// de même que les méthodes Employe et toString

private static ArrayList listeEmployes = new ArrayList();

private static int newId(Employe e) { listeEmployes.add(e); return dernierId++; }

public static void listingEmployes() { for(int i = 0; i < listeEmployes.size(); i++) System.out.println(listeEmployes.get(i).toString());

} // ou ((Employe) listeEmployes.get(i))

}

Le même exemple revisité


Retour sur les attributs

Chaque instance a son propre jeu de variables d’instances (non static)

Il n’existe qu’un seul exemplaire des variables « de classe » (static)

Les règles d’initialisation sont différentes (static = à la première référence à la classe)

Pour initialiser les variables d’instance, il existe des valeurs par défaut il vaut mieux le faire soi-même par le biais des constructeurs ou à la déclaration

Les variables de classe sont accessibles à l’aide du nom de la classe ou de

l’intérieur des méthodes (classes ou instances) de la classe

final pour dire qu’un attribut ne change pas de valeur (constante)

En général, les attributs ne sont pas public


Retour sur les méthodes

Méthodes d’instances:

public, sauf si elles ne servent que de méthodes auxiliaires pour la réalisation

d’autres méthodes

Appel: objetReceveur.nomMéthodes(arguments)

dans le corps de la méthode :

on peut accéder aux attributs définis par la classe.

on peut désigner le receveur du message par this

on peut omettre this

on peut définir des méthodes pour accéder ou modifier les attributs et leur associer

un niveau de visibilité. Cela peut éviter de rendre ces attributs directement visibles.


Retour sur les méthodes (suite)

Méthodes de classes (static) même principe pour la visibilité

appel: NomClasse.nomMéthodes(arguments)

accès impossible aux variables d’instance (de quelle instance ???)

Tant les méthodes d’instances que les méthodes de classes peuvent être surchargées (i.e. avoir le même nom)

Deux méthodes surchargées ne peuvent pas se différencier uniquement par le type de la valeur de retour


Les constructeurs

des méthodes pour initialiser les instances à la création…

si une classe ne définit pas de constructeur, le système fournit un constructeur par défaut, sans argument

si une classe définit au moins un constructeur, il n’existe plus de constructeur par défaut implicite (mais on peut en définir un !)

Le choix du constructeurs appelé est guidé par les paramètres

syntaxe imposée: pas de type de retour le nom de la méthode est celui de la classe


Les constructeurs (suite)

on peut surcharger les constructeurs pour offrir plusieurs syntaxes d’appel possibles

public Employe(String nom) { this(nom, Employe.salaireParDefaut);

System.out.println("Bienvenu cher " + nom);

}

où Employe.salaireParDefaut serait une nouvelle variable de classe.

Utilisation ? Employe E5 = new Employe("coco");

un constructeur peut en appeler un autre via la notation this(…) mais celle-ci doit

être la première instruction du nouveau constructeur

l’appel à new lance automatiquement le constructeur Erreur (à la compilation) si aucun constructeur n’est appelable (visibilité,

paramètres), compte-tenu des constructeurs définis


Exercice

Définir deux classes Employe et Entreprise telles que :

Chaque employé a: nom, salaire, ident. unique, éventuellement une entreprise

Chaque entreprise a: nom, statut (liste fixe de statuts : SA, SARL,…) nombre et collection d’employés

On peut créer un nouvel employé, lister ses informations, lister tous les employés connus

On peut créer une entreprise, lister ses salariés, embaucher une personne (quitte à la débaucher de son entreprise actuelle), débaucher un employé. Un employé sans employeur actuel reste connu du système.

avec toute méthode ou attribut nécessaire…

f. voisin : introduction à java 1 introduction à java frédéric voisin fiifo - « remise à...

Documents

java source java

classes u java

java page

java javac

base java

navigateurs web u java

amlioration io u java

marketing java n moderne