Programme effectif

Vous n'avez pas de notes de cours, je mets donc à jour ce plan qui résume les sujets réellement abordés en cours (par opposition à ceux planifiés). Ceci ne constitue en aucun cas des notes de cours.

Pour chaque rubrique, j'indique entre parenthèse un pointeur sur l'ouvrage de Deitel&Deitel (Java how to program). Vous remarquerez que mes exemples ne sont pas ceux de cet ouvrage (vous avez ainsi plusieurs jeux d'exemples à votre disposition), il ne m'est donc pas toujours possible de vous indiquer exactement la ou les pages associées.

Notez que j'indique également le plan que je compte suivre lors du cours à venir.

Cours 2 - jeudi 20 janvier - (Exemples)

  1. Une première application (Chapitre 2, pages 36-43)
    1. commentaires en début de module (auteur, objet, etc)
    2. convention sur les noms de classes (commence tjs par une majuscule)
    3. la méthode main: première méthode appelée dans une application
    4. introduction de mots clé divers
    5. compilation / exécution
  2. Une première applet (Chapitre 3, pages 85-43 -- Chapitre 6, pages 246-247)
    1. mot clé import, idée d'une organisation des packages
    2. la classe Applet
    3. cycle de vie d'une applet (méthodes init, start , paint puis stop et destroy)
    4. méthode drawString de la classe Graphics
    5. fichier html hôte, tags applet (applet, code, width, height)
    6. compilation / exécution
  3. Passage de paramètres à une application (Chapitre 13, page 649)
    1. la table de String args
    2. méthode parseInt de la classe Integer
    3. concaténation de String
  4. Passage de paramètres à une applet (Chapitre 16, page 796)
    1. les tag param name et value du fichier HTML hôte
    2. méthode getParameter héritée de la classe Applet
  5. Les 8 types prinitifs (ou types de base) (Chapitre 4, page 144)
    1. représentation mémoire de taille fixe -> vers la portabilité
    2. le type char pour gérer l'unicode (sur 2 octets)
    3. le type boolean (non numérique)
    4. mécanisme de coercion: pour la promotion de types, contre les transformations dégradantes
  6. Les opérateurs arithmétiques (Chapitre 4, page 144)
    1. les classiques + - * / % (reste de la divison entière)
    2. attention: l'opérateur binaire / retourne un résukltat entier si ces deux arguments sont entiers, flottant sinon
    3. opérateurs d'affectation += *= /= -= %=
    4. il existe des opérateurs dans la classe Math (du package java.lang) ex: double Math.pow(double a, double b)
    5. faire attention aux priorités et à l'associativité des opérateurs s'il y en a plusieurs dans la même expression

Cours 3 - jeudi 27 janvier - (Exemples) (Chapitres 4,5 et 6)

  1. Survol de la classe String (ammorcé au cours 2)
    1. String est une classe=> String s; // s est une référence sur un objet de la classe String
    2. initialisation: s = "bonjour";
    3. concaténation avec l'opérateur + (attention à "4+3="+4+3 qui produit "4+3=43")
    4. méthode length() : connaître la longueur d'un objet String
    5. méthode charAt(int n)
    6. méthode equals et compareTo
  2. Oubli: les opérateurs ++ et --
    1. deux formes : post- et pré- fixée
    2. mise en garde pour des expressions comme if (t[i++] == s[i])
  3. Les expressions booléennes
    1. une définition rapide: expression à valeur dans {true, false}
    2. opérateurs relationnels: == (égalité) != (différence) < > >= >= (comparaisons)
    3. opérateurs booléens: && (AND) || (OR) ! (NOT)
    4. évaluation courte des expressions booléennes
  4. Les structures de contrôle
    1. if (condition) bloc-inst
    2. if (condition) bloc-inst else bloc-inst
    3. mise en garde sur les effets trompeurs de l'indentation dans les tests imbriqués
    4. opérateur conditionnel: ?:
    5. while (condition) bloc-inst
    6. do bloc-inst while (condition)
    7. for (pre-cond; condition; post-cond) bloc-inst
    8. switch / case structure
    9. break et continue (différence entre for et while)
  5. Les méthodes
    1. définies à l'intérieur de classes (pas de fcts globales)
    2. syntaxe d'une méthode (type de retour obligatoire, mot clé void)
    3. conventions sur les noms de fonction (ex: maFonction)
    4. paramètres formels vs paramètres d'appel (ou actuels)
    5. pas de choix en Java quant au mode de passage des paramètres (valeur ou référence)
    6. durée de vie et portée des variables locales
    7. durée de vie et portée des variables de classe
    8. les variables de classe sont initialisées à contrario des variables locales

Cours 4 - jeudi 3 février - (Exemples) (Chapitres 6 et 7)

  1. Les méthodes (suite et fin)
    1. surdéfinition de fonctions
  2. Les tableaux à une dimension (Chapitre 7 pages 269-288)
    1. un tableau est un objet
    2. déclaration et allocation d'un tableau: opérateur d'allocation new
    3. notion de référence et d'objet
    4. les éléments d'un tableau sont par défaut initialisés lors de l'allocation (0, null, false)
    5. un tableau connaît le nombre d'éléments qu'il contient
    6. initialisation d'un tableau (new implicite)
    7. passage d'un tableau (comme tout objet) par référence- justification
    8. un programme de tri simple: le tri à bulle
  3. Les tableaux à plusieurs dimensions (Chapitre 7 pages 294-300)
    1. un élément d'un tableau peut être un tableau
    2. cas particulier: matrices
  4. La récursivité (prise I) (Chapitre 6, pages 234-244 + exos )
    1. calcul du factoriel d'un entier
    2. comment trouver des solutions à des problèmes pour lesquels vous n'avez pas de solution...

Cours 5 - jeudi 10 février - (Exemples) (Chapitre 8)

  1. une classe hérite toujours d'une classe mère (par defaut la classe Objet)
  2. les variables membres
    1. en général private
    2. initialisées par défaut (0, null, false) mais mieux vaut ne pas en tenir compte
    3. peuvent être masquées par une variable locale (acces par this dans ce cas)
  3. les méthodes membres
    1. méthodes "assesseur" (les méthodes get)
      1. pour accéder aux membres privés
      2. pas nécessaire (rarement en fait) de doter chaque variable privée d'un assesseur
    2. méthodes "modificateur" (le méthodes set)
      1. modifient l'état (les variables membres) d'un objet
      2. vérifient la cohérence de ou des variables affectées
    3. les constructeurs
      1. méthode portant le même nom que la classe
      2. qui ne retourne rien, qui peut être surdéfinie
      3. est appelée uniquement par l'opérateur new lorsque l'objet est crée
      4. sert à mettre un objet dans un état stable (initialisation des variables membres)
      5. un constructeur peut être privé, généralement public
    4. les méthodes de service (généralement privées)
    5. la méthode toString
      1. héritée par défaut de Objet
      2. devrait être systématiquement spécifiée pour chaque classe avec les infos pertinentes
      3. appelée implicitement lorsqu'une String est attendue
    6. finalize: le destructeur
      1. hérité par défaut de Objet
      2. sert à rendre des ressources au système (fichiers, players)
      3. appelée automatiquement lors de la destruction de l'objet (avant)
  4. les membres static
    1. sont partagés de toutes les instances (i.e. objets) d'une classe
    2. une méthode statique ne peut accéder qu'à des variables statiques
    3. les membres statiques sont accessibles indépendament de l'existence de l'instance d'une classe
    4. accès usuel et recommandé par Classe.membre (ou classe est le nom de la classe, et membre le membre)
  5. accès au membre d'une classe
    1. impossible si le membre est privé
    2. si le membre est static, par Classe.membre bien qu'il soit possible de referencer le membre depuis un objet
    3. dans le cas habituel, par objet.membre, ou objet est objet
  6. tableaux d'objets

Cours 6 - jeudi 17 février - (Exemples) (révisions et début Chapitre 9)

  1. Une étude de cas: création d'un type abstrait (classe) gérant les comptes bancaires
  2. Premiers pas vers l'héritage
    1. relation Est un/une, classe mère (super-classe), classe fille (sous-classe)
    2. contrôl d'accès aux membres d'une classe par protected
    3. attention: les membres protected sont accessibles par les méthodes du package
    4. mot clé extends

Cours 7 - jeudi 9 mars - (Exemples) (Chapitre 9)

  1. Une sous-classe ajoute normalement des variables et/ou des méthodes (ou encore des contraintes) à une classe mère. La sous-classe est donc en ce sens plus spécifique et concerne potentiellement moins d'objets.
  2. Une sous-classe ne peut pas accéder aux membres privés de la classe mère de laquelle elle hérite. Ceci afin de préserver l'encapsulation des données.
  3. Discussion sur les modificateurs d'accès: public, private , protected et accès package.
  4. Lorsqu'un objet d'une sous-classe est créé, il y a toujours appel à un constructeur de la classe mère. Cet appel peut-être soit implicite (par l'utilisation du mot clé super) soit de manière explicite (auquel cas c'est le constructeur par défaut de la classe mère qui est appelé).
  5. L'appel explicite d'un constructeur père dans un constructeur d'une sous-classe (super) doit toujours être la première ligne du constructeur de la sous-classe.
  6. Une sous-classe hérite de toutes les variables et méthodes de la classe mère et des super classes indirectes, pour autant que les membres soient accessibles (public, privée, ou dans package).
  7. Si un membre de la classe mère n'est pas approprié à une sous-classe donnée, alors il convient de redéfinir ce membre dans la sous-classe en question. On parle alors de ré-écriture.
  8. Discussion sur la composition ("a une/un") versus l'héritage ("est une/un").
  9. Considérations générales sur l'héritage: il est moins facile de lire le code d'une sous classe car toutes les données membres ne sont pas nécessairement visibles. Il faut donc parcourir les hierarchies de classe. Les API permettent de faire cela "facilement" pour les packages standards.
  10. Un objet d'une sous-classe peut toujours être considéré comme un objet de sa classe mère. L'inverse n'est pas vrai.
  11. Ce dernier point nous permet en JAVA d'utiliser le Polymorphisme.
    1. Le polymorphisme permet de traiter de manière générique un ensemble d'objets de types différents ayant tous une même classe mère à un point donné de la hiérarchie.
    2. Comment marche le polymorphisme: ce qui se passe à la compilation, ce qui se passe à l'exécution (lien dynamique).
    3. Discussion sur l'utilité du polymorphisme versus le codage "classique" par switch.

Cours 8 - jeudi 16 mars - (Exemples) (Chapitres 9 et 12)

  1. Les méthodes abtraites (Héritage suite)
    1. Les méthodes abtraites (mot clé abstract) sont utilisées pour définir des méthodes qui devront être redéfinies dans les sous-classes qui héritent de la classe mère qui contient une méthode abstraite.
    2. Une classe qui contient au moins une méthode abstraite ne peut être instanciée (on ne peut pas créer d'objet de cette classe).
    3. On peut définir une classe comme abstraite. Seules les classes dérivées pourront en tire partie. On utilise les classes abstraites pour définir des propriétés que toutes les classes héritées vont partager.
  2. Les interfaces (Héritage suite)
    1. Sont des classes abtraites. Elles ne contiennent que des méthodes public abstract et des constantes public final abstract.
    2. Une classe donnée peut implanter une interface (mot clé implements) ce qui signifie qu'elle va définir le code de chaque méthode spécifiée dans l'interface. Nous verrons cela lors de la programmation des interfaces graphiques.
    3. Une classe peut implanter plusieurs interfaces à la fois.
  3. Classes abstraites versus interfaces : les interfaces sont généralement utilisées lorsque qu'aucun code par défaut n'est prévu dans une classe abstraite.
  4. Les interfaces graphiques (GUI, chapitre 12)
    1. Hiérarchie des classes - discussion AWT - SWING
    2. Components, Containers, Frame, Panels
    3. Une première interface avec des boutons, une zone texte
    4. Une première gestion d'événements
    5. Comment utliser des fenêtres que l'on peut fermer normalement en Java

Cours 9 - jeudi 23 mars - (Exemples) (Chapitres 12, 13)

  1. De nouveaux composants, de nouveaux Eventlistener, de nouveaux BorderLayout (Chapitre 13)
  2. Evaluation: prenez à votre tour la parole ...
  3. Quelques mots sur les inner classes (classes internes)

Cours 10 - jeudi 30 mars - (Exemples) (Chapitres 14 et 22 et 23)

  1. La gestion des exceptions (Chapitre 14)
  2. Dernière application GUI: les menus déroulants
  3. Application graphique / Applet: passage de l'une à l'autre
    1. ajouter une page d'accueil HTML (avec tag APPLET)
    2. éliminer le main dans l'application qui ne sert normalement que pour créer un objet hérité de Frame. Le fureteur (ou appletviewer) réalise cette opération.
    3. retirer les appels à setSize() ou setLocation(). Utiliser les tags WIDTh et HEIGHT à la place dans le fichier HTML
    4. Enlever les setTitle(), les Applets n'ont pas de titre
    5. Changer éventuellement le Layout : les Frames ont un BorderLayout par défaut, les Applets un FlowLayout.
    6. c'est tout ! Il n'y a pas d'autre différence (du point de vue programmatique) entre une applet et une application. En pratique les contrôles sur les Applets sont plus stricts, interdisant généralement l'accès aux fichiers, etc...
  4. La classe Vector par l'exemple (Chapitre 23)

Cours 11 - jeudi 5 avril - (Exemples) (Chapitres 22, 23 et 24 (un peu))

  • La classe LinkedList (Chapitre 22)
  • La classe Hashtable (Chapitre 23)
  • Amusons-nous avec les Collections (Chapitre 24)

    Examen final le jeudi 20 avril - Salle B-2285 du Pavillon 3200 Jean-Brillant -- 18h30 à 21h30

    Merci à tous ceux qui ont suivi ce cours. Bonne chance.