7 - Introduction à Java

Petit résumé

C est un langage populaire (une partie du cours IFT 1810, langage du IFT 1969). C++ (cours IFT 1166, IFT 1169) est une extension du langage C qui est plus populaire que C. Ses nouveautés rendent plus agréable le C et permettent aussi de faire la programmation orientée objet (POO).

JAVA (IFT 1810, IFT 1170, IFT 1176) utilise surtout la syntaxe du C++. De plus, Java est un langage purement orienté objet.

Dans le cours IFT 1810, on introduit à la programmation orientée objet (POO), à l’aperçu du langage JAVA sans aller dans les détails. Le but de ce résumé est de vous permettre de saisir des explications en classe au lieu de copier des programmes écrits au tableau. Les exemples expliqués en classe et disponibles sur le site Web du cours utilisent l’environnement JCreator.

Quelques mots sur la POO :

Dans notre vie quotidienne, on travaille très souvent avec des objets :

Un tableau est un objet. Il dispose de champs d’informations (des attributs) : materiel, couleur, largeur, hauteur :

On peut fabriquer (construire, instancier) un tableau par plusieurs manières :

matériel : en bois, en métal, en plastique dur, . . .
couleur : noire, blanche, . . .
largeur : 4.2 mètre, 3.8 mètre, . . .
hauteur : 2.3 mètre, 1.90 mètre, . . .

Il faut que le tableau existe (soit construit, instancié) avant de pouvoir travailler avec un tableau.

Que peut-on faire avec un tableau ?

En français, on est habitude avec l’action :

écrire au tableau
effacer le tableau
laver le tableau
etc …

En POO, on écrit souvent sous la forme :

tableau.écrire(. . .) appliquer la méthode écrire sur l’objet tableau
tableau.effacer(. . .) appliquer la méthode effacer sur l’objet tableau
etc . . .

Une porte est un autre objet.

On peut construire une porte par plusieurs manières : en bois, en métal, en pailles, . . .

Que peut-on faire avec une porte ?

ouvrir la porte
fermer la porte
etc …

C’est la même chose en programmation orientée objet (POO) :

Quelles sont les caractéristiques (champs, attributs) d’un objet ? Comment construire un objet ? Quelles sont les méthodes qu’on peut appliquer sur l’objet ?

Une classe en POO est une unité comportant très souvent : des champs d’informations, des méthodes spéciales s’appelant constructeurs pour construire (instancier) des objets de la classe, des méthodes pour appliquer sur ses objets, des clauses d’accès (privée, publique), etc . . .

Exemple : Concevoir la classe cercle en sachant qu’un cercle est déterminé par son champ rayon. On peut calculer la surface, le périmètre d’un cercle, etc …

Réponse :

class Cercle
{    // l’accès au champ rayon est privé, dans le corps
     // de la classe Cercle seulement 
	private double rayon;

     // un constructeur
	public Cercle(double r)
	{
		rayon = r;
	}

     // un autre constructeur  
	public Cercle()
	{
		rayon = 1.234; // valeur par défaut, par exemple
	}

     // méthode calculante et retournant le périmètre
     // d’un cercle où périmètre = 2 x PI x rayon
     // et en Java,  Math.PI fournit le champ PI valant
     // 3.14159
	public double perimetre()
	{
		return 2 * Math.PI * rayon;
	}
     // méthode calculante la surface
	public double surface()
	{
		return  Math.PI * rayon * rayon;
	}
     . . .  etc . . .
} // fin de la classe Cercle

On apprendra plus tard, les détails de la conception d’une classe. Par contre, on utilisera assez tôt, quelques classes du langage Java :

String : classe des chaînes de caractères
Integer : classe associée au type int
Double : classe associée au type double (Le type double est aussi pour les réels mais plus de chiffres significatifs que le type float ).

Affichage à l’écran : appliquer la méthode printf sur l’objet out du System (l’objet sortie du System est l’écran).

System.out.printf("Périmètre : %.2f ", c.perimetre());
                    ;     
System.out.printf("Bon succès en POO!\n); ");

Notions de base de Java vs C :

if, switch, do … while, while, for : comme le C (plus tard, on verra une autre forme de for en Java).

Des opérateurs : pareils en C

Pour les réels : Dans IFT 1810, en Java, on utilise couramment le type double au lieu du type float (double pour réel en double précision).

Commentaire en ligne : une des nouveautés en Java

   //  contenu du commentaire

Exemple :

final double TAUX_TPS = 0.05; // 5 % pour taxe TPS

