Utilisateur:Merrheim/Java

Un article de Wikipédia, l'encyclopédie libre.

Modèle:Infobox programming language

Ce document est une traduction libre d'un article du wikipedia anglophone [[1]

Java est un langage de programmation orienté objet développé par James gosling et ses collègues de la socitété Sun Microsystems au début des années 1990. Le langage qui a été développé pour être indépendant de la plateforme s'est inspiré du langage C++ avec une syntaxe plus simple, un environnement d'exécution plus sécurisé et une gestion simplifiée de la mémoire. Java n'a rien à voir avec le langage Javascript, bien qu'ils aient tout deux quelques petites similitudes et qu'ils partagent quelques notations issues du langage C.


Sommaire

[modifier] Historique

Cet historique provient d'une traduction libre d'un article du wikipedia anglophone Java_programming_language.

[modifier] L'origine du langage

Duke, le mascote de Java
Duke, le mascote de Java

La plateforme Java et la langage a pour origine un projet de Sun microsystem datant de 1990. L'ingénieur Patrick Naughton était de plus en plus insatisfait lorsqu'il constatait l'état du C++ de Sun et des APIs en langage C ainsi que des outils associés. Alors qu'il envisageait une migration vers NeXT, on offrit la chance à Naughton de travailler sur une nouvelle technologie et c'est ainsi que le Projet Stealth vu le jour.

Le Projet Stealth fut rapidement rebaptisé Green Project avec l'arrivée de James Gosling et de Mike Sheridan. Ensemble avec les autres ingénieurs, ils commencèrent à travailler dans un petit bureau de la rue Sand Hille de Menlo Park en Californie. Ils essayèrent de développer une nouvelle technologie pour développer la prochaine génération d'applications avec une chance unique pour Sun de s'ouvrir de nouvelles opportunités.

L'équipe envisageait initialement d'utiliser le langage C++, mais ce fut abandonné pour différentes raisons. Tout d'abord parce qu'ils développaient un système embarqué avec des ressources limitées, ils avaient estimé que l'utilisation du C++ demandait un investissement trop important et que cette complexité était une source d'erreur pour les développeurs. Les lacunes de ce langage au niveau du garbage collector impliquaient que la gestion de la mémoire devait être programmée manuellement, un challenge mais aussi une source d'erreur. L'équipe était aussi troublée par les lacunes du langage au niveau de la sécurité, de la programmation distribuée, du multi-threading. De plus, ils voulaient une plateforme qui pouvait être portée sur tout type d'appareils.

Bill Joy avait envisagé un nouveau langage combinant le meilleur du langage de programmation Mesa et du langage C. Dans un article appelé Autre (further), il proposa à Sun que ses ingénieurs pourraient développer un environnement orienté objet basé sur le langage C++. A l'origine, Giosling envisageait de modifier et d'améliorer le langage C++, qu'il appelait C++ ++ -- mais l'idée fut bientôt abandonnée au profit du développement d'un nouveau langage de programmation, qu'ils appelèrent Oak (chêne) après qu'un arbre se soit abattu juste devant leur bureau.

L'équipa travailla avec acharnement et, à l'été 1992, ils furent capable de faire une démonstration incluant le système d'exploitation Green, le langage Oak (1992), les librairies et le hardware. Leur première réalisation, présentée le 3 septembre 1992, fut la construction d'un PDA appelé Star7ayant une interface graphique et un agent intelligent appelé Duke pour prêter assistance à l'utilisateur. En Novembre de la même année, le Green Project fut abandonné pour devenir FirstPerson, Inc, appartenant en totalité à Sun microsystems et l'équipe déménagea à Palo Alto. L'équipe FirstPerson était intéressée par la construction d'outils hautement interactifs et quand Time Warner publia un RFP en faveur d'un décodeur multifonction, FirstPerson changea d'objectif pour proposer une telle plateforme. Cependant, l'industrie de la télé par cable trouva qu'elle donnait trop de possibilités à l'utilisateur et FirstPerson perdit le marché au profit de Silicon Graphic. Incapable d'intéresser l'industrie audiovisuelle, la société fut réintroduite au sein de Sun.

[modifier] Java rencontre Internet

De juin à juillet 1994, après trois jours de brainstorming avec John Gage, James Gosling, Joy, Naughton, Wayne Rosing et Eric Schmidt, l'équipe recentra la plateforme sur le Web.Ils pensaient qu'avec l'avénement du navigateur Mosaic, Internet était le lieu où allait se développer le même genre d'outil interactif que celui qu'ils avaient envisagé pour l'industrie du cable. Naughton développa comme prototype une petit navigateur Web, WebRunner qui deviendra par la suite HotJava.

