Introduction

Dans ce dossier, vous trouverez les bases nécessaires pour bien débuter en Java. C'est-à-dire non seulement les bases syntaxiques mais aussi la philosophie du langage.

Dossier écrit par Quintoff.



Java

Le java est un langage de programmation portable créé par Sun. Quand vous compilez vos sources, celles-ci sont « traduites » en bytecode. Pour exécuter un programme java, il est nécessaire d’avoir une machine virtuelle java (JVM) qui permet de convertir le bytecode en instructions que votre ordinateur comprend. Cette méthode permet de rendre les programmes java portables, c’est-à-dire s’exécutant sur toutes les systèmes d’exploitations disposant d’une JVM. D’où la phrase célèbre : « Write once, run anywhere ».



Pré-requis

Pour pouvoir compiler et exécuter vos programmes java, vous avez besoin du JDK ou SDK qui contient la JVM et le nécessaire pour compiler vos sources. Même si le JDK ou SDK suffit pour développer en théorie, il est cependant bien plus convivial d’opter pour un IDE, c’est-à-dire une interface qui est plus simple d’utilisation et qui, la plupart du temps, vous permet de créer des espaces de travails et des projets. Parmi les plus connues on retrouve Eclipse, JBuilder, JCreator,… Pour plus d'information vous pouvez consulter ce tutorial.




I - Hello World !

Comme dans tout langage de programmation, il est coutume de commencer par un simple programme qui écrit "Hello, World !" à l’écran. Pour cela, créez un nouveau fichier dans votre IDE du nom de "helloworld.java". Ce nom est important car en Java quand on déclare une classe publique, le fichier doit porter le même nom que la classe. Dans ce fichier, vous allez écrire :

Code :

public class helloworld 
{
    public static void main(String args[]) 
    {
        System.out.println("Hello, World!"); // Affiche Hello, World! à l'écran
    }
}

Analysons la structure de notre premier programme java :
- public class helloworld définit une classe publique, tous les programmes java doivent au moins contenir une classe. Elle est définie du premier { au dernier }. Nous reviendrons sur la notion de classe plus loin.
- public static void main(String args[]) définit la méthode main, cette méthode est celle qui permet à la JVM de lancer le programme, elle est indispensable. Elle est définie du premier { après la définition de la méthode au } suivant.
- String args[] sert à récupérer des arguments qui auraient éventuellement été fournis au programme à son lancement.
- System.out.println("Hello, World!"); fait appel à la méthode println de l’api java. L’api java est une librairie donnant des outils aux programmeurs. Celle-ci est structurée de façon à ce que l’on appelle les méthodes via leur arborescence. La méthode println, qui affiche un texte à l’écran, se trouve dans la package System.out. La fin de l’appel à la méthode se termine par un ; car toutes les instructions en Java doivent se terminer par un ;.
- // annonce le début d’un commentaire en fin de ligne. Tout ce qui suit sur cette ligne est un commentaire. Les commentaires sont ignorés par le compilateur. Ils peuvent se situer entre /* et */ qui permet de commenter sur plusieurs lignes ou de terminer le commentaire avant la fin de la ligne.




II - Les variables

Les variable permettent au programmeur de jongler avec les valeurs, elles peuvent stocker des données, être lues et modifiées. Voici un exemple de programme utilisant des variables :

Code :

public class variables 
{
    public static void main(String args[]) 
    {
        int a = 5;
        double b;
        char c = 'J';
        char d = 'a';

        a=6; // modifie la valeur de 'a'

        System.out.println("La variable 'a' vaut : " + a);

        b=5.3; // donne un valeur à 'b'

        System.out.println("La variable 'b' vaut : " + b);
        System.out.println("Vous manipulez des variables en " + c + d + 'v' + d + '!');
    }
}

Remarquez que toutes les variables sont déclarées avant d’être utilisée.

- int a déclare une variable contenant un nombre entier (int -> integer).

- double b déclare une variable contenant un nombre décimal (idem que float avec cependant une différence de précision).

- char c et char d déclarent des variables contenant chacune un caractère.


Quand une valeur est attribué à la variable en même temps que sa déclaration, on dit qu’elle est initialisée. La valeur des variables peut être modifiée sauf quand il s’agit d’une constante : final int VAR = 32;, une valeur lui est attribuée lors de son initialisation et ne peut être modifiée.


Il existe aussi des variables qui peuvent prendre comme valeur false (faux) ou true (vrai). Ces variables sont principalement utilisées dans les conditions, nous y reviendrons plus tard. En attendant voici comment les déclarés : boolean var;


