Java pour les nuls, ou Tecka va tout planter Options

A la limite Tecka ça m'intéresse de m'entraîner à faire de la formation.
Je peux essayer de concocter un tutorial en plusieurs étapes (1 par semaine par exemple) pour développer une petite application de gestion de stock en partant de zéro connaissance en Java. Ça t'interesserait?
Y'en aurait au moins pour une vingtaine de leçons je pense.

Je suis partant ça commence quand?
J'avoue être pour l'instant un peu perdu sur Eclipse entre
les différents onglets sur la droite car je démarre toujours
en JRE et pas SDK toute aide est la bien venu

Si je trouve le temps ça pourrait m'intéresser aussi

Moi aussi, la dernière fois que j'ai fait du java, c'était tout en ligne de commande

Vendu alors, j'essaie de réfléchir à une première leçon cette semaine

Cool, merci

Y'a de la place pour la session JPLNBA* ?







* : Java Pour Les Nuls By Atarxerxes

Ce message a été modifié par CantKillemAll - 10 Mar 2008, 17:33.

Atar, j'ai les transparents et exercices de mon premier semestre. Tu veux que je te/leur montre ça ? (Si tu complètes un peu, ça peut le faire )

Trop tard (mais bon tu peux les mettre, ça peut compléter). N'hésitez pas à souligner si un truc est pas clair, j'ai du mal à définir la barrière "ceci est évident"/"ceci demande certaines connaissances préalables".


Leçon 0 : le langage Java

Un langage de programmation est un langage dans lequel s'exprime le développeur pour donner des ordres à la machine, afin d'automatiser certaines tâches.
A l'origine (moderne, donc Unix) de la programmation était le C.

