Remerciez-le!

Remerciez @Admin pour avoir partagé cet document gratuitement, de la manière la plus simple, en partageant sur les réseaux sociaux.

CONCEPTION ET ADAPTATION DES SOLUTIONS APPLICATIVES II Programme du cours Cours

CONCEPTION ET ADAPTATION DES SOLUTIONS APPLICATIVES II Programme du cours Cours de conception et Adaptation des Solutions Applicatives II CHAHIE THOMAS PAULIN i SOMMAIRE CHAPITRE 0 PRINCIPE DE LA PROGRAMMATION ORIENTEE OBJET .......................................... 1 I Introduction ............................................................................................................................. 1 II Objet et classe .......................................................................................................................... 1 III Encapsulation des données ..................................................................................................... 2 IV L’HERITAGE .............................................................................................................................. 2 V Le polymorphisme ................................................................................................................... 3 VI Le Langage JAVA ...................................................................................................................... 3 VII Eléments de syntaxe du langage Java ................................................................................ 4 VII.1 Types primitifs ............................................................................................................... 4 VII.2 Déclaration des variables et objets .............................................................................. 5 VII.3 Les opérateurs Java ...................................................................................................... 6 VII.4 Commentaires ............................................................................................................... 7 VIII Les structures de contrôles ................................................................................................. 7 VIII.1 La structure if (Si) .......................................................................................................... 7 VIII.2 Les choix multiples ........................................................................................................ 7 VIII.3 La structure for ( pour) ................................................................................................. 8 VIII.4 La structure While (tant que) ....................................................................................... 9 VIII.5 La structure do..while (Repeter) .................................................................................. 9 IX Les sous programmes .......................................................................................................... 9 CHAPITRE 1 CLASSES / PAQUETAGES .............................................................................................. 11 I Notion générale ...................................................................................................................... 11 I.1 Introduction ..................................................................................................................... 11 I.2 Encapsulation ................................................................................................................... 11 II Constructeurs .......................................................................................................................... 12 III Accesseurs et mutateurs ........................................................................................................13 IV Application ..............................................................................................................................13 V Attributs final et static ........................................................................................................... 14 VI Conversion des objets en chaîne de caractères ................................................................... 14 VII Destructeurs ........................................................................................................................15 VIII Paquetages ..........................................................................................................................15 IX Classes internes ...................................................................................................................15 CHAPITRE 2 Héritage, classes abstraites et interfaces ............................................................... 17 I Héritage ................................................................................................................................... 17 I.1 Introduction ..................................................................................................................... 17 I.2 La classe Object ............................................................................................................... 17 II Méthodes et classes abstraites ............................................................................................. 18 III Interfaces ................................................................................................................................ 19 IV Héritage multiple d’interface ................................................................................................ 19 CHAPITRE 3 COLLECTION ET GESTION DES EXCEPTIONS ......................................................... 20 I Les collections d’objets ......................................................................................................... 20 I.1 La classe ArrayList............................................................................................................ 21 I.2 La classe HashTable ........................................................................................................ 22 I.3 La classe Vector .............................................................................................................. 22 II Les Exceptions........................................................................................................................ 23 II.1 Définition ......................................................................................................................... 23 II.2 Capturer une exception.................................................................................................. 24 II.3 Déﬁnir de nouveaux types d’exceptions ....................................................................... 25 Cours de conception et Adaptation des Solutions Applicatives II CHAHIE THOMAS PAULIN ii CHAPITRE 4 LA PERSISTENCE ...................................................................................................... 26 I Persistance via des fichiers .................................................................................................... 26 II L’API JDBC .............................................................................................................................. 27 II.1 Type de pilote JDBC ........................................................................................................ 27 II.2 Présentation des classes de l’API JDBC ......................................................................... 27 II.3 Etablir une connexion à une base de donnée ............................................................... 28 II.4 Executer des requêtes .................................................................................................... 28 II.5 Executer les requêtes précompilées ............................................................................. 29 III Les transactions ..................................................................................................................... 29 IV Les procédures et fonction stockées .................................................................................... 29 CHAPITRE 5 LES INTERFACES GRAPHIQUES ET LES EVENEMENTS (VOIR TP) ..........................31 I Introduction ............................................................................................................................31 II Les classes de SWING .............................................................................................................31 III Les boites de dialogues ......................................................................................................... 32 IV Utilisation des icones ............................................................................................................. 32 V Utilisation des JTable ............................................................................................................. 32 VI Les looks and Feel .................................................................................................................. 33 VII Les évènements .................................................................................................................. 34 VII.1 Les Interfaces de gestion d’évènements ................................................................... 34 VII.2 Intercepter un évènement ......................................................................................... 35 ANNEXE I : UTILISER JAVA EN LIGNE DE COMMANDE ..................................................................... a ANNXE II : ETUDE DE QUELQUES CLASSES JAVA ............................................................................. c VIII LA CLASSE STRING .............................................................................................................. c IX La classe java.lang.Math ...................................................................................................... d X La gestion des dates ................................................................................................................ d XI Classes enveloppantes des types primitifs ......................................................................... e ANNEXE III : Lecture d'un texte d'une fenêtre console.....................................................................f Cours de Programmation Orientée Objet CHAHIE THOMAS PAULIN 1 CHAPITRE 0 PRINCIPE DE LA PROGRAMMATION ORIENTEE OBJET I Introduction La programmation Orientée Objet est un paradigme (style) de programmation consistant à assembler des briques logicielles (objets). Elle est aujourd'hui plébiscitée par un grand nombre de développeurs ! En effet, ce type de programmation possède de nombreux avantages : o Réutilisation du code, donc gain de temps o Code mieux structuré, maintenance plus aisée structuration du code La programmation orientée objet est apparue avec, pour objectifs principaux : 1) de concevoir l’organisation de grands projets informatiques autour d’entités précisément structurés, mêlant données et fonctions (les objets) facilitant la modélisation de concepts sophistiqués ; 2) d’améliorer la sûreté des logiciels en proposant un mécanisme simple et flexible des données sensibles de chaque objet en ne les rendant accessibles que par le truchement de certaines fonctions associées à l’objet (encapsulation) afin que celles-ci ne soient pas accessibles à un programmeur inattentif ou malveillant. 3) de simplifier la réutilisation de code en permettant l’extensibilité des objets existants (héritage) qui peuvent alors être manipulés avec les mêmes fonctions (polymorphisme). Les concepts fondamentaux de la POO regroupent celles de : o Objet o Encapsulation des données o Classe o Héritage o Polymorphisme II Objet et classe Un objet est une entité cohérente rassemblant des données et du code travaillant sur ses données. o Son Identité : C'est ce qui permet d'identifier un objet parmi d'autres. Dans le code, le nom de variable remplit cette fonction. o Ses Propriétés (ou attributs) : Les propriétés sont les données intrinsèques de l'objet que l'on souhaite gérer. En prenant l'exemple d'un objet Rectangle, il faudra au minimum gérer sa longueur et sa largeur. o Ses Méthodes : Les méthodes sont des fonctions applicables à un objet. Une classe peut être considérée comme un moule à partir duquel on peut créer des objets. Une classe est une structure informatique regroupant les caractéristiques et les modes de fonctionnements d’une famille d’objets, appelés instances de la classe. Exemple : Cours de Programmation Orientée Objet CHAHIE THOMAS PAULIN 2 Un Employé : Un Complexe III Encapsulation des données L’encapsulation est l'un des trois grands principes du paradigme objet. Il consiste à protéger la définition des objets. Ce principe, digne héritier des principes d'abstraction de données et d'abstraction procédurale prône les idées suivantes :  Un objet rassemble en lui même ses données (les attributs) et le code capable d'agir dessus (les méthodes)  Abstraction de données : la structure d'un objet n'est pas visible de l'extérieur, son interface est constituée de messages invocables par un utilisateur. La réception d'un message déclenche l'exécution de méthodes.  Abstraction procédurale : Du point de vue de l'extérieur (c’est-à-dire en fait du client de l’objet), l'invocation d'un message est une opération atomique. L'utilisateur n'a aucun élément d'information sur la mécanique interne mise. Dans les versions canoniques du paradigme objet, les services d'un objet ne sont invocables qu’au travers de messages, lesquels sont individuellement composés de :  Un nom  Une liste de paramètres en entrée  Une liste de paramètres en sortie L’ensemble constitué du nom de la méthode et du type de chaque paramètre d’entrée constitue sa signature La liste des messages auxquels est capable de répondre un objet constitue son interface : C'est la partie publique d'un objet. Tout ce qui concerne son implémentation doit rester caché à l'utilisateur final : c'est la partie privée de l'objet. Il est très important de cacher les détails d'implémentation des objets à l'utilisateur. En effet, cela permet de modifier, par exemple la structure de données interne d'une classe (remplacer un tableau par une liste chaînée) sans pour autant entraîner de modifications dans le code de l’utilisateur, l’interface n’étant pas atteinte. L’encapsulation est gérer à travers le niveau de visibilité. On distingue :  Le niveau public : L’élément est visible partout  Le niveau private : L’élément est visible uniquement à l’intérieur de l’objet  Le niveau protected : L’élément est visible par l’objet et ses descendants.  Le niveau package : L’élément est visible par l’objet et par celles situées dans le même package. IV L’HERITAGE Il est chargé de traduire le principe naturel de Généralisation / Spécialisation. En effet, la plupart des systèmes réels se prêtent à merveille à une classification hiérarchique des éléments qui les composent. Il est basé sur l'idée qu'un objet spécialisé bénéficie ou hérite des caractéristiques de l'objet le plus général auquel il rajoute ses éléments propres. En termes de concepts objets cela se traduit de la manière suivante : Cours de Programmation Orientée Objet CHAHIE THOMAS PAULIN 3  On associe une classe au concept le plus général, nous l'appellerons classe de base ou classe mère ou super - classe.  Pour chaque concept spécialisé, on dérive une classe du concept de base. La nouvelle classe est dite classe dérivée ou classe fille ou sous-classe On parle également de relation est-un pour traduire le principe de généralisation / spécialisation. V Le polymorphisme Le polymorphisme est le troisième des trois grands principes sur lequel repose le paradigme objet. C'est assurément son aspect à la fois le plus puissant et le plus troublant. Comme son nom l'indique le polymorphisme permet à une méthode d'adopter plusieurs formes sur des classes différentes. VI Le Langage JAVA Le langage JAVA est un projet de Sun Microsystems(1991) rachetée par Oracle. La première version apparait en 1995. Aujourd’hui, JAVA est un langage permettant de gérer :  La connectivité aux bases de données et les objets distribués  Les évènements, l’internationalisation  Le graphisme, la sécurité. JAVA est un langage qui possède de nombreux avantages. Les principaux sont  interruptible : il dispose d’un gestionnaire d’exceptions améliorant la robustesse et la lisibilité des programmes ;  à ramasse-miette : la mémoire est gérée automatiquement par le langage ;  sécurisé: de nombreux garde-fous (encapsulation, exceptions, gestionnaire de sécurité,…) contribuent à la robustesse des programmes, tant à la compilation qu’à l’exécution ;  multithread : uploads/Ingenierie_Lourd/ courscasa-2-gsi2-v2.pdf