WarLocG

#! modo de compet

Les bases du langage Java - partie 1

[ A ce stade je peut plus ou moins dire que cette première partie est terminée, mais la suite (la partie qui traite des String, Collection, BufferedReader etc..) est encore en "examen" ]

Sommaire
1. La structure de base d'une classe standard et d'une classe main
2. Les types primitifs
3. Les constructeurs et méthodes
4. Les commentaires et la javadoc
5. Les packages
6. La visibilité des propriétés et méthodes et le champs static

1. La structure de base d'une classe standard et classe main

D'abord, comme on parlera de classe, en Orienté Objet, une classe c'est quoi ?

Une classe est une entité, un objet un peu comme dans la vie réelle. Je vais prendre l'exemple simple d'une balle.
* Une balle possède des attributs : la taille, la couleur, la dureté, également une vitesse, une force, une masse, etc ... en Orienté Objet on appellera ces attributs des propriétés.
* Une balle possède des actions: une balle peut rouler(), peut rebondir(). En Orienté Objet on appellera ces actions des méthodes.

Mais une classe ne sera pas nécessairement quelque chose de concret, on pourra aussi bien créer des objets plus diffus comme par exemple une FormeGeometrique, qui à elle seule est trop vague pour être créée tel quelle mais aura des attributs et actions qui pourront être laissés à ses descendants, comme par exemple: nbCote, perimetre(), surface(), ... ce que nous verront plus tard.

La construction d'une classe en java se fait comme suit:

[== Java ==]
public class NomDeLaClasse
{
  //Ajouter les variables qui auront une visibilité globale sur la classe à la suite
  /* exemple: 
   * public int i=0;
   * private String mot = "bonjour;
   */

  //Ajouter les méthodes à la suite
  /* exemple: 
   * public int afficheMonEntier()
   * {
   *    return this.i;
   * }
   */
}

Jusque là rien de compliqué. Notez que le nom de la classe doit être strictement identique au nom du fichier, en respectant la casse sinon vous aurez une erreur.

Dans cet exemple, this.i appelle la propriété i déclarée en globale.

Notez enfin que cette classe est complètement vide et vous n'irez nulle part avec avec sauf en retirant les commentaires.

La construction du `main` (la classe principale) se fera pratiquement toujours de cette manière:

[== Java ==]
class ClassePrincipale
{
  public static void main(String[] args)
  {
    //Insérez vos instructions à la suite
    /* exemple:
     * NomDeLaClasse foo = new NomDeLaClasse() //appelle le constructeur de la classe NomDeLaClasse
     * int i;
     *
     * for (i=0; i<10; i++)
     * {
     *   foo.faitQuelqueChose(); // utilise la méthode faitQuelqueChose définie dans la classe NomDeLaClasse
     * }
     */
  }
}

C'est à partir du main que le programme va tourner et c'est à partir de son nom qu'il faudra lancer la commande java <nomduprogramme>.

2. Les types primitifs

Java étant un langage typé, voici la liste des types primitifs dont on pourra déclarer nos propriétés.

En java, on dispose des types suivants:

 Type           Signification                Taille (en octets)       Plage de valeurs acceptées
------         ---------------              --------------------     --------------------------------
 char           Caractère Unicode            2                        '\u0000' → '\uffff' (0 à 65535 )
 byte           Entier très court            1                        -128 → +127
 short          Entier court                 2                        -32 768 → +32 767
 int            Entier                       4                        -231≈-2,147×109 → +231-1≈2,147×109
 long           Entier long                  8                        -263≈-9,223×1018 → +263-1≈9,223×1018
 float          Nombre réel simple           4                        ±2-149≈1.4×10-45 → ±2128-2104≈3.4×1038
 double         Nombre réel double           8                        ±2-1074≈4,9×10-324 → ±21024-2971≈1,8×10308
 boolean        Valeur logique (booléen)     1                        true (vrai), ou false (faux)

Ainsi que leur enveloppeur, grosso-modo leur version Objet, indispensable avec les Collections que l'on abordera plus tard.

 Type primitif     Enveloppeur  |  Méthodes pour cast en utilisant l'enveloppeur {type renvoyé}
---------------   ------------- | --------------------------------------------------------------
 char              Character    |                                                 Character.charValue() : char,     Character.valueOf() : static Character
 byte              Byte         |  Byte.parseByte(String) : static byte,          Byte.byteValue() : byte,          Byte.valueOf() : static Byte
 short             Short        |  Short.parseShort(String) : static short,       Short.shortValue() : short,       Short.valueOf() : static Short
 int               Integer      |  Integer.parseInt(String) : static int,         Integer.intValue() : int,         Integer.valueOf() : static Integer
 long              Long         |  Long.parseLong(String) : static long,          Long.longValue() : long,          Long.valueOf() : static Long
 float             Float        |  Float.parseFloat(String) : static float,       Float.floatValue() : float,       Float.valueOf() : static Float
 double            Double       |  Double.parseDouble(String) : static double,    Double.doubleValue() : double,    Double.valueOf() : static Double
 boolean           Boolean      |  Boolean.parseBoolean(String) : static boolean, Boolean.booleanValue() : boolean, Boolean.valueOf() : static Boolean