C pas compliqué
Le C est un langage à programmation impérative classique. La motivation à la base de la création du C est d'avoir une manière facile, puissante et efficace de donner des ordres à la machine. Le C est la base de Unix.
Il se caractérise principalement par les particularités suivantes.
Le développeur écrit des fichiers en texte clair (de l'anglais simplifié et un peu bizarre). On appelle ceux-là les fichiers sources.
La machine ne comprend pas directement ce qu'écrit le développeur dans ces fichiers (sinon on lui donnerait des ordres directement à la voix). Il faut d'abord les transformer dans le seul langage que comprend un ordinateur : le code assembleur (ce sont directement une suite d'appels à des instructions du processeur). Le traducteur, qui s'occupe de produire ce code assembleur à partir des fichiers sources est un compilateur.
Pour le C, un fichier source a pour extension ".c" et un fichier source compilé ".o" (en général).
Rappel : une fonction, en mathématique comme en programmation est une boîte noire qui prend un certain nombre de paramètres pour produire un retour à parti de ceux-ci. Par exemple, on peut définir que une fonction "somme" qui prend deux paramètres a et b, et dont le retour est a+b.
Le C n'est qu'une suite d'appels de fonctions : il existe une fonction spéciale (main(...)) dont le nom, les paramètres et le retour sont toujours les mêmes, par convention. Cette fonction sera toujours le point d'entrée d'une application en C : chaque fois qu'on demande l'exécution d'un code compilé C, c'est sa méthode main(...) qui est appelée.
Donc un programme C se décompose comme cela :
- on demande l'exécution du code compilé
- cela appelle la fonction main(...) du code compilé
- les différentes instructions à l'intérieur de la méthode main(...) sont exécutées
- la méthode main(...) renvoie sa valeur de retour, qui constitue le code retour du code compilé (on peut par exemple trouver ce code retour écrit dans la console lorsqu'une application plante).
Le but d'un programme est d'effectuer un traitement d'informations de manière automatique (c'est de là que vient le terme français "informatique"). Or les informations ne sont pas abstraites, elles se traduisent en types simples (entier, chaînes de caractères) ou plus compliqués (un ensemble de types simples).
En C, par défaut on ne trouve que des types simples (int pour un entier, char pour un caractère) et une manière de définir des types compliqués à partir de ces types simples.
A ce propos, que sont les instructions? En fait il s'agit de tout ordre complet, donc presque tout en C. Les instructions sont séparées par un ";" en général
(sauf quelques unes qui ne nécessitent pas de séparateur).
"int a;" est une instruction qui définit une variable de type entier (une variable est une boîte où stocker une valeur)
"a = 4;" est une instruction qui affecte la valeur 4 à la variable a de type entier.
De la même manière l'appel à une fonction est une instruction :
"int c; c = somme(3,5);" en définissant la fonction somme(...) comme expliqué ci-dessus. On peut aussi écrire "c = somme(a,5);" en réutilisant la valeur qui est stockée en a (4) pour produire la somme de 4 et de 5 et la stocker dans la variable c.
On peut séparer ses fichiers sources en plusieurs fichiers ".c", puis ensuite appeler des méthodes d'un autre fichier, une fois qu'on l'a importé (c'est-à-dire qu'on a dit au début du fichier qu'on allait l'utiliser).
Bien sûr on peut donc utiliser des types plus compliqués en c, par exemple on peut définir un type "point" comme étant un float (nombre à virgule) pour l'abscisse et un float pour l'ordonnée. Pour cela on utilise le mot-clef "struct" :
struct point {
float abscisse;
float ordonnee;
}
On peut même aller plus loin en créant un type compliqué qui utilise d'autres types compliqués. Par exemle, un cercle peut être défini comme un point et un float pour le rayon.

Les limites du C
Les problèmes du C sont les suivants :
- très peu de conventions : les conventions ne sont pas des contraintes en programmation, mais des garde-fous qui permettent au développeur d'être plus direct en le guidant plus efficacement. Il est évident qu'il est plus facile d'utiliser le code c d'un autre développeur si son code se rapproche du nôtre
- il n'est pas évident de créer une documentation claire et formattée
- dans le même esprit de collaboration entre développeurs, lorsqu'on veut utiliser un type compliqué C développé par un autre, il faut déjà récupérer la définition du type, puis les fonctions qui les utilisent (souvent dans un autre fichier). Et le pire est que la moindre adaptation est impossible : si un développeur a défini le type "rectangle" et a créé les fonctions de calcul basique associés (périmètre, surface,...), si on créé le type "carré" on aimerait bien pouvoir réutiliser les fonctions de calcul des rectangles mais on ne peut pas : le compilateur C nous dira que le carré n'est pas un rectangle du point de vue des types C
- problème plus technique : la gestion des réservations mémoires (car il faut bien stocker les informations quelque part dans l'ordinateur pendant l'exécution du code) est lourde et contraignante, surtout à une époque où la mémoire coule à flot dans nos ordinateurs. En plus dès qu'on se trompe, ou si on oublie de réserver la place ou assez de place, l'application se plante avec un message d'erreur incompréhensible. En effet le c ne fournit pas de vrai moyen de gérer les erreurs pendant l'exécution du code
Le langage Java est une réponse à ces défauts.

Les caractéristiques de base du Java
Java est un langage objet. Un objet est à comprendre au sens de composant, comme des pièces de Lego : il est facile d'utiliser ensemble les composants, et il est facile de s'approprier un composant défini par quelqu'un d'autre pour le spécialiser. Un exemple près de nous : le composant "champ de texte" Cocoa (écrit en Objective-C, un autre langage objet) est utilisé dans les applications Cocoa. Il suffit à Apple de l'enrichir d'une fonction de vérification de l'orthographe, pour qu'une simple recompilation de notre application hérite de la fonctionnalité.
Le maître mot ici est "hériter". En fait en Java tous les types compliqués seront en relation de filiation avec un autre type compliqué. Ce sont ces types compliqués qu'on appelle des objets (le code définissant ces objets étant une classe, l'équivalent du code source simple de C) (par la suite on ne distinguera plus trop une classe d'un objet, la classe étant plutôt le type, et un objet l'instanciation de la classe, c'est-à-dire une variable de type la classe).
L'ancêtre commun à tous ces objets, puisqu'il en faut bien un est la classe Object. Il n'a pas beaucoup de code associé réutilisable puisqu'il ne fait pas grand chose. Une autre classe intéressante, qui descend directement de Object, est String, qui représente une chaîne de caractères. Par exemple, on va pouvoir en Java définir l'objet MyString, une chaîne de caractère dont la première lettre serait toujours en majuscule. En indiquant que la classe MyString hérite de la classe String, on peut en particulier utiliser la méthode qui calcule la longueur d'une String sur un objet MyString. C'est donc beaucoup plus facile de réutiliser du code existant pour l'enrichir et l'adapter à nos besoins particuliers. Une classe Java, c'est donc un peu à la fois le struct C, plus les fonctions associées directement intégrées dans le même fichier, plus la possibilité de réutiliser les fonctions pour une classe fille. En Java, les fonctions s'appellent plutôt des méthodes (essentiellement par convention).
Les conventions en Java ont été définies depuis le début :
- les noms de classe commencent par une majuscule : Object
- les noms des variables, des méthodes commencent par une minuscule : Object monObjet;
-...
Un outil est directement intégré à Java pour facilement produire une documentation HTML de son code : la Javadoc. Pour moi c'est la clarté et la complétude de la Javadoc produite par Sun (qui a inventé le Java) pour les très très nombreuses classes de base du langage qui a facilité son développement : pour savoir comment marche la méthode substring de la classe String, il suffit de taper "java String substring" dans google pour tomber en une demi-seconde sur la documentation.
Enfin la gestion des erreurs à l'exécution est directement intégrée dans le système. Comment est-ce possible? En fait la compilation Java ne produit pas un code dans un langage compréhensible par l'ordinateur (il produit du byte code et pas du code assembleur), la machine a besoin d'un traducteur intermédiaire qui s'appelle la JVM (Java Virtual Machine). En fait, sous le capot, la JVM n'est qu'un petit programme, qui lit les fichiers classes compilés (les .class) comme s'il s'agissait de fichiers textes comportant des suite d'instructions qu'il a à exécuter. Et ce petit programme n'est pas bête : si les instructions qu'on lui demande d'exécuter plantent, il nous avertit en langage presque humain. Quand on oublie d'initialiser un objet, au lieu d'un "segmentation fault" à la C, il nous dit "NullPointerException" et nous indique dans quel endroit du code le problème est survenu. On dit que Java intègre la gestion des Exceptions.
Concernant la réservation mémoire, Java simplifie à moitié le problème : en C il faut allouer et libérer la mémoire à la main. En Java on a juste à allouer la mémoire (avec une syntaxe simplifiée par rapport au C), la libération de la mémoire se fait automatiquement (en fait un process de la JVM, le garbage collector (ou ramasse-miettes en français), regarde de temps en temps les objets en mémoire : ceux qui ne sont plus utilisables sont détruits). La syntaxe pour allouer de la mémoire est la suivante (par exemple pour un objet Object) : "Object objet = new Object();".
Mais me direz-vous, tout est donc objet en Java? En fait pour des raisons de performances, Sun a laissé dans le système quelques types simples à la C (ils sont appelés types primitifs en Java pour les distinguer des objets, et sont une poignée seulement). Les types primitifs s'appellent en général comme en C : int, float, char,... On les distingue, en tant que type, des objets car ils sont écrits en minuscules (alors que le type d'un objet aura sa première lettre en majuscule). Pour les types simples, comme en C, il n'est pas question de méthodes ou d'allocation mémoire : ils sont identiques en fonctionnalités et en utilisation aux mêmes types simples en C. Il est un peu compliqué quand on commence le Java à comprendre cette bivalence entre types primitifs et objets. Par exemple, on a à la fois un type primitif "int" et un objet "Integer" : le premier est un type primitif, le second un objet à part entière (qui est en fait défini en interne comme un attribut de type int et un ensemble de méthode de travail sur les Integer). Dans la classe Integer, on a des méthodes pour récupérer un int à partir d'un Integer et inversement.


Prochaine leçon : rapide présentation des différentes librairies utiles fournies avec Java et réalisation d'un premier programme Java avec Eclipse.


[edit]J'avais oublié quelques trucs à la fin

Ce message a été modifié par atarxerxes - 11 Mar 2008, 07:15.

impec, atar!
concernant eclipse, je vais jeter un oeil à mes fiches sitôt rentré. De mémoire elles contiennent quelques info intéressantes quand on débute.

edit : j'en ai déjà retrouvé 2 :
ici et là.

Ce message a été modifié par Ogur - 11 Mar 2008, 16:35.

Bon, je viens d'apprendre quelques trucs, là... Cool

Très intéressant atarxerxes, je ne connais absolument pas la java.
Je te trouve tout de même u peu dur avec le C, disons que c'est un langage qui force à réfléchir un minimum (contrairement au basic avec lequel j'ai commencé en ... 198x , gestion de la mémoire par exemple). Le C++ est assez sympa comme langage objet mais je trouve l'objective-C vraiment bien fait, quand tes élèves auront bien travailler, ils pourront y passer

