Bien que Java soit conçu pour fonctionner indépendament du système, il est parfoit utile de savoir lequel exécute notre programme. Cela permet, par exemple, de choisir si l'on doit exécuter Mozilla, Safari ou plutot Internet Explorer.
Pour cela, il suffit de consulter les variables d'environnement initialisées par la JVM :
String name = System.getProperty ( "os.name" );<br/>String version = System.getProperty ( "os.version" );
Lors d'une conversion d'un réel en entier par une opération d'affection, Java se contente de tronquer la partie décimale.
double a = 1.99;int b = a; <comment>b=1</comment>
Un solution consiste à simplement incrémenter la valeur réelle de 0.5 avant la conversion.
double a = 1.8;<comment>Conversion avec arrondi </comment>int b = a+0.5; <comment>b=2</comment>
Arrondir un réel à 10<sup>-2</sup> :
On peux également faire un arrondi à 10<sup>-2</sup> à la main en faisant:
double a = 1.6666666<comment>Arrondir la valeur a 10^-2</comment>a *= 100;a = (int)(a+.5);a /= 100;
Il est très important de commenter ce genre d'astuce de programmation; dans le cas contraire votre code pourrait rapidement devenir imcompréhensible !
La classe java.lang.Math :
La classe <javaClass class="java.lang.Math"/> fournit un certain nombre de méthodes pour faire les arrondis (inférieur, supérieur ou au plus proche). Elles ont l'avantage d'être plus lisibles que le code fourni précédemment. En revanche, rien n'est prévu pour l'arrondi à 10<sup>-2</sup>.
Arrondir pour afficher :
En revanche, si le résultat est destiné à une conversion en chaîne de caractères, on peux faire beaucoup mieux grâce à la classe <javaClass class="java.text.DecimalFormat"/> (plus d'info ici)
Le rôle des imports en Java est très différent de celui des includes en C / C++.
Les includes en C :
Lorsque le compilateur C (Le préprocesseur pour être précis) rencontre un include, il ouvre et analyse le fichier spécifié. Le contenu du fichier influs directement sur la compilation.
Les imports en Java :
Les imports en Java n'ont aucun impact sur le fichier compilé, ils servent uniquement à préciser les classes que vous souhaitez utiliser sans préciser chaque fois le nom du paquet. Une classe peut être utilisée sans avoir été importée, il suffit pour cela de préfixer le nom de la classe avec son nom de paquet.
L'exécution d'un programme externe se fait grâce à la méthode <javaMethode class="java.lang.Runtime" methode="exec(java.lang.String)" parametres="(commande)" /> de la classe <javaClass class="java.lang.Runtime" />.
On peut ensuite utiliser MonEnum.Val1, MonEnum.Val2 etc, ou mieux on peut faire une interface plutôt qu'une classe afin que les classes l'implémentant puissent directement appeler Val1, Val2...
Le problème reste le typage des éléments, rien n'empêche de passer un objet d'une énumération à la place d'une autre.
2<sup>ème</sup> solution :
Cette deuxième catégorie de solutions, plus complexes, permet d'éviter ce problème. On peut par exemple penser à utiliser des instances de classes :
publicfinalclass MonEnum1private MonEnum1()<comment>Rien à faire</comment><comment>liste des valeurs</comment>publicfinalstatic MonEnum1 Val1 = new MonEnum1();publicfinalstatic MonEnum1 Val2 = new MonEnum1();publicfinalstatic MonEnum1 Val3 = new MonEnum1();
Ainsi un éventuel objet de type MonEnum2 ne pourra jamais être utilisé à la place d'un objet de type Enum1 (Enum1.Val1 Enum1.Val2 ...).
2<sup>ème</sup> bis solution :
La 2<sup>ème</sup> solution pose un autre problème, il reste possible d'utiliser la valeur 'null' alors que celle-ci n'appartient pas au domaine de notre énumération. Pour ce faire, rien de plus simple, si on considère val1 comme la valeur par défaut, on la déclare de la manière suivante :
publicfinalstatic Enum1 val1 = null;
De cette manière il devient totalement impossible de passé un Enum1 non reconnu !
Les deux dernières méthodes posent toutefois un problème, le seule type d'argument accepté par un switch est l'entier. Il est donc impossible d'utiliser ces méthodes là où elle sont le plus souvent attendues. Il n'existe donc pas de solution miracle, à vous de choisir la solution qui correspond le mieux à vos contraintes.
En Java les types de base sont passés aux méthodes par valeur, ils ne peuvent pas être modifiés. Il va falloir utiliser une instance de classe "encapsulant" un entier pour effectuer la modification. Attention la classe fournie Integer ne permet pas la modification et est donc inutile dans ce cas.
Exemple :
class MonEntier<comment>champ privé :</comment>privateint value;<comment>mise à jour de la valeur</comment>publicvoid setValue(int newValue)value = newValue;<comment>Acces à la valeur</comment>publicint getValue()return( value);
L'accès aux variables d'environnement se fait par l'intermédiaire de la classe <javaClass class="java.lang.System" /> et plus précisément par la méthode <javaMethode class="java.lang.System" methode="getProperty(java.lang.String)" parametres="(clé)" />. Cette méthode donne accès à toutes les variables définies par le système. Des variables peuvent facilement être initialisées lors du lancement du programme en les ajoutant à la ligne de commande :
java -DTEST="test" nom_programme<comment> Création d'une variable : TEST = "test"</comment>
Variable d'environnement de Java :
Se baser sur les variables du système n'étant pas très portable, Java définit un certain nombre de variables de façon indépendante de la plateforme d'exécution. Exemple :
La liste des variables d'environnement est disponible par la méthode <javaMethode class="java.lang.System" methode="getProperties()" /> de la classe <javaClass class="java.lang.System" />. Programme affichant la liste de toutes les variables :
Un composant donné a besoin d'informer un ou plusieurs composants externes que certains événements se sont produits.
Un petit exemple :
Le composant MonBouton a besoin d'informer une liste d'objets que le bouton gauche de la souris est appuyé et que le bouton de la souris a été relaché.
<comment>import nécessaire :</comment>import javax.swing.event.EventListenerList;
<comment>attribut :</comment>protected EventListenerList listenerList;
<comment>instanciation nécessaire : (à faire dans son constructeurou dans une méthode appelée par le constructeur)</comment>this.listenerList = new EventListenerList ();
<comment>méthode à faire :permet d'ajouter un composant dans la liste de ceux qui veulentêtre informés de l'évènement</comment>publicvoid addMonBoutonMouseListener (MonBoutonMouseListener l)this.listenerList.add (MonBoutonMouseListener.class, l);
<comment>enlève un objet qui est actuellement écouteur de l'évènement</comment>publicvoid removeMonBoutonMouseListener (MonBoutonMouseListener l)this.listenerList.remove (MonBoutonMouseListener.class, l);
<comment>lance un évènement à tous les objets écouteurs(== appelle la méthode boutonGauchePresse sur tous les objetsécouteurs de la liste)</comment>protectedvoid fireboutonGauchePresse ()MonBoutonMouseListener [] listeners = (MonBoutonMouseListener [])<br_l/> listenerList.getListeners( MonBoutonMouseListener.class);EventObject e = new EventObject (this);for (int i = listeners.length-1; i>=0; i--)listeners [i].boutonGauchePresse (e);
Il suffit ensuite d'appeler cette méthode à chaque fois que l'évènement approprié est généré.
Tout d'abord il faut savoir qu'un type de base tel que int, short, long sont représentés sur 1 ou plusieurs octets. Par exemple un short est représenté sur 16bits soit 2 octets(en Java). Ces octets peuvent ètre organisé suivant 2 ordres :
Big Endian : L'octet de poids le plus fort (Most Significant Byte) en premier c'est aussi le format utilise pour le transfert des donnees sur les reseaux. exemple d'un short Big endian (nota le 0x est pour la representation hexadecimal) short value = 0x2DA5 representation binaire Big Endian sera 00101101 10100101
Little Endian : l'octet de poids le plus faible (Less Significant Byte) en premier. exemple d'un short Little endian (nota le 0x est pour la representation hexadecimal) short value = 0x2DA5 representation binaire Big Endian sera 10100101 00101101
Java par defaut utilise Big Endian donc en general il n'y aura jamais de problème. Le problème apparaîtra lorsque vous voudrez échanger des données entre programmes écrits dans d'autres langages que Java (par exemple C/C++ sur PC...).
Lire un fichier en Little Endian
Avant de vouloir changer l'ordre des octets il vous faut d'abord lire votre flux octet par octet. D'ou l'utilisation des methodes readByte() du package java.io ou le faire a la main en utilisant les bons masques et surement l'opérateur >> et << (décalage de bits)
<comment>Convertir un short Little Endian en short Big Endian</comment><comment>short 16bits (2 octets)</comment>int lowValue = readbyte() & 0xff;int highValue = readbyte() & 0xff;short value = (short )(lowValue << 8 | highValue);
<comment>Convertir un int Little Endian en short Big Endian</comment><comment>integer 32bits (4 octets)</comment>int valueBE = 0;valueBE = ((byte4 & 0xff) << 24)|((byte3 & 0xff)<<16)|((byte2 & 0xff) << 8)|(byte1 & 0xff);
Lorsque l'on exécute une application Java sous windows, un terminal de commande permet d'afficher les entrées/sorties de l'application. Si vous souhaitez exécuter votre application sans le terminal, il suffit d'utiliser javaw.exe à la place de java.exe
javaw -CLASSPATH ... monAppli
Une deuxième solution consiste à créer une archive Jar contenant tous les fichiers de l'application et un fichier 'manifest'. De cette manière, il suffit alors de double-clicker sur le fichier jar pour l'exécuter. Pour plus d'informations, lire : Comment créer un Jar exécutable ?
L'accès au presse-papier se fait grâce à la classe <javaClass class="java.awt.datatransfer.Clipboard" /> disponible dans la boite à outils (<javaClass class="java.awt.Toolkit"/>).
Lire du texte :
<comment>Lecture du contenu :</comment>Transférable t = Toolkit.getDefaultToolkit().getSystemClipboard().getContents(null);try<comment>Vérification que le contenu est de type texte.</comment>if( t!=null && t.isDataFlavorSupported(DataFlavor.stringFlavor) )String txt = (String)t.getTransferData(DataFlavor.stringFlavor);catch( UnsupportedFlavorException e1)catch( IOException e2 )
Ecrire du texte :
tryStringSelection ss = new StringSelection("Mon Texte");Toolkit.getDefaultToolkit().getSystemClipboard().setContents(ss,null);catch( IllegalStateException )<comment>Le presse-papier n'est pas disponible</comment>
Contrôle-C, kill -9 et autres sont des méthodes permettant d'arrêter l'exécution du programme sans lui demander son avis. Pourtant, il est parfois nécessaire de faire au moins quelques instructions capitales telles que la fermeture de flux de fichier, d'une connexion réseaux ou une sauvegarde rapide. Pour se faire il est possible de définir un 'ShutdownHook' ce qui se traduit par un thread exécuté à la réception du signal de fin d'exécution.
Attention :
Ce traitement final sera également exécuté lors de l'arrêt normal de l'application.
Le garbage Collector (rammasse miette) est la partie de la JVM qui s'occupe de la récupération des zones mémoires. Les phases de libération de la mémoire sont gérées de façon autonome, il est inutile de lui dire quand passer.
Il existe néanmoins la fonction <javaMethode methode="gc" class="java.lang.System"/> de la classe <javaClass class="java.lang.System"/> qui permet de faire un appel explicite au garbage collector. Cet appel ne garantit pas que tous les objets inutiles seront supprimés de la mémoire.
<comment>Appel explicite au Garbage collector :</comment>System.gc ();
L'entrée standard est accessible au programmeur grâce au flux 'in' de la classe <javaClass class="java.lang.System"/>. Si vous exécutez votre application dans une console, l'entrée standard contiendra tous les caractères entrés au clavier dans la console. La manipulation directe du flux n'étant pas très aisée, une petite conversion en <javaClass class="java.io.BufferedReader"/> s'impose.
<comment>Convertion du flux en BufferedReader</comment>BufferedReader entree = new BufferedReader(new InputStreamReader(System.in));try<comment>Lecture d'une ligne :</comment>entree.readline();catch( IOException e )e.printStackTrace();
Note : La lecture d'une ligne est une méthode dite 'blocante', tant que l'utilisateur n'a pas fait 'entrée', le processus attends.
Si les paramètres passés au constructeur sont incohérents ou que la construction provoque une erreur, la création de l'objet est impossible et doit être annulée. Comme les méthodes, les constructeurs peuvent lever des exceptions, c'est la façon la plus simple d'annuler l'exécution du constructeur. Techniquement, l'objet est créer en mémoire (l'allocation de la mémoire a lieu au moment de l'appel du constructeur) mais l'appelant étant obligé de traiter l'exception, le pointeur vers cette objet est perdu et sera donc recupéré par le ramasse-miettes.
Une solution plus élégante consiste à utiliser par une méthode statique qui verifie les paramètres et ne fait l'appel au constructeur que si ceux-ci sont corrects.
publicclass Test<comment>Le constructeur est déclaré protected pour interdire son utilisation par les clients de la classe.</comment>protected Test(int val) publicstatic Test createTest( int val )if( val<100 )return( new Test(val) );elsereturn( null);<comment>Ou alors on lève une exception...</comment>
Ce document issu de http://www.developpez.com est soumis à la licence GNU FDL traduit en français ici.
Permission vous est donnée de distribuer, modifier des copies de cette page tant que cette note apparaît clairement.
