Cours Java Avancée - ChapI

JAVA AVANCÉE
Chapitre I : Programmation Java

Contenu
 Présentation générale
 Notions techniques
 Applet
 Conversion
 Entrée/Sortie standard
 Mots clés
 Héritage et polymorphisme
 Classes internes
 Introspection
 Classes d’usage courant
9 Java Avancée- Selma BATTI ATTIA 2020/2021

Présentation générale : Historique
 Naissance : Oak (chêne), 1990 en Californie
 Patrick Naughton, James Gosling et de Mike Sheridan avec d’autres
ingénieur dans le cadre du projet "Projet Stealth" rebatisé "Green
Project".
 Première démo en Septembre 1992, PDA nommé Star7 avec un
assistant graphique appelé Duke
 Chez SUN :
 Java (café), 1992
 Java2, 2000, J2EE et J2SE
 Java5, 2002, généricité
 Chez Oracle : 2009
 Java8, 2014, Expression , Stream
 Java13, 2019, Dynamic CDS Archives, ZGC, Legacy Socket API,
Switch Expressions, Text Blocks

Présentation générale : Différentes versions
Version Label JDK Nom de code Statut
1.0 Java 1.0 JDK 1.0.2 Oak N'est plus soutenu de façon active
1.1 Java 1.1 1.1.8_16 N'est plus soutenu de façon active
1.2 J2SE 1.2 1.2.2_11 Playground N'est plus soutenu de façon active
1.3 J2SE 1.3 1.3.1_29 Kestrel Obsolète
1.4 J2SE 1.4 1.4.2_30 Merlin Obsolète
1.5 J2SE 5.0 1.5.0_22 Tiger Obsolète - 5u51 à 5u85 uniquement
disponibles avec un support Oracle spécifique
1.6 Java SE 6 6u113 Mustang Obsolète - 6u51 à 6u111 uniquement
disponibles avec un support Oracle spécifique
1.7 Java SE 7 1.7.0_79 Dolphin Stable, actuel, version 1.7.0_79 proposée aux
utilisateurs
1.8 Java SE 1.8.0_121 Kenai Stable, actuel, version 1.8.0_121 proposée aux
utilisateurs

Présentation générale : Quelques chiffres
 Quelques chiffres et faits à propos de Java en 2011 :
 97% des machines d'entreprises ont une JVM installée
 Java est téléchargé plus d'un milliards de fois chaque année
 Il y a plus de 9 millions de développeurs Java dans le monde
 Java est un des langages les plus utilisés dans le monde
 Tous les lecteurs de Blue-Ray utilisent Java
 Plus de 3 milliards d'appareils mobiles peuvent mettre en
œuvre Java
 Plus de 1,4 milliards de cartes à puce utilisant Java sont
produites

Présentation générale : Caractéristiques de Java
 Caractéristiques de Java :
 Interprété : le source est compilé en pseudo code ou "byte code" puis exécuté
par un interpréteur Java : la JVM.
 Portable : le code reste indépendant de la machine sur laquelle il s'exécute.
 Orienté objet : chaque fichier source contient la définition d'une ou plusieurs
classes qui sont utilisées les unes avec les autres pour former une application.
 Simple : le choix de ses auteurs a été d'abandonner des éléments mal compris ou
mal exploités des autres langages.
 Fortement typé : toutes les variables sont typées et il n'existe pas de conversion
automatique avec perte de données.

Présentation générale : Suite des caractéristiques
 Assure la gestion de mémoire : l'allocation de la mémoire pour un objet
est automatique à sa création et Java récupère automatiquement la mémoire
inutilisée grâce au "garbage collector".
 Sûre : la sécurité fait partie intégrante du système d'exécution et du compilateur.
 Économe : le pseudo code a une taille relativement petite car les bibliothèques
de classes requises ne sont liées qu'à l'exécution.
 Multitâche : il permet l'utilisation de threads qui sont des unités d'exécution
isolées.
Slogan de Sun : WORA ("Write Once, Run Anywhere")