Ba l'Objective-C 2.0 c'est encore plus convergent avec le Java non? Y'avait pas des modifications dans ce goût pour la gestion de la mémoire par exemple?

La force du C, c'est que ça t'oblige à comprendre ce qu'est un pointeur, et une fois que tu as pigé ça normalement, quelque soit le langage tu ne te trompes plus pour savoir si tu dois affecter de la mémoire ou pas.

Je continue à (essayer de) gérer ma mémoire à l'ancienne, je n'utilise pas le garbage collector
Et oui, il faut savoir ce qu'est un pointeur, c'est le pilier sur lequel repose l'ensemble

Et le pire est que la moindre adaptation est impossible : si un développeur a défini le type "rectangle" et a créé les fonctions de calcul basique associés (périmètre, surface,...), si on créé le type "carré" on aimerait bien pouvoir réutiliser les fonctions de calcul des rectangles mais on ne peut pas : le compilateur C nous dira que le carré n'est pas un rectangle du point de vue des types C.

Et l'héritage?

C'est pas un concept généralisé comme en java.

Ouais, en C on peut toujours ruser mais c'est un peu tordu.

D'où le C++

La suite..................

Vu que y'a le printemps du cinéma ce soir et demain soir, je sais pas si la suite n'arrivera pas avant Mercredi soir (mais elle est déjà commencée)