TAUX_TPS est de type réel, sa valeur est 0.05 et cette valeur est finale, on ne change plus, ne modifie plus. C’est une constante.

Flexibilité de déclaration : on peut mélanger des déclarations avec des instructions.

Exemples :

for(int n = 1; n <= 5; n++)
  System.out.printf("Bonjour!\n");

int  somme = 0;
for (int n = 1; n <= 5; n += 2)
  somme += n ;

Autres nouveautés : à venir

Exemples simples :

Exemple1 : Allure d’un programme très simple en Java

Écrire un programme Java permettant de déclarer et d’initialiser quelques informations d’une étudiante du nom Lachance Pascale. On affiche ses informations ainsi que quelques messages de souhait.

// Fichier Ex0.java
public class Ex0 {


 public static void main(String[] args) {

   String nomPre = "Lachance Pascale" ;

   int age = 21 , nbCafe = 2 ; // 2 tasses de café par jour
   double taille = 1.67, poids = 65.4;

   System.out.printf("Bienvenue au Java et à la POO\n");

   System.out.printf("\nInformations de cette étudiante : \n");
   System.out.printf("Nom et prénom : %s\n", nomPre);
   System.out.printf("Age           : %d an(s)\n", age);
   System.out.printf("Café          : %d tasse(s)par jour\n", 
                               nbCafe);
   System.out.printf("Sa taille     : %.2f mètre\n", taille);
   System.out.printf("Son poids     : %.1f kg\n", poids);

   System.out.printf("\nBon succès en Java!\n\n");
 }
}

Exécution :

---------------Configuration: <Default>--------------------
Bienvenue au Java et à la POO

Informations de cette étudiante :
Nom et prénom : Lachance Pascale
Age           : 21 an(s)
Café          : 2 tasse(s)par jour
Sa taille     : 1,67 mètre
Son poids     : 65,4 kg

Bon succès en Java!
Process completed.

Exemple2 : Allure d’un programme très simple en Java

Écrire un programme Java permettant de déterminer et d’afficher les diviseurs de 6, de 20 puis de 17 selon le format ci-dessous.

Pour ce programme, on n’utilise pas de sous-programmes autres que main (un sous-programme est une fonction en C, une méthode en Java) :

Les diviseurs de 6 sont :
  1)        1
  2)        2
  3)        3
  4)        6

Les diviseurs de 20 sont :
  1)        1
  2)        2
  3)        4
  4)        5
  5)       10
  6)       20

Les diviseurs de 17 sont :
  1)        1
  2)       17

// Fichier Ex1.java
public class Ex1 {


public static void main(String[] args) {

   // declaration de 3 constantes
   final int NOMBRE1 =  6,
             NOMBRE2 = 20,
             NOMBRE3 = 17;
   int rang;

   // afficher les diviseurs de 6 :
    rang = 0;
    System.out.printf("Les diviseurs de %d sont : \n", NOMBRE1);
    for(int candidat = 1 ; candidat <= NOMBRE1 ; candidat++)
    	if (NOMBRE1 % candidat == 0)
    	{
    		rang++;
    		System.out.printf("%3d) %8d\n", rang, candidat);
    	}
    System.out.printf("\n");

    // afficher les diviseurs de 20 :
    rang = 0;
    System.out.printf("Les diviseurs de %d sont : \n", NOMBRE2);
    for(int candidat = 1 ; candidat <= NOMBRE2 ; candidat++)
    	if (NOMBRE2 % candidat == 0)
    	{
    		rang++;
    		System.out.printf("%3d) %8d\n", rang, candidat);
    	}
    System.out.printf("\n");

    // afficher les diviseurs de 17
    rang = 0;
    System.out.printf("Les diviseurs de %d sont : \n", NOMBRE3);
    for(int candidat = 1 ; candidat <= NOMBRE3 ; candidat++)
    	if (NOMBRE3 % candidat == 0)
    	{
    		rang++;
    		System.out.printf("%3d) %8d\n", rang, candidat);
    	}
    System.out.printf("\n");
}
}

Veuillez noter que les 5 lignes du genre :

if (NOMBRE1 % candidat == 0)
    	{
    		rang++;
    		System.out.printf("%3d) %8d\n", rang, candidat);
    	}

peuvent se remplacer par les 2 lignes comme suit :

if (NOMBRE1 % candidat == 0)
     System.out.printf("%3d %8d\n", ++rang, candidat);

Exécution :

-------------Configuration: <Default>--------------
Les diviseurs de 6 sont :
  1)        1
  2)        2
  3)        3
  4)        6

