Introduction à Java

Dans cette formation, on va aborder Java, dans les très grosses lignes, on fera des suites de cours pour apprendre petit à petit le langage et son fonctionnement. 

Dans ce cours, on parlera : 

          -              Comment installer un IDE dédié à Java

          -              Les opérateurs de comparaison et d’affectations/assignations

          -              Les variables et constantes

          -              Les conditions

          -              Les boucles

          -              Les classes et son constructeur

1# Comment installer un IDE dédié à Java 

Il existe énormément d’éditeur de texte pour développer et également divers IDE pour chaque langage. Pour java, nous pourrions passer par Visual Studio Code, mais nous allons passer IntelliJ (https://www.jetbrains.com/fr-fr/idea/download/download-thanks.html?platform=windows&code=IIC).

C’est un éditeur créé par Jetbrains et dédié au langage Java, Kotlin ou Flutter (qui sont très similaire).

Installer l’IDE et ouvrez-le. Créer un nouveau projet et si vous n’avez pas de JDK (Java Developpement Kit), vous pourrez en installer un directement à la création de votre nouveau projet :

Pour en apprendre plus sur le JDK, je vous invite à lire l’article suivant : https://fr.wikipedia.org/wiki/Java_Development_Kit

2# Les opérateurs de comparaison et d’affectations

Maintenant, que notre projet est créé, on peut constater qu’on a déjà une classe de créée (Main) :

Décortiquons ceci, car il est très important de comprendre la structure d’initialisation d’un projet Java.

public class Main {
    public static void main(String[] args) {
        System.out.println("Bonjour à tous");
    }
}

public class Main {} Correspond à notre objet, instance, c’est lui qui initie la création de notre classe. Le nom sera toujours celui de notre fichier (pour avoir un meilleur visuel sur l’ensemble des fichiers du projet).

public static void main(String[] args) {} Correspond à notre point d’entrée du projet, c’est ici ou tout sera « compilé » et lu. Retenez bien cette mise en forme pour l’initialisation du projet via la classe Main. Sans ses arguments, Java retournera une erreur lors de l’exécution du code.

 System.out.println("Bonjour à tous"); Correspond à un affichage console comme la console.log en JavaScript.

Nous voilà donc prêt à voir les opérateurs de comparaison et d’affectation. Si vous faites déjà du code, cette partie ne sera qu’un rappel, dans le cas contraire, il est nécessaire d’apprendre l’utilisation de celle-ci.

Commençons par les opérateurs d’affectation/assignation : 

Le plus connu et le plus utilisé reste le « = » qui permet de définir une valeur, qu’elle soit numérique ou textuelle :

Int numero = 12    // Ici, la variable numero prend la valeur 12.

String prenom = "Eugène"   // La variable prenom prend la valeur textuelle Eugène.

Comme vous pouvez vous en douter, on peut affecter presque n’importe quoi grâce à l’opérateur d’affectation « = ».

Il existe une multitude d’opérateurs qui assigne une valeur selon des règles bien définie : 
 

public class Main {
    public static void main(String[] args) {
        String prenom = "Eugène";
        System.out.println(prenom);
    }
}

Pour exécuter le code, il faut cliquer sur la flèche à côté de la classe Main, ou en faisant « Maj+CTRL+F10 ».

Passons maintenant aux opérateurs de comparaison. Ils jouent également un rôle très important dans le développement en général. Les connaître permet de mieux appréhender ce que vous avez besoin pour votre projet.

Regardons ça de plus près. 

Si nous venions à faire une comparaison de prénom avec notre variable créée plus haut pour voir si Eugène est bien Eugène et pas Tristant, nous utiliserons l’opérateur « == » pour vérifier qu’Eugène est bien dans notre variable :

— 

String prenom = “Eugène”

Si prenom == “Eugène” alors tout est bon, sinon on retournera une erreur.

— 

Dans l’exemple ci-dessus, la variable prenom prend bien Eugène en valeur alors notre condition sera remplie. Dans le cas où nous aurions mis Tristant à la place, notre condition ne serait pas remplie et on passera à autre chose.

Regardons avec un autre exemple :

— 

Int nombre = 14 

Si nombre <= 10 alors on affichera que notre nombre est trop grand, sinon, tout est bon.

— 

3# Les variables et constantes

                3.1# Les variables

Depuis le début de cette formation, vous avez utilisé des variables telles que : 

String prenom ou Int nombre.

Il existe une multitude de type de variable et Java demande à ce qu’on spécifie la nature de notre variable à chaque fois. Il faut donc spécifier son type puis déclarer le nom de notre variable.

Voici les différents type : 

Donc si vous voulions créer une variable de type Booléen, il faut procéder comme suit : 

Boolean isReal = true / false ;  // le « / » veut dire OU, donc soit vous mettez true ou false.

Pour spécifier que notre variable sera un tableau, il faut spécifier le type suivit de [] :

String[] prenom = {"Eugène","Tristant", "Chloé"};

Pour afficher un tableau avec la console Java, il faut rendre le tout textuel avec un Arrays.toString() : 

System.out.println(Arrays.toString(prenom));

                3.2# Les constantes

Les constantes sont similaires aux variables, mais comparées à elles, les constantes ne peuvent pas se voir réaffecter de nouvelles valeurs quand elles en ont une de définie. Pour déclarer une constante en Java, il faut précéder le tout du mot « final » :

final String PRENOM = “Eugène” ;

Il faut comprendre que quand votre constante a une valeur, celle-ci ne pourra plus jamais changer. 

Pour les constantes, il y a une convention de nommage. Il faut mettre le nom de la constante en MAJUSCULE. Respectez ça. Parce que si un jour, vous veniez à partager votre code, au simple coup d’œil, on sait qu’il s’agit d’une constante.

4# Les conditions

Les conditions sont le pilier de tout langage de programmation, sans elles, nous ne pouvons pas mettre de restriction sur un état ou élément, ou même de modifier un celui-ci.

                4.1# La condition if (si) : 

Le if (si), permet de mettre la condition sur du vrai ou faux. Par exemple, on veut vérifier qu’Eugène est bien dans notre variable prenom :

String prenom = "Eugène";

if(prenom == "Eugène") {
    System.out.println("Le prénom est bien Eugène");
}
else {
    System.out.println("Mauvais prénom");
}

Comme on peut le voir dans notre condition, il y a un « sinon » (else). Le « esle » permet de retourner autre chose si la condition n’est pas remplie. Dans notre cas, si on change Eugène par Tristant, on rentrera dans le « else » et nous aurons Mauvais prénom en retour.

Il existe également un sinon si (else if), qui permet de donner une autre condition avant d’entrer dans le « else » :

String prenom = "Eugène";
if(prenom == "Eugène") {
    System.out.println("Le prénom est bien Eugène");
} else if (prenom == "Tristant") {
    System.out.println("Le prénom est bien Tristant");
} else {
    System.out.println("Mauvais prénom");
}

Il n’y a pas de nombre limité d’else if, mais il est fortement conseillé de n’en mettre que 3-4 au maximum ! 

Pour un cas où nous avons plusieurs états ou prénom dans notre cas, on pourrait passer à une autre condition : Le switch.

                            4.2 Le switch

Le switch est là pour facilité le code et éviter de mettre 100 else if dans votre code. 

La structure du switch est comme-ci : 

String prenom = "Eugène";

switch (prenom) {
    case "Eugène":
        System.out.println("Eugène");
        break;
    case "Tristant":
        System.out.println("Tristant");
        break;
    case "Chloé":
        System.out.println("Chloé");
        break;
    default:
        System.out.println("Aucun des prénoms n'est répertorié");
}

Dans les parenthèses on lui défini ce qui doit être vérifié. Puis dans chaque cas défini par « case … : », on lui passe les options possibles. On affiche le tout avec le System.out.println("Eugène"); et on stop le tout avec un break si notre switch rentre dans un des cas donnée, sinon le default sera le résultat fournit si aucun cas n’est valide.

5# Les boucles

Les boucles sont une chose aussi importante que les conditions. Il faut savoir maîtriser les boucles pour développer un bon programme, site, etc... 

Dans Java, les boucles sont faciles à exécuter et similaire. Car en effet, il existe deux (2) types de boucle 

                5.1# La boucle for

La boucle for est a utilisé quand on sait combien de fois, on va devoir utiliser une boucle par exemple pour parcourir un tableau ou si on doit faire une boucle X fois.

for(int i = 0; i < 10; i++){ }

Regardons ce code : 

On déclare le for suivi de parenthèse, on déclare une nouvelle variable int (entier) qui sera égale à 0. On vérifie que notre « i », qui est égale à 0 soit inférieur à 10 si c’est le cas, on ajoute + 1 à notre « i » grâce au i++.

Parlons rapidement des incrémentations et décrémentations. Quand on peut ajouter + 1 à une valeur entière (int), on peut procéder de deux (2) manières :

• Prendre notre variable et lui assigner lui-même + 1 (a = a + 1)
•  
• Prendre la variable et lui mettre ++ ou -- (a++ ou a--)
•  

L’utilisation de ces méthodes est très répandue, car plus simple à comprendre et plus facile à lire.

Il existe deux (2) façon d’écrire l’incrémentation ou la décrémentation qui ont un effet égal, mais un résultat différent lors de l’utilisation.

--a   // Dans ce cas précis, on enlève 1 et on l’insère dans notre code.

a--   // Dans ce cas, on exécute le code, puis on retire 1

++a  // Dans ce cas, on ajoute 1 et on l’insère dans notre code

a++ // Dans ce cas, on exécute le code, puis on ajoute 1

int i = 1;
int b = i--;
System.out.println(i);
System.out.println(b);

int i = 1;
int b = --i;
System.out.println(i);
System.out.println(b);

Revenons sur notre boucles for : 

for(int i = 0; i < 10; i++){
    System.out.print(i);
}

On peut voir que notre « i » ajoute + 1 à chaque tour de boucle, et exécute la boucle 10x, car il doit être inférieur à 10 et que l’on commence à 0. Si nous avions mis 1, on n’aurait eu que 9 tours de boucle.

                5.2# La boucle foreach

Comme la boucle for, la boucle foreach est là pour boucler autant de fois qu’il y a de données. Cette fois-ci, on ne définit pas de maximum avec une variable int. Ici, la boucle foreach va prendre toutes les itérations possibles et boucler dessus.

String[] prenom = {"Eugène","Tristant", "Chloé", "Lucie"};

for(String name:prenom){
    System.out.println(name);
}

Java demande toujours le typage des variables, ici dans notre for, nous avons une nouvelle variable (name) qui est un String et qui prend la valeur de chaque itération de notre tableau. Donc, ici, ce seront les prénoms.

Il faut bien faire le distinguo entre le for classique et le foreach. L’écriture est presque pareille (on utilise for, pas comme PHP qui prend for() et foreach()).

6# Les classes et son constructeur

Java est un langage exclusivement objet. C’est-à-dire qu’il ne fonctionne que via des classes qui peuvent prendre divers statuts. Une classe peut être une personne, un objet, un état etc…

Quand vous avez créé le projet Java pour la première fois, on a vu qu’il nous a créé la classe Main :

public class Main {}

À partir de là, on a notre objet de créé. Mais nous pourrions le faire autrement. Essayons avec une autre classe, pour ça, créons un nouveau fichier classe en faisant « clique droit » sur le dossier « SRC » puis new et Java class : 

Nommez le « Car ». IntelliJ crée la classe, mais sur d’autres IDE, il faudra le créer soit même.

public class Car {}

Public permet de rendre la classe accessible partout. Il est possible de la rendre privée en remplacent public par private. Mais en général, une classe comme la nôtre, doit être accessible depuis notre Main.

NB : Mettez toujours une majuscule au début de votre mot qui définit votre classe.

Créons son constructeur, Java est un peu différent des autres langages, en effet, si on prend JavaScript ou PHP, pour déclarer un constructeur on les définies avec :

Public function __construct{}

Alors qu’en Java seulement la déclaration de la classe suffit : 

public Car(){}

Il y a la possibilité de mettre des paramètres à notre constructeur, celles-ci seront obligatoires quand on créera notre nouvelle classe dans notre Main :

public Car(String marque, int kilometre){
    System.out.println("la voiture est de la marque : "+marque+" et a "+kilometre+"km au compteur");
}

Puis dans notre Main, on appelle Car : 

public class Main {
    public static void main(String[] args) {
        Car voiture = new Car("Ford", 10_000);
    }
}

NB : Java est très fort pour la gestion des nombres, on peut séparer les nombres longs par des underscore « _ » pour séparer visuellement le nombre. Mais cette séparation n’impacte en rien la valeur, c’est purement esthétique !

Il est également possible comme les autres langages, de définir les valeurs via des setters et des getters : 

public class Car {
    private String marque;
    private int kilometre;

    public Car(){ }

    public void setMarque(String marque){
        this.marque = marque;
    }
    public String getMarque(){
        return this.marque;
    }

    public void setkilometre(int kilometre){
        this.kilometre = kilometre;
    }
    public int getKilometre(){
        return this.kilometre;
    }
}

Détaillons rapidement un morceau de code : 

public void setMarque(String marque){
    this.marque = marque;
}
public String getMarque(){
    return this.marque;
}

Le public void setMarque(String marque) permet de définir une valeur à notre classe alors que le public String getMarque() lui nous retourne l’objet défini. Donc si on met “ford” dans le public void setMarque(String marque), le public String getMarque() nous retournera “ford”.

Essayons ça dans notre Main : 

public class Main {
    public static void main(String[] args) {
        Car voiture = new Car();
        voiture.setkilometre(10_000);
        voiture.setMarque("Toyota");
        System.out.println("la voiture est de la marque : " + voiture.getMarque() + " et a " + voiture.getKilometre() + "km");
    }
}

Et voilà, vous savez utiliser Java dans ses grosses lignes. Évidemment, il y a toujours moyen de faire plus gros et plus complexe, mais cette formation a pour but d’initier au Java.

J’espère que vous aurez appris des choses !