En POO, on peut manipuler des variables



01- LES BASES EN JAVA

INTRODUCTION

Définition :

JAVA est un langage de programmation objet créé en 1991 par la firme Sun Microsystems.

Il est très proche du langage C++. C’est un langage portable (indépendant des plates formes : windows, linux….), compilé et interprété. Java est en plus multitâche, robuste ( gestion d’erreurs et d’exceptions intégrées au langage), gratuit, orienté client/serveur (traditionnel ou web).

Avec java, on peut écrire :

• Des applications client/serveur traditionnel

• Des applications côté cliente pour le web (applet)

• Des applications côté serveur pour le web (servlet)

Outils nécessaires :

Pour écrire et mettre au point un programme, vous aurez besoin :

• d'un éditeur de texte. Au choix :

o Les plus courants : bloc-notes, gvim, gedit

o Les plus appropriés pour java : jcreator

o Les spécialisés (IDE) : netbean, eclipse

• du kit de développement appelé J2SE SDK (Software Development Kit) contenant :

o un compilateur : javac

o un interpréteur : java

o la machine virtuelle java appelée J2SE JRE (Java Runtime Environment )

o des utilitaires. Ex : javadoc pour générer de la documentation , jar pour générer des archives, appletviewer pour visualiser des applets,….

Liens utiles :

• Le site dédié à JAVA par son constructeur :

• Et plus particulièrement la documentation sur les classes (API) :



• Des cours et exercices en ligne :

Premier programme :

Stocker une information simple

Vous connaissez déjà l’utilité des variables, mais pas toujours leurs natures.

Avec JAVA, on peut manipuler des variables :

• Simples : entier, caractère,…

• Structurées ou bien dites complexes : les objets

• Multiples : collections, listes ou tableaux

Manipulation d’une variable dite simple

Java étant un langage fortement typé, contrairement à PHP, vous devez déclarer une variable avant de pouvoir l’utiliser : déclarer, c’est définir son type.

|Syntaxe pour définir une variable |Exemple |

| | |

|type nomVariable ; |int a ; // a est un entier |

| |int b , c ; // b et c sont des entiers |

Remarque : On peut affecter une valeur à une variable dès sa définition : c’est une initialisation !

Exemple : int a = 3 ;

|Opérations possibles sur une variable dite simple |

|On peut : |

|appliquer toutes les opérations élémentaires : + - / * |

|les comparer 2 à 2 à l’aide des opérateurs : > >= < b)

{ int max = a ; }

else

{ int max = b ; }

System.out.println(“le max est”+ max); // provoquera une erreur de compilation

Les types simples 

• Catégorie entier

Elle permet l’emploi de valeurs numériques entières et signées.

|Type |Taille occupée dans la mémoire |Eventail de valeurs |

|byte |1 octet |De –128 à 127 |

|short |2 octets |De 32 768 à 32 767 |

|int |4 octets |De – 2 147 483 648 à 2 147 483 647 |

|long |8 octets |De – 9 223 372 036 854 775 808 |

| | |à 9 223 372 036 854 775 807 |

• Catégorie réel

Elle permet l’emploi de nombres à virgule.

|Type |Taille occupée dans la mémoire |Eventail de valeurs |

|float |4 octets |-1.4*10-45 à 3.4*1038 |

|double |8 octets |4.9*10-324 à 1.7*10308 |

• Catégorie texte

char : il sert à représenter des caractères isolés.

Un caractère est codé sur 2 octets.

L’éventail des valeurs est donc de 65 536 caractères différents (216).

ATTENTION :

'F' est considéré comme une variable de type char

"F" est considéré comme un objet de classe String

• Catégorie logique

Il s’agit du type boolean.

Un caractère est codé sur 1 bit.

L’éventail des valeurs est : {false, true} ce qui est traduit par {0,1}

conversion de types simples (casting)

On peut facilement changer le type d’une donnée, cela s’appelle faire une opération de cast.

Exemple :

int x;

x = (int) 8.324;

Exercice :

Des erreurs se cachent dans ces extraits de code, trouvez les puis corrigez les :

|int longueur, largeur = 5, perimetre ; | |

|perimetre = longueur * largeur ; |char genre ; |

| |int prix ; |