Page de la classe java.lang contenant les enveloppeurs sur l'API JAva

La 3ième colonne sert à retrouver les méthodes qu'on a besoin lorsqu'il faudra renvoyer une valeur selon tel type, ou le renvoyer sous forme d'objet. (en fait je dépose déjà ces méthodes ici le temps de voir comment je vais m'occuper de la partie 'conversion de types' plus bas...) mais vous remarquerez que:
  * Type.parseType(String) renvoit le type primitif correspondant en static
  * Type.typeValue() renvoit le type primitif correspondant
  * Type.valueOf() renvoit l'enveloppeur correspondant en static

Notes:
  * un nombre flottant (float et double) s'écrit de la sorte: 0.0 (avec les chiffres que vous voulez mais le . est important)
  * un type float prendra en plus un 'f' au bout sinon il sera par défaut considéré comme un double, et s'écrira donc 0.0f (attention au petit f)
  * un entier long s'écrit de la sorte 0L (pareil, le nombre que vous voulez mais n'oubliez pas le L)

Référence: http://www.commentcamarche.net/contents … atype.php3

Vous pourriez être amené à devoir manipuler des types entiers ou flottants avec des chaînes de caractères, pour convertir un nombre en chaîne de caractère on utilisera la méthode valueOf() de la classe String à cet effet. Ceci sera expliqué plus tard dans un autre chapitre abordant la classe String.

3. Les constructeurs et méthodes

D'abord viennent les constructeurs, qui peuvent s'écrire de 2 manières:
  * Avec une méthode public void init(). /!\ Notez que cette méthode est devenue obsolète et ne s'utilise dorénavant plus. /!\
  * avec la construction suivante public NomDeLaClasse()

Les constructeurs sont une fonctionnalité de l'Orienté Objet servant à créer / initialiser un objet de la classe donnée. Le contraire d'un constructeur s'appelle le destructeur, cependant il n'existe pas en java du fait que la destruction et libération en mémoire des objets détruit se fait automatiquement par le "garbage collector" (le ramasse-miette).