Présentation générale : Différents outils de Java
 Oracle fourni gratuitement un ensemble d'outils et d'API pour
permettre le développement de programmes avec Java. Ce kit,
nommé JDK, est librement téléchargeable sur le site web
d’Oracle http://www.oracle.com/technetwork/java/index.html
 Le JRE (Java Runtime Environment) contient uniquement

l'environnement d'exécution de programmes Java. Le JDK
contient lui même le JRE.
 Le JRE seul doit être installé sur les machines où des applications
Java doivent être juste exécutées.

Présentation générale : Différentes éditions de Java
 Sun définit trois plateformes d'exécution (ou éditions) pour Java
distinctes selon les besoins des applications à développer :
 Java Standard Edition (J2SE / Java SE) : environnement d'exécution et
ensemble complet d'API pour des applications de type desktop. Cette plate-
forme sert de base en tout ou partie aux autres plateformes.
 Java Enterprise Edition (J2EE / Java EE) : environnement d'exécution

reposant intégralement sur Java SE pour le développement d'applications
d'entreprises.
 Java Micro Edition (J2ME / Java ME) : environnement d'exécution et API

pour le développement d'applications sur appareils mobiles et embarqués
dont les capacités ne permettent pas la mise en œuvre de Java SE.

Notions techniques
 La plate-forme Java utilise quelques notions base dans sa mise en
œuvre notamment :
 la compilation du code source dans un langage indépendant de la plate-
forme d'exécution : le "byte code"
 l'exécution du "byte code" par une machine virtuelle nommée JVM (Java
Virtual Machine)
 la notion de paquetage ("package") qui permet d'organiser les classes
 le "classpath" qui permet de préciser au compilateur et à la JVM où elle peut
trouver les classes requises par l'application
 le packaging des classes compilés dans une archive de déploiement nommé
jar (Java ARchive)

Notions techniques : Compilation & exécution
//test01.java
…>javac test01.java
public class test01{
public static void main (String [] args){ …>javac test03.java
…
…
} //test03.java
…
} 1011011…
public class test03{
class test02{ …
… …
… 011011… • test03.class
}
}
• test02.class
0101011…
• test01.class
…>java test01

Notions techniques : Packages
 Les fichiers sources peuvent être organisés en package.
Les packages définissent une hiérarchie de noms,
chaque nom étant séparé par le caractère point.
 Le nom d'un package est lié à une arborescence de sous

répertoire correspondant à ce nom.
 Le package est précisé dans le fichier source grâce à

l'instruction "package". Le fichier doit donc dans ce cas
être stocké dans une arborescence de répertoires qui
correspond au nom du package.
Notions techniques : Packages (suite)
 Dans le code source, pour éviter d'avoir à utiliser les noms pleinement qualifiés