Les diviseurs de 20 sont :
  1)        1
  2)        2
  3)        4
  4)        5
  5)       10
  6)       20

Les diviseurs de 17 sont :
  1)        1
  2)       17

Process completed.

Exemple 3 : Allure d’un programme en Java

Refaites l’exemple 1 en écrivant un programme Java avec méthode d’une classe :

En-tête : static . . . ( . . . )

Appel : Classe.méthode static ( . . . )

méthode static ( . . . )

La méthode est écrite dans la classe

// Fichier Ex3.java
public class Ex2 
{

  // méthode static de la classe Ex2 permettant 
  // d’afficher les diviseurs d’un nombre donné
	static void afficherDiv(int nombre)
	{
      int rang = 0;
      System.out.printf("Les diviseurs de %d sont : \n", 
                           nombre);
      for(int candidat = 1 ; candidat <= nombre ; 
                                             candidat++)
    	if (nombre % candidat == 0)
    		System.out.printf("%3d) %8d\n", ++rang, 
                                  candidat);

      System.out.printf("\n");

	}


public static void main(String[] args) {

   final int NOMBRE1 =  6,
             NOMBRE2 = 20,
             NOMBRE3 = 17;


   Ex2.afficherDiv(NOMBRE1);
   Ex2.afficherDiv(NOMBRE2);
   Ex2.afficherDiv(NOMBRE3);
}
} // fin de classe Ex2

Exécution :

----------------Configuration: <Default>-----------------
Les diviseurs de 6 sont :
  1)        1
  2)        2
  3)        3
  4)        6

Les diviseurs de 20 sont :
  1)        1
  2)        2
  3)        4
  4)        5
  5)       10
  6)       20

Les diviseurs de 17 sont :
  1)        1
  2)       17


Process completed.

Convention des identificateurs en Java :

Pour le nom d’une classe :

Début de chaque mot en majuscule.

Exemples :

Cercle, Ex0, Ex1, Integer, Double, String, StringTokenizer, etc …

Pour le nom d’une constante : tous en majuscules.

Exemples :

final int MAX_AGE = 132 ;
final double BAR_FINAL = 0.40; // 40 % pour le final

Pour le nom d’une variable, d’un objet, d’une méthode :

Le 1er mot en tous minuscules, début d’un nouveau mot en majuscule.

Exemples :

static void afficherDiv(int nombre)
. . .
int age, cafe, nbPieds, nbPouces;
Cercle c1, c2;
String nomPre = “Tremblay Nicole”,
       codePerm = “TREN12619407”;

Quelques éléments de programmation

Type

La sélection simple avec if

if   (   condition    )                            
          instruction A                                                                                            
else                                                    
          instruction B

Fonctionnement

Si la condition vaut vraie, on exécute les instructions sous if.

Dans le cas contraire (sinon), et, si la clause else se présente, on effectue les instructions sous else.

La sélection multiple avec switch …

switch   (   expression    )                            
 {  case cte1 : instructions 1;                            
     case cte2 : instructions 2;                                       
     . . .                                                             
     case ctek : instructions k;                                        
     default  : instructions    ;                      
   }

Pour quitter le suivant que (switch), la dernière instruction de “l’instructions n” est souvent l’instruction break (voir exemples). L’instructions n peut être vide.

Exemple avec Java :

switch   (   rang  )
{ // du lundi à jeudi :
  case 2 :
  case 3 :
  case 4 :
  case 5 : System.out.printlf"On travaille très fort\n");
           break;
  // cas de vendredi
  case 6 : System.out.printf ("Fin de semaine s'en vient\n ");
           break;
  // cas de samedi ou dimanche
  case 1 :
  case 7 : System.out.printf ("Youppi! C'est la fin de semaine\n");
           break;
  default: System.out.printf ("Rang erroné!\n");   
  // break ; n'est pas nécessaire
}

Boucle de répétition avec tant que (while):

while (  condition  )                            
   instruction

Fonctionnement :

Étape 1 : vérifier d’abord la condition

Étape 2 : si la condition vaut vraie alors

On effectue les instructions à répéter
On revient à l’étape 1 si non, on quitte la boucle

Il faut assurer que la condition soit bien définie avant d’exécuter la boucle while. La condition est une expression booléenne en Java (pas une expression entière comme en C, C++).

Exemple simple: Calcul de S = 5 + 15 +… + 105

final int BORNE1 = 5, BORNE2 = 105, LE_PAS = 10 ; 
int somme = 0, valeur = BORNE1;
while (valeur <= BORNE2) {
     somme += valeur ;
     valeur += LE_PAS; 
} 
System.out.printf("somme = %d\n", somme);