Remarque: une méthode commence par une minuscule et renvoit un type, un constructeur commence par une majuscule et n'est d'aucun type (le type c'est lui-même en fait).

exemple:

[== Java ==]
...
public void init()
{
  //Ceci est un constructeur
  this.i = 0;
  this.f = 0.0;
}

public NomDeMaClasse()
{
  //Ceci est aussi un constructeur
  this.i = 0;
  this.f = 0.0;
}
...

Une méthode permet de traiter des blocs d'instructions dans un espace encapsulé. On représente en général les méthodes en deux catégories:
  * Les getters ou accesseurs : ces méthodes permettent l'accès à une propriété. L'objectif étant d'obliger l'accès à la propriété que par cette méthode, c'est une sécurité.

Exemple:

[== Java ==]
...
// Une propriété déclarée en début de classe, ayant une portée globale sur toute la classe
private int i; // Cette propriété est déclarée private; elle ne sera accessible que dans cette classe
public float f; // Cette propriété est déclarée public et sera accessible partout => elle n'est pas protégée !
...

public int lireMaValeurEntiere()
{
  return this.i; // this.i équivaut au i déclarée plus haut en private et c'est grâce à cette méthode qu'on pourra y accéder !
}
...

Note: ma méthode est de type int, je doit donc renvoyer une valeur int, donc je met return suivi d'une valeur de type int.

  * Les setters ou mutateurs : ces méthodes permettent la modifications d'une propriété globale définie comme étant private ou protected.

Si on reprend l'exemple du dessus, on va écrire une méthode pour lui affecter une valeur et remplacer celle qu'elle possède déjà.

[== Java ==]
...
public void remplacerMaValeurEntiere(int entier)
{
  this.i = entier; // j'affecte "entier" au i déclaré globalement.
}
...

Il est possible d'écrire plusieurs méthodes et/ou constructeurs ayant le même nom pour autant que les paramètres passés soient différents.

Accéder à une méthode:

=> Classe.méthode();

Si ma méthode est un getter => le type de la valeur qui recevra la méthode est identique à Classe.méthode();
Exemple:

   ...
   public int maMethode(Objet o){...} // retourne un int   
   ...
   int maPropriete = this.maMethode(o); // un int sera passé a maPropriete
   ...

4. Les commentaires et la javadoc

Commenter en java se fait de deux manières:
* Commentaire sur une seule ligne en commençant la ligne par //

[== Java ==]
// Ceci est un commentaire sur une ligne

* Commentaire sur plusieurs lignes, en entourant ce qui doit être commenté par /* et */

[== Java ==]
/* Ceci est
 * un commentaire
 * sur plusieurs lignes
 */

Alors les javadoc, qu'est-ce que c'est et à quoi ca sert ?

Javadoc sert à créer une documentation au format html sur le code qu'on a écrit, ce qui peut devenir très utile en entreprise lorsque le code doit être confié à d'autres développeurs, afin de pouvoir le comprendre plus rapidement.

Javadoc va regrouper dans une page toutes les déclarations de types, constructeur, méthodes.. trouvées dans la classe, et même mieux, dans le package (si on lui a spécifié plusieurs fichiers au lieu d'un seul). Il va fabriquer les pages en html, ainsi que les styles qui vont avec et les écrire dans un dossier (pour peu qu'on lui ai passer le dossier en paramètre)

Quelques captures afin d'y voir plus clair:

Sous certains environnements graphiques comme Eclipse, le fait d’écrire la javadoc va aussi mettre à jour sa description lorsqu'on passe la souris au dessus du nom d'un champ ou d'une méthode.

Pour rendre ça possible, on va écrire un message, qu'on va entourer par /** et */ juste au dessus d'une déclaration de type, du constructeur ou d'une méthode, voir de la classe même.

[== Java ==]
/** Classe Machin
 *  objectif  : faire des choses a partir des methodes qu'il contient
 */
public class Machin
{
  ...
  /** MonEntier i de type int et de visibilite private */
  private int i;
  ...
  /** Constructeur */
  public Machin(){}
  ...
  /** Methode faitUnTruc() : void
   *  sert a: sort un message aléatoire dans le terminal
   */
  public void faitUnTruc(){
  ...
  }

}

Pour générer une javadoc par ligne de commande, on va utiliser la commande javadoc
Note: il est intéressant de créer un dossier pour mettre les javadoc dedans (pour éviter de foutre un bordel dans le dossier source) et on utilisera alors le paramètre -d pour désigner le dossier

user@hostname:~$ mkdir doc
user@hostname:~$ javadoc -d doc Machin.java

5. Les packages

Les packages en Java sont organisés, hiérarchisés sous forme d'une sorte d'arborescence un peu comme les espaces de noms en dotNet et je pense aussi en C++.

Par défaut, les packages java.util et java.lang sont déjà connues par la machine virtuelle java, c'est une raison pour laquelle on peut écrire String directement au lieu de devoir écrire java.lang.String en entier.

Pour utiliser certaines classes, il faudra cependant soit donner son nom au complet, soit importer le package dans lequel aller le chercher grâce au mot clé import.
Exemple avec la classe File:

[== Java ==]
import java.io.File;

Parfois, on peut être amené à utiliser plusieurs classes dans le même niveau d'arborescence du package, et plutôt que d'importer chacun l'un après l'autre, il sera plus utile d'utiliser le joker *.
Exemple sur javax.swing (pour les interfaces graphiques sous Swing, dont y reviendra plus tard):

[== Java ==]
import javax.swing.*;

Une brève liste de quelques classes avec leur package pouvant être utilisées (la liste complète est disponible depuis les API Java):

 package            classe                Description
----------         --------              --------------
 java.util          *                     Utilités diverses: collections, date/heure, Random, ...
 java.util          ArrayList             Collection d’éléments permettant de gérer des listes
 java.util          Calendar              Calendrier
 java.util          Date                  Date
 java.util          GregorianCalendar     Calendrier; pour récupérer l'heure courant grâce à sa méthode getTime() héritée de Calendar
 java.util          Hashtable             Collection d'elements associatifs en clé -> valeur
 java.util          Random                Générateur de nombres aléatoires
 java.util          Set                   Collection d'elements permettant de gérer des scalaires
 java.lang          *                     Tout ce qui concerne les types: Boolean, Float, Integer, String, ...
 java.lang          Math                  Constantes et fonctions mathématiques
 java.lang          StringBuffer          Manipuler les chaines de caractères, avec une meilleur gestion des Char que String
 java.io            *                     Tout ce qui touche aux entrées/sorties (fichiers) et quelques exceptions courantes...
 java.net           *                     Tout ce qui touche aux réseau
 java.sql           *                     Tout ce qui touche aux bases de données
 java.awt           *                     Tout ce qui touche à l'interface graphique sous AWT
 java.awt.event     *                     Différentes "Listener" pour récupérer des événements comme appui sur un bouton, mouvement de souris, ou état d'un composant graphique qui aurait changé, ...
 javax.swing        *                     Tout ce qui touche à l'interface graphique sous Swing

6. La visibilité des propriétés et méthodes et le champ static

Java est un langage dit Orienté Objet, ca signifie que le programme va être reparti sur différentes classes avec leurs propriétés et méthodes disposant de différentes visibilité pour assurer une certaine sécurité au niveau des accès aux classes, propriétés et méthodes (internes à la classe comme externes), on appele ces visibilité un champ.

Ces différents champs sont les suivants:
* private : les propriétés et méthodes dites privées ne sont accessibles que dans la classe mère, et cette classe uniquement (donc même pas les classes filles).
* protected : les propriétés et méthodes dites protégées sont accessibles entre des classes mères et leurs filles (on abordera les relation mère-fille plus tard lorsqu'on verra l'héritage).
* public : les propriétés et méthodes dites publiques sont accessibles depuis n'importe où. Il convient donc de faire attention de ne pas tout déclarer public pour ne pas compromettre son programme.
* abstract : les propriétés et méthodes dites abstraites sont un peu spéciales, elles peuvent servir à créer des "interface" que l'on abordera plus tard ou des classes mères dont les méthodes et propriétés seront amenées à être partagées avec leurs descendances. Concrètement, ce sont des classes que l'on ne peut pas instancier et qui serviront essentiellement pour des besoins de polymorphisme, qu'on abordera dans un autre chapitre.

Petite remarque: par défaut, si aucun champ n'est spécifié, il sera considérée comme étant public.

A coté de cela, on retrouve aussi deux champs  un peu spécifiques:
* final : sert à définir des constantes.
* static : les champs statiques, on une double fonction:
1) elle servent à l'utilisation de champs qui conservent leur valeur, un peu comme en C ou une variable déclarée static quand elle a été initialisé et qu'elle passée dans une fonction/méthode, elle conserve sa valeur initiale, alors qu'une variable normale serait écrasée et sera réinitialisée à 0.
2) elles sont utilisées globalement dans la classe et n'ont pas besoin d'être instanciées. Ainsi on créera des méthodes et propriétés static si l'objectif est de les appeler directement sans créer l'instance de l'objet en question.
Exemple:

messageChiffre = MaClasseChiffrementPerso.fabriquerHash(mot);

au lieu de devoir écrire:

MaClasseChiffrementPerso chiff = new MaClasseChiffrementPerso();
messageChiffre = chiff.fabriquerHash(mot);

Du coup dans le premier exemple, on gagne une ligne mais surtout on a pas eu besoin d'allouer de l'espace en mémoire pour créer un nouvel objet, ca permet de gagner un peu de ressources.

Remarque concernant l'utilisation de champ static: pour utiliser une propriété static, il faudra utiliser une méthode static. Pour utiliser une méthode getter ou setter static, on utiliser pas le "this", mais le nom de la classe.

Exemple:

[== Java ==]
public class Exemple{

  private int maProprieteNormale = 0;
  private static int maProprieteStatic = 1;

  /** Constructeur */
  public Exemple{
    //TODO : insertion des instruction en dessous
  }

  public int retourneMaProprieteNormale(){
    return this.maProprieteNormale;
  }

  public static int retourneMaProprieteStatic(){
    return Exemple.maProprieteStatic;
  }
}

---

Avant de poser vos questions, jeter un oeil ici
Mon CodeVault et Wiki : ici
Les messages privés envers le staff sont uniquement pour les cas d'urgence ou affaires privées (personnelles). Les demandes se feront exclusivement sur le forum. Merci de respecter cette clause sous peine de sanctions.

WarLocG

#! modo de compet

Re : Les bases du langage Java - partie 1

Petit up pour signaler que j'ai réadapté les colonnes des types primitifs et des packages, ca sera plus facile à lire et à suivre. J'ai aussi remarqué avoir oublié de parler des tableaux/vecteurs/scalaires d'élements du style array[], je verrai pour l'intégrer dans cette partie et éditerai en conséquence.

---

Avant de poser vos questions, jeter un oeil ici
Mon CodeVault et Wiki : ici
Les messages privés envers le staff sont uniquement pour les cas d'urgence ou affaires privées (personnelles). Les demandes se feront exclusivement sur le forum. Merci de respecter cette clause sous peine de sanctions.

WarLocG

#! modo de compet

Re : Les bases du langage Java - partie 1

Complément à cette partie:

Sommaire:
1. Afficher un message dans la console (sortie standard)
2. Récupérer des informations saisis au clavier (entrée standard)
  a. Façon simple via la classe Scanner
  b. Façon 'fabriqué maison' via BufferedReader, InputStreamReader et System.in
3. Les conversions de types
  a. Façon (nouveauType) ancienType
  b. Depuis les méthodes de leur enveloppeur (variante objet du type)
4. La classe String
  a. la méthode valueOf()
  b. concaténation de String
  c. comparaison de String via compareTo() et equals()
  d. quelques méthodes de manipulation de String : substring(), indexOf(), charAt(), toUpperCase(), toLowerCase() et length()
