Médiaforma

All posts tagged float

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

Dans cette rubrique, je vais vous montrer comment faire une mise en page sur deux colonnes. La première de largeur fixe et la deuxième qui occupe le reste de l’espace horizontal disponible.

Vous vous en doutez certainement : chacune des colonnes sera représentée par une balise <div>. Le document HTML est des plus classiques. Il contient deux balises <div> d’identifiant col1 et col2 et un texte quelconque est placé dans chacune des balises.

Le code CSS est bien plus intéressant.

Les lignes 1 à 7 définissent les caractéristiques de la première balise <div>. Cette dernière sera flottante, sur le côté gauche de la fenêtre. Elle aura une largeur de 200 pixels, une couleur spécifique et une marge intérieure de 10 pixels.

Les lignes 9 à 14 précisent les caractéristiques de la deuxième balise <div>. En définissant une marge à gauche de 220 pixels, cette balise s’insère à droite de la première balise <div>. Vous vous demandez peut-être pourquoi avoir défini une marge de 220 pixels et non de 200 pixels, puisque la première balise <div> est large de 200 pixels. Ajoutez à ces 200 pixels la marge gauche de 10 pixels et la marge droite de 10 pixels de la première balise <div> et vous obtenez une marge de 220 pixels. La ligne 12 définit la couleur d’arrière-plan de la deuxième balise <div> et la ligne 13 sa marge intérieure.

Il ne reste plus qu’à afficher le document HTML dans un navigateur. Lorsque l’on redimensionne la fenêtre du navigateur, la deuxième balise <div> s’étire pour occuper tout l’espace horizontal qui lui est donné.


Dans la rubrique précédente, vous avez appris à faire flotter un élément par rapport à un autre. Supposons que vous vouliez que le texte cesse de s’enrouler autour de l’image à un certain point. Par exemple juste avant le mot “Totam“.

La première idée qui vient à l’esprit consiste à mettre le texte qui commence par Totam dans un autre paragraphe :

Le texte est bien scindé en deux paragraphes, mais le deuxième paragraphe continue de s’enrouler autour de l’image :

Pour parvenir au résultat souhaité, il faut définir la propriété CSS clear dans le deuxième paragraphe et lui affecter la valeur both :

Maintenant, le résultat est bien celui qui était attendu :


Dans les rubriques précédentes, vous avez appris à positionner un élément à un emplacement bien précis. Je vous propose maintenant d’apprendre à faire flotter un élément par rapport à un autre. Cela vous permettra par exemple d’enrouler du texte autour d’une image.

La technique à utiliser est élémentaire : il vous suffit de définir l’attribut float dans l’élément que vous désirez voir flotter et de lui affecter la valeur left ou right en fonction de l’emplacement souhaité.

Ici par exemple, l’image chat-poisson.png flotte à droite et le texte qui suit s’enroule autour :

Si vous affectez la valeur left à la propriété float, l’image flotte à gauche et le texte s’enroule autour :


Plusieurs types de données peuvent être utilisés en PHP :

  • Booléen : c’est le type le plus simple. Il peut valoir TRUE ou FALSE (ces deux mots sont insensibles à la casse).
  • Entier : un nombre entier peut être spécifié en décimal (1234), en octal (0123) ou en hexadécimal (0x1F).
  • Décimal : un nombre décimal peut être spécifié sous une forme traditionnelle (1.46) ou en virgule flottante (1.2e3 ou 6E-9).
  • Chaîne : elle peut être délimitée par des guillemets ou par des apostrophes. Utilisez le caractère d’échappement antislash (\) pour insérer un guillemet ou une apostrophe dans une chaîne délimitée (respectivement) par des guillemets ou des apostrophes.
  • Tableau : il peut être constitué d’une suite de valeurs individuelles ou d’une suite de couples clé=>valeur. Nous y reviendrons par la suite.
  • Objet : pour définir un objet, vous devez instancier une classe en utilisant le mot-clé new. Les fonctions membres sont accédées avec l’opérateur -> et les variables membres avec l’expression $this->var_membre. Nous y reviendrons par la suite.
  • Ressource : il s’agit d’un type particulier qui fait référence à une ressource externe. Consultez cette page pour en savoir plus : http://www.php.net/manual/fr/resource.php. Nous y reviendrons par la suite.
  • NULL : ce type représente une variable sans valeur. Une variable est de type NULL si :
    • On lui a affecté la constante NULL ;
    • Elle n’a pas encore reçu de valeur ;
    • Elle a été effacée avec la fonction unset().