La même année le langage fut renommé Java après qu'on eu découvert que le nom Oak était déjà utilisé par un fabricant de carte video. Le nom Java fut inventé dans un petit bar fréquenté par quelques membres de l'équipe. Il n'est pas clair de savoir si oui ou non le nom est un acronyme, bien que certains prétendent qu'il signifie James Gosling, Arthur Van Hoff et Handy Bechtolsheim ou tout simplement Just Another Vague Acronym (littéralement un nouvel acronyme vague). La croyance selon laquelle Java doit son nom aux produits vendus dans le bar est le fait que le code sur 4 octets (également appelés nombre magique) des fichiers de classe est en hexadécimal 0xCAFEBABE. En octobre 1994, HotJava et la plateforme Java fur présentée pour Sun Exécutives. Java 1.0a fut disponible en téléchargement en 1994 mais la première version publique du navigateur HotJava arriva le 23 mai 1995 à la conférence SunWorld. L'annonce fut effectuée par John Gage, le directreur scientifique de Sun Microsystems. Son annonce fut accompagnée de l'annonce surprise de Marc Andressen, vice président de l'exécutif de Netscape que Netscape allait inclure le support de Java dans ces navigateurs. Le 9 janvier 1996, le groupe Javasoft fut constitué par Sun Microsystems pour développer cette technologie [2]. Deux semaines plus tard la première version de java était disponible.

[modifier] Histoire récente

[modifier] Utilisation Web

[modifier] Coté client

La possibilité des navigateurs web de lancer des applet Java garantit la perennité de l'utilisation de Java par le grand public. Flash Macromédia est plus spécialisé dans les petites animations interactives et les développeurs commencent à utiliser la technologie Ajax dans ce sens également. La puissance de Java est souvent utilisée pour des applications plus consistantes comme Les jeux Yahoo et plus récemment les lecteurs video multiplateformes (par exemple [3]).

[modifier] Coté serveur

Sur le Web coté serveur, Java n'a jamais été aussi populaire avec de nombreux serveurs Web uqui tilisent la technologie JavaServer Pages (JSP) et les autres technologies basées sur Java.

[modifier] Utilisation sur le poste de travail

L'utilisation native du langage Java pour des applications sur un poste de travail reste relativement rare à cause de leur manque de rapidité. Cependant, avec l'accroissement rapide de la puissance des ordinateurs, les améliorations au cours de la dernière décennie de la machine virtuelle Java et de la qualité des compilateurs, plusieurs technologie ont gagné du terrain comme par exemple Netbeans et l'environnement Eclipse, les technologies de fichiers Limewire et Azureus. Java est aussi utilisée dans le programme de mathématique Matlab au niveau de l'interface homme machine et pour le calcul formel. Les applications Swing apparaisent également comme une alternative à la technologie .NET.

[modifier] Microsoft et autres systèmes

  • Microsoft a fourni une environnement de travail Java avec ces systèmes d'exploitation avant la sortie de Windows XP en 2001. Beacoup de fabricant d'ordinateurs cintinuent d'inclure un envrionnement JRE sur leurs systèmes Windows.
  • Java apprait également comme un standard au niveau du Mac OS X d'Apple aussi bien que pour les distributions Linux. De nos jours, la plupart des utilisateurs peuvent lancer des applications Java saans aucun problème.

[modifier] Historique des versions

Image:Java WebStartApplicationMan.png
Java Web Start, sorti pour la version J2SE 1.3, permet d'exécuter des applications provenant du Web juste en cliquent sur une icône ou sur un lien hypertexte

Le langage Java a connu plusieurs évolutions depuis le JDK (Java Developpement Kit) 1.0 avec l'ajout de nombreuses classes et packages à la librairie standard. Depuis de J2SE1.4, l'évolution de java est dirigée par le JCP (Java Community Process) qui utilise les JSR (Java spécifications Requests) pour proposer des ajouts et des changement sur la plateforme Java. Le langage est spécifié par le JLS (Java Spécification Language). Les modifications du JSL sont géré sous le code JSR 901 [4]

  • JDK 1.1 (19 février 1997) — De nombreux ajouts (communique de presse) avec notamment :
    • une refonte complète du modèle événementiel AWT.
    • Les classes internes sont ajoutées au langage.
    • JavaBeans
    • JDBC
    • Java Remote Invocation (RMI)
  • J2SE 1.2 (9 décembre 1998) — Nom de code Playground. Cette version et les suivante jusque J2SE 5.0 sont rebaptisées Java 2 et la version nommée J2SE (Java 2 Platform, Standard Edition) remplace JDK pour distinguer la plateforme de base de la version "J2SE" (Java 2 Platform, Standard Edition) et de la version J2ME (Java 2 Platform, Micro Edition). Plusieurs ajouts (communique de presse) avec notamment  :
    • le mot-clé strictfp
    • la réflection
    • l'API graphique Swing est intégrée.
    • Pour la première fois, la machine virtuelle Java de sun inclut un compilateur "Juste à temps" (Just in Time).
    • Java Plug-in
    • Java IDL, une implémentation de IDL pour l'interopérabilité avec CORBA.
    • le framework Collections.
  • J2SE 1.3 (8 mai 2000) — Nom de codeKestrel. Le changement le plus important(communique de presse-liste complète des changements) avec notamment :
    • HotSpot JVM inclus (La machine virtuelle HotSpot sortit en Avril 1999 pour la machine virtuelle du J2SE 1.2)
    • Changement pour les RMI pour être basé sur CORBA.
    • JavaSound
    • JNDI (Java Naming and Directory Interface) inclus de base (disponible auparavant comme extension)
    • JPDA (Java Platform Debugger Architecture)
    • le mot-clé assert (Spécifié dans JSR 41.)
    • les expressions régulières modélisées en s'inspirant du langage Perl.
    • Le chaînage d'exception permet à une exception d'encapsuler l'exception de base niveau d'origine. (Specifié dans JSR 51.)
    • API de connexion (Specifiée dans JSR 47.)
    • l'API Image I/O pour lire et écrire des images dans des formats comme JPEG et PNG.
    • intégration d'un parser XML et du moteur XSLT nommé JAXP (Specifié dans JSR 5 et JSR 63.)
    • intégration des extensions de sécurité JCE, JSSE et JAAS.
    • Java Web Start (introduit pour la première fois en mars 2001 pour J2SE 1.3 - Specifié dans JSR 56.)
  • J2SE 5.0 (30 Septembre 2004) — Nom de code Tiger. (initialzment numérotée 1.5, qui est toujours utilisé comme numéro de version intern[5]). Développé parJSR 176, Tiger ajoute un nombre significatif de nouveautés (communique de presse) au langage :
    • Programmation générique — (Specifié par JSR 14.)
    • Metadata — également appelées annotations, permet au langage de construire des classes et des méthodes étiquetées avec des données additionnelles qui peuvent être utilisée en tant que méta-données (Specifiée dans JSR 175.)
    • Autoboxing]]/unboxing — conversion automatique entre des types primitifs (comme le type int) et le Wrapper de classe correspondant (comme la classe Integer) (Specifié dans JSR 201).
    • Enumérations — le mot-clé enum permet de créer une liste ordonnée de valeurs sans type. Auparavant, cecei pouvait seulement être réalisé par des entiers constants (Specifié dans JSR 201).
    • Extension du for pour les boucles — la syntaxe du for est étendue avec une syntaxe spéciale pour les itérer sur n'importe quel Itérable comme un tableau, ou une collection en utilisant la syntaxe :
