Langauage objets orienté

salut, tu peux aller sur des sites de java

Java est un langage orienté objets
Les premiers ordinateurs étaient programmés en langage machine, c'està-
dire en utilisant directement les instructions comprises par le processeur.
Ces instructions ne concernaient évidemment que les éléments
du processeur : registres, opérations binaires sur le contenu des registres,
manipulation du contenu d'adresses mémoire, branchement à des
adresses mémoire, etc.
Le premier langage développé a été l'assembleur, traduisant d'une part
mot à mot les instructions de la machine sous forme de mnémoniques
plus facilement compréhensibles, et masquant d’autre part la complexité
de certaines opérations en libérant le programmeur de l'obligation
de décrire chaque opération dans le détail (par exemple, choisir
explicitement un mode d'adressage).
L'assembleur, comme le langage machine, permet d'exprimer tous les
problèmes qu'un ordinateur peut avoir à résoudre. La difficulté, pour
le programmeur, réside en ce que le programme (la “solution” du problème)
doit être exprimé en termes des éléments du processeur (registres,
adresses, etc.) plutôt qu'en termes des éléments du problème luimême.
Si vous avez à programmer un éditeur de texte, vous serez bien
ennuyé, car l'assembleur ne connaît ni caractères, ni mots, et encore
moins les phrases ou les paragraphes. Il ne permet de manipuler que
des suites plus ou moins longues de chiffres binaires1.
Certains programmeurs pensèrent alors qu'il serait plus efficace d'exprimer
les programmes en termes des éléments du problème à résoudre. Les premiers ordinateurs étaient utilisés uniquement pour les calculs
numériques. Aussi, les premiers langages dits “de haut niveau”
exprimaient tous les problèmes en termes de calcul numérique. En ce
qui concerne le déroulement des programmes, ces langages reproduisaient
purement et simplement les fonctions des processeurs : tests et
branchements.
Est rapidement apparue la nécessité de mettre un frein à l'anarchie régnant
au sein des programmes. Les données traitées par les ordinateurs
étant en majorité numériques, c'est au déroulement des programmes
que fut imposée une structuration forte. Ainsi, le déroulement des programmes
devenait (en théorie) plus facilement lisible (et donc ceux-ci
devenaient plus faciles à entretenir), mais les données était toujours
essentiellement des nombres (mais de différents formats) et éventuellement
des caractères, voire des chaînes de caractères, ou même des tableaux
de nombres ou de chaînes, ou encore des fichiers (contenant,
bien sûr, des nombres ou des chaînes de caractères). Le pionnier de ces
langages dits “structurés” fut Pascal, que sa conception extrêmement
rigide limitait essentiellement à l'enseignement. Le langage C, universellement
employé par les programmeurs professionnels, marqua l'apogée
de ce type de programmation.
Tous les problèmes se présentant à un programmeur ne concernent pas
forcément des nombres ou des caractères uniquement. Cela paraît évident,
mais cette évidence était probablement trop flagrante pour entrer
dans le champ de vision des concepteurs de langages, jusqu'à l'apparition
des premiers langages orientés objets. Ceux-ci, en commençant par
le précurseur, Smalltalk, permettent d'exprimer la solution en termes
des éléments du problème, plutôt qu'en termes des outils employés.
Cela représente un énorme pas en avant pour la résolution de problèmes
complexes, et donc pour la productivité des programmeurs. Bien
sûr, toute médaille a son revers. En termes de performances pures, rien
ne vaudra jamais un programme en assembleur. Toutefois, dans le cas
de projets très complexes, il est probable que l'écriture et surtout la
mise au point de programmes en assembleur, voire en langages “structurés”,
prendraient un temps tendant vers l'infini.
Le langage orienté objets le plus répandu est sans équivoque C++. Il
s'agit d'une version de C adaptée au concept de la programmation par objets. Dans ce type de programmation, on ne manipule pas des
fonctions et des procédures, mais des objets qui s'échangent des
messages. Le principal avantage, outre le fait que l'on peut créer des
objets de toutes natures représentant les véritables objets du problème
à traiter, est que chaque objet peut être mis au point séparément.
En effet, une fois que l'on a défini le type de message auquel
un objet doit répondre, celui-ci peut être considéré comme une boîte
noire. Peu importe sa nature. Tout ce qu'on lui demande est de se
comporter conformément au cahier des charges. Il devient ainsi extrêmement
facile de mettre en oeuvre un des concepts fondamentaux
de la programmation efficace : d'abord écrire un programme de façon
qu'il fonctionne. Ensuite, l'améliorer afin qu’il atteigne une rapidité
suffisante.
Ce concept est particulièrement important, sinon le plus important de
la programmation orientée objets. En effet, avec les langages des générations
précédentes, cette approche, souvent utilisée, conduisait généralement
à une solution médiocre, voire catastrophique. Il était
d'usage de développer un prototype fonctionnel, c'est-à-dire un programme
conçu rapidement dans le seul but de reproduire le fonctionnement
souhaité pour le programme final. Les programmeurs les plus
sérieux utilisaient pour cela un langage de prototypage. Une fois un
prototype satisfaisant obtenu, ils réécrivaient le programme dans un
langage plus performant. L'avantage était qu'ils avaient ainsi l’assurance
de repartir sur des bases saines lors de l'écriture de la version
finale. L'inconvénient était qu'il fallait faire deux fois le travail, puisque
l'intégralité du programme était à réécrire. De plus, il était nécessaire
de connaître deux langages différents, ce qui n'augmentait pas la
productivité.
Une autre approche consistait à développer un prototype dans le même
langage que la version finale, avec la ferme décision de réécrire ensuite,
de façon “propre”, les éléments qui auraient été mal conçus au départ.
Satisfaisante en théorie, cette solution n'était pratiquement jamais réellement
appliquée, la version finale étant presque toujours la version
initiale agrémentée de nombreux replâtrages là où il aurait fallu une
réécriture totale, celle-ci s'avérant impossible en raison des nombreuses
connexions apparues en cours de développement entre des parties du
code qui auraient dû rester indépendantes.
Les langages orientés objets, et en particulier Java, apportent une solution
efficace et élégante à ce problème en définissant de manière
très stricte la façon dont les objets communiquent entre eux. Il devient
ainsi tout à fait possible de faire développer les parties d'une application
par des équipes de programmeurs totalement indépendantes. C'est
d'ailleurs le cas pour le langage Java lui-même, comme on peut s'en
apercevoir en examinant les noms choisis pour les méthodes des différents
objets du langage. Certains sont courts et obscurs, d'autres
longs et explicites, en fonction de la personnalité du programmeur les
ayant choisis. (Ces différences ont d'ailleurs tendance à disparaître
dans les nouvelles versions du langage, marquant en cela une volonté
d'unification appréciable.)

****c ca en gros*****