Revision java

Qu’est-ce qu’une variable ?

Une variable est un outil contenant une donnée, par exemple un mot ou un chiffre, et qui va
être utilisée par un programme.
Qu’est-ce qu’une classe java ?
Une classe est un ensemble :

 de variables, nommées attributs;

 Et de comportements, nommées méthodes.
Les classes représentent les patrons de construction des objets de votre programme. Nous
y reviendrons dans la deuxième partie de ce cours.

Qu’est-ce qu’une fonction ?

Une fonction peut être considérée comme un bloc de code avec un nom, qui exécute un
service. Quand il s'agit d'une fonction main, le service effectué est en fait le programme lui-
même ! Plutôt cool, non ? En d’autres termes, lorsque vous lancez votre programme, c’est
la fonction main qui se lance. Elle est aussi appelée le point d’entrée.

⚠ Lorsqu'une fonction est située à l'intérieur d'une classe, elle s'appelle une méthode.
Puisque tout le code est situé à l'intérieur de classes, vous pouvez utiliser les deux termes
(fonctions et méthodes) de manière interchangeable.

Deux étapes sont importantes pour qu’un programme Java se lance : la compilation et
l'interprétation. Le compilateur intervient en amont pour prendre le code du développeur
et le transformer en byteCode (ou code binaire – langage machine). Puis
l'interpréteur traduit le byteCode en instructions pour exécuter le programme.
Le langage dans lequel le code Java doit être transformé est appelé Bytecode. Pour
transformer le code Java en Bytecode, il est nécessaire d'utiliser le compilateur javac.

Résumé :
 Les programmes Java sont structurés en packages et en classes.
 Aucun code n'est écrit en dehors d'une classe, ce qui signifie que toutes les fonctions
sont des méthodes en Java.
 Les packages sont mappés dans des dossiers et les classes dans des fichiers.
 La commande javac convertit le code Java en Bytecode.
 La commande java exécute le programme actuel en exécutant la fonction main dans la
classe fournie.
 Il existe deux types de classes :
1. Les classes modèles qui sont utilisées comme modèles pour l'instanciation des objets.
2. Les classes utilitaires qui contiennent des méthodes statiques qui peuvent être appelées
directement sur la classe.
 Vous pouvez accompagner vos classes et méthodes avec des commentaires de
documentation, écrits entre /** et */, pour générer une page HTML avec toute la
documentation de la classe, appelée un Javadoc. La méthode main peut vous
être masquée si vous utilisez un Framework.
 Les principes du code propre exigent qu'aucune logique ne soit écrite à l'intérieur de la
méthode main. Tout le travail doit être délégué à des fonctions bien nommées.

Niveau de contrôle :
En Java, vous devez utiliser un des mots clés suivants pour désigner un niveau de
contrôle :
 public : visible pour tous et par conséquent le moins restrictif ;
 protected (protégé) : visible pour le package et l'ensemble de ses sous-classes ;
 package-protected (protégé par paquet) : généralement visible uniquement par le
package dans lequel il se trouve (paramètres par défaut). Ne pas mettre de mot clé
déclenche ce niveau de contrôle ;
 private (privé) : accessible uniquement dans le contexte dans lequel les variables sont