des classes, il est possible d'utiliser l'instruction "import" suivi d'un nom de
package suivi d'un caractère "." et du nom d'une classe ou du caractère "*"
(l'instruction import sera détaillée plus tard).
 L'API Java est organisée en packages répartis en trois grands ensembles :

 Packages standards : ce sont les sous packages du package java
 Packages d'extensions : ce sont les sous packages du package javax
 Packages tiers : ces packages concernant notamment Corba et XML

Notions techniques : Packages de base
Packages JDK JDK JDK JDK JDK JDK JDK JDK JDK
1.0 1.1 1.2 1.3 1.4 1.5 6.0 7.0 8.0
java.applet
X X X X X X X X X
Développement des applets
java.awt
X* X* X* X X X X X X
Toolkit pour interfaces graphiques
java.beans
X* X X X X X X X
Développer des composants réutilisables
java.io
X X X X X X X X X
Gérer les flux
java.lang
X* X* X* X* X* X X X X
Classes de base du langage
java.math
X X X X X X X X
Utiliser des opérations mathématiques
java.net
X X X X X X X X X
Utiliser les fonctionnalités réseaux
*:certains sous-packages ne font pas partie di JDK et ont étés rajoutés dans des versions ultérieures

Notions techniques : Packages de base (suite)
1.0 1.1 1.2 1.3 1.4 1.5 6.0 7.0 8.0
java.nio X X X X X
java.rmi
X* X X X X X X X
Développement d'objets distribués
java.security
X* X X X X X X X
Gérer les signatures et les certifications
java.sql
X X X X X X X X
JDBC pour l'accès aux bases de données
java.text
X* X* X* X* X* X X X
Formater des objets en texte
java.util
X* X* X* X* X* X* X X X
Utilitaires divers
javax.accessibility X X X X X X X
javax.activation X X X
javax.activity X X X X

Notions techniques : Packages de base (suite 2)
1.0 1.1 1.2 1.3 1.4 1.5 6.0 7.0 8.0
javax.annotation X X X
javax.crypto
X X X X X
Utiliser le cryptage des données
javax.imageio X* X X X X
javax.jws X X X
javax.lang.model X X X
javax.management X X X X
javax.naming X X X X X X
javax.net X X X X X
javax.print X X X X X
javax.rmi X* X* X X X X
… X X

Notions techniques : Le "classpath"
 Le compilateur java ("javac") et la machine virtuelle
("java") prennent en charge l'option "classpath".
 Cette option permet d'indiquer au compilateur ou à la
JVM où chercher les classes et paquetages sollicités dans
le code.
 Exemple :
javac -classpath rep1; rep2 App.java
où rep1 et rep2 sont les chemins ou se trouve des classes sollicitées dans le code
du fichier App.java

Notions techniques : Java archive (JAR)
 Il est possible de créer une enveloppe qui va contenir tous les
fichiers d'une application Java ou une portion de cette application
dans un fichier .jar (Java archive).
 Le Java archive inclus : l'arborescence des packages, les fichiers
.class, les fichiers de ressources (images, configuration, ...), ...
 Un fichier .jar est physiquement une archive de type Zip qui
contient tous ces éléments.
 L'outil jar fourni avec le jdk permet de manipuler les fichiers jar.

Notions techniques : Commandes JAR
Opération Commande
Création d'un fichier JAR jar cf fichier_jar fichier_1 fichier_2 …
Visualiser le contenu d'un jar tf fichier_jar
fichier JAR
Extraire le contenu d'un fichier jar xf fichier_jar
JAR
Extraire des fichiers en jar xf fichier_jar fichier_1 fichier_2 …
particulier d'un fichier JAR
Exécuter une application java –jar application.jar
compressée dans un fichier JAR
Invoquer une applet <applet code=fichier.class
compressée dans un fichier JAR archive ="fichier_jar.jar"
width=largeur height=hauteur>
</applet>

Applet : Exécution d'une applet
 Créer une page HTML.
 Exemple :
<HTML>
<TITLE> test applet Java </TITLE>
<BODY>
<APPLET code="NomFichier.class" width="270" height="200"> </APPLET>
</BODY>
</HTML>
 Visualiser la page dans l'appletviewer ou dans un

navigateur compatible avec la version de Java dans
laquelle l'applet est écrite.

Exemple d’une Applet : Animation d’un logo
import java.applet.*;
import java.awt.*;
public class AppletAnimation extends Applet implements Runnable {

Thread thread;
protected Image tabImage[];
protected int index;
public void init() {

super.init();
// chargement du tableau d'images
index = 0;
tabImage = new Image[2];
for (int i = 0; i < tabImage.length; i++) {
String fichier = new String("monimage" + (i + 1) + ".gif ");
tabImage[i] = getImage(getDocumentBase(), fichier);
}
}

Applet : Suite le l’exemple
public void paint(Graphics g) {
super.paint(g);
// affichage de l'image
g.drawImage(tabImage[index], 10, 10, this);
}
public void run() {

// traitements exécutés par le thread
while (true) {
repaint();
index++;
if (index >= tabImage.length)
index = 0;
try {
thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

Applet : Suite et fin de l’exemple
public void start() {
// démarrage du thread
if (thread == null) {
thread = new Thread(this);
thread.start();
}
}
public void stop() {

// arrêt du thread
if (thread != null) {
thread.stop();
thread = null;
}
}
public void update(Graphics g) {

// la redéfinition de la méthode permet d'éviter les scintillements
paint(g);
}
}
* Développons en Java, v 2.20 Copyright (C) 1999-2019, Jean-Michel DOUDOUX (https://www.jmdoudoux.fr/java/dej/chap-applets.htm)

Conversion de type
 Possibilité d'utiliser le casting.
 Plusieurs classes de l'API fournissent des méthodes de
manipulation et de conversion de types élémentaires
Classe Rôle
String pour les chaines de caractères Unicode
Integer pour les valeurs entières (integer)
Long pour les entiers longs signés (long)
Float pour les nombres à virgules flottante (float)
Double pour les nombres à virgule flottante en double précision (double)

Exemple de conversion de type
 Conversion implicite :
 float f;
 int i = 25;
 f = i; // Conversion de int vers float
 System.out.println (f); //25.0
 Conversion explicite :
 float f = 25.5F;
 int i;
 i = (int)f; // Conversion de float vers int
 System.out.println (i); //25

Entrée/Sorite standard
Ecriture des informations à

l'écran Traitement des informations
U.C
Mémoire
Lecture des informations depuis

un fichier du disque
Ecriture des informations sur un
fichier du disque
Lecture d'informations Disque
provenant du clavier

Sortie standard
System.out.println(expression)
 où expression est tout type de donnée qui peut être

converti en chaîne de caractères pour être affiché à
l'écran.

Entrée standard
 Le flux de données provenant du clavier est désigné par l'objet
System.in de type InputStream. Ce type d'objets permet de lire
des données caractère par caractère.
 Le type InputStream ne permet pas de lire d'un seul coup une
ligne de texte. Le type BufferedReader le permet avec la méthode
readLine.
BufferedReader IN=new BufferedReader(new InputStreamReader(System.in));

…
String s = IN.readLine();

Mot clé "static"
 S'applique aux :
 Attributs
 Méthodes
 Permet de :
 Définir un attribut de classe partagé entre toutes les instances
d'une même classe
 Définir une méthode qui n'utilisent que des attributs statiques

Mot clé "final"
 Attributs
 Méthodes
 Classes
 Permet de :
 Définir un attribut qui ne change plus de valeur après son
initialisation.
 Définir une méthode qui ne peut plus être surchargée dans une
classe héritière.
 Définir une classe qui ne peut être dérivée (mère).

Mot clé "abstract"
 Méthodes
 Classes
 Permet de :
 Indiquer que la classe ne pourra être instanciée telle quelle.
 Forcer l'implémentation de la méthode dans une sous classe.
 Une classe est automatiquement abstraite dès qu'une de ses
méthodes est déclarée abstraite.
 Il est possible de définir une classe abstraite sans méthodes
abstraites.

Mot clé "synchronized"
 Attributs
 Méthodes
 Permet de :
 Gérer l'accès concurrent aux attributs et méthodes lors de
traitement de thread (exécution simultanée de plusieurs petites
parties de code du programme).

Mot clé "volatile"
 Attributs
 Permet de :
 Préciser que l'attribut peut être changé par un périphérique ou
de manière asynchrone. Cela indique au compilateur de ne pas
stocker cet attribut dans des registres. A chaque utilisation, on
lit la valeur et on réécrit immédiatement le résultat s'il a changé.

Mot clé "native"
 Méthodes
 Permet de :
 Indiquer que la méthode est implémentée dans un autre
langage.
 L'utilisation de ce type de méthode limite la portabilité

du code mais permet une vitesse exécution plus rapide.

Héritage et polymorphisme
 Généralités sur l'héritage
 Mot clé "super"
 Surcharge ses méthodes
 Polymorphisme
 Interfaces

Héritage
 Créer facilement de nouvelles classes à partir de classes
existantes  réutilisation du code.
 Syntaxe pour que la classe "A" hérite des propriétés de
la classe "B" :
public class A extends B
 La classe A est appelée la classe parent (ou mère) et la
classe B la classe dérivée (ou fille). Un objet A a toutes
les qualités d'un objet B en plus des attributs et
méthodes qui lui sont spécifiques.

Surcharge des méthodes
 L'héritage permet de surcharger dans la classe fille des
méthodes de même nom dans la classe mère.
 La surcharge permet d'adapter la classe fille à ses
propres besoins.
 Une méthode surchargée chez la fille peut se baser sur la
méthode de la mère qui est appelée grâce au mot clé
"super".

Polymorphisme
 Définition : la faculté pour une variable de référencer
différents types d'objets (héritiers).
C
B
A
void affiche (){
…("Je suis le C."); void affiche (){
} …("Je suis le B."); void affiche (){
} …("Je suis le A.");
A a = new A(); }
a = new B();
a = new C();  L'héritage définit un "casting" implicite de la
classe fille vers la classe mère

Gestion du polymorphisme
 La gestion du polymorphisme est assurée par la machine
virtuelle dynamiquement à l'exécution.
 Une méthode héritée et surchargée : la forme de la
méthode à exécuter est choisie en fonction des
paramètres associés à l'appel.
 Compte tenu du principe de l'héritage, le temps
d'exécution du programme et la taille du code source et
de l'exécutable augmentent.

Surcharge et polymorphisme
 Le système va chercher la méthode appelée dans la hiérarchie des
classes menant à la classe qui définie l'objet référencé en
commençant par la dernière.
 Exemple :
A a = new C();
a.affiche();
 Le système va chercher la méthode affiche() dans la classe C,
 S'il ne la trouve pas, il cherche dans la classe mère B,
 S'il ne la trouve pas, il cherche dans la classe mère A,
 S'il ne la trouve pas, il la cherche dans la classe mère de toutes les classes
Java "Object"

Définition des interfaces
 L'héritage multiple n'existe pas en Java.
 Les interfaces permettent de mettre en œuvre un
mécanisme de remplacement.
 Une interface est un ensemble de constantes et de
déclarations de méthodes.
 Tous les classes qui implémentent une interface
possèdent les méthodes et les constantes déclarées dans
celle-ci.
 Plusieurs interfaces peuvent être implémentées dans une
même classe.

Syntaxe des interfaces
[public] interface Interface [implements Interface1,
Interface2 …] {
// declaration des méthodes
// ou des attributs statiques
}
Modificateurs class nomClasse [extends superClasse]
[implements Interface1, Interface2 …] {
//méthodes et attributs
}

Contraintes des interfaces
 Toutes les méthodes d'une interface sont abstraites :
elles sont implicitement déclarées comme telles.
 Une interface peut être d'accès public ou par défaut.
Toutes ses méthodes sont implicitement de même
modificateur même si elles ne sont pas déclarées avec le
modificateur.
 Les attributs des interfaces sont des variables statiques
qui doivent être constantes : implicitement static et final.

Polymorphisme et interfaces
 L'implémentation d'une interface définit un casting,
l'implémentation d'une interface est une forme d'héritage.
 L'héritage d'une classe qui implémente une interface définit un
casting implicite de la classe fille vers cette interface.
 Suite au casting, il n'est possible de faire des appels qu'à des
méthodes de l'interface. Pour utiliser des méthodes de l'objet, il
faut définir un casting explicite : il est préférable de contrôler la
classe de l'objet pour éviter une exception ClassCastException à
l'exécution.

Interfaces dans Java 8
 Java 8 permet aux interfaces :
 de définir des méthodes avec un comportement par défaut
 de définir des méthodes statiques
 Tout en évitant les problèmes reliés à l’héritage multiple.

Interfaces dans Java 8 : Méthodes statiques
 Exemple :
public interface Interface1 {
public static void description() {
System.out.println("Méthode statique dans une interface.");
}
}
public class Main {

public static void main(String[] args) {
Interface1.description();
}
}
 Résultat :
Méthode statique dans une interface.

 Autre exemple :
public interface Interface2 extends Interface1 {
System.out.println("Redéfinie dans Interface2.");
}
}

}
}

 Programme de test :
public class Main {
public static void main(String[] args) {
}
}
 Résultat :
Redéfinie dans Interface2.
Redéfinie dans Interface3.

Interfaces dans Java 8 : Méthodes par défaut
 Il est possible d'ajouter un comportement par défaut à des
méthodes dans une interface grâce au mot clé « default ».
 Exemple :
}
default void fct() {
System.out.println("Méthode par défaut de l’Interface2.");
}
}

}
default void fct() {
System.out.println("Méthode par défaut de l’Interface3.");
}
}

