Principes Fondamentaux de l'Informatique et de la POO en Java

Introduction à l'Informatique

Qu'est-ce que l'Informatique ?

L'informatique est un ensemble de connaissances scientifiques, techniques et technologiques qui permettent le traitement automatique des données.

Le Système Informatique

Un système informatique est un système qui traite l'information. Il est composé d'entités interdépendantes :

• Matériel (Hardware) : processeur, mémoire, périphériques...
• Logiciel (Software) : programmes, systèmes d'exploitation...
• Humain (Peopleware) : utilisateurs, développeurs...

Programmation et Langages

Le Logiciel

Un logiciel est un ensemble d'instructions qui indiquent à l'ordinateur ce qu'il doit faire de manière précise et exacte.

Il est important de noter que les programmes :

• Ne sont pas intelligents.
• N'ont pas d'initiative.
• N'ont pas d'imagination ni d'inventivité.

Le Modèle

Un modèle est une simplification de la réalité qui permet d'abstraire les détails superflus et de se concentrer sur ce qui est véritablement important.

Les Langages de Programmation

Selon leur niveau d'abstraction :

• Langage machine
• Langage d'assemblage
• Langages de haut niveau : C, C++, Java...
• Langages de 4ème génération (4GL) : SQL...
• Langages à base de composants : NESC...
• Langages de modélisation

Selon le style de programmation :

• Déclaratif (Prolog, LISP...)
• Impératif (C, Java, C++...)

Selon le processus de traduction :

• Compilés
• Interprétés

Un langage de programmation possède deux composantes de base :