définies (à l'intérieur de la classe dans laquelle il est situé).
⚠ Rappelez-vous que le paramètre "par défaut" est plus restrictif que "public" ou "protégé".

Résumé :
 La portée (scope) d'une variable est la zone de code où elle a été déclarée.
 La portée variable générale s'applique à tous les blocs de code, y compris les classes.
 Un autre moyen nécessaire pour contrôler l'accès aux variables et aux fonctions est
d'utiliser des niveaux de contrôle : public, protected, package-protected et private.

Résume
Les boucles d'énumération exécutent un ensemble d'instructions un nombre de fois fixe,
basé sur les valeurs limites inférieure et supérieure de l'énumérateur.
 Les boucles conditionnelles exécutent un ensemble d'instructions jusqu'à ce qu'une
condition définie soit remplie.
 Une erreur courante à surveiller avec les boucles conditionnelles : les boucles infinies !
 Les itérations dans une boucle peuvent ignorer certaines instructions à l'intérieur de la
boucle en utilisant la commande continue.
 Le cycle de boucle peut être interrompu et la boucle peut être interrompue prématurément à
l'aide de la commande break.
Les opérateurs logiques :
Ces opérateurs vous permettent de combiner des valeurs booléennes : soit des valeurs
booléennes spécifiques, soit des résultats d'expressions. Ils sont au nombre de trois:

 && ET logique.
Le résultat n'est vrai que si toutes les parties participantes sont vraies.
Exemple : le résultat de expression1 && expression2 n’est vrai que si expression1 est
vraie ET expression2 est également vraie.
 || OU logique.
Le résultat est vrai si au moins une des parties participantes est vraie.
Exemple : le résultat de expression1 || expression2 est vrai si expression1 est
vraie OU expression2 est vraie. Il en sera de même si les deux expressions sont
vraies !
 ! NON logique.
Il inverse simplement l'expression donnée.
Le résultat de !expression1 est vrai si expression1 est fausse ; le résultat est faux
si expression1 est vraie.

⚠ Comme pour les opérateurs numériques, les opérateurs logiques respectent la

priorité des opérations : l'opérateur d'inversion ! vient en premier, puis l'opérateur
ET && et enfin, l'opérateur OU ||
En résumé
 Les conditions vous permettent d'exécuter un bloc de code uniquement si une
valeur boolean , une variable ou une expression est évaluée comme true .
 Un moyen de fournir des valeurs à un programme est d'envoyer
des arguments sur la ligne de commande. Ces arguments sont mis à la
disposition de la fonction main dans le tableau args .
 Les expressions conditionnelles utilisent l'arithmétique booléenne, notamment
les opérateurs de comparaison et les opérateurs logiques.
 Vous pouvez évaluer plusieurs conditions en créant des
chaînes d'instructions if/else if/else.
 L'instruction switch est une façon plus propre d'exécuter en fonction des
différentes valeurs possibles d'une condition particulière.
 Les énumérations vous permettent de définir un ensemble de valeurs possibles
pour rendre votre code encore plus propre.

 Utilisez une classe comme modèle pour vos futurs objets. Dans une classe,
définissez le nom et le type de certaines variables. En Java, ceux-ci sont
généralement appelés attributs et champs ;
 Pour utiliser le plan vraiment cool que vous avez créé, vous devez créer un objet
en utilisant le processus d'instanciation. Cela signifie déclarer une
variable avec votre classe comme type, puis utiliser l'expression de création
d'objet que vous avez vue ci-dessus ;
 Un objet s'appelle une instance de classe.
En résumé
 Une classe est le plan d'un objet.
 Une classe vous permet de créer des types complexes en regroupant ses attributs, en
définissant des champs.
 Pour créer un objet, vous devez déclarer une variable d'une classe et l'instancier.
Utiliser le point (.) donne accès aux champs.

L’héritage et le polymorphisme:
C’est le concept de polymorphisme. L’idée étant de pouvoir utiliser le même nom de méthode
sur des objets différents. Et bien sûr, cela n’a de sens que si le comportement des méthodes
est différent.
La redéfinition (override) fait référence au remplacement d'une méthode héritée dans une
classe dérivée (sous-classe). Cela se produit lorsque vous avez une hiérarchie de classes avec
une relation d'héritage. La sous-classe peut alors fournir une implémentation différente de la
méthode héritée de sa superclasse.
Dans le contexte de l'héritage, la redéfinition (override) permet de substituer une méthode de
la superclasse avec une méthode de même nom et même signature dans la sous-classe. Cela
permet de modifier ou d'étendre le comportement de la méthode héritée sans avoir à modifier la
superclasse.
En revanche, la surcharge (overload) se produit au sein d'une même classe (ou d'une classe
dérivée) et ne nécessite pas nécessairement d'héritage. Elle permet de définir plusieurs
méthodes avec le même nom, mais des signatures différentes (différents types de paramètres,
différents nombres de paramètres, ordre différent, etc.). Cela permet d'offrir une plus grande
flexibilité en permettant à la classe de traiter différemment les appels de méthode en fonction
des arguments passés.
En résumé, la redéfinition (override) concerne la substitution d'une méthode héritée dans une
sous-classe, tandis que la surcharge (overload) concerne la définition de plusieurs méthodes
avec le même nom mais des signatures différentes dans une même classe (ou une classe
dérivée).
Quelle est la différence entre Héritage et Polymorphisme ?
– L’héritage permet, la réutilisabilité du code et le polymorphisme permet à une fonction d’avoir
différente forme. La différence fondamentale entre l’héritage et le polymorphisme est
que l’héritage permet de réutiliser le code existant dans la classe mère, et
le polymorphisme fournit un mécanisme permettant de décider dynamiquement quelle forme
d’une fonction à invoquer.
L’abstraction est un concept de définition des objets du monde réel en termes de classes ou
d’interfaces.
L’encapsulation est implémentée en combinant des méthodes et des attributs dans une classe.
La classe agit comme un conteneur de propriétés d’encapsulation.
Association est une relation où tous les objets ont leur propre cycle de vie et où il n’y a pas de
maître. L’agrégation est une forme spécialisée d’association dans laquelle tous les objets ont
leur propre cycle de vie, mais il y a un maître et les objets enfants ne peuvent pas appartenir à
un autre objet parent.