Pour tester si une donnée est d’un certain type (ou peut être convertie dans ce type), vous utiliserez des fonctions PHP prédéfinies :

Fonction Effet
is_array() Teste si l’argument est un tableau
is_bool() Teste si l’argument est un booléen
is_float() Teste si l’argument est un nombre réel
is_int() Teste si l’argument est un nombre entier
is_null() Teste si l’argument est nul
is_numeric() Teste si l’argument est numérique
is_object() Teste si l’argument est un objet
is_string() Teste si l’argument est une chaîne

 

Voici quelques exemples :

$ch="ceci est une chaîne"; // La fonction is_string($ch) retourne true

$i = 12; // La fonction is_int($i) retourne la valeur true

$r = 16.34; // La fonction is_float($r) retourne la valeur true


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

Dans cette section, nous allons définir un design sur trois colonnes. La première colonnes sera ancrée à gauche et aura une largeur fixe. La troisième colonne sera ancrée à droite et aura une largeur fixe. Quant à la deuxième colonne, elle occupera tout l’espace laissé libre par les deux autres colonnes.

Le code HTML est rudimentaire : il contient trois balises <div> consécutives, remplies avec un peu de texte :

Le code CSS est bien plus intéressant.

Les lignes 1 à 7 définissent les caractéristiques de la première balise <div>. La colonne est flottante, ancrée à gauche, large de 200 pixels, a une couleur spécifique et une marge interne de 10 pixels.

Les lignes 9 à 15 définissent les caractéristiques de la troisième balise <div>. La colonne est flottante, ancrée à droite, large de 250 pixels, a une couleur spécifique et une marge interne de 10 pixels.

Enfin, les lignes 17 à 23 définissent les caractéristiques de la deuxième balise <div>, qui se trouve entre les deux colonnes flottantes gauche et droite. Cette balise est décalée de 220 pixels à gauche, c’est-à-dire de la largeur de la balise flottante gauche augmentée de ses marges internes. Elle est également décalée de 270 pixels à droite, c’est-à-dire de la largeur de la balise flottante droite augmentée de ses marges internes. Tout comme les deux autres <div>, cette balise a une couleur spécifique et une marge interne de 10 pixels.

Affichons le résultat du code HTML dans un navigateur. Comme vous pouvez le voir la première et la troisième colonne sont ancrées sur les bords gauche et droit de la fenêtre. Quant à la deuxième colonne, elle occupe toute la largeur disponible lorsque la fenêtre est redimensionnée.


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

MAX_VALUE représente la valeur maximale qui puisse être stockée dans une variable float : 3.40282346638528860e+38f.

MIN_VALUE représente la valeur minimale qui puisse être stockée dans une variable float : 1.40129846432481707e-45f.

NEGATIVE_INFINITY représente la valeur -infini.

POSITIVE_INFINITY représente la valeur +infini.

NaN représente une valeur indéterminée.

Le constructeur

Le constructeur Float permet de définir un objet Float à partir d’une variable float ou double :

public Float(float value);
public Float(double value);

Exemple :

Voir méthodes IntValue, longValue, doubleValue, floatValue et hashCode.

Les méthodes

isInfinite()

Cette méthode retourne la valeur true si le float spécifié en argument a une valeur infinie. Elle retourne la valeur false dans le cas contraire :

static public boolean isInfinite(float v);

