Programmation Par Objets et Langage Java

Partie II. Introduction à Java



Najib Tounsi
Ecole Mohammadia d'Ingénieurs, Rabat Logo EMI



Année 2017/2018
1ère année Génie Informatique

http://www.mescours.ma/Java/PooJavaPart-2.pdf

Sommaire

Partie II. Introduction à Java

Langage de programmation avec des TADs.



Le langage se prête bien à la programmation avec les types abstraits de données.


Exemple de la classe Pile

La classe Pile (source complet, documentation associée )

public class Pile {
 
// 
// Déclarations des attributs de la pile
//
    static final int MAX = 8;
    char[] t;
    int top;

// 
// Programmation des opérations (méthodes) de la pile
// 

    public Pile(){
        // Initialise une pile vide
        t = new char[MAX];
        top = -1;
    }

    public void empiler(char c){
        // Empile le caractère donné
        if (!estPleine())
            t[++top] = c;
        else
            System.out.println("Pile pleine");
    }

    public char sommet(){ 
        // Retourne le caractère au sommet de la pile
        if (!estVide())
            return t[top];
        else {
            System.out.println("Pile vide Sommet");
            return '\0';
        }
    }

    public void depiler(){
        //    décapite la pile (retire le sommet )
        if (!estVide())
            top--;
        else
            System.out.println("Pile vide Depiler");
    }
 
    public boolean estVide(){ 
        //    Teste si la pile est vide
        return (top < 0);
    }

    public boolean estPleine(){ 
        // teste si la pile est pleine
        return (top >= (MAX - 1));
    }
}; // Fin class Pile


A noter:

  1. Aspects présentation
    • Une classe est un bloc dans lequel sont déclarée des données et des fonctions qui les utilisent. Les spécifications aussi, sous forme de commentaires ici.
    • C'est donc une implantation d'un TAD, i.e. choix de représentation (tableau t + indice sommet de pile top) de la pile et programmation des méthodes.
    • Une seule unité de compilation
    • La syntaxe des instructions est proche de C.
  2. Ici on a tout mis dans un même fichier. Avec les interfaces Java, on peut séparer en deux partie: Spécification abstraites  &  Représentation. (voir plus tard.)
    • Deux unités de compilation.


Remarque: Dans ce dernier cas, il est possible de définir plusieurs implantations (représentations)  pour un même TAD  (spécification abstraite).

Programme Java qui utilise une pile


Un programme principal (classe avec fonction main.)

Lire un mot et imprimer son image miroir.


public class TestPile { 
    static public void main(String args[]){
         // Imprime l'mage miroire d'un mot

         char c;
         Pile p = new Pile();

   // On lit les lettres et on les empile 
         while ((c=Support.readChar()) != '#') { 
                 p.empiler (c) ; 
                 if( p.estPleine()) break; 
         } 

   // On depile les lettres et on les imprime
         while (!p.estVide()) {
                c = p.sommet();
                System.out.println (c); 
                p.depiler();
         }
     }
}

A noter

Spécificités de Java autres que la notions de classe.


Programming in the small...

Dans la suite de ce chapitre, on va s'intéresser  à l'aspect programmation procédurale du langage Java

Hello World


Programme main dans une classe HelloWorld (fichier HelloWorld.java)

// Mon premier programme Java
class HelloWorld {
    static public void main(String args[]){
          System.out.println("Hello, World");
    }
}

Un programme plus complet (avec E/S de données)

Programme qui lit un nom et une température en Celcius, convertit cette dernière en Fahrenait et affiche bonjour avec cette nouvelle valeur. (source Bonjour.java)


import java.util.Scanner;
class Bonjour {
    static public void main(String args[]) {
        Scanner clavier = new Scanner(System.in);
        int c;
        String nom;
        double f;

        // Partie lecture de données
        System.out.print("Quelle est votre nom?: ");
        nom = clavier.nextLine();
        System.out.print("Quelle t° fait-il aujourd'hui?: ");
        c = clavier.nextInt();

        // Partie calcul
        f = 9./5 * c + 32;

        // Partie sortie des résultats
        System.out.println("Bonjour " + nom);
        System.out.print("Il faut " + c + "° Celsius,");
        System.out.println(" soit "+ f + "° Fahrenait.");
     }
}

