[Java][BlueJ] Manipulation graphique des Classes et des Objets sous BlueJ

BlueJ est un excellent outil pour apprendre à programmer en Java. Nous avons déjà cité une excellente fonctionnalité qui permet d'exécuter un code Java sans se méfier de la fonction main et de la classe qui la contient.
Dans cet bref article, nous allons présenter quelques manipulations possibles grâce à l'éditeur graphique de BlueJ.
L'éditeur graphique de BlueJ permet de visualiser les différentes classes du projet en cours ainsi que les liens et les dépendances qui les relient. Il permet un affichage proche de celui de UML (il est possible d'installer une extension qui rend le diagramme confirme au diagramme des classes d'UML).
Les classes et les liens peuvent être créés graĉe aux outils disponibles à gauche. Ce panel contient quatre (04) commandes :

• Créer une nouvelle classe,
• Créer un lien d'héritage,
• Créer un lien d'utilisation,
• Compiler la(les) classe(s).

Prenons un exemple et créons une classe "Employe" (employé). Pour cela, il suffit de cliquer sur l'outil "New class". Une petite fenêtre s'affiche pour permettre de choisir le type de classe à créer (classe, interface, etc.) et de saisir le nom de la nouvelle classe. La classe créée est visualisée et mise en haut à droite de l'éditeur graphique.

Il est possible d'éditer le code de la classe en faisant un double-clique. Le code s'affiche dans une fenêtre séparée. Dans notre exemple, nous avons fait les modifications suivantes :

Cette même fenêtre permet d'afficher la documentation Javadoc générér pour la classe en cours. Il suffit de changer le mode d'affiche de "Source" à "Documentation" :

En deuxième étape, nous allons créer une deuxième classe appellée "Manager" et en utilisant l'éditeur graphique nous allons créer un lien d'héritage entre les deux classes "Employe" et "Manager".

En ouvrant l'éditeur du code, nous constatons que la mention "extends" est bien définie dans la déclaration de la nouvelle classe "Manager".

Il est possible de montrer le lien d'utilisation entre deux classes. Créons par exemple une nouvelle classe "Entreprise".

Pour cette entreprise, nous allons définir un attribut "m" qui est le "Manager" de cette entreprise :

En sauvegardant cette nouvelle classe et en revenant vers l'éditeur graphique, nous constatons que BlueJ a mis à jour le modèle en ajoutant le lien d'utilisation entre les deux classes "Entreprise" et "Manager".

L'éditeur graphique permet aussi quelques manipulations sur les classes créées. Ces manipulations nécessitent la compilation des classes par un clic sur la commande "Compile" à gauche de l'écran. Si une classe contient des erreurs, elle sera marquée par un point d'exclamation rouge.
Une fois les classes compilées, il est possible d'accéder aux différentes fonctionnalités par un clic-droite sur la classe concernée. Cela nous permet de :

• Invoquer les méthodes statiques,
• Invoquer les constructeurs pour créer des instances de la classe,
• Inspecter la classe : voir les différentes variables statiques et leurs valeurs.

Créons une instance de la classe "Employe". Pour cela, nous allons choisir le constructeur qui exige deux paramètres :

L'objet créé avec le nom choisi s'affiche en bas à gauche de l'écran dans la zone dédiée aux instances (objets) des classes.

Il est possible de l'inspecter :

Comme il est possible d'invoquer ses méthodes (les méthodes non statiques).
Si une méthode est invoquée et qu'elle retourne une valeur, elle est affichée dans une fenêtre séparée. A titre d'exemple, nous allons invoquer la méthode tatique "description" de la classe "Employe" :

BlueJ offre plusieurs autres fonctionnalités. La plus essentielle est la possibilité d'installer (et de développer) des extensions. Plusieurs extensions très performantes sont déjà disponibles, jetez un coup d'oeil par ici.
BlueJ se montre comme une solution très efficace (particulièrement pour les enseignants) pour l'apprentissage de la programmation en Java et pour l'apprentissage de la programmation Orientée Objet.

[Java] [BlueJ] Commencer avec Java sans passer par les Classes

Apprendre un premier langage de programmation n'est pas (toujours) une tâche facile. Il est important de saisir :

• Les notions de la programmation comme les variables, les constantes et les structures de contrôle.
• Les notions liées au langage utilisé. En effet, il est rare de trouver un langage qui respecte à la lettre les propositions théoriques sans avoir des caractéristiques particulières.

Dans ce sens, l'apprentissage de Java est lié, dans la majorité des universités (au moins Algériennes) à l'apprentissage de la programmation Orientée Objet. Les étudiants doivent assimiler des notions liées à la programmation Orientée Objet comme "la classe", "l'objet" et "l'instantiation", comme ils doivent saisir les notions liées au langage Java comme la fameuse fonction :

public static void main(String args[]){
}

Cette fonction qui doit faire part d'une classe.
Ainsi, il sera difficile, suivant cette approche, de séparer les notions de la programmation Orientée Objet des notions propres au langage Java.
La pratique suivie aujourd'hui est de demander aux étudiants de commencer par un exemple (le fameux "Hello World") sans chercher à comprendre les différents mots-clés utilisés, alors, l'étudiant va réussir à écrire un programme et de l'exécuter sans vraiment comprendre :