Exemple :

public class Test {
  public static void main (String args[]) {
    float x = (float) (1/0.0);
    System.out.println(x);
    System.out.println(Float.isInfinite(x));
  }
}

Le premier println affiche la valeur infinite et le second la valeur true. Java considère donc que la valeur stockée dans la variable x est infinie.

Remarque

Vous pouvez également utiliser la méthode isInfinite() pour déterminer si un objet Float a une valeur infinie :

public boolean isInfinite();

toString()

Cette méthode renvoie une chaîne de caractères qui représente le float passé en argument :

public static native String toString(float f);

Exemple :

public class Test {
  public static void main (String args[])
  {
    float x = (float) Math.PI;
    String S;
    S = Float.toString(x);
    System.out.println(S.length());
  }
}

Après conversion du float x en chaîne de caractères :

S = Float.toString(x);

il devient possible d’utiliser les méthodes de la classe String pour travailler sur la valeur convertie du float :

System.out.println(S.length());

Remarque

Vous pouvez également utiliser la méthode toString() pour convertir un objet Float en un objet String :

public String toString();

intValue()

La méthode intValue() retourne la valeur entière de l’objet Double sur lequel elle est appliquée :

public int intValue()

Exemple :

public class Test {
  public static void main (String args[])
  {
    float x = (float) Math.PI;
    Float frr = new Float(x);
    System.out.println(frr.intValue());
  }
}

La première instruction affecte la constante PI à la variable float x :

float x = (float) Math.PI;

La deuxième instruction définit l’objet Float frr à partir de la variable float x :

Float frr = new Float(x);

Enfin, la troisième instruction affiche la valeur entière de l’objet frr :

System.out.println(frr.intValue());

Remarque

Si la valeur à convertir est stockée dans une variable float (et non dans un objet Float), il sera plus simple d’utiliser la syntaxe suivante :

float x = (float) Math.PI;
System.out.println((int) x);

longValue()

La méthode longValue() retourne la valeur entière long de l’objet Double sur lequel elle est appliquée :

public long longValue()

Exemple :

public class Test {
  public static void main (String args[])
  {
    float x = (float) 1486618620.65617;
    Float Fx = new Float(x);
    long Lx = Fx.longValue();
    System.out.println(Lx);
  }
}

La première instruction initialise la variable x :

float x = (float) 1486618620.65617;

La deuxième instruction définit l’objet float Fx à partir de la variable float x :

Float Fx = new Float(x);

La troisième instruction définit la variable long Lx en appliquant la méthode longValue() sur l’objet Float Fx :

long Lx = Fx.longValue();

Remarque

Si la valeur à convertir est stockée dans une variable double (et non dans un objet Double), il sera plus simple d’utiliser la syntaxe suivante :

float x = (float) 1486618620.65617;
long Lx = (long) x;

floatValue()

La méthode floatValue() retourne la valeur réelle float de l’objet Float sur lequel elle est appliquée :

public float floatValue()

Exemple :

public class Test {
  public static void main (String args[])
  {
    float x = (float) 1.234567890123456789e12f;
    Float Fx = new Float(x);
    float fx = Fx.floatValue();
    System.out.println("Le nombre original : " + x);
    System.out.println("Après conversion : " + fx);
  }
}

La première instruction initialise la variable x :

float x = (float) 1.234567890123456789e12f;

La deuxième instruction définit l’objet Float Fx à partir de la variable float x :

Float Fx = new Float(x);

La troisième instruction définit la variable float fx en appliquant la méthode floatValue() sur l’objet Float Fx :

float Fx = Fx.floatValue();

doubleValue()

La méthode doubleValue() retourne la valeur réelle double de l’objet Double sur lequel elle est appliquée :