void displayWidgets (Iterable<Widget> widgets) {
    for (Widget w : widgets) {
        w.display();
    }
}

Cet exemple itère l'objet Iterable widgets de la classe Widget, assignant chacun de ces éléments à la variable w et ensuite appelle la méthode display() sur l'élément w (Specifié dans JSR 201).
  • Java SE 6 — Nom de code Mustang. En 2006, cette version est encore en développement (voir JSR 270). Une beta-version est sortie le 15 février 2006. Une autre béta est attendue pour l'été 2006 avec la version finale pour l'autone 2006. Avec cette version, Sun remplace le nom J2SE par Java SE et supprime le .0 au numéro de version (voir[6]).
  • Java SE 7 — Nom de code Dolphin. EN 2006, cette version est encore à un stade de développement précoce. C'est la dernière version à être planifiée. Le développement devrait commencer à l'été 2006 avec une sortie estimée en 2008 (voir [7]).

En plus des changements au niveau du langage, des changements plus dramatiques ont eu lieu au fil des années qui on conduit des quelques centaines de classes dans le JDK 1.0 à plus de 3000 dans J2SE 5.0. Des API entières, comme Swing ou Java2D ont été ajoutées et beaucoup de méthodes de l'original JDK 1.0 ont été déclarées deprecated]].


[modifier] Philosophie

Lors de la création du langage Java, il avait été décidé que ce langage devait répondre à 5 objectifs :

  1. Il devait utiliser une méthodologie orientée objet.
  2. Il devait permettre à un même programme d'être exécuté sur plusiurs systèmes d'exploitation différents.
  3. Il devait pouvoir utiliser de manière native les réseaux informatiques.
  4. Il devait pouvoir exécuter du code distant de manière sûre.
  5. Il devait être facile à utiliser et posséder les points forts des langages de programmation orientés objet comme le C++.


[modifier] Un langage orienté objet

La première caractérique, le caractère orienté objet du langage ("OO"), fait référence à une méthode de programmation et d'écriture du langage. Bien qu'il existe plusieurs interprétation de l'expression orienté objet, une idée phare dans ce type de développement est que les différents types de données doivent être directement associés avec les différentes opérations qu'on peut effectuer sur ces données. En conséquence, les données et le code sont combinés dans une même entité appelé objet. Un objet peut être vu comme une entité unique regroupant un comportement, le code, avec un certain état, les données. Le principe est de séparer les choses qui changent de celles qui ne changent pas; souvent un changement au niveau d'une structure de données va impliquer un changement dans le code servant à manipuler ces données et réciproquement. Ce découpage en entités cohérentes appelés objets permet d'avoir des fondations plus solides pour bâtir une architecture logicielle de qualité. L'objectif est de pouvoir développer des projets plus simples à gérer et de réduire de nombre de projets aboutissant à un échec.

Un autre objectif majeur de la programmation orienté objet est de développer des objets génériques de façon à ce que le code puisse être réutilisable entre différents projets. Un objet "client" générique par exemple doit avoir globalement le même comportement dans les différents projets, en particulier si ces différents projets se recoupent comme c'est souvent le cas dans les grandes organisations. Dans ce sens, un objet doit être peut être vu comme un composant logiciel enfichable, permettant à l'industrie du logiciel de bâtir des projets d'envergure à partir d'éléments de base réutilisables et à la stabilité éprouvée tout en diminuant de manière drastrique le temps de développement.