Toutes les variables que nous venons de voir ci-dessus sont des types dis primitifs. Ce sont les seules variables qui ne sont pas des objets en java, les objets sont des instances de classe, nous y reviendrons plus tard.


On peut effectuer des opérations mathématiques entre des types entiers sans problème de précisions. On peux également effectuer des opérations mathématiques entre des types décimaux.


Le type String

Quand on crée un chaîne de caractère (string), on crée un objet, une instance de la classe String. Voici un exemple de programme utilisant également l’opérateur ‘+’
qui permet de concaténer des chaînes :

Code :

public class Chaine 
{
    public static void main(String args[]) 
    {
        String prenom = "Jean"; // les valeurs attribuées au chaînes doivent être
        String nom = "Dujardin"; // placées en des "

        System.out.println(prenom + " " + nom);
    }
}

III - Java et la POO

Le java est un langage de programmation orienté objet. Ce qui signifie que quand vous déterminez un programme, vous devez avant tout penser à séparer les données du reste du programme. C’est ce qu’on appelle l’abstraction des données. La programmation orientée objet est encore plus précise que cela, car elle nécessite la privatisation des champs de données qui composent les classes, elles même étant à l’origine des objets.


Un objet est un type qui n’est pas primitif mais qui est définis pas l’utilisateur. Les objets sont des instances de classes. Voici un exemple de création d’objet :

Code :

public class Voiture 
{
    private String couleur;
    private String marque;
    private String modele;
    private int prix;

    public Voiture(String coul, String mar, String mod, int p) 
    {
        this.couleur = coul;
        this.marque = mar;
        this.modele = mod;
        this.prix = p;
    }

    public String Affiche() 
    {
        String aff="Cette "+marque+" "+modele+" "+couleur+" coute "+prix+" euros";
        return aff;
    }

    public static void main(String args[]) 
    {
        Voiture ma_voiture = new Voiture("noire", "Volvo", "S80", 35000);
        Voiture votre_voiture = new Voiture("bleu ciel", "Peugeot", "607", 35000);

        System.out.println(ma_voiture.Affiche());
        System.out.println(votre_voiture.Affiche());
    }
}

Dans ce programme, la classe Voiture permet de créer des objets, les caractéristiques de ceux-ci sont définis par les champs qui sont les variables couleurs, marque, modèle et prix. Pour initialiser un objet, il faut faire appel à son constructeur. Ici, public Voiture(String coul, String mar, String mod, int p). Les constructeurs sont déclarés comme un fonction classique sauf que l’on ne précise pas leur type (void signifie que la méthode ne retourne rien), elle doit toujours être publique et doit porter le même nom que la classe. On appelle un constructeur avec le mot clé new.

Ce chapitre a introduit brièvement la notion d’objets et de classes en Java, un dossier spécifique sera bientôt disponible pour vous éclairer d’avantage sur le sujet.




IV - Les conditions

Dans vos programmes Java, il vous sera souvent nécessaire de tester des valeurs. Pour cela, nous utiliserons les boucles if ou switch. Cependant avant de pouvoir utiliser les boucles, il est nécessaire de prendre connaissance des opérateurs :



a == b teste si deux variables sont égales, revoit true si elles sont égales sinon false

a > b teste si la variable a est strictement plus grande que b, revoit true si oui sinon false

a >= b teste si la variable a est plus grande ou égale que b, revoit true si oui sinon false

a < b teste si la variable a est strictement plus petite que b, revoit true si oui sinon false

a <= b teste si la variable a est plus petite ou égale que b, revoit true si oui sinon false


Vous pouvez désormais comprendre les conditions présentes dans les boucles if et switch.

Example de boucle if :

Code :

public class cond_if 
{
    public static void main(String args[]) 
    {
        boolean test = 5 > 7;

        if(test) // si test vaut true on exécute le bloc qui suit
        { 
            System.out.println("5 est plus grand que 7");
        } 
        else // si la condition de if est fausse on exécute ce qui suit
        { 
            System.out.println("5 n'est pas plus grand que 7");
        }
    }
}

Un autre exemple avec plusieurs conditions :

Code :

public class cond_elseif 
{
    public static void main(String args[]) 
    {
        int a = -5;

        if(a > 0) // faux, on va voir au « else » suivant
        { 
            System.out.println(a+" est positif");
        } 
        else if(a < 0) // vrai, on exécute le bloc suivant
        { 
            System.out.println(a+" est negatif");
        } 
        else 
        {
            System.out.println(a+" est nul");
        }
    }
}

Exemple de boucle switch :

Code :