public double doubleValue();

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException
  {
    double d1;
    String Interm;

    System.out.println("Entrez une valeur réelle float : ");
    Interm = Lit();
    d1=Float.valueOf(Interm).doubleValue();
    System.out.println("Voici sa conversion en double : " + d1);
  }

  public static String Lit() throws java.io.IOException
  {
    String S = "";
    char C;
    while ((C=(char)System.in.read()) != '\r')
    {
      S = S + C;
    }
    C=(char)System.in.read();
    return S;
  }
}

La fonction Lit() acquiert les caractères tapés au clavier et les retourne sous forme d’une chaîne String lorsque la touche Entrée est pressée.

Dans la procédure main(), un message invite l’utilisateur à entrer une valeur réelle float :

System.out.println("Entrez une valeur réelle float : ");

Les caractères tapés sont ensuite mémorisés et stockés dans la variable String Interm :

Interm = Lit();

L’instruction suivante stocke dans la variable r1 la conversion réelle double de la chaîne Interm :

r1=Float.valueOf(Interm).doubleValue();

La méthode valueOf(Interm) convertit la chaîne Interm en un objet Float. Cette méthode fait partie de la classe Float. Elle est dont référencée par Float.valueOf(Interm). On applique ensuite la méthode doubleValue() à l’objet Float qui vient d’être défini, pour le convertir en un réel double…

Remarque

Si la valeur à convertir est stockée dans une variable float (et non dans un objet Float), il sera plus simple d’utiliser la syntaxe suivante :

double d1 = (double) x;

hashCode()

Cette méthode retourne le hashcode (chaque objet Java possède un hashcode qui lui est propre) de l’objet sur lequel elle est appliquée :

public int hashCode();

Exemple :

public class Test {
  public static void main (String args[])
  {
    float x = 1.2345678f;
    Float Fx = new Float(x);
    System.out.println(Fx.hashCode());
  }
}

La troisième instruction de la procédure main() affiche le hashcode de l’objet Float précédemment défini :

Float Fx = new Float(x);
System.out.println(Fx.hashCode());

equals()

Cette méthode compare l’objet this et l’objet spécifié. Elle renvoie la valeur true si les objets sont identiques et la valeur false dans le cas contraire :

public boolean equals(Object obj)

valueOf()

Cette méthode retourne un objet Float initialisé à la valeur numérique placée dans l’argument String :

public static native Float valueOf(String s) throws NumberFormatException;

Exemple :

Voir la méthode doubleValue().

floatToIntBits()

Cette méthode renvoie la représentation binaire d’une valeur double :

public static native int floatToIntBits(float value);

Exemple :

public class Test {
  public static void main (String args[])
  {
    float x = 123.456f;
    int binaire = Float.floatToIntBits(x);
    System.out.println("Valeur initiale : " + x);
    System.out.println("Conversion binaire : " + binaire);
    System.out.println("Conversion binaire->float : " + Float.intBitsToFloat(binaire));
  }
}

Dans un premier temps, une valeur réelle float est stockée dans la variable x :

float x = 123.456f;

Cette variable est convertie en binaire avec la méthode floatToIntBits() et stockée dans la variable int binaire :

int binaire = Float.floatToIntBits(x);

La valeur initiale et la conversion binaire sont ensuite affichées :

System.out.println("Valeur initiale : " + x);
System.out.println("Conversion binaire : " + binaire);

Enfin, la valeur binaire est reconvertie en un réel float avec la méthode intBitsToFloat() et affichée :

System.out.println("Conversion binaire->float : " + Float.intBitsToFloat(binaire));

intBitsToFloat()

Cette méthode renvoie la représentation float d’une valeur binaire :

public static float intBitsToFloat(int bits);

Exemple :

Voir la méthode floatToIntBits().

parseFloat()

Cette méthode renvoie la représentation String d’un objet Float.


Types de données prédéfinis

Les types de données prédéfinis en Java ne sont pas très nombreux. Ils permettent de manipuler des nombres entiers (byte, short, int, long), des nombres réels (float, double), des booléens (boolean) et des caractères (char). Par extension, vous pouvez également utiliser la classe String pour manipuler facilement des chaînes de caractères.