Le réutilisation de code, lorsqu'elle est soumise à l'épreuve de la pratique, rencontre deux difficultés majeures : la création d'objets génériques réellement réutilisables est une notion très mal comprise et une méthodologie pour diffuser de l'information nécessaire à la réutilisation de code manque cruellement. Certaines communauté du monde "Open Source" veulent contribuer à résoudre se problème en fournissant aux programmeurs la possibilité de diffuser largement de l'information sur les objets réutilisables et les bibliothèques objet.

[modifier] Indépendance vis à vis de la plateforme

Le "look and feel" d'une interface homme machine Swing est indépendante de la plateforme sur laquelle elle tourne.
Le "look and feel" d'une interface homme machine Swing est indépendante de la plateforme sur laquelle elle tourne.

La deuxième caractéristique, l'indépendance vis à vis de la plateforme signifie que les programmes écrits en Java fonctionne de manière parfaitrement similaire sur différentes architectures matérielles. On peut effectuer le développement sur une architecture donnée et faire tourner l'application sur toutes les autres.

Ce résultat est obtenu par les compilateurs Java qui compile le code source "à moitié" afin d'obtenir un bytecode (plus précisément le bytecode Java, un langage machine spécifique à la plateforme Java). Le code est ensuite interprété sur une machine virtuelle Java (JVM en anglais), un programme écrit spécifiquement pour la machine cible qui interprète et exécute le bytecode Java. De plus, des librairies standard sont fournies pour pouvoir accéder à certains éléments de la machine hôte (le graphisme, le multithreading, la programmation réseau,...) exactement de la même manière sur toutes les architectures. Notons que même s'il y a explicitement une première phase précoce de compilation, le bytecode Java est interprété ou alors converti à la volée en code natif par un compilateur "juste à temps" (Just in time - JIT).

Il existe également des compilateurs Java qui compile directement le Java en code objet natif pour la machine cible, comme par exemple GCJ, supprimant la phase intermédiaire du bytecode mais le code final produit par ces compilateurs ne peut alors être exécuté que sur une seule architecture.

La licence de Sun pour Java insiste sur le fait que toutes les implémentations doivent être compatibles. Ceci aboutit à la plainte en Justice contre Microsoft après que Sun eut constaté que l'implémentation de Microsoft ne supportait pas les interfaces RMI et JNI et comportait des éléments spécifiques à certaines plateformes par rapport plateforme initiale de Sun. Sun obtint des dommages et intérêt (20 millions de dollars) et l'acte de justice renforça encore les termes de la licence de Sun. En réponse, Microsoft arrêta le support de java sur ses plateformes et, sur les versions récentes de Windows, Internet Explorer ne supporte pas les applet Java sans rajouter de plug-in. Cependant, Sun met à disposition gratuitement des environnements d'exécution de Java pour les différentes plateformes Microsoft.

Les premières implémentations du langage utilisaient une machine virtuelle interprétée pour obtenir la portabilité. Ces implémentation produisaient des programmes qui s'exécutaient plus lentement que ceux écrits en C ou en C++, si bien que le langage souffrit d'une réputation d'avoir de faibles performances. Des implémentation plus récentes de la machine virtuelle Java (JVM) produisent des programmes beaucoup plus rapides qu'auparavant, en utilisant différentes techniques.

La première technique est de compiler directement en code natif comme un compilateur traditionnel, supprimant complètement la phase de bytecode. On obtient ainsi de bonnes performances mais aux dépends de la portabilité. Une autre technique appelée compilation "Juste à temps" (Just In Time - JIT) traduit le byte code en code natif duarnt la phase de lancement du programme. Certaines machines virtuelles plus sophistiquées utilisent une recompilation dynamique durant laquelle la machine virtuelle analyse le comportement du programme et en recompile sélectivement certaines parties. La recompilation dynamique permet d'ontenir de meilleurs résultats que la compilation statique car les compilateurs dynamiques peuvent optimiser en fonction de leur connaissance de l'environnement cible et des classes qui sont utilisées. La compilation JIT et la recompilation dynamique permettent à Java de tirer profit de la rapidité du code natif sans perdre la portabilité.

La portabilité est techniquement un objectif difficile à atteindre et le succès de Java en ce domaine est mitigé. Quoiqu'il soit effectivement possible d'écrire des programmes pour la plateforme Java qui fonctionne correctement sur beacoup de machines cibles, le nombre important de plateformes avec de petites erreurs et des incohérences, a abouti à un détournement du slogan de Sun "Write once, run anywhere" ("Ecrire une fois, fonctionne partout") en "Write once, debug everywhere" ("Ecrire une fois, déboguer partout") !

L'indépendance de Java vis à vis de la plateforme est cependant un succés avec les applications côté serveur comme les services Web, les servlets et le Java Beans aussi bien que les systèmes embarqués sur OSGi, utilisant l'environnement Embedded Java.

[modifier] Le ramasse-miettes