public class ClasseTest implements Interface2, Interface3 {
public void fct() {
System.out.println("Je suis la méthode

de la classe d’implémentation
des Interfaces 2 et 3.");
}
}

public class ClasseTest implements Interface3, Interface2 {
public void fct() {
System.out.println("Je suis la méthode

de la classe d’implémentation
des Interfaces 2 et 3.");
Interface2.super.fct ();
Interface3.super.fct ();
}
}
Classes internes
 Définition
 Caractéristiques
 Classes internes non statiques
 Classes internes locales
 Classes internes anonymes
 Classes internes statiques

Définition des classes internes
 Si une classe n'a de sens que pour une autre classe :
donner son implémentation dans la classe qui l'utilise.
 Exemple : le métier de monteur de ligne n'existe que
chez les fournisseurs et gérants des réseaux électriques
(STEG).
GestResElec
… class GestResElec{
… …
class MonteurDeLigne{
…
MonteurDeLigne }
… }
…
Caractéristiques des classes internes
 Il est possible d'imbriquer plusieurs classes internes.
Mais des classes imbriquées ne peuvent avoir le même
noms.
 Le nom de la classe interne utilise la notation qualifiée
avec le point préfixé par le nom de la classe où elle est
définie.
 Le nom du fichier du byte code de la classe interne est
géré par le compilateur : concaténation des noms des
classes dans l'ordre d'inclusion séparés par le caractère $
(dollar).

Classe interne non statique
 Définie dans une classe dite "principale" en tant que
membre de cette classe.
 Peut accéder aux autres membres de la classe principale
même ceux déclarés avec le modificateur "private".
 Les membres de la classe principale sont accessibles :
 Par leurs noms, s'il n'y a pas de conflit
 Par la version qualifiée du mot clé "this" : le nom de la classe.

Classe interne locale
 Définie à l'intérieure d'une méthode ou d'un bloc de
code
 Utilisable que dans le bloc de code où elle est définie.
 La classes peut accéder :
 Aux membres de la classe principale.
 Aux variables locales constante du bloc où elle est déclarée.

Classe interne anonyme
 Définie dans une classe sans avoir de nom. Elle ne peut
être instanciée qu'à l'endroit ou elle est définie.
 Syntaxe :
new classe_ou_interface () {
// définition des attributs et des méthodes
// de la classe interne
}
 Peut hériter d'une classe ou implémenter une interface.
 Ne peut pas avoir de constructeur.

Classe interne statique
 Définie dans une classe principale avec le modificateur
"static".
 Elle ne peut pas accéder aux membres d'instance de sa
classe principale.
 Elle peut avoir accès aux variables statiques de la classe
principale.

Gestion dynamique des objets
 Présentation de l'introspection
 Classe "class"
 Méthodes de "Class"
 Opérateur "instanceof"

Présentation
 L'introspection est un mécanisme qui permet de
connaître le contenu d'une classe dynamiquement.
 Il permet notamment de savoir ce que contient une
classe sans en avoir les sources.
 Les différentes classes utiles pour l'introspection sont
rassemblées dans le package "java.lang.reflect".

Classe "class"
 Définie dans le package "java.lang".
 La méthode "getClass()" de la classe "Object" retourne une
instance de la classe "Class".
 La méthode statique "forName()" de la classe prend en
argument une chaîne désignant une classe et retourne
un objet de la classe "Class" pour cette classe (exception
"ClassNotFoundException").
 L'attribut "class" appartient à la classe "Object" et est de
type "Class".

Méthodes de la classe "Class"
Méthode Principe
static Class forName(String) Instancie un objet de la classe dont le nom est
fourni en paramètre et renvoie
un objet Class la représentant
Class[] getClasses() Renvoie les classes et interfaces publiques qui
sont membres de la classe
Constructor[] getConstructors() Renvoie les constructeurs publics de la classe
Class[] getDeclaredClasses() Renvoie un tableau des classes définies comme
membre dans la classe
Constructor[] Renvoie tous les constructeurs de la classe
getDeclaredConstructors()
Field[] getDeclaredFields() Renvoie un tableau de tous les attributs définis
dans la classe

Suite des méthodes de "Class"
Méthode Principe
Method getDeclaredMethods() Renvoie un tableau des méthodes
Field getFields() Renvoie un tableau des attributs publics
Class[] getInterfaces() Renvoie un tableau des interfaces implémentées
par la classe
Method getMethod() Renvoie un tableau des méthodes publiques
incluant celles héritées
int getModifiers() Renvoie un entier qu'il faut décoder pour
connaître les modificateurs de la classe
Package getPackage() Renvoie le package de la classe
Classe getSuperClass() Renvoie la classe mère de la classe
boolean isArray() Indique si la classe est un tableau
boolean IsInterface() Indique si la classe est une interface
Object newInstance() Permet de créer une nouvelle instance

Opérateur "instanceof"
 L'opérateur "instanceof" permet de déterminer si l'objet
est une instance de la classe donnée en paramètre.
 Syntaxe :
objet instanceof classe

Exemple
void afficheChaine(Object o) {
if (o instanceof MaClasse){
MaClasse m = (MaClasse) o;
System.out.println(m.getChaine());
// OU System.out.println( ((MaClasse)
o).getChaine() );
}
}