• public : et les principes d'encapsulation,
• static : et la différence entre des méthodes propres à la classe et des méthodes propres aux objets, et pour comprendre cette différence, il faut comprendre la notion d'instanciation et du mot-clé "new".
• String agrs[] : "pourquoi ce tableau est en paramètre? Quel est son rôle?"
• System.out.println : "pourquoi tous ces points? Est-ce un enregistrement?"

Ce problème peut être évité avec d'autres langages. En effet, si on veut créer le fameux Hello World dans le langage Pascal, il suffit d'écrire :

Program HelloWorld;
Begin
 WriteLn('Hello World');
End.

Dans ce cas, il n'est pas très difficile d'expliquer ou de justifier les quatre (04) mots-clés cités : Program, Begin, Write et End.

Une solution : BlueJ

Pendant les premiers chapitres, ce qui est demandé des étudiants est d'écrire des programmes pour manipuler les types des données, les variables et les structures de contrôle en modifiant à chaque fois le corps de la méthode main sans y toucher. La question qui se pose est : existe-t-il un outil qui permet de prendre un bout de code et de l'insérer dans une méthode main (ou autre) et de l'exécuter d'une manière transparente par rapport à l'apprenant? La réponse est, heureusement, Oui. BlueJ peut le faire.
BlueJ est un éditeur Java open source. Il permet de créer des projets Java, de les compiler et de générer la Javadoc. Il donne aussi la possibilité de faire une édition graphique des classes et de leurs dépendances en manipulant un diagramme des classes (proche de celui en UML).
Parmi les fonctionnalités offertes, nous trouvons un espace particulier appelé le Code Pad. En l'utilisant, nous pouvons exécuter des bouts de code Java sans se méfier de la création d'une classe et d'une méthode main là-dedans.

Il est ainsi possible de se concentrer sur les mots-clés et les notions de base avant de passer vers les notions plus complexes de la programmation Orientée Objet. En plus, la console est affichée dans une fenêtre séparée mais propre à l'éditeur ce qui évite de faire appel à des éditeurs plus lourds ou bien d'utiliser la ligne de commande.

Il est possible de créer, localement, des variables. Dans cet exemple, nous créons un entier nommé (x) qui prend la valeur 10 :

Chaque ligne est exécutée en la validant, malgré cela, il est possible de créer des bloques. Il suffit de ne pas valider la ligne par la touche "Entrée" et de faire un retour à la ligne par la combinaison "Shift+Entrée".

Il est possible de manipuler des objets de l'API standard. Pour cela, il faut mettre la déclaration complète vu qu'il n'est pas possible de faire un "import".

BlueJ permet aussi une manipulation visuelle des objets. Nous présenterons ces fonctionnalités dans un autre article.

[Théorie des Organisations] Critique de l'école classique