|int a =10, b=15 ; |….. // genre est initialisé par une saisie utilisateur |

|if (a>b) |if (genre == ‘A’) |

|max = a; |prix = 10 ; |

|else |if (genre == ‘E’) |

|max = b; |prix = 8 ; |

| |System.out.println("Le prix est de" + prix); |

|int a,b,c ; | |

|a = 2 ; | |

|b = a ; |float prix ; |

|c = c + b ; |….. // prix est initialisé par une saisie utilisateur |

| |if ( prix > 250 ) |

|float pi = 3.14 ; |int prixAvecRemise = prix * 0.9 ; |

|int rayon = 2 ; |System.out.println("Le prix :" + prix); |

|int perimetre = 2 * pi * (rayon * rayon) ; |System.out.println("Le prix avec remise : " |

| |+ prixAvecRemise); |

Communiquer une information

afficher une information

• En mode console : System.out.println(…)

|System.out.print( expr ) ; // affiche à l’écran le contenu de expr |

|System.out.println( ) ; // saute une ligne |

|System.out.println( expr ) ; // affiche à l’écran le contenu de expr et saute une ligne |

|System.out.println( "Mon texte" ) ; // affiche à l’écran le texte et saute une ligne |

|System.out.println("Mon texte" + expr ) ; // affiche à l’écran le le texte et le contenu de expr |

Remarque : Println et print sont des méthodes (fonctions) qui ont été définies plusieurs fois de manière à fonctionner quelque soit le type de l’expression qu’on leur passe en paramètre.

• En mode graphique : JOptionPane.showMessageDialog(…)

|import javax.swing.*; |

|….. |

|JOptionPane.showMessageDialog (null,"Mon texte") ; // affiche une boite de dialogue contenant le texte |

Remarque : La méthode showMessageDialog est définie dans la classe JOptionPane qui se situe dans le package swing qui lui même est dans un plus gros package appelé javax. Remarque : un package est une unité (un fichier) regroupant des classes.

Ainsi pour utiliser, cette méthode, vous pouvez :

o la préfixez par le nom des packages : javax.swing.JOptionPane.showMessageDialog (null,"texte") ;

o utilisez l’instruction d’import ( cf exemple ci dessus )

Pour les méthodes print et println , cela est inutile car elles font parties des classes standards.

recuperer une information (saisie)

• En mode console : lire …(…)

Tout comme en PHP, il n’existe pas de méthode prédéfinie pour lire les données saisies par l’utilisateur dans une console. Alors, vous allez utiliser les méthodes définies dans la classe Lire (classe fournie en TP). Cette classe n’est pas définie par Java. C’est un fichier que vous devrez donc avoir en permanence.

|Class Lire |

|static String |lireStr() |

| |renvoie la saisie de l’utilisateur sous forme d’une donnée de type String |

|static float |lireFloat() |

| |renvoie la saisie de l’utilisateur sous forme d’une donnée de type float |

|static int |lireInt() |

| |renvoie la saisie de l’utilisateur sous forme d’une donnée de type int |

|static char |lireChar() |

| |renvoie la saisie de l’utilisateur sous forme d’une donnée de type char |

Pour les utiliser, vous devrez faire référence à la classe afin que le compilateur puisse savoir où trouver la définition de ces méthodes.

| |

|System.out.println(" Entrez votre age ") ; |

|int age = Lire.lireInt() ; |

• En mode graphique : JOptionPane.showInputDialog(…)

| |

|String nom = JOptionPane.showInputDialog (null,"Votre nom ") ; |

Remarque : cette méthode ne sait renvoyer que des variables de type String.

Il faut alors utiliser des méthodes qui permettent de changer le type des données. Ex :

String sAge = JOptionPane.showInputDialog (null,"Votre age ") ;

Int age = Integer.parseInt(sAge ) ;

Structures conditionnelles et répétitives

Les instructions conditionnelles et répétitives sont généralement les mêmes quelque soit le langage.

Remarques :

o L’imbrication est toujours possible

o Pour former une condition, les règles sont aussi les mêmes quelque soit le langage, on utilise les opérateurs de comparaison (,==, !=…) et les opérateurs logiques (&&, ||| )

o S’il n’y a qu’une seule instruction, vous n’êtes pas obligé de mettre les accolades.