Classes d'usage courant
 Classe String
 Classe Vector
 Classe ArrayList
 Classe Arrays A voir dans le chapitre de la généricité
 Classe Enumeration
 Classe Hashtable

Classe "String"
 La classe "String" représente les chaînes de caractères.
 Exemple :
String nom;
nom="cheval";
///*ou*/ nom=new String("cheval");

Quelques méthodes de "String"
Méthodes Description
public char charAt(int i) donne le caractère i de la chaîne, le premier caractère
ayant l'indice 0.
public int compareTo(chaine2) compare une chaine à chaine2 et rend 0 si
chaine1=chaine2, 1 si chaine1>chaine2, -1 si
chaine1<chaine2
public boolean equals(Object rend vrai si chaine1=chaine2, faux sinon
anObject)
public String trim() rend la chaine débarrassée de ses espaces de début et de
fin
public String substring(int rend la sous chaine comprise entre les deux indices
beginIndex, int endIndex)
public char[] toCharArray() permet de mettre les caractères de la chaîne dans un
tableau de caractères
int length() nombre de caractères de la chaîne
int indexOf(String chaine2) rend la première position de chaine2 dans la chaîne
courante ou -1 si chaine2 n'est pas présente
Autres méthodes de "String"
public String toLowerCase() rend chaine en minuscules
public String toUpperCase() rend chaine en majuscules
int indexOf(String chaine2, int rend la première position de chaine2 dans la chaîne
startIndex) courante ou -1 si chaine2 n'est pas présente. La
recherche commence à partir du caractère n°
startIndex.
boolean endsWith(String chaine2) rend vrai si la chaîne courante finit par chaine2
boolean startsWith(String chaine2) rend vrai si la chaîne commence par chaine2
int lastIndexOf(String chaine2) rend la dernière position de chaine2 dans la chaîne
courante sinon -1
boolean matches(String regex) rend vrai si la chaîne courante correspond à
l'expression régulière regex.
String[] split(String regex) permet de récupérer les champs séparés par la chaine
regex dans un tableau.
String replace(char oldChar, char remplace dans la chaîne courante le caractère oldChar
newChar) par le caractère newChar.

