• Java tutorial
• Relations entre les classes
• Generalisation

1. Entrez sur le site de IntelliJ IDEA et appuyez sur le bouton Download
2. Suivre le tutoriel d'installtion d'ici: Installer IntelliJ IDEA

Pour créer un nouveau projet en IntelliJ IDEA, s'il vous plait suivre le tutoriel d'ici: Creer votre premier application Java

• boolean: valeur true/false

         boolean myBool = true;
 

• int/float/double/long: numéros entiers et réels

          int numberInt = 3;
          float numberFloat = 4.2f;
          double numberDouble = 19.99d;
          long numberLong = 15000000000L;
 

• char: une caractere entoure par '

          char c = 'a';
 

• String: Un String continent une collection des caractères entourés par des “

        String str = "Some string";
 

• array: liste de valeurs ayant le meme type et une taille fixe

          int[] numbers = {1, 2, 3};
          String[] words = {"some", "strings", "here"};
 

• enums: Un type spécial de classe qui représente un groupe des constantes

          enum Sujets{
            ALF,
            SDE,
            AM
          }
 

Les variables sont utilisées pour stocker des données. Pour les déclarer on doit mentionner le type de données de notre variable(int, float, String etc.) et, après ça, le nom du variable.

float a;
a = 14.5f;
 
int x = 10;
int x = 20; // error: can't re-declare 'x' in the same scope

En Java, nous avons les instructions conditionnelles suivantes:

• if - pour spécifier un bloc de code à exécuter, si la condition est vraie
• else - pour spécifier un bloc de code à exécuter, si la même condition qua est fausse
• else if - pour spécifier une nouvelle condition à tester, si la première condition est fausse
• switch - pour spécifier plusieurs blocs de code alternatives à exécuter

int x = 1;
if(x == 1) {
   System.out.println(x); //l'instruction s'execute
}
if(x > 3) {
   System.out.println(x + 3); //l'instruction ne s'execute pas
}

int x = 5;
 
if(x < 3) {
   System.out.println(x + 3);
}
else {
   System.out.println(x + 1); //seulement cette instruction s'execute
}

int x = 2;
 
if(x < 3) {
   System.out.println(x + 3); //seulement cette instruction s'execute
}
else if (x > 4){
  System.out.println(x + 1);
}

int x = 2;
 
switch(x) {
   case 1:
      System.out.println(x + 1);
      break;
   case 2:
      System.out.println(x + 2); //seulement cette instruction s'execute
      break;
   case 3:
      System.out.println(x + 3);
      break;
   default:
      System.out.println(x); //instruction qui s'execute si x n'est pas egal a 1, 2 ou 3
   }

Les boucles peuvent exécuter un bloc de code plusieurs fois.

La boucle for parcourt un bloc de code un certain nombre de fois.

int x = 10;
int sum = 0;
 
for(int i = 1; i <= x; i++) {
   sum += i;
}
 
System.out.println(sum); //55

La boucle while parcourt un bloc de code tant qu'une condition spécifiée est vraie.

int x = 1;
int sum = 0;
 
while(x <= 10) {
   sum += x;
   x++;
}
 
System.out.println(sum); //55

Une classe représente un modèle selon lequel les objets sont créés.

Un objet est l’unité de base de la programmation orientée objet et représente des entités réelles. Un objet est une instance d'une classe.

La syntaxe pour creer une classe et instancier un objet c'est la suivante:

public class MyClass{
 int x = 5;
}
 
public static void main(String[] args) {
    MyClass myObj = new MyClass();
    System.out.println(myObj.x);
  }

Dans Java, il existe 4 modificateurs d'accès pour les classes, attributs, constructeurs et methodes:

• default
• public
• protected
• private

public class MyClass {
  public String name;
  public int age;
 
  MyClass(String name, int age) {
    this.name = name;
    this.age = age;
  }
 
  MyClass() {
    this.name = "DefaultName";
    this.age = 20;
  }
}

L'encapsulation en Java est un mécanisme d'encapsulation des données (variables) et du code agissant sur les données (méthodes) en une seule unité. Dans l'encapsulation, les variables d'une classe seront cachées des autres classes et ne seront accessibles que par les méthodes de leur classe actuelle. Par conséquent, il est également connu sous le nom de masquage de données.