Boucle de répétition avec pour (for . . .) :

for ( exp1 ; exp2; exp3  )                 
    instruction

Fonctionnement classique:

Initialiser la variable de contrôle de la boucle:

variable = valeur de départ

Tant que Variable <= valeur d’arrivée Faire

Effectuer les instructions à répéter
Ajuster la valeur de la variable de contrôle variable = variable + lePas

Domaines d’utilisation:

On utilise la boucle for quand on sait à l’avance le nombre de fois qu’on répète le même traitement. C’est le cas des valeurs dont le pas est une constante entre deux bornes données. On l’utilise également pour parcourir les indices d’un tableau.

Calcul de S = 10 + 15 + 20 + 25 + … + 150

int somme = 0 ;
for ( int valeur = 10 ; valeur <= 150; valeur += 5)
     somme += valeur ;
System.out.printf("S = %d\n", somme);

int somme = 0 ;
for ( int valeur = 150 ; valeur >= 10; valeur -= 5)
     somme += valeur ;
System.out.printf("S = %d\n", somme);

Boucle de répétition avec do . . . while

do                                                       
    instruction                                       
while  ( condition pour continuer ) ;

Exemple 1 : Calcul de P = 10 * 15 * 20 * … * 45

int produit = 1, valeur = 10;
do {
   produit *= valeur ;
   valeur += 5 ;
} while (valeur <= 45);
System.out.printf("P = %d", produit) ;

Exemple 2 : Calcul la somme des diviseurs de 100

final int NOMBRE = 100;
int somDivi = 0, candidat = 1 ;
do {  
    if (NOMBRE % candidat == 0)
    	somDivi += candidat ;
    candidat++;    
} while (candidat <= NOMBRE);
System.out.printf("somme des diviseurs de %d est %d",                 
                     NOMBRE, somDivi);

Exercices :

Exercice 1

Écrire un programme Java permettant d’utiliser de méthodes static permettant de déterminer puis afficher les 3 lignes suivantes :

Les 4 diviseurs de  6 sont :   1   2   3   6
Les 6 diviseurs de 20 sont :   1   2   4   5  10  20
Les 2 diviseurs de 17 sont :   1  17

Solution :

// Fichier Exercice1.java (page 17, document java_01.doc)
public class Exercice1 
{

   // méthode static de la classe Exercice1 comptant et retournant
   // le nombre de diviseurs d’un entier nombre > 0
static int nbDiv(int nombre){
     int n = 0;
     for(int candidat = 1 ; candidat <= nombre ; candidat++)
         if (nombre % candidat == 0)
              n++;
     return n;
}

static void afficherDiv(int nombre){
    System.out.printf("Les %d diviseurs de %2d sont : ", nbDiv(nombre),nombre);
    for(int candidat = 1 ; candidat <= nombre ; candidat++)
         if (nombre % candidat == 0)
              System.out.printf("%3d ", candidat);

    System.out.printf("\n");

}

public static void main(String[] args) {

   final int NOMBRE1 =  6,
             NOMBRE2 = 20,
             NOMBRE3 = 17;


   Exercice1.afficherDiv(NOMBRE1);
   afficherDiv(NOMBRE2);
   afficherDiv(NOMBRE3);
}
} // fin de la classe Exercice1

Exécution :

--------------------Configuration: <Default>--------------------
Les 4 diviseurs de  6 sont :   1   2   3   6
Les 6 diviseurs de 20 sont :   1   2   4   5  10  20
Les 2 diviseurs de 17 sont :   1  17

Process completed.

Exercice 2

Écrire un programme Java permettant d’utiliser des méthodes static permettant de déterminer puis afficher les 2 blocs de lignes suivantes :

Solution :

// Fichier Exercice2.java (page 18, document java_01.doc)
public class Exercice2 {


    static void afficher(int nombre){
       for(int fin = nombre ; fin >= 1 ; fin -= 2){
      	  for(int debut = 1; debut <= fin ; debut += 2)
      	      System.out.printf("%3d ", debut);
      	System.out.printf("\n");
       }

       System.out.printf("\n");

    }


    public static void main(String[] args) {

       final int NOMBRE1 =  9,
                 NOMBRE2 =  5;

       afficher(NOMBRE1);
       afficher(NOMBRE2);
    }
}

Exécution :

--------------------Configuration: <Default>--------------------
  1   3   5   7   9
  1   3   5   7
  1   3   5
  1   3
  1

  1   3   5
  1   3
  1


Process completed.