5. Les tableaux
  a. Les tableaux statiques du style array[]
  b. Les tableaux à plusieurs dimensions
  c. Les tableaux sous leur forme objet (afin de comprendre les enveloppeurs)
  d. Les listes via List et sa descendance : ArrayList
  e. Les scalaires via Set et sa descendance
  f. Les tableaux associatifs (tableaux du style clé -> valeur) via Map et sa descendance : Hashtable

1. Afficher un message dans la console (sortie standard)

Le plus simple pour commencer à écrire et tester des programmes est d'envoyer les informations dans la console. La classe System faisant partie de java.lang, déjà accessible par défaut - donc pas d'import nécessaire - , fournit les outils nécessaires pour ce qui est des entrées et sorties standards, ainsi que les erreurs standards. Voir classe System depuis l'API Java pour plus de renseignements.

System comprend out, in et err pour output, input et error, on va surtout utiliser System.out dans la grosse majorité des cas, muni des méthodes print() ou println() selon que l'on veuille que le resultat se fasse sur une même ligne (à la suite) ou sur des lignes séparées.

En consultant l'API Java, on constate aussi qu'une partie des méthodes de la classe System.methode() reviennent à utiliser Runtime.getRuntime().methode() - à partir de exit() on le remarque mieux - mais on ne va pas s'attarder la dessus.

De la manière la plus bête et méchante lorsqu'on apprend à coder en Java on nous apprend à écrire des programmes comme celui-là et on nous dit : "retenez que ca fonctionne comme ça et ne vous en préoccupez pas pour le moment".

Et donc, pour sortir un message sur la console, on passera par System.out.print("message") ou System.out.println("message"). Voici un exemple simple:

[== Java ==]
public class TutoJavaCyberTrack_SimpleHello{

	public static void main(String[] args){
		//Simple demo de sortie sur ecran
		String message = "Hello le monde";
		
		System.out.println(message); //Sort le contenu de message sur la console
	}
}

Et après compilation, on constate que le message est effectivement envoyé sur la console.

[warlocg][linux][~/Desktop/Sources/Java][16:49:07][user mode]
Enter command here -> javac TutoJavaCyberTrack_SimpleHello.java 
[warlocg][linux][~/Desktop/Sources/Java][16:49:20][user mode]
Enter command here -> java TutoJavaCyberTrack_SimpleHello 
Hello le monde

2. Récupérer des informations saisis au clavier (entrée standard)

Comme partiellement abordé plus haut, l'entrée standard sera récupérée depuis System.in, voici quelques façons de l'utiliser:

a. Façon simple via la classe Scanner

[== Java ==]
import java.util.Scanner; // On importe la classe Scanner, normalement comme il est dans
                          // java.util ce n'est pas nécessaire, mais c'est toujours mieux
                          // de le rajouter

public class TutoJavaCyberTrack_EntreeStandardSimple{

	public static void main(String[] args){
		//Simple demo d'entrée standard utilisant la classe Scanner
		System.out.print("Inserez un message: > ");
		Scanner sc = new Scanner(System.in); // on créé une instance de Scanner
		String message = sc.next(); // on récupère le message présent dans le buffer
		sc.close(); // On n'a plus besoin de l'objet Scanner, on le ferme
		
		System.out.println("Le message : > "+message); //Sort le contenu de message sur la console
	}
}

Note: Je n'ai pas encore abordé les "cast" , c'est-à-dire, les conversions de types, mais sachez que Scanner dispose de ses méthodes à lui pour déjà récupérer la saisie standard sous forme d'entier, flottant, etc.. exemple: sc.nextInt() aurait eu pour effet de fournir un entier au lieu d'une String.

Résultat après compilation:

[warlocg][linux][~/Desktop/Sources/Java][17:55:32][user mode]
Enter command here -> javac TutoJavaCyberTrack_EntreeStandardSimple.java 
[warlocg][linux][~/Desktop/Sources/Java][17:55:39][user mode]
Enter command here -> java TutoJavaCyberTrack_EntreeStandardSimple 
Inserez un message: > salut
Le message : > salut

b. Façon 'fabriqué maison' via BufferedReader, InputStreamReader et System.in

