Médiaforma

All posts tagged propriétés

Cliquez ici pour accéder au pack eBook+vidéos HTML5, CSS3, JavaScript

Avant d’aller plus loin dans l’utilisation du langage CSS, nous allons marquer une pause pour définir ou rappeler quelques termes techniques qui seront utilisés tout au long de cette formation.

Une balise HTML est encadrée par les caractères “<” et “>“. Elle peut comporter un ou plusieurs attributs auxquels on affecte une valeur, généralement spécifiée entre guillemets. Par exemple, cette balise <a> contient deux attributs : href et target. Le premier précise l’adresse URL du lien et le deuxième indique que la page correspondante devra s’ouvrir dans une fenêtre secondaire :

<a href="https://www.mediaforma.com" target="_blank">Mediaforma</a>

Dans une feuille de styles (interne ou externe), on redéfinit une ou plusieurs propriétés en leur affectant des valeurs. Ici par exemple, trois propriétés sont redéfinies dans la balise h1 :

  • la valeur red est affectée à la propriété color ;
  • la valeur 50px est affectée à la propriété font-size ;
  • la valeur bold est affectée à la propriété font-style :
h1
 {
 color: red;
  font-size: 50px;
  font-style: bold;
 }

Pour faciliter la lisibilité du code, chaque couple propriété/valeur est généralement placé sur une ligne qui lui est propre. Mais si vous le souhaitez, il est possible de tout rassembler sur une seule ligne :

h1 {color: red; font-size: 50px; font-style: bold; }

Lorsqu’un style est redéfini à l’intérieur d’une balise HTML, on utilise l’attribut style suivi du signe “=“. Les couples propriété/valeur sont placés entre guillemets et séparés entre eux par des “;” :

<h1 style="color: red; font-size: 50px; font-style: bold; ">Texte</h1>


Pour accéder à la boîte de dialogue des propriétés d’une icône de raccourci ou d’application, je suis prêt à parier que vous cliquez du bouton droit sur cette icône et que vous sélectionnez Propriétés dans le menu contextuel. Cette technique fonctionne à la perfection, mais je vais vous donner une astuce pour accéder plus rapidement à la boîte de dialogue des propriétés.

Maintenez la touche Alt du clavier enfoncée et double-cliquez sur l’icône de raccourci ou d’application. Comme vous pouvez le voir cette technique est équivalente à la précédente, mais bien plus rapide.


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).


Dans cette rubrique, vous allez apprendre à ouvrir systématiquement une fenêtre d’application en mode maximisé. Nous allons raisonner sur l’application Internet Explorer, mais la même technique s’applique à toutes les applications affichées dans le menu Démarrer.

Cliquez sur Démarrer. Tapez explo dans la zone de texte Rechercher. Cliquez du bouton droit sur Internet Explorer et sélectionnez Propriétés dans le menu contextuel. Dans la boîte de dialogue des propriétés, déroulez la liste Exécuter et sélectionnez Agrandie. Il ne vous reste plus qu’à valider en cliquant sur OK. Désormais, lorsque vous lancerez Internet Explorer depuis le menu Démarrer, la fenêtre de l’application sera systématiquement maximisée.


Propriétés et méthodes de classes

Lorsque vous définissez une propriété et une méthode dans une classe en la faisant précéder du mot clé static, ces deux objets sont définis une fois pour toutes les instances de cette classe. Il est même possible d’y faire référence sans instancier la classe.

Si, au contraire, vous omettez le mot static lorsque vous définissez les propriétés et méthodes d’une classe, elles seront redéfinies dans chaque instance de la classe.

Supposons par exemple que vous définissiez une propriété et une méthode static dans une classe nommée Init :

class Init{
  static int i;
  static void m(){
    i = 1;
  }
}

Pour accéder à cette variable et à cette méthode dans une autre classe, il suffira de préciser le nom de la classe où elles ont été définies :

public class Test{
  public static void main (String args[]) {
    Init.i = 5;
    System.out.println(Init.i);
    Init.m();
    System.out.println(Init.i);
  }
}

Définissez les classes Init et Test en créant les fichiers Init.java et Test.java. Compilez ces fichiers avec le compilateur javac et vérifiez le bon fonctionnement de la classe Test.

Protection des membres

Java fournit plusieurs niveaux de protection pour les membres d’une classe (propriétés, méthodes) :

  • Les membres public sont accessibles par tous les autres objets de l’application.
  • Les membres private ne sont accessibles que par les méthodes de la même classe. Il est plus fréquent de rencontrer des données private que des méthodes private.
  • Tout comme les membres private, les membres protected ne sont accessibles que par les méthodes de la même classe. Par contre, les fonctions membres d’une classe héritée d’une classe qui possède des membres protégés peuvent accéder à ces derniers.

Constantes de classe

Si vous êtes amené à manipuler plusieurs fois une donnée définie dans une classe dont la valeur n’évoluera pas, il est pratique de la définir en tant que constante. Pour ce faire, vous utiliserez le mot clé final. Par exemple :

public class Test {
  final int Maxima = 25;
  final int Nombre[] = {1, 2, 3, 4, 5, 6, 7};
}

Vous pouvez tout aussi bien définir un tableau de constantes :

final int Nombre[] = {1, 2, 3, 4, 5, 6, 7};

Attention :

Le mot clé final ne peut être utilisé qu’à l’intérieur d’une classe.

Définir une classe

Nous allons développer l’exemple précédent pour aborder pas à pas la démarche permettant de définir une nouvelle classe.