Un argument possible à l'encontre de langages comme le C++ est la lourde tâche d'avoir à programmer manuellement la gestion de la mémoire. En C++, la mémoire est allouée directement par le programmeur pour créer une objet et désallouée lors de la destruction de celui-ci. Si le programmeur oublie de désallouer la mémoire, ceci peut aboutir à un manque de mémoire et le programme consomme peti à petit de la mémoire sans nettoyer derrière lui. Encore pire, si une zone mémoire est désallouée 2 fois, le programme peut dévenir instable et aboutir à un plantage.

En java, ce problème est évité grâce au ramasse-miettes (Garbage collector). Les objets sont créés et placés sur un tas. Le programme et les autres objets peuvent faire référence à l'objet grâce à son adresse sur le tas. Quand il ne reste plus aucune référence vers l'objet. Le ramasse-miettes détruit automatiquement l'objet devenu inaccessible, libérant la mémoire et prévenant ainsi un manque de mémoire. Les manques de mémoire peuvent néanmoins survenir quand un programmeur garde une référence vers un objet dont il n'a plus besoin; ils continuent d'exister mais en fait uniquement à un niveau concept beaucoup plus élevé. Mais dans l'ensemble, le ramasse-miettes rend la création et la destruction d'objets en Java plus simple, potentiellement plus sûre et souvent plus rapide qu'en C++.

Le rammase-miettes est transparent pour le développeur. Les développeur peuvent très bien n'aucune idée de quand le ramasse-miettes intervient et ce n'est pas une partie du programme qu'ils doivent écrire eux-même.

[modifier] Criticism

Java was intended to serve as a novel way to manage software complexity. Most consider Java technology to deliver reasonably well on this promise. However, Java is not without flaws, and it does not universally accommodate all programming styles, environments, or requirements.

  • Not all projects or environments require enterprise-level complexity, such as stand-alone websites or sole-proprietorship programmers. Some individuals find Java's self-enforcing complexity management to be overkill.
  • Java is often a focal point of discontent for those who are not enthusiastic about object-oriented programming.
  • Java can be considered a less pure object-oriented programming language than for instance Ruby or Smalltalk because it makes certain compromises (such as the fact that not all values are objects) for performance reasons.
  • Java failed to deliver state-of-the-art arithmetic. The IEEE 754 Standard for Binary Floating-Point Arithmetic had appeared in 1985 and has remained an industry standard since then. But the designers of Java did not adopt the standard. Details about this kind of criticism can be found below in the external links section.
  • Java programs may have lower performance than those written in other languages that are compiled directly into machine code for the following reasons:
    • Java byte code must either be interpreted at run time by a virtual machine instead of running directly on the computer's hardware, or must be compiled at load time or runtime into machine code. Interpretation is slower than native exectution, and compilation at load time or runtime has an initial performance penalty for the compilation.
    • Java byte code is not optimized to the same extent as the machine code produced by compilers that produce object code targeted to run on a single platform, except when compiled using a JIT compiler or a dynamic compiler which compiles, optimizes, and produces object code targeted to run on a single platform.
    • Java does not support manual inlining of method calls, although many JIT compilers perform this optimization at load time. Dynamic recompilation performed by some JVMs such as Sun's HotSpot JVM provide more inlining than is possible with static manual inlining.
    • The use of a garbage collector to automatically decide when to delete objects adds overhead compared to maunual deallocation. However, with the modern generational garbage collectors used in many JVMs, many applications actually experience performance improvements due to the greater efficiency of the underlying memory management algorithms.
  • As an established technology, Java inevitably invites comparison with contemporary languages such as C++, C#, Python, and others. Commenting upon Java's proprietary nature, supposed inflexibility to change, and growing entrenchment in the corporate sector, some have said that Java is "the new COBOL". Many consider this to be a somewhat hyperbolic assertion, although it does allude to some legitimate concerns with Java's prospects for the future. An appropriate comparison would be ALGOL60, the Java of its day back in the mainframe era, which lost its way after it over-inflated into ALGOL68.

[modifier] Language

  • The distinction between reference types and primitive types may be viewed as artificial by programmers who are familiar with languages such as Smalltalk, Python and Ruby, where everything is an object.
  • Conversely, C++ programmers can become confused with Java because in Java primitives are always automatic variables and objects always reside on the heap, whereas C++ programmers are explicitly given the choice in both cases by means of operator new.
  • Java code is often more verbose than code written in other languages. This is due in part to its frequent type declarations and manual casts. It is also due to the lack of operator overloading (see below) and the relatively simple syntax. However, J2SE 5.0 introduced Generics which addresses the issue of manual casts, as well as new syntax for for-loops which also reduces verbosity.
  • Unlike C++, Java does not support user-definable operator overloading; however, this is a deliberate design decision, seen by many as a plus because of the well-known readability and maintenance problems experienced with operator overloading.
  • Java is predominantly a single-paradigm language. Historically, it has not been very accommodating of paradigms other than object-oriented programming. As of J2SE 5.0, the procedural paradigm is somewhat better supported in Java with the addition of the ability to import static methods and fields so that they can be used globally as one could do in, for example, C.
  • Java only supports single inheritance of implementation. This causes consternation to programmers accustomed to orthogonal multiple inheritance, which is available in many other languages. However, Java employs interfaces, which allow multiple inheritance of type and abstract methods.
  • Java's support of text matching and manipulation is not as strong as languages such as Perl, Ruby, or PHP, although regular expressions were introduced in J2SE 1.4.

