Remerciez-le!

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

Prof : R.ZRIOUILE Page 1 2éme année DSI POO-Java- SOMMAIRE Chapitre 1 : Program

Prof : R.ZRIOUILE Page 1 2éme année DSI POO-Java- SOMMAIRE Chapitre 1 : Programmation Orientée Objets ............................................................................ 6 1. De la programmation classique vers la programmation orientée objet ............................................. 6 2. Concepts de la Programmation Orientée Objets ............................................................................. 6 2.1 Objet .............................................................................................................................................. 7 2.2 Classe ............................................................................................................................................ 7 2.3 Encapsulation ................................................................................................................................. 7 2.4 Héritage ......................................................................................................................................... 7 2.5 Polymorphisme .............................................................................................................................. 8 3. Comment penser POO .................................................................................................................... 8 Chapitre 2 : Vue d’ensemble de la plate-forme Java .............................................................. 9 1. Introduction ..................................................................................................................................... 9 2. Caractéristiques ................................................................................................................................ 9 3. La plateforme Java ........................................................................................................................... 9 4. Java : de l’édition à l’exécution ....................................................................................................... 10 5. Le Java SE Development Kit ......................................................................................................... 10 6. Java : les éditions ............................................................................................................................ 10 7. Génération de code exécutable dans les langages de programmation ........................................... 10 8. Génération de code en java ............................................................................................................ 11 9. Différents modes de compilation ................................................................................................... 11 10. Avantages de la JVM pour Internet ............................................................................................ 11 11. Exemple: Mon premier programme en Java .............................................................................. 12 12. Exécution d’un programme Java ................................................................................................ 13 Chapitre 3 : Structures de contrôle ............................................................................................ 14 1. Variables ........................................................................................................................................ 14 1.1. Déclaration des variables ........................................................................................................ 14 1.2. Initialisation des variables ....................................................................................................... 14 2. Style de programmation non standard ........................................................................................... 15 3. L’affectation ................................................................................................................................... 15 4. Types de données en Java .............................................................................................................. 15 4.1. Types primitifs ....................................................................................................................... 15 4.2. Type objet: Constante null ..................................................................................................... 17 5. Transtypage .................................................................................................................................... 17 6. Principaux opérateurs .................................................................................................................... 18 6.1. Opérateurs arithmétiques ....................................................................................................... 18 6.2. Opérateurs d’affectation ......................................................................................................... 18 6.3. Opérateurs d’incrémentations et décrémentations ................................................................ 18 Prof : R.ZRIOUILE Page 2 2éme année DSI POO-Java- 6.4. Opérateurs relationnels .......................................................................................................... 18 6.5. Opérateurs logiques ............................................................................................................... 19 6.6. Opérateurs bit à bit ................................................................................................................ 19 7. Instructions de contrôle ................................................................................................................. 19 Chapitre 4 : les Classes et les Objets ........................................................................................ 21 1. Création d’une classe ..................................................................................................................... 21 2. Création et manipulation d’Objets ................................................................................................. 22 2.1. Introduction ........................................................................................................................... 22 2.2. Etapes de création des Objets ................................................................................................ 22 2.3. Création d’un objet ................................................................................................................ 23 2.4. Initialisation par défaut ........................................................................................................... 24 3. Définition des méthodes ................................................................................................................ 24 4. Accès aux membres d’un objet ...................................................................................................... 25 4.1. Accès aux attributs (données membres) ................................................................................. 25 4.2. Accès aux méthodes: appels des méthodes ............................................................................ 26 5. Encapsulation (accessibilité) ........................................................................................................... 27 6. Méthodes d’accès aux valeurs des variables depuis l’extérieur ....................................................... 29 7. Autoréférences: emploi de this ...................................................................................................... 31 8. Champs de classe (variable de classe)............................................................................................. 32 9. Les constructeurs ........................................................................................................................... 32 9.1. Définition de Constructeur .................................................................................................... 32 9.2. Quelques règles concernant les constructeurs ........................................................................ 33 9.3. Surcharge des constructeurs (Plusieurs constructeurs) ........................................................... 34 9.4. Utilisation du mot clé this dans un constructeur .................................................................... 35 Chapitre 5: les tableaux ................................................................................................................. 36 1. Tableaux unidimensionnels ........................................................................................................... 36 1.1. Déclaration de tableaux.......................................................................................................... 36 1.2. Création par l’opérateur new.................................................................................................. 36 1.3. Initialisation............................................................................................................................ 36 1.4. La taille d’un tableau : length ................................................................................................. 36 1.5. Utilisation d’un tableau .......................................................................................................... 37 1.6. Affectation de tableaux ........................................................................................................... 37 2. Tableaux multidimensionnels ........................................................................................................ 38 Chapitre 6 : Héritage et polymorphisme ................................................................................... 40 1. Principe de l'héritage ...................................................................................................................... 40 1.1. Présentation ........................................................................................................................... 40 Prof : R.ZRIOUILE Page 3 2éme année DSI POO-Java- 1.2. Appel des constructeurs ......................................................................................................... 41 1.3. Accès d’une classe dérivée aux membres de sa classe de base ............................................... 41 1.4. Redéfinition ........................................................................................................................... 42 2. Polymorphisme .............................................................................................................................. 42 2.1. Surclassement (upcasting) et Déclassement (downcasting) ..................................................... 44 2.2. Régles du polymorphisme en Java ......................................................................................... 44 3. La classe Object ............................................................................................................................. 44 4. Les classes abstraites ...................................................................................................................... 46 4.1. Concept des classes abstraites ................................................................................................ 46 4.2. . Règles des classes abstraites .................................................................................................. 47 4.3. Intérêt des classes abstraites ................................................................................................... 47 5. Les interfaces ................................................................................................................................. 48 5.1. Concept d’interface ................................................................................................................ 48 5.2. Syntaxe ................................................................................................................................... 48 5.3. Interface et dérivations ........................................................................................................... 49 5.4. Conflits des noms ................................................................................................................... 50 Chapitre 7 : Gestion d’exception ................................................................................................. 51 1. Présentation ................................................................................................................................... 51 2. Classement des exceptions ............................................................................................................. 51 3. Structure de gestion d’exceptions : le bloc try… catch… finally ....................................................... 52 4. Définition et lancement des exceptions utilisateurs(throws et throw) ............................................. 53 5. Gestion de plusieurs exceptions et transmission d’information ...................................................... 55 Chapitre 8 : Interfaces Comparables et Cloneables/Classes enveloppes56 ................. 56 1. Interfaces Comparables ................................................................................................................. 56 2. Interfaces Cloneables ..................................................................................................................... 56 3. Classes enveloppes ......................................................................................................................... 59 Chapitre 9 : Flux d’entrées sorties.............................................................................................. 61 1. Présentation ................................................................................................................................... 61 2. Création séquentielle d’un fichier binaire ...................................................................................... 63 3. Liste séquentielle d’un fichier binaire ............................................................................................. 64 4. Accès directe à un fichier binaire ................................................................................................... 66 5. Création d’un fichier texte .............................................................................................................. 67 6. Lecture d’un fichier texte ............................................................................................................... 68 6.1. Accès aux lignes d’un fichier texte .......................................................................................... 68 6.2. La classe StringTokenizer ...................................................................................................... 69 7. La gestion des fichiers: la Classe File .............................................................................................. 70 Prof : R.ZRIOUILE Page 4 2éme année DSI POO-Java- 7.1. Création d’un objet de type File ............................................................................................. 70 7.2. les méthodes de la classe File ................................................................................................. 70 8. sérialisation et désérialisation ......................................................................................................... 72 8.1. Interface Serializable .............................................................................................................. 72 8.2. Etapes de sérialisation: Ecrire un objet sérialisé dans un fichier ............................................. 73 8.3. Etapes désérialisation ............................................................................................................. 73 Chapitre 10 : Collections ............................................................................................................... 75 1. Définition ....................................................................................................................................... 75 2. Interfaces ....................................................................................................................................... 75 3. Description des interfaces .............................................................................................................. 75 3.1. Interface Collection ................................................................................................................ 75 3.2. List ......................................................................................................................................... 76 3.3. Interface Set ........................................................................................................................... 80 3.4. Map........................................................................................................................................ 81 3.5. Description des algorithmes ................................................................................................... 82 Chapitre 11 : Threads ..................................................................................................................... 85 1. Notion de threads .......................................................................................................................... 85 2. Thread et interface runnable .......................................................................................................... 85 3. Durée de vie d’un thread ............................................................................................................... 87 4. Sommeil d'un thread ...................................................................................................................... 88 5. La classe Timer .............................................................................................................................. 88 6. Synchronisation .............................................................................................................................. 89 Chapitre 12 : Interfaces graphiques .......................................................................................... 91 1. Présentation ................................................................................................................................... 91 2. Première fenêtre ............................................................................................................................ 91 2.1. La classe JFrame .................................................................................................................... 91 2.2. Action sur les caractéristiques d’une fenêtre .......................................................................... 92 3. Composants atomiques .................................................................................................................. 92 3.1. Création d’un bouton et ajout dans la fenêtre ........................................................................ 92 3.2. Création d’une case à cocher et ajout dans la fenêtre ............................................................. 92 3.3. Création de Bouton Radio ..................................................................................................... 93 3.4. Création des étiquettes ........................................................................................................... 94 3.5. Création des champs de texte ................................................................................................ 94 3.6. Création des boites de liste..................................................................................................... 94 3.7. Création des boites de liste combinée .................................................................................... 96 4. Gestionnaires de mise en forme..................................................................................................... 96 Prof : R.ZRIOUILE Page 5 2éme année DSI POO-Java- 4.1. BorderLayout......................................................................................................................... 97 4.2. FlowLayout ............................................................................................................................ 97 4.3. CardLayout ............................................................................................................................ 98 4.4. GridLayout............................................................................................................................. 99 4.5. BoxLayout ............................................................................................................................. 99 4.6. Programme sans gestionnaire de mise en forme ............................................................... 100 4.7. Une classe Insets pour gérer les marges ............................................................................... 100 5. JTextArea..................................................................................................................................... 101 6. JTable .......................................................................................................................................... 101 6.1. Tables simples ..................................................................................................................... 102 6.2. Modèles de table .................................................................................................................. 102 Prof : R.ZRIOUILE Page 6 2éme année DSI POO-Java- Chapitre 1 : Programmation Orientée Objets 1. De la programmation classique vers la programmation orientée objet La programmation classique telle que étudiée au travers des langages C, Pascal... définie un programme comme étant un ensemble de données sur lesquelles agissent des procédures et des fonctions. Les données constituent la partie passive du programme. Les procédures et les fonctions constituent la partie active. Programmer dans ce cas revenait à : - définir un certain nombre de variables (structures, tableaux...) - écrire des procédures pour les manipuler sans associer explicitement les unes aux autres. Exécuter un programme se réduit alors à appeler ces procédures dans un ordre décrit par le séquençage des instructions et en leur fournissant les données nécessaires à l’accomplissement de leurs tâches. Problèmes de la programmation procédurale :  Instructions exécutées à la suite  Il n’y a pas de méthode ou de cadre pour bien organiser les fonctions.  Un seul résultat possible  Allocation mémoire définie  Inutilisable pour un logiciel  Les modifications d’une fonction entraînent d’autres modifications dans autre fonctions, etc. – la portée d’une modification est trop grande et difficile à gérer.  Redondance dans le code (la même chose est codée plusieurs fois)  Propagation des erreurs – débogage difficile Dans cette approche données et procédures sont traitées indépendamment les unes des autres sans tenir compte des relations étroites qui les unissent. Les questions qu’on peut poser dans ce cas : 1. Cette séparation (données, procédures) est-elle utile ? 2. Pourquoi privilégier les procédures sur les données (Que veut-on faire ?) ? 3. Pourquoi ne pas considérer que les programmes sont avant tout des ensembles objets informatiques caractérisé par les opérations qu’ils connaissent ? Les langages objets sont nés pour répondre à ces questions. Ils sont fondés sur la connaissance d’une seule catégorie d’entités informatiques : les objets. Un objet incorpore des aspects statiques et dynamiques au sein d’une même notion. Avec les objets ce sont les données qui deviennent prépondérantes. On répond tout d’abord à la question « De quoi parle-t-on ? » 2. Concepts de la Programmation Orientée Objets La POO se base sur les notions clés suivantes : - Encapsulation - Abstraction - Classe et objets Prof : R.ZRIOUILE Page 7 2éme année DSI POO-Java- - Héritage - Polymorphisme 2.1 Objet Un objet est une structure informatique caractérisée par un état et un ensemble d'opérations exécutables par cet objet qui caractérise son comportement. Objet = état + comportement (opérations) Exemple: Une Fenêtre : Etat : position, taille, bordure, titre, couleur,... uploads/s3/ java-zriouile.pdf