Un programme plus complet (exécution)


On compile et on exécute  (en mode ligne commande)

$ javac Bonjour.java
$ java Bonjour
Quelle est votre nom?: Ali
Quelle t° fait-il aujourd'hui?: 17
Bonjour Ali
Il faut 17° Celcius, soit 62.6° Fahrenait.
$ _

Conversions entre entiers et réels

  int i;
  double d;
  i = 1.23;        // Erreur: Javac trouve un double là où il faut un 
                   // int. En effet, 1.23 est un littéral réel double.
  d = 2;           // OK 2.0, conversion implicite
  i = 3;           // OK 
  d = 1.23;        // OK 
  i = d;           // Idem. Erreur: risque de perte de précision.
                   // d peut contenir un réel très précis.
  d = i;           // OK 3.0, conversion implicite aussi.
  i = (int) -1.23; // OK valeur tronquée i = -1.
  i = (int) d;     // idem, conversion (troncature) forcée (cast)

Typage fort

Les Types de Données en Java


Il ne convient pas toujours de parler de type de données pour un langage de classes. Néanmoins, il convient de distinguer, pour des raisons de performance, le traitement des données élémentaires des autres objets.  Il y a deux genres de variables en Java:

Les Types de Données en Java (suite)


référence tableau

Les Types de Données en Java (suite)

Les Types Primitifs

Les Types primitifs (suite)

Les Constantes Numériques


boolean result = true;
char capitalC = 'C';
byte b = 100;
short s = 10_000;
int i = 20;
long l = 5_000_000_000L;
int decVal = 26;
int hexVal = 0x1a;
int binVal = 0b11010;

Les Constantes Numériques (suites)

double d1 = 123.4
double d2 = 1.234e2;   // même valeur en notation  scientifique
float f1  = 123.4f;
float f = 1234;    // OK. Conversion de int vers float.
float f = 123.4;   // erreur. Perte de précision.
                   //123.4 constante double précision.
                   // utiliser 123.4f


Les Constantes Caractères


'a', '%', '\t', '\\', '\'', '\u03a9', '\uFFFF', '\177', 'Ω', '', 'é', 'ج'

Les Constantes Chaînes


""                      // chaîne vide
"\""                    // chaîne avec un seul car. " 
"This is a string"      // chaîne avec 16 caractères
"This is a " +          // une expression  constante  String,
    "two-line string"   // formée de deux littéraux

Conversions et Promotions

Conversions et Promotions (suites)

long i = 25;    // int vers long OK
int i = 1234567890;
float f = i;          // int vers float OK.
  // ici f vaut 1.23456794E9 et (int)f vaut 1234567936

Conversions et Promotions (suites)

String s1 = "Douze = " + 12; // s1 = "Douze = 12"
String s2 = "" + 12;     // s2 = "12"

String s2 = String.valueOf(i);

int i;
double d;
String s3 = Integer.toString(i);
String s4 = Double.toString(d);

Conversions et Promotions (suites)

Integer I = new Integer(45);  // I = 45  // Boxing de 45
int i = I.intValue ();        // i est aussi 45 // Unboxing de I

Les Opérateurs Java