[modifier] Library

The look and feel of GUI applications written in Java using the Swing platform is often different from native applications. While programmers can choose to use the AWT toolkit that displays native widgets (and thus look like the operating platform), the AWT toolkit is unable to meet advanced GUI programming needs by wrapping around advanced widgets and not sacrificing portability across the various supported platforms, each of which have vastly different APIs especially for higher-level widgets. The Swing toolkit, written completely in Java, avoids this problem by reimplementing widgets using only the most basic drawing mechanisms that are guaranteed available on all platforms. The drawback is that extra effort is required to resemble the operating platform. While this is possible (using the GTK+ and Windows Look-and-Feel), most users do not know how to change the default Metal Look-And-Feel to one that resembles their native platform, and as a result they are stuck with Java applications that look radically different from their native applications. Of note however, Apple Computer's own optimized version of the Java Runtime, which is included within the Mac OS X distribution, by default implements its "Aqua" Look-And-Feel, giving Swing applications a similar appearance to native Mac software.

Some parts of the standard Java libraries are considered excessively complicated, or badly designed, but cannot be changed due to the need for backward compatibility.

[modifier] Performance

It is misleading to make any generalization about the performance of Java programs in general, because runtime performance is affected much more by the quality of the compiler or JVM than by any intrinsic properties of the language itself.

There are a few language requirements which incur an unavoidable time penalty, although these features are not unique to Java. Among these are array bounds checking, run-time type checking, and virtual function indirection. Garbage collection can have a positive or negative impact, or no discernable impact at all, on performance depending upon the garbage collector implementation and the characteristics of the application's use of objects.

Relative performance of JIT compilers as compared to native compilers can be quite close, and is often a subject of debate. The JIT stage may be time-consuming, which is inconvenient for applications that are short-lived and/or contain large amounts of code. Once this is done, however, the performance of the program can be comparable to that achieved by a native compiler, even on numerical tasks. In addition, JITs can exploit information from the runtime environment to guide more effective transformations, such as profile-directed inlining. Dynamic recompilation, as provided by Sun's HotSpot JVM, can exceed the performance of the static compilation available in most other languages by exploiting information that is only available at runtime.

Java was designed with an emphasis on security and portability, and does not support direct access to the machine architecture and address space. Applications can drop down to native code to access these features using the Java Native Interface (JNI).

[modifier] Syntax

Main article: Java syntax

The syntax of Java is largely derived from C++. But unlike C++, which combines the syntax for procedural and object-oriented programming, Java was built from the ground up to be fully object-oriented. Everything in Java is an object (with a few exceptions), and everything in Java is written inside a class.

[modifier] Hello world

For an explanation of the tradition of programming "Hello World", see Hello world program.

[modifier] Stand-alone application

// Hello.java
public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, world!"); 
    } 
}

The above example merits a bit of explanation for those accustomed to languages with inherently relaxed security, weak typing, and weak object orientation.

  • Everything in Java is written inside a class, including stand-alone programs.
  • Source files are by convention named the same as the class they contain, appending the mandatory suffix .java. A class which is declared public is required to follow this convention. (In this case, the class is Hello, therefore the source must be stored in a file called Hello.java).
  • The compiler will generate a class file for each class defined in the source file. The name of the class file is the name of the class, with .class appended. For class file generation, anonymous classes are treated as if their name was the concatenation of the name of their enclosing class, a $, and an integer.
  • Programs to be executed as stand-alone must have a main() method.
  • The keyword void indicates that the main method does not return anything.
  • The main method must accept an array of String objects. By convention, it is referenced as args although any other legal identifier name can be used.
  • The keyword static indicates that the method is a class method, associated with the class rather than object instances. Main methods must be static.
  • The keyword public denotes that a method can be called from code in other classes, or that a class may be used by classes outside the class hierarchy. Main methods must also be public.
  • The printing facility is part of the Java standard library: The System class defines a public static field called out. The out object is an instance of the PrintStream class and provides the method println(String) for displaying data to the screen (standard out).
  • Standalone programs are run by giving the Java runtime the name of the class whose main method is to be invoked. For example, at a Unix command line java -cp . Hello will start the above program (compiled into Hello.class) from the current directory. The name of the class whose main method is to be invoked can also be specified in the MANIFEST of a Java archive (Jar) file.

[modifier] Applet

Java applets are programs that are embedded in other applications, typically in a Web page displayed in a Web browser.

// Hello.java
import java.applet.Applet;
import java.awt.Graphics;

public class Hello extends Applet {
    public void paint(Graphics gc) {
        gc.drawString("Hello, world!", 65, 95);
    }    
}

<html>
  <head>
    <title>Hello World Applet</title>
  </head>
  <body>
    <applet code="Hello" width="200" height="200">
    </applet>
  </body>
</html>