Les getters et setter nous permettent d'accéder et modifier la valeur d’un attribut privé.

La methode get renvoie la valeur d'un attribut.

La methode set modifie la valeur d'un attribut.

public class Person {
  private String name;
 
  Person(String name) {
    this.name = name;
  }
 
  public String getName() {
    return this.name;
  }
 
  public void setName(String name){
    this.name = name;
  }
 
}

En Java, il est possible d'hériter d'attributs et de méthodes d'une classe à une autre. Nous regroupons le “concept d'héritage” en deux catégories:

• subclass (enfant) - la classe qui herite un autre classe
• superclass (parent) - la classe qui est héritée

Pour indiquer q'une classe herite un autre classe on utilise le mot cle extends.

Le mot-clé super peut être utilisé pour accéder au constructeur de la classe parent. Une chose plus importante est que “super” peut appeler à la fois des constructeurs paramétriques et non paramétriques en fonction de la situation.

public class Person {
  public String name;
  public int age;
 
  MyClass(String name, int age) {
    this.name = name;
    this.age = age;
  }
}
 
public class Student extends Person {
  public String name;
  public int age;
  public double grade;
 
  MyClass(String name, int age, double grade) {
    super(name, age);
    this.grade = grade;
  }
}

L'abstraction de données est le processus consistant à masquer certains détails et à ne montrer que les informations essentielles à l'utilisateur. L'abstraction peut être réalisée avec des classes abstraites ou des interfaces.

Le mot clé abstract est un modificateur de non-accès, utilisé pour les classes et les méthodes:

• Classe abstraite: une classe restreinte qui ne peut pas être utilisée pour créer des objets
• Methode abstraite: ne peut être utilisé que dans une classe abstraite et n'a pas de corps. Le corps est fourni par la sous-classe (héritée de)

abstract class Animal {
  public abstract void animalSound();
  public void sleep() {
    System.out.println("Zzz");
  }
}

Une interface est une “classe complètement abstraite” qui est utilisée pour regrouper des méthodes liées avec des corps vides.