(Extraits de Java Tutorial http://docs.oracle.com/javase/tutorial/java/nutsandbolts/op1.html) 
=       Simple assignment operator

+       Additive operator (also used for String concatenation)
-       Subtraction operator
*       Multiplication operator
/       Division operator
%       Remainder operator

+       Unary plus operator; indicates positive value
        (numbers are positive without this, however)
-       Unary minus operator; negates an expression
++      Increment operator; increments a value by 1
--      Decrement operator; decrements a value by 1
!       Logical complement operator; inverts the value of a boolean

==      Equal to
!=      Not equal to
>       Greater than
>=      Greater than or equal to
<       Less than
<=      Less than or equal to

&&      Conditional-AND
||      Conditional-OR
?:      Ternary (shorthand for if-then-else statement)


instanceof      Compares an object to a specified type


~       Unary bitwise complement
<<      Signed left shift
>>      Signed right shift
>>>     Unsigned right shift
&       Bitwise AND
^       Bitwise exclusive OR
|       Bitwise inclusive

Les Tableaux en Java (Déclaration)


Un tableau Java

(extrait de http://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html)
int ai[];         // tableau d'entiers. (Vecteur)
short[] as, ab;   // 2 tableau de short.

short[][] matrice;     // tableau deux dimension de short.
int[][][] cube;        // tableau trois dimension de int.

int[] ai, mi [];     // Notation mixte. Equivalent à
int ai[], mi [][];   // Equivalent aussi à
int [] ai;
int [][] mi;         // :-)

Les Tableaux en Java (Création et Initialisation)


int[] ai = new int[5];   // ai tableau de 5 entiers.
                         // La dimension est obligatoire
int[] ai;          //  ai est ici juste une référence
ai = new int[5];   //  ai désigne un tableau de 5 entiers.

Reference tebleau null
reference tableau crée
Référence tableau avant et après new
ai = new int[5];
...
ai = new int [10];

Les Tableaux en Java (Création et Initialisation)


ai[0] = 2;   // premier élément est 2
ai[1] = 3;   // deuxième élément est 3
ai[2] = -1;  // etc.

System.out.println(ai.length);   // imprime 5

 int m[][] = new int [2][3];  // 2 lignes et 3 colonnes 

 m[0][0] = 11;
 m[1][2] = 23;
  //etc.

 System.out.println(m.length);     // 2 nombre de lignes 
 System.out.println(m[1].length);  // 3 nombre de colonnes 
                                   // (dans la ligne 2, en fait)

Les Tableaux en Java (Création et Initialisation)


int[] factorielle = { 1, 1, 2, 6, 24, 120, 720, 5040 };

char aoc[]      = { 'c', 'e', ' ', 'n', '\'', 'e', 's', 't',
                   ' ', 'p', 'a', 's', ' ', 'u', 'n', 'e',
                   ' ', 'c', 'h', 'a', 'i', 'n', 'e'};

String[] aos    = { "array", "of", "String", };

int[][] m = {{1, 2, 3},
             {10, 20, 30},
             };     // matrice à 2 lignes et 3 colonnes.  
String[][] noms = {
        {"M. ", "Mme ", "Mlle"},
        {"BenHlima", "BenAli"}
 };    // ici il y a 2 lignes, mais de longueurs différentes

Copie de Tableaux


String [] noms = {"Ali", "Amina"};
String [] mesNoms = new String [3];
mesNoms = noms;

public static void arraycopy( Object src, int srcPos,
                              Object dest, int destPos, int length)
copie de tableau

Tableaux d'Objets non primitifs


tableau de références
 int[][] m = new int[2][];  // Creation deux références lignes  
                            //  m[0] et m[1]. 
 m[0] = new int[3];       // Création trois éléments entiers  en ligne 1 
 m[1] = new int[2];       // Création deux éléments entiers  en ligne 2
                          // Tous initialisés à nulles 

String[] s = new String[3];  // trois éléments tous égaux à null.
s[1] = new String("toto");   // le deuxième élément est une 
                             // référence à "toto"


Point [] p = new Point [10];    // vecteur p de 10 Points
for (int i=0; i<10; i++)
     p[i] = new Point();        // instanciation de chaque Point

Création de tableau par new


new Type [] {liste d'objets};

String s [] = new String [] {"abc", "def"};

String s[] = new String[2];
s[0] = "abc";
s[1] = "def";




int t [] = new int[] { 11, 23, 45 };




Point p [] = {new Point(1,2), new Point(2,3)}

Les Objets String ...

String salut = "Bonjour";

 String salut = new String ("Bonjour");

char [] bonjour = {'b', 'o', 'n', 'j', 'o', 'u', 'r'};
String salut = bonjour;            // erreur compilation: incompatible types

char [] bonjour = {'b', 'o', 'n', 'j', 'o', 'u', 'r'};
String salut = new String (bonjour);       // :-)

Les Objets String

String s = "Bonjour";
s = s + " Ali";          // nouvelle chaîne "Bonjour Ali" désignée par s.

Opérations sur les Chaînes: Length(), charAt()

String palindrome = "Dot saw I was Tod";
int len = palindrome.length();             // len vaut  17.

char c;
String salut ="Bonjour";
c = salut.charAt(2);   // c devient 'n'

Opérations sur les Chaînes:  + et concat()

String nom = " Ali";
String s = salut.concat(nom). // s est "Bonjour Ali"
"bon".concat("jour")          // retourne la chaîne "bonjour"

salut + " Ali"
salut + " " + "Ali" 
"La racine de 2 est " + Math.sqrt(2)
  // donne "La racine de 2 est 1.4142135623730951"

3 + 4 + " chats"               // est la chaîne "7 chats"
"chats " + 4 + 3               // est la chaine "chats 43"


Recherche Dans une Chaîne: indexOf()

Méthodes indexOf() et lastIndexOf(). Recherche de caractère ou sous-chaîne dans une chaîne.

 "alibaba".indexOf('b')         // retourne 3
 "alibaba".indexOf('b', 4)      // retourne 5
 "alibaba".lastIndexOf('a')     // retourne 6
 "alibaba".lastIndexOf('a', 5)  // retourne 4
indexOf()

Extraction de Sous Chaîne: substring()

Méthode substring().

 String s ="/users/me/hello.java";
 int dot = s.lastIndexOf('.');
 int sep = s.lastIndexOf('/');
 System.out.println (s.substring(dot+1));       // donne java
 System.out.println (s.substring(sep+1,dot));   // donne hello


La Classe StringBuffer et StringBuilder


 StringBuffer sb = new StringBuffer("Chat");
 System.out.println(sb.append("on"));       // Chaton
 System.out.println(sb.insert(3,"rles"));   // Charleston
 System.out.println(sb.append(3.4567));     // Charleston3.4567 

StringBuffer sb = new StringBuffer("Salut!");
System.out.println(sb.length() + "  " + sb.capacity());     //  6  22
sb.append(" Comment ça va ?");
System.out.println(sb.length() + "  " + sb.capacity());     // 23  46

Les Wrappers Java


On va donner des exemple pour la classe des entiers Integer. Les autres cas sont analogues.

Integer I = new Integer (2);
Integer J = new Integer ("23");

 System.out.println(Integer.MAX_VALUE) ;   // 2147483647
 System.out.println(Integer.MIN_VALUE) ;   // -2147483648
 System.out.println(Integer.SIZE) ;        // 32
 System.out.println(Integer.TYPE) ;        // int

Conversions par Wrapper

Integer I = new Integer (34);      // Integer à partir de 34
I = Integer.valueOf(34);           // idem mais sans new 
int i = I.intValue();              // retrouve le 34 int


Integer I;
I = new Integer ("123");             // Par constructeur
I = Integer.valueOf("123");          // ou comme ceci

int i;
i = Integer.parseInt("456");             // de String vers int


Integer I = 345;
String s = I.toString();   // s devient "345"

int i = 34;
s = String.valueOf(i);             // s devient "34"


 I = 3;            // Autoboxing                   
 i = I;            // Unboxing

Utilitaires des Wrappers


Character.isLetter('!')      // false
Character.isLetter('ج')      // true
Character.isDigit('5')       // true
Character c = 'e';
c.hashCode()                 // vaut 101
Character.toUpperCase('e')   // E

Wrappers Comme Objets Immutables

Integer i = 2;
i = i + 1;  // crée une nouvelle référence vers le 
            // résultat 3 dans ce cas
class TestParamInteger {
    public static void main(String[] args) { 
        Integer i = new Integer(20); // 20 est objet immutable!
        System.out.println(i); 
        change(i);                   // référence i copiée dans n
        System.out.println(i); 
    } 
    private static void change(Integer n) { 
        n = n + 1;  // NOUVEL objet résultat de n+1 est créé, 
                    // son adresse affectée à n (la copie)!
    } 
}

Les Instructions de Java.


Expressions Java

Instructions Java


Bloc d'Instructions


if (a > b) {
    b++; 
} else {
    a--;
}

{
     int i;
        // ... i visible dans ce bloc 
}

Structures de Contrôle



Type d'instruction Mots clés
Boucle while, do-while , for
Choix d'exécution if-else, switch-case
Gestion d'Exception try-catch-finally, throw
Branchement break, continue, label:, return

Instruction if-else


 if (moyenne >= 16){
     System.out.println ("Admis(e) avec félicitations");
 }
 System.out.println ("Admis(e)");

    moyenne = 16.5;
    if (moyenne >= 17){
      mention = "TB";
    } else if (moyenne >= 15) {
         mention = "B";
    } else if (moyenne >= 13) {
        mention = "AB";
    } else {
        mention = "P";
    }
    System.out.println ("Admis(e) avec mention: " + mention);

max = (a > b ? a : b);      // si (a > b)  alors a  sinon  b

Instruction  switch


switch (note) {
       case 20 : case 19 : case 18 : case 17 : 
            System.out.println ("Mention Très Bien"); 
            break;
       case 16 :  case 15 : 
            System.out.println ("Mention Bien");
            break;
      case 14 : case 13 :
            System.out.println ("Mention Assez Bien");
            break;
       case 12 : default :
            System.out.println (" Mention Passable\n");
            break;
}

enum Taille { S, M, L, XL, XXL };
    ...
    public static void f(Taille t) {
        switch (t) {
            case S:
                System.out.println("Small = 1 ou 2");
                break;
            case M:
                System.out.println("Medium = 3");
                break;
            case L: 
                System.out.println("Large = 4");
                break;
            case XL: case XXL:
                System.out.println("eXtra Large = 5 ou 6");
                break;                
        }   
    }

Instructions While et do-while

public class WhileDemo {
    public static void main(String[] args) {
        String copyFromMe = "Copy this string until you " +
                            "encounter the letter 'g', not included";
        StringBuffer copyToMe = new StringBuffer();
        int i = 0;
        char c = copyFromMe.charAt(i);
        while (c != 'g') {
            copyToMe.append(c);
            c = copyFromMe.charAt(++i);
        }
        System.out.println(copyToMe);
    }
}

Instructions While et do-while

public class DoWhileDemo {
    public static void main(String[] args) {
        String copyFromMe = "Copy this string until you " +
                            "encounter the letter 'g', included.";
        StringBuffer copyToMe = new StringBuffer();
        int i = 0;
        char c;
        do {
            c = copyFromMe.charAt(i++);
            copyToMe.append(c);
        } while (c != 'g');
        System.out.println(copyToMe);
    }
}

Instructions for

 int[] t = { 32, 87, 3, 589, 12, 1076, 8, 622, 127 };
 for (int i = 0; i < t.length; i++) {
      System.out.print(t[i] + " ");
 }
 System.out.println();

 for (int element : t){
    System.out.print(element + " ");
 }
 System.out.println();

Instructions de Traitement d'Exception try-catch-finally


Rupture de Contrôle (Instructions de Branchement)


Instruction break


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

        int[] arrayOfInts = 
            { 32, 87, 3, 589, 12, 1076, 2000, 8, 622, 127 };
        int searchfor = 12;

        int i;
        boolean foundIt = false;

        for (i = 0; i < arrayOfInts.length; i++) {
            if (arrayOfInts[i] == searchfor) {
                foundIt = true;
                break;
            }
        }

        if (foundIt) {
            System.out.println("Found " + searchfor + " at index " + i);
        } else {
            System.out.println(searchfor + " not in the array");
        }
    }
}

Instruction break(suite)


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

        int[][] arrayOfInts = { 
            { 32, 87, 3, 589 },
            { 12, 1076, 2000, 8 },
            { 622, 127, 77, 955 }
        };
        int searchfor = 12;

        int i;
        int j = 0;
        boolean foundIt = false;

    search:
        for (i = 0; i < arrayOfInts.length; i++) {
            for (j = 0; j < arrayOfInts[i].length;
                 j++) {
                if (arrayOfInts[i][j] == searchfor) {
                    foundIt = true;
                    break search;
                }
            }
        }

        if (foundIt) {
            System.out.println("Found " + searchfor +
                               " at " + i + ", " + j);
        } else {
            System.out.println(searchfor +
                               " not in the array");
        }
    }
}