En Java, la signature d'une méthode ou d'une fonction fait référence à la combinaison unique
de son nom, de ses types de paramètres et de son type de retour. La signature permet de
distinguer une méthode d'une autre et d'identifier de manière précise la méthode à appeler lors
de l'exécution d'un programme.

 L’héritage est un concept fondamental en Java qui permet de réutiliser du code

de la classe mère.
 Le polymorphisme permet de "surcharger" les méthodes de la classe mère
pour redéfinir leurs comportements sans changer leur signature.
Gérez les piles de données avec la bonne collection :
Comment déclarer un tableau :
Import necessaire:
import java.util.ArrayList;
String [ ] tableau = new String [10] ;

Liste :
Declaration :
List<String> myList = new ArrayList<String>();

 add(element) : Ajoute un élément à la fin de la liste.

 add(index, element) : Insère un élément à l'index spécifié dans la liste.
 remove(index) : Supprime l'élément à l'index spécifié de la liste.
 get(index) : Récupère l'élément à l'index spécifié de la liste.
 set(index, element) : Remplace l'élément à l'index spécifié de la liste par un
nouvel élément.
 size() : Renvoie le nombre d'éléments dans la liste.
 isEmpty() : Vérifie si la liste est vide.
 clear() : Supprime tous les éléments de la liste.
 contains(element) : Vérifie si la liste contient l'élément spécifié.
 indexOf(element) : Renvoie l'index de la première occurrence de l'élément
spécifié dans la liste.
 lastIndexOf(element) : Renvoie l'index de la dernière occurrence de l'élément
spécifié dans la liste.
 toArray() : Convertit la liste en un tableau d'objets.
 addAll(collection) : Ajoute tous les éléments d'une autre collection à la fin de
la liste.

Set<String> ingredients = new HashSet<String>();

Voici un tableau répertoriant certaines des fonctions prédéfinies (méthodes statiques) de la

classe `java.lang.Math` en Java, ainsi que leurs rôles :