Cours Java Avancée - ChapI

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Java Avancée - ChapI

Transféré par

Droits d'auteur :

Formats disponibles

JAVA AVANCÉE

Chapitre I : Programmation Java

9 Java Avancée- Selma BATTI ATTIA 2020/2021

10 Java Avancée- Selma BATTI ATTIA 2020/2021

11 Java Avancée- Selma BATTI ATTIA 2020/2021

12 Java Avancée- Selma BATTI ATTIA 2020/2021

13 Java Avancée- Selma BATTI ATTIA 2020/2021

Slogan de Sun : WORA ("Write Once, Run Anywhere")

14 Java Avancée- Selma BATTI ATTIA 2020/2021

 Le JRE (Java Runtime Environment) contient uniquement

15 Java Avancée- Selma BATTI ATTIA 2020/2021

 Java Enterprise Edition (J2EE / Java EE) : environnement d'exécution

 Java Micro Edition (J2ME / Java ME) : environnement d'exécution et API

16 Java Avancée- Selma BATTI ATTIA 2020/2021

17 Java Avancée- Selma BATTI ATTIA 2020/2021

18 Java Avancée- Selma BATTI ATTIA 2020/2021

 Le nom d'un package est lié à une arborescence de sous

 Le package est précisé dans le fichier source grâce à

 L'API Java est organisée en packages répartis en trois grands ensembles :