Avant de pouvoir utiliser une classe, il faut la déclarer comme suit :

class Cylindre{
   ...
  // Propriétés et méthodes de la classe
  ...
};

A l’intérieur des accolades sont propriétés et les méthodes de la classe. Par exemple :

class Cylindre {
  double rayon;     // Rayon de la base du cylindre
  double hauteur;   // Hauteur du cylindre

  double Calcule() {
    return 3.1415 * rayon * rayon * hauteur;
  }
}

Cette déclaration indique au compilateur le contenu de la classe Cylindre, mais ne réserve en rien l’espace mémoire qui permettra de travailler avec cette classe. Pour ce faire, vous devez définir une instance de la classe Cylindre (on parle aussi d’objet) avec une instruction du type suivant :

Cylindre Cyl = new Cylindre();

Cette instruction définit le bloc de mémoire Cyl dans lequel les propriétés rayon et hauteur et la méthode Calcule() pourront être manipulées.

La classe Cylindre ainsi définie n’est pas accessible de l’extérieur. En effet, toutes les propriétés et méthodes d’une classe sont par défaut de type private (privé). Elles ne peuvent donc être initialisées par des instructions extérieures à la classe. Pour résoudre ce problème, il suffit d’ajouter un spécificateur d’accès public comme suit :

public class Cylindre {
  static public double rayon;     // Rayon de la base du cylindre
  static public double hauteur;   // Hauteur du cylindre

  static public double Calcule() {
    return 3.1415 * rayon * rayon * hauteur;
  }
}

Dans cet exemple, les deux propriétés et la méthode sont rendues publiques. Elles sont accessibles à toutes les méthodes de l’application, qu’elles fassent partie d’autres classes ou non. Nous pouvons donc y accéder avec des instructions “à point” :

public class Calcul
{

  public static void main(String args[])
  {

    Cylindre Cyl = new Cylindre();  // Définition de l'objet Cyl de type Cylindre
    Cyl.rayon = 4.6;    // rayon de la base : 4,6 cm
    Cyl.hauteur = 12;   // hauteur du cylindre : 12 cm
    System.out.println("Volume du cylindre : " + Cyl.Calcule());
  }
}

Dans la procédure principale main, un objet de classe Cylindre est défini :

Cylindre Cyl = new Cylindre();  // Définition de l'objet Cyl de type Cylindre

Grâce à cette instruction, l’objet Cyl a désormais une existence réelle. Les deux instructions suivantes initialisent les variables membres rayon et hauteur :

Cyl.rayon = 4.6;    // rayon de la base : 4,6 cm
Cyl.hauteur = 12;   // hauteur du cylindre : 12 cm

Enfin, la dernière instruction utilise la fonction membre Calcule() pour calculer le volume du cylindre, et affiche le résultat sur l’écran :

System.out.println("Volume du cylindre : " + Cyl.Calcule());

Comme nous le verrons par la suite, il est parfois important que les variables utilisées dans une classe ne soient pas accessibles aux fonctions extérieures à la classe. Pour cela, il suffit de les faire précéder du spécificateur d’accès private :

public class Cylindre {
  static private double rayon;     // Rayon de la base du cylindre
  static private double hauteur;   // Hauteur du cylindre

static public double Calcule()
  {
    return 3.1415 * rayon * rayon * hauteur;
  }
}

Mais alors, les variables rayon et hauteur d’un objet Cylindre ne peuvent pas être initialisées directement. Les instructions suivantes sont donc illicites :

Cylindre Cyl = new Cylindre();  // Définition de l'objet Cyl de type Cylindre
Cyl.rayon = 4.6;   // Impossible d'initialiser une variable
Cyl.hauteur = 12; // private depuis une fonction extérieure

Pour initialiser ces variables, on utilise généralement une fonction membre public à laquelle on passe les valeurs à affecter aux variables privées :

static public void DefDonnees (double r, double h){
  rayon = r;
  hauteur = h;
};

Inversement, il peut être intéressant pour une fonction extérieure à la classe de connaître les valeurs courantes du rayon et de la hauteur. Pour cela, on définit deux fonctions membres publiques :

static double LitRayon() {
  return rayon;   // Le rayon est retourné par la fonction publique
}

static double LitHauteur() {
  return hauteur;   // La hauteur est retournée par la fonction publique
}

Le code permettant de définir la classe Cylindre devient :

public class Cylindre{
  static private double rayon;     // Rayon de la base du cylindre
  static private double hauteur;   // Hauteur du cylindre

  static public void DefDonnees (double r, double h) {
    rayon = r;
    hauteur = h;
  };

  static double LitRayon() {
    return rayon;   // Le rayon est retourné par la fonction publique
  }

  static double LitHauteur() {
    return hauteur;   // La hauteur est retournée par la fonction publique
  }

  static public double Calcule() {
    return 3.1415 * rayon * rayon * hauteur;
  }
}

L’application qui calcule le volume du cylindre doit être modifiée comme suit :

public class Calcul {
  public static void main(String args[])  {
    Cylindre Cyl = new Cylindre();  // Définition de l'objet Cyl de classe Cylindre
    double R = 4.6; // Rayon passé à la classe
    double H = 12;  // Hauteur passée à la classe
    Cylindre.DefDonnees(R, H); // Initialisation indirecte du rayon et de la hauteur
    System.out.println("Volume du cylindre : " + Cyl.Calcule());
  }
}