Faire des tests

|Syntaxe |

| | | |

|if (condition ) |if (condition ) |if (condition ) |

|{ // instructions … } |{ // instructions … } |{ // instructions … } |

| |else |elseif ( condition) |

| |{ // instructions … } |{ // instructions … } |

| | |else |

| | |{ // instructions … } |

| | | |

Répéter des actions

|Syntaxe |

| | | |

|while (condition) |do |for ( init° cpt; condition pour continuer ; pas du cpt) |

|{ // instructions } |{// instructions } |{// instructions } |

| |while (condition); | |

Premier objet : variable de type String 

Une chaîne de caractère n’est pas considérée comme une variable simple, mais comme un objet de la classe String, autrement dit une variable complexe de type String !

Déclarer un objet String

|Déclaration et initialisation d’un objet de classe String |

| | |

|String maChaine ; |String maChaine  = new String( "toto" ) ; |

|maChaine = new String( "toto" ) ; | |

Remarques :

• On peut aussi initialiser un objet de classe String à l’aide d’une saisie utilisateur.

• Etant donné que String est un type couramment utilisé, déjà existant dans les langages procéduraux, les concepteurs de JAVA ont voulu faciliter son utilisation. On peut donc écrire :

| |

|String maChaine = "toto" ; |

Manipuler un objet String

Pour manipuler un objet String, il faut utiliser les méthodes définies pour la classe String.

En POO, on dit qu’on applique une méthode à un objet. Cela se traduit en programmation :

| |

|nomObjet . nomMethode(param1,…) ; |

Exemple :

int taille = maChaine.length() ; // taille = 4

if (maChaine.equals("" ) == true)

System.out.println ("Chaîne vide") ;

Remarque : pour concaténer une chaîne de caractère, il existe une méthode mais vous pouvez utiliser

l’opérateur + .

Extrait des méthodes de la classe String 

|Class String |

|boolean |endsWith(String suffix) |

| |test if this String ends with the specifies suffix |

|boolean |equalsIgnoreCase( String anotherString) |

| |Compares this String to another String ignoring case considerations. |

|boolean |equals( String anotherString) |

| |Compares this String to another String |

|String |toLowerCase() |

| |   Converts all of the characters in this String to lower case using the rules of the default locale. |

|String |toUpperCase() |

| |   Converts all of the characters in this String to upper case using the rules of the default locale. |

|int |indexOf(int ch) |

| |Returns the index within this string of the first occurrence of the specified character. |

|int |indexOf(int ch, int fromIndex) |

| |Returns the index within this string of the first occurrence of the specified character, starting the search at the |

| |specified index. |

|int |length() |

| |Returns the length of this string. |

|String |replace(char oldChar, char newChar) |

| |  Returns a new string resulting from replacing all occurrences of oldChar in this string with newChar. |

|String |subString(int beginIndex, int endIndex) |

| |Returns a new string that is a substring of this string. |

|String |StartsWith( String prefix) |

| |  Tests if this string starts with the specified prefix. |

Exercices :

1. Ecrivez les programmes JAVA permettant :

a. D’afficher la somme 2 chiffres saisis par l’utilisateur.

b. D’afficher un message de bienvenue personnalisé après avoir saisi le nom de l’utilisateur.

2. Que va afficher cet extrait de code :

|String chaine = «incontournable» ; |

|boolean b = chaine.startsWith(«in»); |

|if ( b == true) |

|{ |

|String sousChaine = chaine.substring(2,13) ; |

|System.out.println (« C’est le contraire de » + sousChaine) ; |

|} |

|b = chaine.endsWith(«s»); |

|if ( b == false) |

|System.out.println (« ce mot est au singulier ») ; |

|else |

|System.out.println (« ce mot est au pluriel») ; |

| |

3. Ecrivez les programmes JAVA permettant :

a. D’afficher le nombre de lettre contenu dans un mot saisi par un utilisateur, ainsi que sa 1ere et dernière lettre

b. D’afficher le nom de l’utilisateur en majuscule et son prénom en minuscule excepté sa 1er lettre.

c. D’afficher le login d’un utilisateur, celui-ci est composé des 6ères lettres du nom puis de la 1ere lettre du prénom. Remarque : java est un langage rigoureux, si vous demandez les 6ères lettres du nom mais que celui-ci ne comporte pas 6 caractères, vous aurez un plantage de votre programme !

Suite outils de base en java

Contrairement au php, les notions de tableaux et de listes sont claires. Un tableau permet de stocker un nombre fixe de données alors que la liste permet de stocker un nombre indéterminé de données.

Collectionner un nombre fixe d’objets

Les tableaux à une dimension

Comme toute variable utilisée dans un programme, un tableau doit être déclaré afin de :

• Donner un nom à l’ensemble des valeurs à regrouper

• Définir la taille du tableau

• Déterminer le type des valeurs

|Déclaration d’un tableau |

|type [ ] nomTableau ; |

| |

|Exemple : float [ ] notes  ; // notes est un tableau de float |

|Création d’un tableau |

|nomTableau = new type [ taille ] ; |

|ou bien |

|nomTableau = new type [ ] {valeur1,valeur2,...} ; |

| |

| |

|Exemples : |

|notes = new float[35] ; //notes vient d’être créé pour pouvoir stocker 35 float. |

|mois=new String[]{« janvier », « février », « mars »,....} |

La création et la déclaration peuvent être faites sur la même ligne !

On peut définir des tableaux de valeurs :

o de type simple

o de type structuré : tableaux d’objets

Remarques :

o La taille du tableau correspond au nombre maximal de valeurs à traiter. Il n’est plus possible de la modifier en cours d’exécution ! Cependant il est possible de ne pas fixer la taille avant la compilation en plaçant une variable au lieu d’une valeur numérique entre les [].

o Tous les tableaux ont un attribut publique length.

Les tableaux à deux dimension

|Déclaration et création d’un tableau à 2 dimensions |

|type [ ] [ ] nomTableau  = new type [nbLignes] [nbColonnes]; |

| |

|Exemple : float [ ] [ ] px = new float[2] [5]  ; |

Collectionner un nombre indéterminé d’objets

Mieux encore que les tableaux, il existe les listes. Les listes permettent de stocker un nombre variable de valeurs car le programmeur n’est pas contraint d’indiquer la taille de la liste lors de sa création. Mais dans la plupart des langages, la gestion d’une liste est beaucoup plus complexe que la gestion d’un tableau. Excepté pour Java, en effet, ce langage fournit deux types permettant de gérer facilement les listes : Vector et ArrayList .

Définition de la classe ArrayList

La classe ArrayList permet de gérer les listes. Elle a succédé à la classe Vector.

Etant plus efficace, il est préférable de l’utiliser à la place des vecteurs ( objets de type Vector).

Cette classe est une classe de la bibliothèque java, elle est définie dans le package java.util.

Pour l’utiliser, il faut donc importer le package : import java.util.* ;

Alors que les tableaux sont une fonctionnalité du langage java, utilisables à tout moment.

Construction d’une liste

Comme toute variable utilisée dans un programme, une liste (ici, objet de type ArrayList) doit être déclarée puis créée.

Déclaration d’une liste

ArrayList nomListe;

Création (ou construction) d’une liste

Il existe 2 constructeurs :

|ArrayList() |Construit une liste ayant une capacité de 10 objets |

|ArrayList(int capacite) |Construit une liste ayant pour capacité celle passée en paramètre |

nomListe = new ArrayList() ;

ou nomListe = new ArrayList(x) ; x étant un entier > 0

Exemple :

Créez une liste: lstMatiere-Elle servira à stocker le nom des matières

Créez une liste: lstEtudiant-Elle servira à stocker des étudiants

La classe ArrayList gère un tableau d’objets. Plus précisément, elle gère un tableau de références à des objets.

Lorsque le tableau est plein, la liste crée automatiquement un tableau plus grand et recopie tous les objets du plus petit tableau vers le plus grand. Si vous connaissez déjà le nombre d’éléments que peut contenir la liste, il est bon de l’indiquer, cela évite des réallocations coûteuses. Cela ne limite en rien le nombre d’éléments effectifs puisqu’une liste est capable de s’agrandir en fonction des besoins.

Taille d’une liste

|int |size() |Renvoie le nombre réel d’éléments contenus dans une liste |

Exercice : Que vont afficher ces instructions ?

ArrayList lstEtud = new ArrayList(50);

System.out.println("taille de la liste : " + lstEtud.size());

Etudiant [] tabEtud = new Etudiant[50];

System.out.println("taille du tableau : " + tabEtud.length);

Remarques

• Une liste est ordonnée, comme pour les tableaux un indice est géré pour chaque élément de la liste.

On peut donc accéder à chacun des éléments à l’aide de l’indice.

• Contrairement aux tableaux, on ne définit pas le type des valeurs stockées dans une liste.

Une liste gère des élément de type Object. La classe Object représente l’ancêtre ultime de toutes les autres classes.

N’importe quel objet, qu’il soit de classe Etudiant, String,… est avant tout de classe Object.

Donc une liste peut gérer n’importe quel type d’objet, excepté les types primitifs.

Manipulation d’une liste (objet de classe ArrayList)

Ajouter des éléments ( des objets ) à une liste

|boolean |add(Object o) |Ajoute l’objet passé en paramètre en fin de liste- Renvoie true. |

|void |add(int indice, Object o) |Insère l’objet passé en paramètre dans la liste à l’indice spécifié |

Exercice :

1. Ajouter 2 matières : alsi et amki à la liste des matières déclarée précédemment

2. Ajouter 2 étudiants à la liste d’étudiants déclarée précédemment. Ils doivent être rangés par ordre alphabétique.

La classe Etudiant possède un constructeur : Etudiant( String nom, String prenom, int age)

Ajouter tout d’abord l’étudiant : (Gregory, Puchot,19)

Puis ajouter l’étudiant : (Adel,Zellama, 21)

Une liste se compose uniquement d’objets, elle ne peut pas stocker des valeurs de types primitifs, comme peut le faire un tableau. Pour résoudre ce problème JAVA a prévu des classes qui redéfinissent les types primitifs. Exemple : classe : Float, Integer, …

Exemple d’utilisation :

|Integer a = new Integer(2) ; |ArrayList lstNote = new ArrayList(); |

|Integer b = new Integer(4) ; |lstNote.add(new Integer(2)); |

|ArrayList lstNote = new ArrayList(); |lstNote.add(new Integer(4)); |

|lstNote.add(a); | |

|lstNote.add(b); | |

Remarque : il est donc possible de stocker des objets de différents types dans une même liste. Les collections hétérogènes sont utiles dans de rares occasions. Cela n’est pas recommandé et traduit souvent une erreur de conception.

Accéder aux éléments d’une liste

|void |set(int indice, Object o ) |Place l’objet passé en paramètre à l’indice spécifié. Ecrase l’ancienne valeur. |

|Object |get(int indice) |Récupère l’objet stocké à l’indice spécifié en paramètre. |

Exercice : Modifier dans la liste des matières amki par amsi.

Remarque :

Pour travailler sur un objet contenu dans une liste, on doit avant tout extraire cet objet de la liste à l’aide de la méthode get !

Extraire un élément d’une liste est assez complexe, car le type renvoyé par la méthode get est Object.

Il faut donc convertir l’objet dans le type souhaité. On dit que l’on doit caster explicitement l’objet qui nous est renvoyé.

Exemple : Etudiant unEtudiant ;

unEtudiant = (Etudiant) lstEtudiant.get(1) ;

Exercice : Afficher les propriétés du 1er étudiant à l’aide de la méthode afficheToi() : void

Supprimer un élément d’une liste

|Object |remove(int indice) |Supprime l’objet dont l’indice est spécifié en paramètre. Retourne l’objet supprimé |

Rechercher un objet dans une liste

|int |indexOf(Object o) |Retourne l’indice de la 1ere occurrence de l’objet passé en paramètre dans la liste |

Remarque : Cette méthode compare l’objet passé en paramètre aux objets de la liste en utilisant la méthode equals de la classe Object. Or equals ne fait que vérifier si les 2 objets ont la même référence. Ce n’est donc pas un test utile. Pour que cela fonctionne, il faut alors redéfinir equals au niveau de la classe utilisée. Ici : il faut ajouter à Etudiant :

................
................

In order to avoid copyright disputes, this page is only a partial summary.

Google Online Preview   Download