The import statements direct the Java compiler to include the java.applet.Applet and java.awt.Graphics classes in the compilation. The import statement allows these classes to be referenced in the source code using the simple class name (i.e. Applet) instead of the fully-qualified class name (i.e. java.applet.Applet).

The Hello class extends (subclasses) the Applet class; the Applet class provides the framework for the host application to display and control the lifecycle of the applet. The Applet class is an Abstract Windowing Toolkit (AWT) Component, which provides the applet with the capability to display a graphical user interface (GUI) and respond to user events.

The Hello class overrides the paint(Graphics) method inherited from the Container superclass to provide the code to display the applet. The paint() method is passed a Graphics object that contains the graphic context used to display the applet. The paint() method calls the graphic context drawString(String, int, int) method to display the "Hello, world!" string at a pixel offset of (65, 95) in the applet's display.

An applet is placed in an HTML document using the <applet> HTML element. The applet tag has three attributes set: code="Hello" specifies the name of the Applet class and width="200" height="200" sets the pixel width and height of the applet. (Applets may also be embedded in HTML using either the object or embed element, although support for these elements by Web browsers is inconsistent.[8][9])

[modifier] Servlet

Java servlets are server-side Java EE components that generate responses to requests from clients.

// Hello.java
import java.io.*;
import javax.servlet.*;

public class Hello extends GenericServlet {
    public void service(ServletRequest request, ServletResponse response)
        throws ServletException, IOException
    {
        response.setContentType("text/html");
        PrintWriter pw = response.getWriter();
        pw.println("Hello, world!");
        pw.close();
    }
}

The import statements direct the Java compiler to include all of the public classes and interfaces from the java.io and Modèle:Javadoc:EE packages in the compilation.

The Hello class extends the Modèle:Javadoc:EE class; the GenericServlet class provides the interface for the server to forward requests to the servlet and control the servlet's lifecycle.

The Hello class overrides the Modèle:Javadoc:EE method defined by the Modèle:Javadoc:EE interface to provide the code for the service request handler. The service() method is passed a Modèle:Javadoc:EE object that contains the request from the client and a Modèle:Javadoc:EE object used to create the response returned to the client. The service() method declares that it throws the exceptions Modèle:Javadoc:EE and IOException if a problem prevents it from responding to the request.

The Modèle:Javadoc:EE method in the response object is called to set the MIME content type of the returned data to "text/html". The Modèle:Javadoc:EE method in the response returns a PrintWriter object that is used to write the data that is sent to the client. The println(String) method is called to write the "Hello, world!" string to the response and then the close() method is called to close the print writer, which causes the data that has been written to the stream to be returned to the client.

[modifier] Swing application

Swing is the advanced graphical user interface library for the Java SE platform.

// Hello.java
import javax.swing.*;

public class Hello extends JFrame {
    Hello() {
        setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
        add(new JLabel("Hello, world!"));
        pack();
    }

    public static void main(String[] args) {
        new Hello().setVisible(true);
    }
}

The import statement directs the Java compiler to include all of the public classes and interfaces from the javax.swing package in the compilation.

The Hello class extends the JFrame class; the JFrame class implements a window with a title bar with a close control.

The Hello() constructor initializes the frame by first calling the setDefaultCloseOperation(int) method inherited from JFrame to set the default operation when the close control on the title bar is selected to WindowConstants.DISPOSE_ON_CLOSE—this causes the JFrame to be disposed of when the frame is closed (as opposed to merely hidden), which allows the JVM to exit and the program to terminate. Next a new JLabel is created for the string "Hello, world!" and the add(Component) method inherited from the Container superclass is called to add the label to the frame. The pack() method inherited from the Window superclass is called to size the window and layout its contents.

The main() method is called by the JVM when the program starts. It instantiates a new Hello frame and causes it to be displayed by calling the setVisible(boolean) method inherited from the Component superclass with the boolean parameter true. Note that once the frame is displayed, exitting the main method does not cause the program to terminate because the AWT event dispatching thread remains active until all of the Swing top-level windows have been disposed.

[modifier] Resources

[modifier] Java Runtime Environment

The Java Runtime Environment or JRE is the software required to run any application deployed on the Java Platform. End-users commonly use a JRE in software packages and Web browser plugins. Sun also distributes a superset of the JRE called the Java 2 SDK (more commonly known as the JDK), which includes development tools such as the Java compiler, Javadoc, and debugger.

[modifier] Components

  • Java libraries that are the compiled byte codes of source code developed by the JRE implementor to support application development in Java. Examples of these libraries are:
    • The core libraries, which include:
    • The integration libraries, which allow the application writer to communicate with external systems. These libraries include:
      • The Java Database Connectivity (JDBC) API for database access
      • Java Naming and Directory Interface (JNDI) for lookup and discovery
      • RMI and CORBA for distributed application development
    • User Interface libraries, which include:
      • The (heavyweight, or native) Abstract Windowing Toolkit (AWT), which provides GUI components, the means for laying out those components and the means for handling events from those components
      • The (lightweight) Swing libraries, which are built on AWT but provide (non-native) implementations of the AWT widgetry
      • APIs for audio capture, processing, and playback
  • A platform dependent implementation of Java virtual machine (JVM) which is the means by which the byte codes of the Java libraries and third party applications are executed
  • Plugins, which enable applets to be run in Web browsers
  • Java Web Start, which allows Java applications to be efficiently distributed to end users across the Internet
  • Licensing and documentation

