Médiaforma

All posts tagged classes

Plusieurs méthodes jQuery permettent de manipuler les classes des éléments du DOM :

  • addClass() : ajoute la classe spécifiée en argument
  • removeClass() : supprime la classe de la sélection, si elle existe
  • toggleClass() : retire ou ajoute la classe de la sélection, selon si elle existe ou si elle n’existe pas

Pour vous entrainer à manipuler ces méthodes, saisissez le code suivant dans Notepad+++ et sauvegardez-le sous le nom manipule-classes.htm :

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Manipulation de l'attribut class</title>
    <style type="text/css">
      .rouge { color: red; }
      .vert { color: green; }
      .petit { font-size: 100%; }
      .grand {font-size: 300%; }
    </style>
  </head>
  <body>
    <div id="kevin">Kévin</div>
    <div id="eric">Eric</div>
    <div id="cathy">Cathy</div>
    <div id="julie">Julie</div>
    <div id="trich">Patricia</div>

    <script src="jquery.js"></script>
    <script>
      $(function() {
        // Ajouter le code jQuery ici

      });
    </script>
  </body>
</html>

 

Exécutez le code. Voici ce que vous devez obtenir :

 

A l’aide des méthodes addClass(), removeClass() et toggleClass(), modifiez les classes des éléments div pour obtenir ce résultat :

 

Voici le code à utiliser :

$('#kevin').removeClass('rouge').addClass('vert');
$('#eric').addClass('rouge').addClass('grand');
$('#cathy').removeClass('grand');
$('#julie').addClass('vert');
$('#trich').removeClass('vert').addClass('rouge').addClass('grand');

 

Remarque : Plusieurs autres variantes sont possibles.

Il est possible d’enlever ou d’ajouter plusieurs classes simultanément : précisez le nom des classes concernées dans les parenthèses en les séparant d’un espace. Par exemple :

addClass('bleu immense');

 

Simplifiez le code jQuery précédent :

$('#kevin').removeClass('rouge').addClass('vert');
$('#eric').addClass('rouge grand');
$('#cathy').removeClass('grand');
$('#julie').addClass('vert');
$('#trich').removeClass('vert').addClass('rouge grand');

 

Pour terminer, la méthode hasClass() renvoie la valeur true si la sélection a pour classe la valeur spécifiée en argument. Elle renvoie la valeur false dans le cas contraire.

 

Exercice : A titre d’exemple, appliquez la méthode hasClass() à tous les éléments div du document. Si un élément est de classe rouge, supprimez cette classe et remplacez-la par la classe vert.

Solution :

    $('div').each(function(){
  element=$(this);
  if (element.hasClass('rouge')) {
    element.removeClass('rouge');
    element.addClass('vert');
  }
});

La programmation orientée objet (POO) a essentiellement deux avantages. Elle :

  • facilite l’organisation du code et donc le développement ;
  • permet de définir des modules réutilisables.

La programmation orientée objets repose sur trois notions fondamentales : l’encapsulation, l’héritage et le polymorphisme.

Les classes définissent des structures composées de variables et de fonctions. Pour utiliser les termes propres à la POO, les variables d’une classe sont appelées propriétés. Quant aux fonctions de la classe, elles sont appelées méthodes.

Les instances, c’est-à-dire les utilisations d’un type classe, sont appelées des objets. Les variables et fonctions d’une classe sont appelés composants ou membres de la classe.

Si vous avez du mal à vous y retrouver avec tous ces nouveaux termes, nous allons faire une analogie. Considérez une classe comme une usine qui fabrique des voitures. Les instances de l’usine (la classe) sont des voitures (les objets). La cylindrée, la couleur, le type des pneus, etc. sont des caractéristiques (propriétés) propres à chaque voiture. Selon les caractéristiques des voitures à fabriquer, il faut appliquer différents procédés de fabrication (méthodes).


Il est peu fréquent d’attribuer plusieurs classes à un élément. C’est pourtant tout à fait possible, en séparant les noms des classes par un espace.

Lorsqu’un élément se voit affecter plusieurs classes, les propriétés de chacune des classes lui sont appliquées. Ici par exemple, nous avons défini quatre classes au nom évocateur :

  • rouge colore le texte en rouge ;
  • bleu colore le texte en bleu ;
  • gras affecte l’attribut gras au texte ;
  • italique affecte l’attribut italique au texte.

Deux classes sont affectées au premier paragraphe : rouge et gras.

Deux classes sont affectées au deuxième paragraphe : bleu et italique.

Enfin, trois classes sont affectées au troisième paragraphe : gras, rouge et italique.

Voici le résultat dans Internet Explorer. Comme vous pouvez le voir, chacun des paragraphes cumule les propriétés de toutes ses classes :


Pour utiliser une classe dans une servlet, vous pouvez insérer une directive <%@page%> en précisant le paramètre import, ou insérer le chemin complet de la méthode Java à utiliser. A titre d’exemple, ces deux servlets sont équivalentes :

Version 1 – En insérant le chemin de la classe dans l’instruction