Les divers types de données utilisables en Java vont être passés en revue dans les sections suivantes.

Nombres entiers

Selon la taille des nombres à manipuler, vous utiliserez le format byte, short, int ou long :

  • Les entiers byte sont codés sur 8 bits. Ils permettent de manipuler des nombres compris entre -2^7 et (2^7)- 1, c’est-à-dire entre -128 et 127.
  • Les entiers short sont codés sur 16 bits. Ils permettent de manipuler des nombres compris entre -2^15 et (2^15)-1, c’est-à-dire entre -32768 et 32767.
  • Les entiers int sont codés sur 32 bits. Ils permettent de manipuler des nombres compris entre -2^31 et (2^31)-1, c’est-à-dire entre -2147483648 et 2147483647.
  • Enfin, les entiers long sont codés sur 64 bits. Ils permettent de manipuler des nombres compris entre -2^63 et 2^63, c’est-à-dire entre -9223372036854775808 et 9223372036854775807.

Exemples :

Les nombres entiers peuvent être exprimés en décimal (base 10), en hexadécimal (base 16) ou en octal (base 8) :

byte NombreDécimal = 127;       // Un nombre entier exprimé en décimal
int NombreHexadécimal = 0x5ec;  // Un nombre entier exprimé en hexadécimal
long NombreOctal = 0346;        // Un nombre entier exprimé en octal

Nombres réels

Les nombres réels sont composés d’une partie entière suivie d’un point, d’une partie décimale, de la lettre e (ou E) et d’un exposant, éventuellement précédé d’un signe + ou -.

Voici quelques exemples de nombres réels :

325.707
3.25707E2
.325707E3
-45.567E-5

Le langage Java manipule deux types de réels :

  • Les réels float sont codés en simple précision sur 32 bits (1.40239846e-45 à 3.40282347e38).
  • Les réels double sont codés en double précision sur 64 bits (4.94065645841246544e-324 à 1.79769313486231570e308).

Vous pouvez spécifier le type d’une variable réelle pendant sa création en utilisant les mots clés double et float :

double d = 34.56567;
float f = 123.56;

Attention :

La seconde instruction est incorrecte : Lorsque Java rencontre un point décimal dans une affectation, il suppose qu’il s’agit d’un réel double. En affectant un nombre contenant un point décimal à une variable float, vous obtiendrez un message d’erreur vous indiquant une incompatibilité de type. Pour résoudre ce problème, vous utiliserez l’une des deux syntaxes suivantes :

float f = (float)123.56;
float f = 123.56f;
La lettre "f" à la fin de la seconde instruction indique que la donnée est de type float et non double. De la même façon, vous pouvez utiliser le suffixe "d" pour affecter une valeur double à une variable :
double d = 145.56565d;

Remarque

Les suffixes f et d peuvent être indifféremment utilisés en lettres minuscules ou majuscules.

Booléens

Ils peuvent prendre la valeur true ou la valeur false. Si vous le souhaitez, il est également possible d’utiliser (comme dans de nombreux autres langages) un nombre non nul pour représenter la valeur true et le nombre 0 pour représenter la valeur false.

Dans l’exemple suivant, les instructions définies entre les deux accolades seront exécutées. En effet, la variable Valeur étant non nulle, sa valeur est interprétée comme true.

Valeur = 4;
if Valeur then {
  ...
}

Type char

Une variable de type char peut contenir un (et un seul !) caractère. Java utilise le jeu de caractères 16 bits Unicode qui contient quelque 65 000 caractères! Il est donc possible de manipuler des caractères spécifiques à la langue française (à, é, è, ç, etc.) dans les variables char… et par extension dans les chaînes String.

A titre d’exemple, les deux affectations ci-après sont correctes :

char c1 = 'é';
char c2 = '1';

Par contre, cette troisième affectation produira une erreur lorsqu’elle sera exécutée :

char c3 = 'er';