public class cond_switch 
{
    public static void main(String args[]) 
    {
        char a = 'c';

        switch(a) 
        {
            case 'a' : System.out.println("Ce texte ne sera pas affiche.");
            case 'b' : System.out.println("Ce texte ne sera pas affiche.");
            case 'c' : System.out.println("Ce texte sera affiche.");
            case 'd' : System.out.println("Ce texte sera affiche.");
            case 'e' : System.out.println("Ce texte sera affiche.");
        }
    }
}

Avec une boucle switch, on teste la valeur d’une variable à l’aide d’une série de constantes (ici ‘a’, ‘b’, ‘c’, ‘d’ et ‘e’). Dès que la variable testée est également à la constante, on exécute toutes les instructions qui suivent même celles des cases suivantes. Si on veux juste exécuter les instructions du case correspondant, il suffit de placer le mot-clé break qui permet de sortir de n’importe quelle boucle à n’importe quel moment :

Code :

public class cond_switch_break 
{
    public static void main(String args[]) 
    {
        char a = 'c';

        switch(a) 
        {
            case 'a' : System.out.println("Ce texte ne sera pas affiche.");
            break;

            case 'b' : System.out.println("Ce texte ne sera pas affiche.");
            break;

            case 'c' : System.out.println("Ce texte sera affiche.");
            break; // comme a vaut ‘c’, on sort de switch ici.

            case 'd' : System.out.println("Ce texte ne sera pas affiche.");
            break;

            case 'e' : System.out.println("Ce texte ne sera pas affiche.");
        }
    }
}

Les conditions sont indispensables dans tous les langages de programmation, elles sont notamment utilisées pour vérifier des données entrées par l’utilisateur.




V - Les boucles for, while et do while

Les boucles for, while et do while permettent d’exécuter plusieurs fois la même série d’instructions tant qu’une condition est vraie.


Les boucles while sont les plus simples, elles exécutent leur bloc d’instructions tant que leur condition revoit true :

Code :

public class boucle_while 
{
    public static void main(String args[]) 
    {
        int a = 30;

        while(a>0) // boucle tant que a > 0
        {
            System.out.println(--a); // -- est un opérateur qui décrémente d'un.
        }
    }
}

Les boucles do while sont équivalents aux boucles while sauf que leur condition est vérifiée après le bloc d’instructions :

Code :

public class boucle_dowhile 
{
    public static void main(String args[]) 
    {
        int a = 30;

        do 
        {
            System.out.println(--a);
        } 
        while(a>0); // recommence la boucle si a > 0
    }
}

Les boucles for permettent d’exécuter un certain nombre de fois les même instructions :

Code :

public class boucle_for 
{
    public static void main(String args[]) 
    {
        for(int i = 1; i<=30; ++i) // ++ incrément i de un.
        { 
            System.out.println(i);
        }
    }
}

- int i = 1 signifie qu’on initialise i avec la valeur 1 au premier passage dans la boucle.

- i<=30 on teste cette condition avant chaque exécution du bloc d’instructions.

- ++i permet d’incrémenter i de un à chaque passage dans la boucle.




VI - Les tableaux

Il est possible de rassembler plusieurs valeurs en un tableau. On y accède ensuite par un index qui est propre à chaque valeur et qui commence à 0 et qui va jusqu’au nombre de valeurs total moins un. Donc si, par exemple, on veut sélectionner le cinquième élément, on utilise l’index 4.

Exemple de programme utilisant un tableau :

Code :

public class alphabet 
{
    public static void main(String args[]) 
    {
        //on déclare le tableau et on l'initialise.
        char t[] = {'a', 'b', 'c', 'd', 'e', 'f',
                         'g', 'h', 'i', 'j', 'k', 'l', 'm', 
                         'n', 'o', 'p', 'q', 'r', 's', 't', 
                         'u', 'v', 'w', 'x', 'y', 'z'};

        /* On va parcourir le tableau grâce à une boucle for qui incrémente une
        variable i qui représente l'index */
        for(int i=0; i<26; i++) 
        {
            System.out.println(t[i]);
        }
    }
}

Un tableau ne peut être remplit à l’aide de {…} que lors de son initialisation.

Voici un autre exemple :

Code :

public class carre 
{
    public static void main(String args[]) 
    {
        int t[] = new int⎖] //on déclare un tableau de 10 entiers.

        for(int i=0; i<10; i++) 
        {
            t[i] = (i+1)*(i+1); // on élève au carré l'index augmenté d'un.
        } // on remplit le tableau

        for(int i=0; i<10; i++) 
        {
            System.out.println((i+1)+" au carre vaut "+t[i]);
        } // on affiche le tableau
    }
}

y z = new y[x] signifie que l’on crée x éléments de type y dans le tableau z.

Ecrit par Quintoff