L'instruction Continue


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

        String searchMe 
            = "peter piper picked a " +
              "peck of pickled peppers";
        int max = searchMe.length();
        int numPs = 0;

        for (int i = 0; i < max; i++) {
            // interested only in p's
            if (searchMe.charAt(i) != 'p')
                continue;

            // process p's
            numPs++;
        }
        System.out.println("Found " +
            numPs + " p's in the string.");
    }
}

L'instruction Return


Compilation et Exécution d'Un Programme Java

public class HelloWorld {
    static public void main(String args[]){
     System.out.println("Hello World!");
    }
}

$ ls
HelloWorld.java
$ javac HelloWorld.java
$ ls 
HelloWorld.class
HelloWorld.java

$ java HelloWorld
Hello, World

La Machine Virtuelle Java

Cycle de développement Java

Write once run everywhere



Machine virtuelle Java sur plusieurs platesformes

Java Plateforme

(Figures extraites de http://docs.oracle.com/javase/tutorial/getStarted/intro/definition.html)

Environnement de Développement Intégrés Vs. mode commande


Surcharge de Fonction


 class DataArtist {
    static void draw(String s) {
        System.out.println("Ceci est une chaîne: "+s);
    }
    static void draw(int i) {
        System.out.println("Ceci est un entier: "+i);
    }
    static void draw(double f) {
        System.out.println("Maintenant un double: "+f);
    }
    static void draw(int i, double f) {
        System.out.format("Une entier %d et un double %f %n",i,f);
    }
}

 DataArtist.draw ("Picasso");      // 1ère méthode, draw(String)
 DataArtist.draw (1);              // 2e méthode, draw(Int)
 DataArtist.draw (3.1459);         // 3e méthode, draw(double)
 DataArtist.draw (2, 1.68);        // 4e méthode, draw (int, double)

Paramètres de fonctions


public static void modifObj(int p[]) {
      p[0] = p[0] + 200;    // Objet référencé par p est modifié
}
    
public static void modifVal(int x) {
      x = x + 200;          //  paramètre x modifié
 }

int x = 2;
modifVal (x);     
        // ici, x vaut toujours = 2

int [] t = {2, 3};
modifObj (t); 
     // t[0] a changé en 202 


public static void modifObj(int p[]) {
    int r[]={200,300};
    p = r;                 // p[0] = 200,
}

p ne désigne plus  le tableau t de l'appel qui  reste donc inchangé

int [] t = {2, 3};
modifObj (t); 
      // t[0] vaut toujours = 2


Remarque: En Java les paramètres sont réellement passés par valeur.  Dans la cas des objets, c'est la valeur de la référence à l'objet qui est passée en paramètre. 

Gestion des Exceptions

 try {
      int n = fact(5);
 }
 catch (ExceptionFactNegatif e) {
    System.out.println("Valeur negative pour factorielle");
 }


 static public int fact(int x) throws ExceptionFactNegatif {
     if( x < 0 )
         throw new ExceptionFactNegatif();
     else
         // calcul factorielle f ...
         return f;
 }



class ExceptionFactNegatif extends Throwable {};

Les APIs Java


Les APIs Java

 

API Java

Les APIs Java

Ancien style. Jusqu'à Java 6.

API Java

Exemples de Packages (java.lang)


Package java.util


Package java.io


Plateforme Java


Java component technologies



That's all folks...