L'école classique appliquée au début du 20ème siècle a constitué le début de la théorie des organisations qui nous a donné cette nouvelle structure économique qu'est l'entreprise. Néanmoins, cette école a connu plusieurs inconvénients.
L'inconvénient majeur était sa vision de l'employé. Pour l'école classique, l'employé (ou le salarié) est un acteur passif qui se contente d'appliquer les ordres et qui ne présente aucun esprit d'initiative. Cette vision est prouvée incorrecte, surtout avec l'arrivée  des théories X et Y de McGregor qui décrit mieux la situation réelle.
L'école classique insistait, aussi, l'existence de la One Best Way pour organiser le travail. Ainsi, les ingénieurs (concepteur de la chaîne de production) ont toujours essayé d'atteindre cette meilleure organisation qui permet d'obtenir une productivité maximale. D'un côté, l'application d'une approche scientifique pure a poussé les ingénieurs à voir les employés comme des machines; cela était nécessaire pour pouvoir estimer le temps d'exécution des tâches, le temps de production et le taux de consommation de la matière première. De l'autre côté, la nature humaine des employés peut se manifester pendant les différentes interactions entre les employés et peut même avoir un effet négatif si elle est source des conflits; cette dimension était complètement absente de l'analyse scientifique faite pour atteindre la méthode idéale d'organisation. Pour ces raisons, l'école classique était largement critiquée par la deuxième génération des employés.
Dans son film "Modern Times" réalisé en 1936, Charlie Chaplin a dédié une scène complète (Factory Work) pour critique cette vision qui enlève toute dimension humaine des employés.
Dans cette scène très courte (d'environ 4 minutes), Charlie a pu mettre la main quelques inconvénients de l'école classique :

• L'employé est supposé avoir une performance constante; exactement comme une machine.
• La structure de commandement est stricte avec les employés et suppose que l'employé essaie d'éviter le travail; l'employé n'était pas écouté par ses supérieurs.
• La modification des conditions et de la configuration des chaînes de production se fait suite à des calcul et par des valeurs précise mais sans discussion avec les employés; les ingénieurs possédaient le pouvoir absolu dans la gestion des chaînes de production.
• Des fois, les employés eux-mêmes confirment la théorie X ce qui provoque des conflits. Vu que le travail à réaliser est défini d'une manière précise, si un employé ne fait pas sa part, ses collègues se trouvaient obligés de la faire à sa place.

Malgré ces inconvénients, l'école classique reste l'école fondatrice de ce domaine qui a évolué pour nous donner des structures modernes, flexibles et avec des conditions respectables comme environnements de travail.

Listes linéaires chaînées en Java

Les listes linéaires chaînées sont une structure des données essentielles. Tout développeur doit les comprendre et apprendre à les utiliser. Il est, ainsi, nécessaire de penser à écrire un code pour faciliter la tâche aux débutants. Néanmoins, un problème essentiel s'affiche : les listes linéaires chaînées sont une structure des données, tout comme les tableaux, que nous utilisons pour réaliser une tâche. Elles sont considérées comme un outil, non pas une finalité. Ecrire un code pour aider les débutants semble sans intérêt si on ne connaît pas le problème exact sur lequel ils travaillent.
Malgré cela, j'ai décidé d'écrire un petit code en Java pour implémenter une liste linéaire chaînée très basique et ensuite l'utiliser pour implémenter une file d'attente et une pile en se basant entièrement sur la définition de la liste linéaire chaînée.
Sans un exemple d'application réel, l'exemple reste très limité alors j'ai préféré de faire une liste linéaire chaînée d'entiers; j'ai laissé l'utilisation de la programmation générique pour d'autres exemples.
La liste linéaire chaînée est comme une chaîne de maillons. Chaque noeud est attaché au noeud suivant et il suffit de connaitre le premier noeud (appelé souvent "la tête") pour connaitre (et avoir accès) à tous les autres noeuds, mais, il suffit de le perdre pour perdre une partie de (ou bien toute) la liste chaînée.
Un noeud se compose de deux parties :

1. Une valeur : ou bien les données à sauvegarder, cette partie peut contenir une variable d'un type simple comme elle peut contenir un enregistrement de plusieurs champs.
2. Un pointeur vers l'élément suivant : ce pointeur (ou référence) représente le chaînage qui existe entre les neouds et garantit la navigation et le parcours de la liste.

Pour déclarer une liste linéaire chainée, il suffit de déclarer sa tête, c'est à dire, un noeud. Par la suite, il faut faire attention pour ne pas le modifier ou bien le perdre.

En Java, les choses sont plus simples pour plusieurs raisons (qui découlent essentiellement de la POO) :

1. Java n'utilise pas une manipulation directe et libre des pointeurs parce que chaque référence à un objet est en réalité un pointeur.
2. La composition des objets est très simple, ainsi, la partie "données" du noeud peut être un objet avec toutes les possibilités qu'une telle déclaration apporte.
3. Java représente un mécanisme très puissant pour la gestion des exceptions. Cela peut être vu comme une solution aux problèmes liés aux valeurs inconnues qui peuvent surgir lors de la manipulation des listes linéaires chaînées. Par exemple, quelle valeur à retourner si on est en train de récupérer la 5ème valeur d'une liste de trois valeurs seulement. Toute valeur retournée est en réalité erronée. Il est possible d'envisager des solutions si, par exemple, la liste ne contient que des valeurs positives et dire que je vais retourner la valeur -1. Ce type de solution ne peut pas être utilisé dans les cas généraux et l'utilisation des exceptions restent de loin une meilleure solution.

Dans cet exemple, la liste linéaire chaînée créée est exploitée pour implémenter une file d'attente et une pile.
La file d'attente est une structure des données qui permet de stocker des données et de les récupérer dans le même ordre de leur insertion. Elle respecte le principe du FIFO (First In, First Out). Comme les listes, les files d'attente sont des structures de données qui facilitent la résolution de quelques problèmes algorithmiques; elles sont vues comme un moyen et non pas une finalité.
La pile est une structure de données qui permet de stocker des données et de les récupérer dans l'ordre inverse de leur arrivée. Elle respecte le principe LIFO (Last In, First Out). Elle est, aussi, considérée comme un moyen et non pas une finalité.

Dans cet exemple, les files d'attente et les piles sont dotées d'une taille limite. Les listes permettent de stocker un nombre (théoriquement) illimité des données; il sera, des fois, nécessaire de mettre une limite pour ce nombre des données que la liste peut sauvegarder. Dans cet exemple, la taille limite peut prendre deux types de valeur :

• La valeur nulle (le zéro, 0) : qui signifie que le nombre d'éléments de la liste est illimité.
• Une valeur positive : qui sera égale au nombre maximal des éléments que la liste peut contenir.

Pourquoi une taille limite dans cet exemple ? Sans raison particulière. Comme j'ai déjà mentionné, il est difficile de mettre toutes les possibilités offertes par les listes, les files et les piles; il y en a des milliers, alors j'ai choisi l'une des plus simples pour l'implémenter.
Téléchargez le projet par ici.