<html>
  <head>
    <title>Accès à une classe Java</title>
  </head>
  <body>
    Aujourd’hui nous sommes le <%= new java.util.Date().toString() %>.
  </body>
</html>

Version 2 – En important la classe

<%@ page import="java.util.Date" %>
<html>
  <head>
    <title>Accès à une classe Java</title>
  </head>
  <body>
    Aujourd’hui nous sommes le <%= new Date().toString() %>.
  </body>
</html>

 

Ces deux servlets produisent le même effet :

 

 

 

Exercice

Définissez une servlet qui affiche la date du jour en français, comme dans la capture d’écran ci-après :

 

 

Solution

<%@ page import="java.util.Date" %>
<html>
  <head>
    <title>Date en français</title>
  </head>
  <body>
    <% String[] jours = {"Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi" };
    Date laDate = new Date();
    int leJour = laDate.getDay();
    out.println("Aujourd'hui, nous sommes " + jours[leJour]);
    %>
  </body>
</html>

Considérez le code suivant :

public class GenericsTypeAvant {

    private Object t;
     public Object get() {
        return t;
    }

    public void set(Object t) {
        this.t = t;
    }

    public static void main(String args[]){
        GenericsTypeAvant type = new GenericsTypeAvant();
        type.set(12);
        String str = (String) type.get();
    }
}
Ce code se compile correctement, mais il produit une erreur CassCastException à l’exécution. En effet, le nombre 12 ne peut pas être casté en un String :

 

 

Considérez maintenant le code suivant :

public class GenericsTypeMaintenant<T> {

    private T;

    public T get(){
        return this.t;
    }

    public void set(T t1){
        this.t=t1;
    }

    public static void main(String args[]){
        GenericsTypeMaintenant<String> type = new GenericsTypeMaintenant<>(); // Type String
        type.set("chaîne"); // OK

        GenericsTypeMaintenant<Integer> type1 = new GenericsTypeMaintenant<>(); //Type Integer
        type1.set(12); //OK
        //type1.set("abc"); //Invalide

        GenericsTypeMaintenant type2 = new GenericsTypeMaintenant(); //Type quelconque
        type2.set("texte"); //OK
        type2.set(10); //Valide

    }
}

Le type T est spécifié dans la classe :

public class GenericsTypeMaintenant<T>

Lors de l’instanciation d’un objet de classe GenericsTypeMaintenant, on définit le type de l’objet passé. Par exemple, un type String :

GenericsTypeMaintenant<String> type = new GenericsTypeMaintenant<>();

On passe alors un objet de type String au setter après l’instanciation de la classe :

type.set("chaîne");

Si on lui passe un autre type, une erreur sera déclenchée à la compilation.

Par exemple, cette instruction :

type.set(12);

Provoque une erreur à la compilation :

 

 

Lors de l’instanciation d’un objet GenericsTypeMaintenant, on peut aussi définir un type Integer :

GenericsTypeMaintenant<Integer> type1 = new GenericsTypeMaintenant<>();

 

Dans ce cas, les instructions suivantes ne produiront aucune erreur de compilation :

GenericsTypeMaintenant<Integer> type1 = new GenericsTypeMaintenant<>();
type1.set(12); //OK

 

Par contre, ces instructions provoqueront une erreur à la compilation :

GenericsTypeMaintenant<Integer> type1 = new GenericsTypeMaintenant<>();
type1.set("abc"); //Invalide

 

Si aucun type n’est spécifié :

GenericsTypeMaintenant type2 = new GenericsTypeMaintenant();

 

Une valeur de type quelconque peut être passée au setter. Ainsi, ces deux instructions sont correctes :

type2.set("texte");
type2.set(10);

Dans cette section, nous allons passer en revue les classes permettant de définir et de manipuler des types composites. Après l’avoir parcourue, vous ferez la différence entre les types simples et les types composites, et saurez passer de l’un à l’autre sans aucune difficulté.

La classe Boolean

Les constantes, variables et méthodes de cette classe sont immédiatement accessibles sans qu’il soit nécessaire d’utiliser une instruction import. La déclaration suivante est implicite :

import java.lang.*;
Les variables

Les objets Boolean peuvent prendre deux valeurs : FALSE et TRUE :

public final static Boolean FALSE
public final static Boolean TRUE

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException {
    Boolean B1 = new Boolean(false);
    System.out.println("B1 = " + B1);

    B1 = Boolean.TRUE;
    System.out.println("B1 = " + B1);
  }
}

Le premier bloc d’instructions définit un objet Boolean, lui affecte la valeur false, et l’affiche :

Boolean B1 = new Boolean(false);
System.out.println("B1 = " + B1);

Le second bloc d’instructions assigne la valeur TRUE à cet objet et l’affiche :

B1 = Boolean.TRUE;
System.out.println("B1 = " + B1);

Le constructeur

Le constructeur Boolean permet de définir un objet Boolean à partir d’une variable ou d’une valeur boolean :

public Boolean(boolean value)

Exemple :