Ce code-ci est un peu plus avancé, sachez que si, pour une raison, vous ne voulez pas utiliser la classe Scanner, vous devrez dans ce cas passer par un InputStreamReader (sinon y a encore plus bête et méchant dans le sens ou vous recevez une classe à utiliser et ne vous souciez pas de ce qu'elle contient).

L'objet InputStreamReader est un "lecteur de flux en entrée standard", on lui passera donc soit un InputStream, soit directement System.in (voir classe InputStreamReader sur API Java). On va pas s'embêter, on va lui mettre directement System.in.

Ensuite, pour se faciliter la vie (et parce qu'on nous le recommande), on déposera ce "lecteur de flux" dans un BufferedReader.

public class InputStreamReader
extends Reader

An InputStreamReader is a bridge from byte streams to character streams: It reads bytes and decodes them into characters using a specified charset. The charset that it uses may be specified by name or may be given explicitly, or the platform's default charset may be accepted.

Each invocation of one of an InputStreamReader's read() methods may cause one or more bytes to be read from the underlying byte-input stream. To enable the efficient conversion of bytes to characters, more bytes may be read ahead from the underlying stream than are necessary to satisfy the current read operation.

For top efficiency, consider wrapping an InputStreamReader within a BufferedReader. For example:

BufferedReader in
   = new BufferedReader(new InputStreamReader(System.in));

Since:
    JDK1.1
See Also:
    BufferedReader, InputStream, Charset

Enfin, afin de lire la saisie depuis cet objet, on se servira de ses méthodes read() ou readLine(). Mais attention, ces méthode générant une Exception, il faudra insérer la partie de code entre try et catch.. cette partie sera abordée un peu plus en détail dans la partie 2.

read

    public int read()
             throws IOException

    Reads a single character.

    Overrides:
        read in class Reader
    Returns:
        The character read, as an integer in the range 0 to 65535 (0x00-0xffff), or -1 if the end of the stream has been reached
    Throws:
        IOException - If an I/O error occurs

read

    public int read(char[] cbuf,
           int off,
           int len)
             throws IOException

    Reads characters into a portion of an array.

    This method implements the general contract of the corresponding read method of the Reader class. As an additional convenience, it attempts to read as many characters as possible by repeatedly invoking the read method of the underlying stream. This iterated read continues until one of the following conditions becomes true:
        The specified number of characters have been read,
        The read method of the underlying stream returns -1, indicating end-of-file, or
        The ready method of the underlying stream returns false, indicating that further input requests would block.
    If the first read on the underlying stream returns -1 to indicate end-of-file then this method returns -1. Otherwise this method returns the number of characters actually read.

    Subclasses of this class are encouraged, but not required, to attempt to read as many characters as possible in the same fashion.

    Ordinarily this method takes characters from this stream's character buffer, filling it from the underlying stream as necessary. If, however, the buffer is empty, the mark is not valid, and the requested length is at least as large as the buffer, then this method will read characters directly from the underlying stream into the given array. Thus redundant BufferedReaders will not copy data unnecessarily.

    Specified by:
        read in class Reader
    Parameters:
        cbuf - Destination buffer
        off - Offset at which to start storing characters
        len - Maximum number of characters to read
    Returns:
        The number of characters read, or -1 if the end of the stream has been reached
    Throws:
        IOException - If an I/O error occurs

readLine

    public String readLine()
                    throws IOException

    Reads a line of text. A line is considered to be terminated by any one of a line feed ('\n'), a carriage return ('\r'), or a carriage return followed immediately by a linefeed.

    Returns:
        A String containing the contents of the line, not including any line-termination characters, or null if the end of the stream has been reached
    Throws:
        IOException - If an I/O error occurs
    See Also:
        Files.readAllLines(java.nio.file.Path, java.nio.charset.Charset)

Vous l'aurez compris, il faudra souvent consulter l'API Java en cas de doute avec une classe et ses méthodes, voici celui de la classe BufferedReader. Heureusement, des environnements de programmations tels que Eclipse ou Netbeans nous aide beaucoup grace à leur auto-completion.

Voici un bout de code afin de tester

[== Java ==]
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class TutoJavaCyberTrack_EntreeStandardAvancee{

	public static void main(String[] args){
		//Demo d'entrée standard un peu plus avancé
		System.out.print("Inserez un message: > ");

		// BufferedReader a besoin d'un Reader tel que InputStreamReader en paramètre
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		// Comme la méthode readLine génère une IOException, on encapsule dans un try..catch
		// Ne vous ennuyez pas avec ca pour le moment, on verra ca plus tard.	
		try{
			String message = br.readLine(); // on récupère le message présent dans le buffer
			System.out.println("Le message : > "+message); //Sort le contenu de message sur la console
			br.close(); // On libère br
		} catch (IOException e){
			e.getMessage(); // génère un message d'erreur si une IOException est détectée
		}			
	}
}

3. Les convertions de types

a. Façon (nouveauType) ancienType

Une première façon de convertir un type en un autre est via un 'cast' se faisant de la manière (type) variable.
Exemple:

int i = 10;
float f = 0.5f, somme;
somme = f + (float) i; // convertion de i de type int en float

b. Depuis les méthodes de leur enveloppeur (variante objet du type)

(voir les enveloppeurs dans la partie "types primitifs" de la première partie de ce poste)

Exemple:

String chiffre="10";
int i = Interger.parseInt("chiffre"); // convertion de chiffre de type String en int

4. La classe String

Pour les informations détaillées sur cette classe, voir API Java de la classe java.lang.String, je vais surtout me concentrer sur quelques méthodes utiles, vous pourrez toujours paufiner votre code avec d'autres méthodes de cette classe si besoin.

a. la méthode valueOf()

La méthode valueOf() permettra de convertir un type primitif (int, float, double, ...) en String. Ca sera utile pour l'affichage de message contenant des nombres entiers, décimaux, enfin des nombres en général.

Exemple avec un générateur de nombres aléatoire et affichage dans le terminal:

[== Java ==]
import java.util.Random; /* on importe la classe Random */

class TutoJavaCyberTrack_StringValueOf{

  public static void main(String[] args){
    /* Demo sur String.valueOf avec des nombres aléatoires */
    Random rnd = new Random(); /* générateur de nombre aléatoire */
    int nombre = rnd.nextInt(1001); /* un nombre entre 0 et 1000 */
    
    /* on utilise String.valueOf() afin de convertir nombre de type int en String */
    System.out.println("Le nombre sortant est "+String.valueOf(nombre));
  }
}

Résultat après compilation:

[warlocg][linux][~/Desktop/Sources/Java][16:23:36][user mode]
Enter command here -> javac TutoJavaCyberTrack_StringValueOf.java 
[warlocg][linux][~/Desktop/Sources/Java][16:23:43][user mode]
Enter command here -> java TutoJavaCyberTrack_StringValueOf 
Le nombre sortant est 881
[warlocg][linux][~/Desktop/Sources/Java][16:23:51][user mode]
Enter command here -> java TutoJavaCyberTrack_StringValueOf 
Le nombre sortant est 896
[warlocg][linux][~/Desktop/Sources/Java][16:24:01][user mode]
Enter command here -> java TutoJavaCyberTrack_StringValueOf 
Le nombre sortant est 663

b. La concaténation de String

Pour concaténer des chaines de caractères, 2 solutions s'offrernt à vous:
* soit vous concaténez chaine1 + chaine2 pour obtenir chaine3
* soit vous utilisez la méthode concat sur chaine1 en prenant chaine2 en paramètre, de cette facon chaine1.concat(chaine2)

Voici un exemple:

[== Java==]
class TutoJavaCyberTrack_StringConcat{

  public static void main(String[] args){
    /* Demo sur concaténation de String */
    String mot1 = "Hello ";
    String mot2 = "le monde"; 
    
    /* concaténation avec le + */
    System.out.println("Concatenation avec + -> "+mot1+mot2);
    
    /* concaténation avec la méthode concat() */
    System.out.println("Concatenation avec la méthode concat() -> "+mot1.concat(mot2));
  }
}

Résultat après compilation:

[warlocg][linux][~/Desktop/Sources/Java][16:44:22][user mode]
Enter command here -> javac TutoJavaCyberTrack_StringConcat.java 
[warlocg][linux][~/Desktop/Sources/Java][16:44:31][user mode]
Enter command here -> java TutoJavaCyberTrack_StringConcat 
Concatenation avec + -> Hello le monde
Concatenation avec la méthode concat() -> Hello le monde

c. comparaison de String via compareTo() et equals()

Il existe deux manières de comparer des String entre elle:

* la méthode equals() va tester si une String est en tout point pareil à une autre.

String leBonMot = "victoire";
...
if ( mot.equals(leBonMot)){ System.out.println("bravo, vous avez trouvé le bon mot"); }
else { System.out.println("désolé, ce n'est pas le bon mot"); }

* la méthode compareTo() va comparer caractère par caractère une String par rapport à une autre et renverra un entier positif, un entier négatif ou 0 si la String est identique. Cette méthode permet de déterminer l'égalité mais également la place qu'occupe alphabétiquement une String par rapport à une autre. La valeur de l'entier correspond au décalage entre les code ASCII des caractères au même index et s'arrêtera dès qu'il trouvera une différence.
Exemple:
tata et tao
't' = 't'
'a' = 'a'
't' > 'o'  => 't' = 0x74 et 'o' = 0x6f; écart de 5; renverra 5 ou -5 selon qu'on ait comparé tata à tao ou inversément.

d. Quelques méthodes de manipulation de String : substring(), indexOf(), charAt(), toUpperCase(), toLowerCase() et length()

* substring() : permet de récupérer une partie d'une chaine, exemple "Hello le monde".substring(6,8) renvoit "le "
* indexOf() : renvoit la position du premier caractère donné en paramètre, ou du premier caractère d'une chaine donnée en paramètre, exemple "Hello le monde".indexOf("le") renvoit 6 (en démarrant de 0, le 7e caractère étant le 'l' de "le")
* charAt() : renvoit le caractere à la position donnée en paramètre d'une chaine, exemple "Hello le monde".charAt(4) renvoit 'o' (le 'o' de "Hello")
* toUpperCase() : met en majuscule, exemple "Hello le monde".toUpperCase() renvoit "HELLO LE MONDE"
* toLowerCase() : met en minuscule, exemple "Hello le monde".toLowerCase() renvoit "hello le monde"
* length() : renvoit la taille de la chaine, exemple "Hello le monde".length() renvoit 14

On pourra bien entendu les combiner comme dans l'exmple de code donné

[== Java ==]
class TutoJavaCyberTrack_MethodesString{

 public static void main(String[] args){
   /* Demo sur java.lang.String et quelques unes de ces méthodes */
   String message = "Hello le monde";
   
   /* substring */
   System.out.println(message.substring(6,8)); /* renvoit "le " */
   
   /* indexOf */
   System.out.println(message.indexOf("le")); /* renvoit 6 */
   
   /* charAt */
   System.out.println(message.charAt(4)); /* renvoit 'o' */
   
   /* toUpperCase */
   System.out.println(message.toUpperCase()); /* renvoit "HELLO LE MONDE" */
   
   /* toLowerCase */
   System.out.println(message.toLowerCase()); /* renvoit "hello le monde" */
   
   /* length */
   System.out.println(message.length()); /* renvoit 14 */
   
   /* Combinaison de substring, indexOf et length */
   System.out.println(message.substring(message.indexOf("monde"),message.length())); /* renvoit "monde" */
 }
}

Résultat après compilation

[warlocg][linux][~/Desktop/Sources/Java][14:13:49][user mode]
Enter command here -> javac TutoJavaCyberTrack_MethodesString.java 
[warlocg][linux][~/Desktop/Sources/Java][14:14:01][user mode]
Enter command here -> java TutoJavaCyberTrack_MethodesString 
le
6
o
HELLO LE MONDE
hello le monde
14
monde

Il y a encore plein d'autres méthodes qui ont leur utilité comme trim(), split(), replace(), ... je vais pas toutes les écrire, vous les trouverez dans la page de l'API Java.

5. Les tableaux

a. Les tableaux statiques du style array[]

Une première manière de construire des tableaux d'éléments est sous la forme

Type tableau[] = new Type[nombreElements];

Exemple:

int vecteur[] = new int[10]; // tableau de 10 entiers

Attention: si le nombre d'éléments est dépassé ou non initialié, on se retrouvera avec une IndexOutOfBoundsException(). Il arrive souvent que des développeurs débutants oublient de "fabriquer" le tableau d'élements. Exemple:

private int a, i, monTableau[];
...
a = monTableau[i]; // génère une IndexOutOfBoundsException car monTableau ne contient aucun élément car non initialisé
...

b. Les tableaux à plusieurs dimensions

On peut créer des tableaux multidimensionnels de la même manière en cumulant les [] à la suite de la propriété.
Exemple:

private final int LONGUEUR = 5; // final définit une constante
private final int LARGEUR = 3;
private int matrice[][] = new int[this.LONGUEUR][this.LARGEUR];
...
public int getElement(int i,j){ if (i >= 0 and i < this.LONGUEUR and j >=0 and j < this.LARGEUR) return this.matrice[i][j]; else return -1; }

(en chantier...)

---

Avant de poser vos questions, jeter un oeil ici
Mon CodeVault et Wiki : ici
Les messages privés envers le staff sont uniquement pour les cas d'urgence ou affaires privées (personnelles). Les demandes se feront exclusivement sur le forum. Merci de respecter cette clause sous peine de sanctions.

IceF0x

#! Gourou Linux

Re : Les bases du langage Java - partie 1

Joli avec la coloration syntaxique et tout

---

Utiliser des logiciels propriétaires, c'est comme les plats préparés, on est incapable de dire les conservateurs qu'ils contiennent, on dira toujours que c'est bon, mais ça ne remplacera jamais le repas fait maison par sa maman.
]:D #! Crunchbang & Archlinux GNU/Linux User ]:D

WarLocG

#! modo de compet

Re : Les bases du langage Java - partie 1

Et bien, j'espère en tout cas que c'est clair car si il y a des zones d'ombres il ne faut pas hésiter à le signaler, mais c'est du très gros tuto donc ca prendra le temps qu'il faudra pour le faire (je dois surtout veiller à la relecture afin de m'assurer de ne pas écrire des bétises)

Joli avec la coloration syntaxique et tout

La coloration n'est visible que lorsqu'on s'est authentifié Les personnes extérieures ne la voient pas

---

Avant de poser vos questions, jeter un oeil ici
Mon CodeVault et Wiki : ici
Les messages privés envers le staff sont uniquement pour les cas d'urgence ou affaires privées (personnelles). Les demandes se feront exclusivement sur le forum. Merci de respecter cette clause sous peine de sanctions.