| Fonction | Rôle |
|---------------------------|----------------------------------------------------------|
| `abs(x)` | Retourne la valeur absolue de `x`. |
| `sqrt(x)` | Retourne la racine carrée de `x`. |
| `pow(x, y)` | Retourne `x` élevé à la puissance `y`. |
| `exp(x)` | Retourne l'exponentielle de `x`. |
| `log(x)` | Retourne le logarithme naturel (base e) de `x`. |
| `log10(x)` | Retourne le logarithme base 10 de `x`. |
| `sin(x)` | Retourne le sinus de `x` (en radians). |
| `cos(x)` | Retourne le cosinus de `x` (en radians). |
| `tan(x)` | Retourne la tangente de `x` (en radians). |
| `floor(x)` | Retourne le plus grand entier inférieur ou égal à `x`. |
| `ceil(x)` | Retourne le plus petit entier supérieur ou égal à `x`. |
| `round(x)` | Retourne l'entier le plus proche de `x`. |
| `random()` | Retourne un nombre aléatoire entre 0.0 (inclus) et 1.0 (exclus). |
| `max(x, y)` | Retourne le plus grand des deux nombres `x` et `y`. |
| `min(x, y)` | Retourne le plus petit des deux nombres `x` et `y`. |

Il est important de noter que ce tableau répertorie uniquement certaines des fonctions
prédéfinies de la classe `Math`, mais il existe d'autres classes et packages dans la
bibliothèque standard de Java qui fournissent des fonctions prédéfinies pour différents
besoins, tels que la manipulation de chaînes de caractères (`java.lang.String`), les
opérations sur les tableaux (`java.util.Arrays`), les opérations sur les dates et heures
(`java.time.*`), etc.

Il est également possible de créer vos propres fonctions définies par l'utilisateur en Java en
utilisant les méthodes définies dans vos propres classes.

Voici un tableau répertoriant certaines des fonctions prédéfinies de la classe

`java.lang.String` en Java, ainsi que leurs rôles :

| Fonction | Rôle |
|-----------------------------|--------------------------------------------------------------------------|
| `length()` | Retourne la longueur de la chaîne de caractères. |
| `charAt(index)` | Retourne le caractère à l'index spécifié. |
| `substring(beginIndex)` | Retourne une sous-chaîne à partir de l'index spécifié jusqu'à la
fin. |
| `substring(beginIndex, endIndex)` | Retourne une sous-chaîne entre les indices spécifiés
(inclus). |
| `indexOf(str)` | Retourne l'index de la première occurrence de la sous-chaîne
spécifiée. |
| `lastIndexOf(str)` | Retourne l'index de la dernière occurrence de la sous-chaîne
spécifiée. |
| `startsWith(prefix)` | Vérifie si la chaîne commence par le préfixe spécifié. |
| `endsWith(suffix)` | Vérifie si la chaîne se termine par le suffixe spécifié. |
| `toLowerCase()` | Convertit la chaîne en minuscules. |
| `toUpperCase()` | Convertit la chaîne en majuscules. |
| `trim()` | Supprime les espaces blancs au début et à la fin de la chaîne. |
| `replace(oldChar, newChar)` | Remplace toutes les occurrences d'un caractère par un
autre. |
| `replaceAll(regex, replacement)` | Remplace toutes les occurrences correspondant à une
expression régulière. |
| `split(regex)` | Divise la chaîne en sous-chaînes en utilisant une expression
régulière. |
| `concat(str)` | Concatène la chaîne avec une autre chaîne. |

Il est important de noter que ce tableau répertorie uniquement certaines des fonctions
prédéfinies de la classe `String`. La classe `String` offre de nombreuses autres méthodes
utiles pour la manipulation et le traitement des chaînes de caractères. Vous pouvez
consulter la documentation officielle de Java pour obtenir la liste complète des méthodes de
la classe `String` et leurs descriptions détaillées.

Il est également possible d'utiliser d'autres classes de la bibliothèque standard de Java pour
effectuer des opérations avancées sur les chaînes de caractères, telles que `StringBuilder`
pour la construction efficace de chaînes modifiables et `StringBuffer` pour la manipulation
de chaînes dans un contexte multithread.

equals est une méthode de la classe String qui permet de comparer deux chaînes.
Voici un tableau répertoriant certaines des fonctions prédéfinies pour les tableaux et les
vecteurs (Vector) en Java, ainsi que leurs rôles :