20 Java Avancée- Selma BATTI ATTIA 2020/2021

21 Java Avancée- Selma BATTI ATTIA 2020/2021

22 Java Avancée- Selma BATTI ATTIA 2020/2021

23 Java Avancée- Selma BATTI ATTIA 2020/2021

24 Java Avancée- Selma BATTI ATTIA 2020/2021

25 Java Avancée- Selma BATTI ATTIA 2020/2021

26 Java Avancée- Selma BATTI ATTIA 2020/2021

 Visualiser la page dans l'appletviewer ou dans un

27 Java Avancée- Selma BATTI ATTIA 2020/2021

public class AppletAnimation extends Applet implements Runnable {

public void init() {

28 Java Avancée- Selma BATTI ATTIA 2020/2021

public void run() {

29 Java Avancée- Selma BATTI ATTIA 2020/2021

public void stop() {

public void update(Graphics g) {

* Développons en Java, v 2.20 Copyright (C) 1999-2019, Jean-Michel DOUDOUX (https://www.jmdoudoux.fr/java/dej/chap-applets.htm)

30 Java Avancée- Selma BATTI ATTIA 2020/2021

31 Java Avancée- Selma BATTI ATTIA 2020/2021

32 Java Avancée- Selma BATTI ATTIA 2020/2021

Ecriture des informations à

Lecture des informations depuis

33 Java Avancée- Selma BATTI ATTIA 2020/2021

 où expression est tout type de donnée qui peut être

34 Java Avancée- Selma BATTI ATTIA 2020/2021

BufferedReader IN=new BufferedReader(new InputStreamReader(System.in));

35 Java Avancée- Selma BATTI ATTIA 2020/2021

45 Java Avancée- Selma BATTI ATTIA 2020/2021

46 Java Avancée- Selma BATTI ATTIA 2020/2021

47 Java Avancée- Selma BATTI ATTIA 2020/2021

48 Java Avancée- Selma BATTI ATTIA 2020/2021

49 Java Avancée- Selma BATTI ATTIA 2020/2021

 L'utilisation de ce type de méthode limite la portabilité

50 Java Avancée- Selma BATTI ATTIA 2020/2021

51 Java Avancée- Selma BATTI ATTIA 2020/2021

52 Java Avancée- Selma BATTI ATTIA 2020/2021

53 Java Avancée- Selma BATTI ATTIA 2020/2021

54 Java Avancée- Selma BATTI ATTIA 2020/2021

55 Java Avancée- Selma BATTI ATTIA 2020/2021

56 Java Avancée- Selma BATTI ATTIA 2020/2021

57 Java Avancée- Selma BATTI ATTIA 2020/2021

58 Java Avancée- Selma BATTI ATTIA 2020/2021

59 Java Avancée- Selma BATTI ATTIA 2020/2021

60 Java Avancée- Selma BATTI ATTIA 2020/2021