Boolean B1 = new Boolean(false);
Boolean B2 = new Boolean(true);

Les méthodes

booleanValue()

La méthode booleanValue() retourne la valeur booléenne d’un objet Boolean :

public boolean booleanValue()

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException {
    Boolean B1 = new Boolean(false);
    System.out.println("B1 = " + B1.booleanValue());
  }
}

La première instruction définit l’objet Boolean B1 et lui affecte la valeur false :

Boolean B1 = new Boolean(false);

La seconde instruction utilise la méthode booleanValue() pour afficher la valeur de l’objet B1 :

System.out.println("B1 = " + B1.booleanValue());

Notez que l’instruction suivante aurait eu le même effet :

System.out.println("B1 = " + B1);

equals()

La méthode equals() teste l’égalité entre deux objets Boolean. Elle renvoie la valeur true si les deux objets sont égaux et la valeur false dans le cas contraire :

public boolean equals(Object obj)

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException {
    Boolean B1 = new Boolean(false);
    Boolean B2 = new Boolean(true);
    Boolean B3 = new Boolean(false);

    System.out.println("B1 = " + B1);
    System.out.println("B2 = " + B2);
    System.out.println("B3 = " + B3);

    if (B1.equals(B2))
      System.out.println("B1 = B2");
    else
      System.out.println("B1 <> B2");
    if (B1.equals(B3))
      System.out.println("B1 = B3");
    else
      System.out.println("B1 <> B3");
  }
}

Le premier bloc d’instructions définit trois objets Boolean, B1, B2 et B3 :

Boolean B1 = new Boolean(false);
Boolean B2 = new Boolean(true);
Boolean B3 = new Boolean(false);

Le deuxième bloc d’instructions affiche la valeur de ces trois objets :

System.out.println("B1 = " + B1);
System.out.println("B2 = " + B2);
System.out.println("B3 = " + B3);

Le troisième bloc d’instructions utilise la méthode equals() pour tester l’égalité des objets B1, B2 et B3 :

if (B1.equals(B2))
  System.out.println("B1 = B2");
else
  System.out.println("B1 <> B2");
if (B1.equals(B3))
  System.out.println("B1 = B3");
else
  System.out.println("B1 <> B3");

getBoolean()

La méthode getBoolean() renvoie la valeur d’une propriété boolean dont le nom est précisé dans l’argument :

public static boolean getBoolean(String name)

toString()

La méthode toString() convertit un objet Character en un objet String.

public String toString();

Exemple :

Boolean B = new Boolean(false);
String S = B.toString();

La première instruction définit l’objet Boolean B et lui affecte la valeur false :

Boolean B = new Boolean(false);

La seconde instruction définit l’objet String S et lui affecte la valeur convertie en String de B :

String S = B.toString();

Les classes abstraites sont utilisées pour définir des méthodes qui dépendent d’autres méthodes dont le code n’est pas défini dans la classe. Ici par exemple, la méthode rapport() fait appel aux méthodes abstraites perimetre() et surface(). Seule leur signature est définie dans la classe abstraite :

public abstract class Forme {
   public abstract float perimetre(); //methode abstraite
   public abstract float surface(); //methode abstraite

   public double rapport() {
      return surface() / perimetre();
   }
}

Nous pourrions par exemple créer une classe Cercle qui étend la classe Forme, qui définit les deux méthodes abstraites (perimetre() et surface()) de la classe Forme et qui surcharge la méthode toString de java.lang.Object :

public class Cercle extends Forme {
   private int rayon;

   public Cercle(int r) {
      this.rayon=r;
   }

   public float perimetre() {
      float resultat = 2 * (float)Math.PI * rayon;
      return resultat;
   }

   public float surface() {
      return (float)Math.PI * rayon * rayon;
   }

   public String toString() {
      return ("un cercle de rayon " + rayon);
   }
}

De la même manière, nous pourrions définir la classe Rectangle() qui étend la classe Forme, qui définit les deux méthodes abstraites (perimetre() et surface()) de la classe Forme et qui surcharge la méthode toString de java.lang.Object :

public class Rectangle extends Forme {
  private int longueur, largeur;

  public Rectangle(int longueur, int largeur) {
    this.longueur = longueur;
    this.largeur = largeur;
  }

  public float perimetre() {
     return 2 * (longueur + largeur);
  }

  public float surface() {
     return longueur * largeur;
  }

  public String toString() {
    return ("un rectangle de longueur " + longueur + " et de largeur " + largeur);
  }
}

Voici un exemple d’utilisation des sous-classes de Forme :

class EssaiFormes {

  public static void main(String[] arg) { 

      Cercle = new Cercle(2);

      Rectangle = new Rectangle(2, 1);

     

      System.out.printf("Rapport Surface/Périmètre pour " + cercle + ": %.3f\n", cercle.rapport());

      System.out.printf("Rapport Surface/Périmètre " + rectangle + " : %.3f\n", rectangle.rapport());

  }

}

Voici le résultat :

 

Essayez ce code et vérifiez son fonctionnement.