Pfffffffff si maintenant les profs sèchent les cours

Bon alors déjà, bonjour à tous... (je suis de retour normalement )
Je vais mettre mon petit grain...

Voila le java c'est bien...Quoique au bout de 2 ans de java intensif je crois que j'ai le cerveau formatté maintenant

Pour ceux qui veulent un tuto rapide et concis sur Eclipse, j'ai un prof qui en a un pas mauvais...j'avais trouvé à l'époque. Mais je conseille d'apprendre tout d'abord avec un éditeur de texte basique (qui a dit vim ?)...

C'est ici que ca se passe

Si y'en a qui ont des questions sur Eclipse je peux aussi y répondre, j'ai tellement galéré avec ce soft...

à plus, je repasserai vite !!!!

j'aime bien le gros jeu de mot en première page

en effet

Bon il suffit que je ne passe plus pendant un moment pour que l'on fasse des choses interessantes....
mais je ne veux pas trop ramener "ma pomme" sur ce sujet car je trouve tres bien l'auto pedagogie... surtout en groupe ....

Une remarque: pour moi, "java pour les nulls" et un bouquin nullissime (comme la serie)... Pour le prix de 28e (prohibitif pour cette (pour moi) daube) il y a bien d'autres bouquins qui permettent d'apprendre et que l'on peut conserver ensuite. Par exemple les livres de Delannoy. Les O'Reilly sont (for me) dables mais à utiliser plutot comme bouquins de references voir cependant dans cette collection: Introduction à Java.

Ce message a été modifié par appleseed - 19 Mar 2008, 20:18.

Leçon 1 : à la découvert des packages

(pour la partie concernant la création d'un projet Eclipse, se reporter aux documents de Ogur et appeler à l'aide en cas de difficultés).