[modifier] APIs

Sun has defined three platforms targeting different application environments and segmented many of its APIs so that they belong to one of the platforms. The platforms are:

  • Java Platform, Micro Edition (Java ME) — targeting environments with limited resources,
  • Java Platform, Standard Edition (Java SE) — targeting workstation environments, and
  • Java Platform, Enterprise Edition (Java EE) — targeting large distributed enterprise or Internet environments.

The classes in the Java APIs are organized into separate groups called packages. Each package contains a set of related interfaces, classes and exceptions. Refer to the separate platforms for a description of the packages available.

The set of APIs is controlled by Sun Microsystems in cooperation with others through the Java Community Process program. Companies or individuals participating in this process can influence the design and development of the APIs. This process has been a subject of controversy.

In 2004, IBM and BEA publicly supported the notion of creating an official open source implementation of Java but as of 2006, Sun Microsystems has refused that.

[modifier] Extensions and related architectures

The extensions to standard Java are typically in javax.* packages. They are not included in the JDK or JRE. Extensions and architectures closely tied to the Java programming language include:

  • Java EE (previously J2EE) (Java Platform, Enterprise Edition—for distributed enterprise applications)
  • Java ME (previously J2ME) (Java Platform, Micro Edition—for PDAs and cellular phones)
  • JMF (Java Media Framework)
  • JNDI (Java Naming and Directory Interface)
  • JSML (Java Speech API Markup Language)
  • JDBC (Java Database Connectivity)
  • JDO (Java Data Objects)
  • JAI (Java Advanced Imaging)
  • JAIN (Java API for Integrated Networks)
  • JDMK (Java Dynamic Management Kit)
  • Jini (a network architecture for the construction of federated distributed systems)
  • Jiro
  • Java Card
  • JavaSpaces
  • JML (Java Modeling Language)
  • JMI (Java Metadata Interface)
  • JMX (Java Management Extensions)
  • JSP (JavaServer Pages)
  • JSF (JavaServer Faces)
  • JNI (Java Native Interface)
  • JXTA (Open Protocols for Peer-to-Peer (P2P) Virtual Network)
  • Java 3D (A high level API for 3D graphics programming)
  • JOGL (Java OpenGL—A low level API for 3D graphics programming, using OpenGL)
  • LWJGL (Light Weight Java Game Library—A low level API providing access to OpenGL, OpenAL and various input devices)
  • OSGi (Dynamic Service Management and Remote Maintenance)

[modifier] See also

  • Java syntax
  • Java keywords
  • Java virtual machine
  • Java platform
  • Java applet
  • Java Platform, Standard Edition (Java SE, J2SE)
  • JavaOS
  • Optimization of Java
  • Comparison of Java and C++
  • Comparison of C# and Java
  • Java User Group
  • Java Community Process
  • JavaOne
  • Join Java programming language
  • Javapedia

[modifier] Lists

  • List of articles with Java source code
  • List of Java scripting languages
  • Java platform software
  • Java development tools

[modifier] References

[modifier] Notes

  1. Modèle:Note The device was named Star7 after a telephone feature activated by *7 on a telephone keypad, which enabled users to answer the telephone anywhere.

[modifier] External links

Wikibooks
Wikibooks Programming a d'autres information au sujet de :
Wikibooks
Wikibooks Java Programming a d'autres information au sujet de :

[modifier] Sun

[modifier] Java Specification Requests

There are several JSRs related to the Java Language and core API packages.

  • JSR 14 Add Generic Types To The Java Programming Language (J2SE 5.0)
  • JSR 41 A Simple Assertion Facility (J2SE 1.4)
  • JSR 47 Logging API Specification (J2SE 1.4)
  • JSR 51 New I/O APIs for the Java Platform (J2SE 1.4)
  • JSR 59 J2SE Merlin Release Contents (J2SE 1.4)
  • JSR 133 Java Memory Model and Thread Specification Revision (J2SE 5.0)
  • JSR 166 Concurrency Utilities (J2SE 5.0)
  • JSR 175 A Metadata Facility for the Java Programming Language (J2SE 5.0)
  • JSR 176 J2SE 5.0 (Tiger) Release Contents (J2SE 5.0)
  • JSR 201 Extending the Java Programming Language with Enumerations, Autoboxing, Enhanced for loops and Static Import (J2SE 5.0)
  • JSR 203 More New I/O APIs for the Java Platform ("NIO.2") (Java SE 7)
  • JSR 204 Unicode Supplementary Character Support (J2SE 5.0) – support for Unicode 3.1
  • JSR 270 Java SE 6 ("Mustang") Release Contents (Java SE 6)
  • JSR 901 Java Language Specification (J2SE 5.0)

[modifier] Tutorials

[modifier] Resources

[modifier] History

[modifier] Alternatives

[modifier] Criticism

Modèle:Major programming languages small

Modèle:Featured article

Category:C programming language family Programming language Programming language Category:Programming languages Category:Sun Microsystemsfr:Java (langage)