• Syntaxe : Quoi et comment écrire ? (Vocabulaire et règles d'écriture)
• Sémantique : Que signifie ce que j'écris ?

Gestion des Erreurs de Programme

• Définir de façon systématique, ordonnée et en suivant les conventions permet de réduire considérablement les erreurs sémantiques.
• La planification avant la conception est une règle générale très importante.

Types d'Erreurs en Programmation

• Les erreurs détectées lors de la compilation sont toujours des erreurs de syntaxe. Le compilateur vérifie la syntaxe.
• Les erreurs détectées lors de l'exécution.
• Les erreurs non liées au programmeur.
• Les erreurs (bugs) du programmeur.
• Mécanisme d'exceptions en Java.

Algorithmique

L'algorithmique est l'étude des procédures optimales pour mener à bien la résolution d'un problème.

L'Algorithme

Un algorithme est une "recette" pour résoudre un problème.

Efficacité d'un Algorithme

L'efficacité d'un algorithme est la capacité à effectuer une tâche de manière optimale. L'efficacité d'un algorithme est mesurée par sa complexité (en temps et en espace).

Algorithme Efficace

Un algorithme est dit efficace lorsqu'il résout correctement le problème pour lequel il a été conçu.

Génie Logiciel

Le génie logiciel est l'application de principes et de techniques d'ingénierie au développement de logiciels.

Phases du Génie Logiciel : Analyse

L'analyse consiste en la capture et l'analyse des besoins :

• Besoins fonctionnels.
• Besoins non fonctionnels : coût, temps de développement, maintenabilité, extensibilité, temps de mise en œuvre global...

Phases du Génie Logiciel : Conception (Design)

La conception (ou design) consiste à élaborer différents modèles pour que le client puisse choisir celui qui lui convient.

Phases du Génie Logiciel : Implémentation

L'implémentation est la partie la moins créative, elle consiste à coder la conception.

Phases du Génie Logiciel : Tests (V&V)

Les tests (ou V&V : Validation et Vérification) sont cruciaux.

Phases du Génie Logiciel : Maintenance (80% du coût)

La maintenance logicielle représente environ 80% du coût total et inclut :

• Extension et mise à niveau (10%).
• Résolution des problèmes et des erreurs (60%).
• Réalisation de tests périodiques (30%).

Introduction à la Programmation

Cette section sert de transition vers les concepts de programmation.

La Programmation Structurée

Principes Fondamentaux de la Programmation Structurée

1. Un programme est une séquence d'instructions.
2. Principe d'empilement : Toute action peut être remplacée par deux ou plusieurs actions exécutées dans l'ordre.
3. Principe de structuration : Toute action peut être remplacée par l'une des trois structures de contrôle valides suivantes :
   • Séquence
   • Sélection (ou branchement)
   • Itération (ou répétition)

Toutes les structures de contrôle ont un seul point d'entrée et un seul point de sortie.

Note : Ces règles peuvent être appliquées aussi souvent que nécessaire.

Procédure et Abstraction des Données

La programmation structurée (voir section 4) est une base.

La programmation modulaire suit le principe « diviser pour régner ».

Avantages de la Programmation Modulaire

1. Encapsulation algorithmique : Les modules peuvent être généralisés comme des opérateurs qui prennent des paramètres d'entrée (0 ou plus) et produisent des résultats de sortie (0 ou plus).
   • Avantage : Si nous devons corriger, améliorer ou modifier un module, il suffit de modifier sa déclaration.
   • Le code de programmation modulaire devient plus facile à modifier et à déboguer.
2. Abstraction de procédure : Une fois qu'un module est créé, il peut être réutilisé autant de fois que souhaité sans avoir à répéter le code. Les modules peuvent être vus comme des "boîtes noires" fonctionnelles.
   • Avantage : Le code est raccourci, sans répétition, et donc plus lisible.
   • En Java, les modules sont appelés méthodes.

Types de Classes en Java

• Classes standards.
• Classes de bibliothèque.
• Méthodes statiques de bibliothèque : méthodes qui ne nécessitent pas d'objet pour être exécutées. Elles s'exécutent en utilisant le nom de la classe comme destinataire du message.
• Classes d'objets modélisés :
  • Structure (attributs)
  • Comportement (méthodes non statiques)

Paramètres d'Entrée des Méthodes

• Dans la définition d'une méthode, ces paramètres sont appelés paramètres formels (type + identifiant).
• Lors de l'invocation d'une méthode, les paramètres passés sont appelés paramètres actuels (valeurs littérales ou variables).
• Il existe deux types de passage d'arguments :
  • Passage des arguments par valeur : transmission d'une copie.
  • Passage des arguments par référence : transmission de l'adresse mémoire (pointeur).

ATTENTION : En Java, TOUT est passé par valeur.

Passage de Valeurs (par Valeur et par Référence)

Les méthodes peuvent avoir zéro ou plusieurs paramètres d'entrée. Dans leur définition, ces arguments sont appelés paramètres formels. Lors de l'invocation de la méthode, les données passées comme arguments sont appelées paramètres actuels.

En Java, les paramètres formels sont toujours une copie des paramètres actuels. Les paramètres sont passés à la méthode par valeur. Si un paramètre formel est modifié à l'intérieur de la méthode, cela n'a pas d'impact sur le paramètre actuel (par exemple, pour les types primitifs).

La Surcharge de Méthodes (Overloading)

En Java, il est possible de définir plusieurs méthodes (différentes versions de la même méthode) avec le même nom au sein de la même classe. On dit alors que la méthode est surchargée. Pour déterminer quelle version d'une méthode surchargée est appelée, Java vérifie la liste des paramètres réels (nombre, type et ordre des paramètres) lors de l'appel de la méthode.

Deux versions d'une méthode surchargée sont considérées comme correctes si et seulement si elles ont une signature différente. Le type de retour n'a pas d'incidence sur la signature.

Signature d'une Méthode

La signature d'une méthode est définie par : nom + liste des paramètres.

Identificateur d'une Méthode

L'identificateur d'une méthode est défini par : signature + type de retour.

L'Abstraction

• Abstraction de contrôle (boucles).
• Abstraction de procédure (méthodes).
• Abstraction de données :
  • Tableaux (collections).
  • Classes.

Type de Données Abstraits (TDA)

Un Type de Données Abstraits (TDA) est un modèle ou une structure abstraite qui définit la structure (attributs) et les comportements (méthodes) des objets concrets appartenant à cette catégorie.

Classes "Enveloppes" (Wrapper Classes)

Les classes "enveloppes" (ou wrapper classes) sont utilisées lorsque nous avons besoin d'un objet plutôt que d'un type de données primitif (par exemple, dans les collections comme les files d'attente, où un élément est lié à un autre).

Méthodes Non Statiques

Les méthodes non statiques s'exécutent sur une instance d'objet.

Méthodes Statiques

Les méthodes statiques s'exécutent au niveau de la classe.

Récursivité vs. Itération

La récursivité est un processus où une entité s'appelle elle-même. Elle est liée au principe d'induction.

La récursivité peut consommer beaucoup de ressources mémoire, car elle empile les appels de méthode lors de l'exécution. Bien que la récursivité soit coûteuse en ressources, elle est souvent plus naturelle et élégante pour exprimer certaines solutions. Par exemple, en Java, le calcul récursif de la factorielle d'un très grand nombre (comme un million) pourrait entraîner un débordement de pile (StackOverflowError) en raison de la consommation excessive de mémoire. Cependant, elle est essentielle pour la conception et la compréhension de certains programmes.

Comparaison : Récursion vs. Itération

1. Les deux approches effectuent une répétition :
   • La solution itérative répète le corps de la boucle.
   • La solution récursive répète les appels de méthode récursive.
2. Les deux approches ont une condition de terminaison :
   • Dans une solution itérative, le processus se termine lorsque la condition de continuation de la boucle n'est plus respectée.
   • Dans une solution récursive, l'appel se termine lorsque le cas de base (condition d'arrêt) est atteint, déclenchant une séquence de retours en arrière.

   Le Recul (Backtracking)

   Le recul (ou backtracking) est une succession d'éléments de preuve de principe.

3. Les deux approches doivent être conçues pour converger vers la solution (principe de convergence, sans sauter la condition de terminaison) :
   • Dans une solution itérative, il faut s'assurer que la condition de terminaison sera satisfaite.
   • Dans une solution récursive, il faut s'assurer que le cas de base sera atteint.

Principe Important

Toute solution récursive peut trouver une solution itérative équivalente, mais l'inverse n'est pas toujours vrai.

Concepts Avancés en Programmation Orientée Objet

1. Encapsulation au Moment du Développement

Lors du développement, nous construisons l'intérieur de la classe, où les données et les méthodes sont définies et conçues pour correspondre à la classe.

2. Encapsulation au Moment de l'Exécution

Lorsque la classe existe déjà et que des objets sont créés à partir d'elle, ils sont traités comme des "boîtes noires". Les objets encapsulent des données et des méthodes ; il suffit de savoir quoi faire pour obtenir un service. L'état d'un objet ne doit être modifié que par les méthodes de l'objet lui-même.

3. Définition de l'Interface et Propriétés Associées

Une interface est une collection de constantes et de méthodes abstraites. Les interfaces ne sont pas utilisées seules, mais sont implémentées par d'autres classes. La classe qui implémente l'interface fournit les implémentations des méthodes déclarées dans l'interface. Une classe peut implémenter plus d'une interface, ce qui offre une certaine capacité d'héritage multiple.

4. L'Abstraction

L'encapsulation est une forme d'abstraction. À un faible niveau d'abstraction, dans une classe, nous manipulons les données et les méthodes individuellement. À un niveau élevé d'abstraction, la classe est considérée comme une unité et seuls ses services sont utilisés.

5. Relations entre les Classes

• Généralisation (relation "est un").
• Association.
• Dépendance (relation "utilise un").

6. Généralisation (Relation "Est un")

Cette relation existe entre un élément général (super-classe) et un cas spécifique (sous-classe ou classe enfant). Il s'agit d'une relation d'héritage. La classe enfant hérite des attributs (données) et des procédures (méthodes) de la classe parente, et peut y ajouter les siens.

7. Association

Dans une relation d'association, une classe est composée d'autres classes. Ce résultat est obtenu en utilisant un objet d'une classe comme attribut (donnée) de la classe composite. La multiplicité indique combien d'objets sont liés dans une association.

8. Dépendance (Relation "Utilise un")

C'est une relation d'utilisation, où un changement dans l'état d'un objet (l'indépendant) affecte l'état de l'autre (le dépendant), mais pas l'inverse.

9. Les Constructeurs

Les constructeurs sont une ou plusieurs méthodes (surchargées) utilisées pour créer des objets d'une classe. Ils portent le même nom que la classe. Ils n'ont pas de type de retour, mais peuvent accepter des paramètres (pour initialiser les variables de l'objet créé).

10. Les Références

Dans l'affectation par référence, si deux références pointent vers le même objet, modifier le contenu de l'objet en utilisant une référence modifie également le contenu accessible via l'autre référence, car nous travaillons réellement sur le même objet, même si les références sont différentes.

11. Les Modificateurs d'Accès et Autres

Modificateurs de Visibilité :

• public : Accessible de n'importe où.
• protected : Accessible depuis la classe, le même paquet ou les sous-classes.
• private : Accessible uniquement depuis la même classe.

Autres Modificateurs :

• final : Utilisé pour déclarer des constantes (variables) ou empêcher l'héritage/la surcharge (classes/méthodes).
• static : Rend la variable ou la méthode globale à tous les objets de la classe.
• Les méthodes statiques peuvent être invoquées sans avoir besoin d'une instance de la classe.

12. Les Trois Piliers de la POO

Les trois principales caractéristiques de la Programmation Orientée Objet (POO) sont : l'encapsulation, l'héritage et le polymorphisme.

13. Le Polymorphisme

Le polymorphisme est la capacité de lier une référence à des objets de différentes classes liées par héritage. En termes pratiques, cela signifie qu'une référence peut pointer vers un objet de sa propre classe ou vers un objet d'une classe descendante.

14. Utilité des Classes Abstraites

Les classes abstraites ne fournissent pas d'implémentation pour toutes leurs méthodes, obligeant ainsi les classes enfants à les implémenter comme elles le souhaitent. Si les méthodes n'étaient pas abstraites, la classe enfant ne serait pas obligée de choisir comment les implémenter et pourrait utiliser la méthode héritée de sa classe parente.

15. Les Exceptions en Java

• Exceptions contrôlées (Checked Exceptions) : Il est obligatoire de les capturer (avec try-catch) ou de les déclarer dans la clause throws, sinon des erreurs de compilation se produiront.
• Exceptions non contrôlées (Unchecked Exceptions) : Il n'est pas nécessaire de les déclarer dans la clause throws. Ce sont des erreurs qui peuvent être évitées lors de l'écriture du code, comme une division par zéro ou un dépassement de taille de tableau (ArrayIndexOutOfBoundsException).

16. Les Frameworks

Un framework est une application semi-complète qui peut être spécialisée et réutilisée en appliquant certains mécanismes d'extension ou de configuration pour produire des applications spécifiques. Il inclut souvent une infrastructure de mise en œuvre.

Le point clé d'un framework est de définir les points qui peuvent être modifiés ou spécialisés par le programmeur (les "points chauds" ou hot spots) et ceux qui ne le peuvent pas (le "code stable" ou cold spots). Les frameworks sont souvent conçus en utilisant des modèles de conception (design patterns).

17. Les Arbres Binaires

Les arbres binaires sont des structures de données formées de nœuds. Il y a un premier nœud (la racine) qui peut avoir deux nœuds descendants (fils gauche et fils droit). Chaque nœud a une valeur "V" et peut avoir un fils gauche et un fils droit.