Pour accéder aux méthodes d'interface, l'interface doit être implémentée (un peu comme héritée) par une autre classe avec le mot clé implements (au lieu d'extends). Le corps de la méthode d'interface est fourni par la classe “implement”:

// Interface
interface Animal {
  public void animalSound(); // interface method (does not have a body)
  public void sleep(); // interface method (does not have a body)
}
 
// Pig "implements" the Animal interface
class Pig implements Animal {
  public void animalSound() {
    // The body of animalSound() is provided here
    System.out.println("The pig says: wee wee");
  }
  public void sleep() {
    // The body of sleep() is provided here
    System.out.println("Zzz");
  }
}
 
class Main {
  public static void main(String[] args) {
    Pig myPig = new Pig();  // Create a Pig object
    myPig.animalSound();
    myPig.sleep();
  }
}

En Java, le polymorphisme fait référence à la capacité d'une classe à fournir différentes implémentations d'une méthode, selon le type d'objet passé à la méthode. Pour le dire simplement, le polymorphisme en Java nous permet d'effectuer la même action de différentes manières.

Overloading d'un méthode en Java est une fonctionnalité qui permet à une classe d'avoir plus d'une méthode avec le même nom, mais avec des paramètres différents.

public class Square{
  private double l = 5.5;
 
  Square(double l) {
    this.l = l;
  }
 
  public double calculateArea() {
    return l * l;
  }
 
  public double calculateArea(double side) {
    return side * side;
  }
}

Overriding est réalisée une sous-classe fournit l'implémentation spécifique de la méthode qui a été déclarée par l'une de ses classes parentes, on parle de remplacement de méthode.

public class Greeting{
  private String name;
 
  Greeting(String name) {
    this.name = name;
  }
 
  public void greet(String greeting) {
    System.out.println(greeting);
  }
}
 
public class Hello extends Greeting{
  private String name;
 
  Greeting(String name) {
    this.name = name;
  }
 
  public void greet(String greeting) {
    System.out.println(greeting + ", " + name + "!");
  }
 
  public static void main(String[] args) {
    Greeting g = new Greeting("Steven");
    Hello h = new Hello("Steven");
 
    g.greet("How are you "); // Prints "How are you Steven"
    h.greet("Hello"); //Prints "Hello, Steven!" 
  }
 
}

La classe Scanner est utilisée pour obtenir les entrées de l'utilisateur et se trouve dans le package java.util.

Pour utiliser la classe Scanner, créez un objet de la classe et utilisez l'une des méthodes disponibles trouvées dans la documentation de la classe Scanner. Dans notre exemple, nous utiliserons la méthode nextLine(), qui sert à lire les Strings:

import java.util.Scanner;  // Import the Scanner class
 
class Main {
  public static void main(String[] args) {
    Scanner myObj = new Scanner(System.in);  // Create a Scanner object
    System.out.println("Enter username");
 
    String userName = myObj.nextLine();  // Read user input
    System.out.println("Username is: " + userName);  // Output user input
  }
}

Pour lire le contenu d'un fichier, on peut utiliser le class Scanner:

import java.io.File;  // Import the File class
import java.io.FileNotFoundException;  // Import this class to handle errors
import java.util.Scanner; // Import the Scanner class to read text files
 
public class ReadFile {
  public static void main(String[] args) {
    try {
      File myObj = new File("filename.txt");
      Scanner myReader = new Scanner(myObj);
      while (myReader.hasNextLine()) {
        String data = myReader.nextLine();
        System.out.println(data);
      }
      myReader.close();
    } catch (FileNotFoundException e) {
      System.out.println("An error occurred.");
      e.printStackTrace();
    }
  }
}

import java.io.FileWriter;   // Import the FileWriter class
import java.io.IOException;  // Import the IOException class to handle errors
 
public class WriteToFile {
  public static void main(String[] args) {
    try {
      FileWriter myWriter = new FileWriter("filename.txt");
      myWriter.write("Files in Java might be tricky, but it is fun enough!");
      myWriter.close();
      System.out.println("Successfully wrote to the file.");
    } catch (IOException e) {
      System.out.println("An error occurred.");
      e.printStackTrace();
    }
  }
}

1. Ecrivez un programme qui affiche sur l'écran:
   • Votre nom, prénom et age en utilisant la concatenation des strings. (0.2p)
   • Les donnees(nomme, prénom et age) de 3 personnes(3 lignes differentes) qui sont lit a partir de la claviature(user input). (0.4p)
   • La date d'aujourd'hui et l'heure courant en utilisant Date avec un format a votre choix. (0.4p)
2. Creer un array avec des 4 elements de type int qui represent l'age de 4 personnes et un autre array avec 4 elements de type String qui represent les nommes des ces personnes. Affichez sur l'écran:
   • Le nom de la personne la plus âgée
   • La moyenne d'âge et le personnes qui ont l'âge moins que cette moyenne
   • Les personnes qui ont le nombre de lettres dans leur nom égal avec leur âge (1.5p)
3. Stockez un nombre quelconque dans une variable. Utilisez la boucle while pour compter seulement ses diviseurs pairs. Affichez sur l’écran :
   • “I chose the number x which has y even divisors”, où x représente la valeur du numéro que vous avez choisi et y le numéro de ses diviseurs (0.5p)
   • Si le nombre est premier. (0.5p)
4. Faire une fonction differente pour chaque demande. En utilisant les différents types de boucle, résolvez les demandes suivantes :
   • lisez 10 numéros d'un fichier txt et ecrivez leur somme et leur moyenne dans un autre fichier. (0.4p)
   • affichez sur l'écran la table de multiplication du numéro 5 (1×5=5, 2×5=10, 3×5=15 … 10×5=50) (0.4p)
   • vérifiez si le numéro 56 est un parfait (la somme des diviseurs est égale a 56) (0.4p)
   • vérifiez si un numéro est Strong. (Un nombre Strong est un nombre spécial dont la somme des factorielles de chiffres est égale au nombre d'origine: 1! + 4! + 5! = 145 (0.4p)
   • une pyramide d'étoiles avec 4 lignes (0.4p)

                 * 
                * * 
               * * * 
              * * * *

   • la pyramide suivante (0.5p)

          1234567654321                                                                                            
           12345654321                                                                                             
            123454321                                                                                              
             1234321                                                                                               
              12321                                                                                                
               121                                                                                                 
                1 

5. Implementez les classes et relations entre les classes(lire la documentation) du diagramme UML suivante et faites une classe de test pour tester tous les methodes:(4p)