Petit point de langage :
- j2se désigne le pack de classes destinés à la production d'applications en ligne de commande ou à interface graphique
- j2ee désigne le pack de classes (complémentaires à j2se) destinées plus spécialement au développement d'application Internet/Intranet (des applications qu'on utilise par un navigateur web en gros)
- les numéros de version de Sun sont bizarres, on peut distinguer essentiellement les versions suivantes :
--- 1.3.x : vieille version à qui il manque des classes de base (les expressions régulières faciles à utiliser entre autres), mais encore de temps en temps utilisée dans les applications développées il y a 5 ans ou plus et qui n'ont pas été migrées
--- 1.4.2 : la plus stable des versions, celle qu'on rencontre le plus, pas vraiment de manque au niveau des classes de base
--- 1.5 : commence à supplanter de temps en temps la 1.4.2, n'apporte pas vraiment de classes indispensables en plus mais juste des simplifications du langage (le problème étant, en développement internet que des serveurs d'applications majeurs en version d'il y a 2 ou 3 ans ne comprendront pas des classes développées en 1.5 (par exemple Oracle Application Server 10.1.2))
--- 1.6 : très peu utilisé actuellement, n'apporte pas a priori de classes indispensables mais simplifie encore un peu le langage (les simplifications en 1.5 et 1.6 consistent souvent à demander moins de travail au développeur, et un peu plus au compilateur)

Le langage Java n'est pas fourni nu, il comprend par défaut de nombreuses librairies d'objets déjà tout fait qu'il suffit soit de récupérer et d'utiliser tel quel, soit d'adapter en héritant les objets pour les spécialiser à ses besoins propres.
La page d'accueil de la documentation des classes fournies se trouve ici : http://java.sun.com/j2se/1.4.2/docs/api/ov...ew-summary.html (pour la version j2se 1.4.2).
On remarque déjà la dénomination assez conventionnelles des packages.

La première ligne du fichier d'une classe est la déclaration du package auquel appartient la classe (et qui doit correspondre à l'arborescence des répertoires où se trouve la classe). Exemple : "package fr.iclan;".
Pour utiliser une classe d'un package, on insère ensuite une ligne du type "import java.util.List;" au début du fichier de sa classe, après la déclaration du package (Eclipse peut insérer cette ligne semi-automatiquement lui-même avec l'auto-complétion (CTRL+espace)).
On peut inclure directement toutes les classes qui sont dans un package (mais ça ne prend pas en compte les packages fils) par "import java.util.*;".
On met autant de ligne que de classe qu'on a besoin d'utiliser (avec le cas particulier de l'inclusion d'un package entier, et sachant que les classes du même package que celui de la classe qu'on écrit sont implicitement incluses).
(dans le texte suivant, j'ai dit inclure pour ne pas m'embêter mais c'est un import qui est réalisé. En fait la différence include/import est aussi un avantage du Java par rapport à C/C++ ou un inconvénient suivant l'obédience des analystes. J'ai jamais trop creusé la question moi-même cela dit mais la différence se situe au niveau du travail que doit effectuer le compilateur et l'optimisation possible du code qui en découle).

Les packages qu'on utilise à chaque fois ou presque :
- java.lang : comporte les objets de base du système (en particulier les types : Boolean, Integer,...). Il est importé automatiquement
- java.io : comporte les classes qui servent à lire/écrire un fichier (ou n'importe quel flux de données, avec des flux au sens Unix). On y trouve par exemple les classes File, FileReader, FileWriter
- java.math : comporte juste deux classes : BigDecimal et BigInteger, qui permettent de travailler sur des nombres aussi gros qu'on veut sans perdre en précision (utile pour mapper les colonnes d'identifiants de base de données (c'est à dire faire transiter une information entre un objet Java et un autre type de données))
- java.sql : les classes de base JDBC (le langage universel de communication avec les BDD en Java, quelque soit le type réel de BDD sous-jacent) : les objets connexion, ResultSet, PreparedStatement
- java.util : comporte toutes les structures de données de base (Vector, List, Date, Iterator). Très utile donc.
- javax.swing (et les packages fils) : comporte tous les objets d'affichage SWING (le système d'affichage de Java pour les applications standard (les applications qui fonctionnent de manière indépendante et pas dans un navigateur Web) et pour les Applets (l'équivalent des ActiveX ou du Flash (grosso modo pour le Flash)). On peut y trouver des objets comme les boutons (JButton), les listes de données (JTable), les checkbox (JCheckbox). En général les classes SWING commencent par un "J"
[Le package s'appelle javax, cela signifie "java extension", comme tous les packages additionnels au langage de base, même s'ils font désormais partie à part entière du langage].

Prochaine leçon : la théorie du MVC (en fait plutôt l'architecture 3-tiers sans doute), avec pour objectif de pouvoir commencer à réfléchir à notre problème de gestion de stocks.