| Fonction | Rôle |
|-------------------------------|------------------------------------------------------------------------------------------
--------|
| `length` (pour les tableaux) | Retourne la taille (nombre d'éléments) du tableau.
|
| `size` (pour les vecteurs) | Retourne le nombre d'éléments dans le vecteur.
|
| `clone` (pour les tableaux) | Crée une copie superficielle du tableau (nouvel objet
référençant les mêmes éléments). |
| `addElement` | Ajoute un élément à la fin du vecteur.
|
| `add` (pour les ArrayList) | Ajoute un élément à la fin de la liste.
|
 | `removeElement` | Supprime la première occurrence de l'élément spécifié du
vecteur. |
| `remove` (pour les ArrayList) | Supprime la première occurrence de l'élément spécifié de la
liste. |
| `get` | Retourne l'élément à l'index spécifié dans le tableau ou le vecteur.
|
| `set` | Modifie l'élément à l'index spécifié dans le tableau ou le vecteur.
|
| `sort` (pour les tableaux) | Trie les éléments du tableau dans l'ordre naturel (pour les
types primitifs ou implémentant Comparable) ou en utilisant un comparateur spécifié. |
| `toArray` (pour les vecteurs) | Retourne un tableau contenant les éléments du vecteur.
|
| `contains` | Vérifie si le tableau ou le vecteur contient un élément spécifié.
|
| `indexOf` | Retourne l'index de la première occurrence de l'élément spécifié
dans le tableau ou le vecteur. |
| `isEmpty` | Vérifie si le tableau ou le vecteur est vide.
|

Il est important de noter que ce tableau répertorie seulement quelques-unes des fonctions
prédéfinies pour les tableaux et les vecteurs en Java. Il existe d'autres méthodes
disponibles pour manipuler et travailler avec des tableaux et des vecteurs dans la
bibliothèque standard de Java. Vous pouvez consulter la documentation officielle de Java
pour obtenir la liste complète des méthodes disponibles pour ces structures de données.

Les fonctions prédéfinies en java

Fonction Rôle
Convertir les caractères d'une chaîne de
toUpperCase ()
caractères en majuscules.
Convertir les caractères d'une chaîne de
toLowerCase ()
caractères en minuscules.
Permet de remplacer une partie de texte par
replace («val à changer », « nouv val »)
une autre

Scanner scanner = new Scanner(System.in);

 System.out.print("Entrez votre nom : ");

String nom = scanner.nextLine();

System.out.print("Entrez votre âge : ");

int age = scanner.nextInt();

System.out.println("Bonjour " + nom + ", vous avez " + age + " ans.");

scanner.close();

double random = Math.random();

System.out.println(random);

PHYTON
Tableau :
En Python, les tableaux sont généralement représentés par des listes, qui offrent
un large éventail de fonctions prédéfinies pour les manipuler. Voici quelques-unes
des fonctions couramment utilisées pour travailler avec des listes en Python :

1. `len(liste)`: Renvoie la longueur de la liste.

2. `liste.append(element)`: Ajoute un élément à la fin de la liste.
3. `liste.insert(index, element)`: Insère un élément à un index spécifié dans la liste.
4. `liste.remove(element)`: Supprime la première occurrence de l'élément spécifié
de la liste.
5. `liste.pop(index)`: Supprime et renvoie l'élément à un index spécifié dans la
liste.
6. `liste.index(element)`: Renvoie l'index de la première occurrence de l'élément
spécifié dans la liste.
7. `liste.count(element)`: Renvoie le nombre d'occurrences de l'élément spécifié
dans la liste.
8. `liste.sort()`: Trie les éléments de la liste par ordre croissant.
9. `liste.reverse()`: Inverse l'ordre des éléments dans la liste.
10. `liste.copy()`: Renvoie une copie superficielle de la liste.
11. `liste.clear()`: Supprime tous les éléments de la liste.
12. `liste.extend(iterable)`: Ajoute les éléments d'un iterable (par exemple, une
autre liste) à la fin de la liste.
13. `liste[start:end:step]`: Permet d'accéder à une tranche (slice) de la liste avec
une start (début), end (fin) et step (pas) spécifiés.
14. `liste.pop()`: Supprime et renvoie le dernier élément de la liste.
15. `liste.sort(reverse=True)`: Trie les éléments de la liste par ordre décroissant.
16. `liste.reverse()`: Inverse l'ordre des éléments dans la liste.
17. `liste.copy()`: Renvoie une copie superficielle de la liste.
18. `liste.clear()`: Supprime tous les éléments de la liste.

ARRAY NUMPY :
pip install numpy
import numpy as np
my_array = np.array([1, 2, 3, 4, 5])
ou
zeros_array = np.zeros((3, 3)) # Crée un tableau de zéros de dimension 3x3
ones_array = np.ones((2, 4)) # Crée un tableau de uns de dimension 2x4
random_array = np.random.random((2, 2)) # Crée un tableau de nombres
aléatoires de dimension 2x2
element = my_array[index] # Accès à un élément spécifique
slice = my_array[start:end:step] # Accès à une tranche (slice) du tableau
result = array1 + array2 # Addition de deux tableaux
result = array1 * array2 # Multiplication de deux tableaux
result = np.sin(my_array) # Application de la fonction sinus à chaque élément du
tableau
Oui, la bibliothèque NumPy offre de nombreuses fonctions prédéfinies pour
travailler avec les tableaux multidimensionnels. Voici quelques-unes des fonctions
couramment utilisées de NumPy :

1. Fonctions de création de tableaux :

- `numpy.array()`: Convertit une liste ou une séquence en un tableau NumPy.
- `numpy.zeros()`: Crée un tableau rempli de zéros.
- `numpy.ones()`: Crée un tableau rempli de uns.
- `numpy.empty()`: Crée un tableau vide sans initialiser ses éléments.
- `numpy.arange()`: Crée un tableau avec des valeurs espacées régulièrement.
- `numpy.linspace()`: Crée un tableau avec des valeurs espacées linéairement dans
un intervalle donné.
- `numpy.random.rand()`: Crée un tableau avec des valeurs aléatoires dans
l'intervalle [0, 1].

2. Fonctions de manipulation de tableaux :

- `numpy.shape()`: Renvoie les dimensions d'un tableau.
- `numpy.reshape()`: Modifie la forme d'un tableau existant.
- `numpy.concatenate()`: Concatène plusieurs tableaux le long d'un axe donné.
- `numpy.split()`: Divise un tableau en plusieurs sous-tableaux.
- `numpy.transpose()`: Transpose les dimensions d'un tableau.

3. Fonctions mathématiques et statistiques :

- `numpy.sum()`: Calcule la somme des éléments d'un tableau.
- `numpy.mean()`: Calcule la moyenne des éléments d'un tableau.
- `numpy.min()`, `numpy.max()`: Trouve les valeurs minimales et maximales d'un
tableau.
- `numpy.var()`: Calcule la variance des éléments d'un tableau.
- `numpy.std()`: Calcule l'écart-type des éléments d'un tableau.
- `numpy.dot()`: Calcule le produit scalaire de deux tableaux.
- `numpy.sin()`, `numpy.cos()`, `numpy.exp()`, etc. : Fonctions trigonométriques,
exponentielles, logarithmiques, etc.

4. Fonctions de filtrage et de tri :

- `numpy.where()`: Renvoie les indices où une condition donnée est vraie.
- `numpy.sort()`: Trie les éléments d'un tableau.
- `numpy.argsort()`: Renvoie les indices qui trieraient le tableau.

import numpy as np

# Créer un tableau NumPy

tableau = np.array([1, 2, 3, 4, 5])

# Parcourir le tableau avec une boucle for

for element in tableau:
print(element)
import numpy as np

# Créer un tableau multidimensionnel NumPy

tableau = np.array([[1, 2, 3], [4, 5, 6]])

# Parcourir le tableau avec des boucles imbriquées

for ligne in tableau:
for element in ligne:
print(element)
import numpy as np

# Créer un tableau NumPy

tableau = np.array([1, 2, 3, 4, 5])
# Parcourir le tableau avec nditer()
for element in np.nditer(tableau):
print(element)