Introduction : un peu d'histoire

Table des matières
Introduction : un peu d'histoire
1. Java : genèse d'un nouveau langage
Programmer en Java
1. Un premier exemple
1.1. Aperçu général, cycle de vie
1.2. Un premier programme
1.3. Programmes, applets, servlets, etc...
2. Une première classe
2.1. Écriture d'une classe
2.2. Instanciation de cette classe
3. Types de base, classes et objets
3.1. Types de base
3.2. Classes et objets
Classes Object et String
1. Introduction
2. La classe Object
2.1. La méthode toString()
2.2. La méthode clone()
2.3. La méthode equals()
2.4. La méthode hashCode()
2.5. La méthode finalize()
2.6. La méthode getClass()
3. La classe String
3.1. Introduction
3.2. Construction d'un objet de type String
3.3. Concaténation, StringBuffer et StringBuilder
3.4. Concaténations de chaînes de caractères depuis Java 8
3.5. Concaténations de chaînes de caractères depuis Java 11
3.6. Extraction d'une sous-chaîne de caractères
3.7. Comparaison de deux chaînes de caractères
3.8. Méthodes de comparaisons lexicographiques
3.9. Méthode de recherche de caractères
3.10. Méthode de modification de chaîne
3.11. Méthode de duplication
3.12. Support de l'unicode, internationalisation
Structure d'une classe
1. Introduction
2. Classes
2.1. Classes publiques
2.2. Classes internes
2.3. Classe membre
2.4. Classes locales
2.5. Classes anonymes
2.6. Le mot-clé this
3. Éléments statiques
3.1. Champ statique
3.2. Cas des constantes
3.3. Bloc statique
3.4. Classe membre statique
4. Membres d'une classe, visibilité
4.1. Bloc non statique
4.2. Accès à un membre, visibilité
4.3. Les champs
4.4. Signature d'une méthode
4.5. Les méthodes
4.6. Getters et Setters
5. Constructeur, instanciation
5.1. Chargement d'une classe
5.2. Constructeurs d'une classe
5.3. Instanciation d'un objet
5.4. Destruction d'objets
5.5. Le mot-clé final
6. Énumérations
6.1. Déclaration d'une énumération
6.2. Classe énumération
6.3. Méthode toString()
6.4. Méthode valueOf()
6.5. Méthode values()
6.6. Méthode ordinal()
6.7. Méthode compareTo()
6.8. Constructeurs privés
6.9. Classe utilitaire : EnumSet
Noms, opérateurs, tableaux
1. Introduction
2. Identificateurs, noms et expressions
2.1. Identificateurs et noms
2.2. Expressions
3. Opérateurs, ordre d'exécution
3.1. Ordre d'exécution
3.2. Les opérateurs
3.3. Les opérateurs ++ et --
3.4. Les opérateurs % et /
3.5. Les opérateurs <<, >> et >>>
3.6. L'opérateur instanceof
3.7. Les opérateurs &, | et ^
3.8. Les opérateurs && et ||
3.9. L'opérateur ? ... :
3.10. Les opérateurs d'affectation
4. Tableaux
4.1. Création d'un tableau
4.2. Initialisation d'un tableau
4.3. Utilisation d'un tableau comme un Object
4.4. Tableaux de tableaux
4.5. Copie de tableaux
5. Blocs, boucles et contrôles
5.1. Blocs
5.2. Mots-clés réservés
5.3. Tests : if et switch
5.4. Boucles : for, while, do ... while
5.5. Commandes continue et break
5.6. Commandes return et goto
Nombres, précision, calculs
1. Introduction
2. Calculs
2.1. Précision
2.2. Codage des nombres flottants
2.3. Le mot-clé strictfp
2.4. Conversion de types
3. Dépassements de capacité
3.1. Cas des entiers
3.2. Cas des flottants
3.3. Bibliothèques BigInteger et BigDecimal
4. Fonctions mathématiques
4.1. Fonctions usuelles
4.2. Générateurs aléatoires
5. Classes enveloppe
5.1. Associer les types de base à des objets
5.2. Auto-boxing
Héritage, abstraction, interfaces
1. Introduction
2. Abstraction et encapsulation
2.1. Abstraction
2.2. Encapsulation
3. Héritage
3.1. Définition de l'héritage
3.2. Conséquences pour les membres
3.3. Polymorphisme
3.4. Empêcher l'héritage
4. Classes abstraites
5. Interfaces
5.1. Introduction
5.2. Définition
5.3. Java 8 et les interfaces
5.4. Utilisation des interfaces
5.5. Définition de constantes dans les interfaces
5.6. Utilité des interfaces
Packages
1. Introduction
2. Notion de paquet
2.1. Déclaration d’appartenance à un paquet
2.2. Chargement d’une classe
2.3. Choix de nom
3. Archives, chemin de recherche, classpath
3.1. Archives
3.2. Variable CLASSPATH
3.3. Notion de classloader
3.4. Bilan sur les classes chargées
3.5. Visibilité
3.6. Conseils d'écriture, bibliothèque standard
Exceptions
1. Introduction
2. Erreurs et Exceptions
2.1. Classe Throwable, notion de stack trace
2.2. Classe Error
2.3. Classe RuntimException
2.4. Classe Exception
3. Déclenchement d'une exception
3.1. Exceptions déclenchées par la JVM
3.2. Exceptions déclenchées par l'application
4. Capter une exception
4.1. Traiter une exception localement
4.2. Code de captage
5. Créer ses propres exceptions
Entrées / sorties
1. Introduction
2. Notion de fichier
2.1. Introduction
2.2. La classe File
2.3. Construction d'une instance de File
2.4. Méthodes exposées
3. Flux de sortie
3.1. Introduction, notion de flux
3.2. Écriture de caractères, classe Writer
3.3. Bufferisation, construction d'un flux sur un autre
3.4. Utilisation de PrintWriter
3.5. Écriture d'octets, OuputStream
3.6. Écriture de types primitifs : DataOutputStream
3.7. Écriture d'objets : ObjectOutputStream
4. Flux d'entrée
4.1. Introduction
4.2. Lecture de caractères, classe Reader
4.3. Bufferisation, lecture ligne par ligne
4.4. Lecture d'octets : InputStream
4.5. Lecture de types primitifs : DataInputStream
4.6. Lecture d'objets : ObjectInputStream
5. Lecture et écriture de flux croisés
5.1. Introduction
5.2. Lire des caractères sur un flux binaire : classe InputStreamReader
5.3. Écrire des caractères sur un flux binaire : classe OutputStreamWriter
5.4. Remarque sur les jeux de caractères
6. Serialization d'objets
6.1. Enjeu de la sérialization d'objets
6.2. Serialization d'un objet
6.3. Sérialization d'une grappe d'objets
6.4. Première surcharge : méthode writeObject() readObject()
6.5. Deuxième surcharge : utilisation d'un externalizer
6.6. Troisième surcharge : utilisation d'un objet proxy
7. Flux compressés
7.1. Introduction
7.2. Flux de type gzip
7.3. Flux de type zip

1. Java : genèse d'un nouveau langage

Le projet Java est né en 1991, dans le secret d’une équipe de Sun Microsystem. C’est cette année-là que le Green Project a démarré, dans le but d’étudier l’impact de la convergence entre les appareils ménagers (blancs et bruns) contrôlés numériquement et les ordinateurs. Après 18 mois d’isolement total, les 13 personnes faisant partie du projet avaient fabriqué une télécommande digitale, munie d’un écran tactile graphique et animé. Cette seule télécommande était capable de contrôler tout un équipement audio et vidéo de salon. On peut d'ailleurs regretter qu’elle n’ait jamais été commercialisée, et que les constructeurs préfèrent aujourd’hui saturer leurs appareils de multiples boutons aux fonctionnements obscurs... La raison pour laquelle cette télécommande était unique est qu’elle était programmée dans un nouveau langage, indépendant du processeur sur lequel il s’exécutait, conçu par James Gosling, un des membres du Green Project. James Gosling aimait bien le chêne qu’il voyait de la fenêtre de son bureau, et a appelé ce langage Oak. Le projet gagna alors en importance, des contacts furent pris avec des câblo-opérateurs américains, et il changea de nom pour s’appeler FirstPerson. Il ne rencontra pas de succès commercial, probablement trop en avance dans un milieu industriel qui était encore à la recherche de moyens de gagner de l’argent. L’arrivée du protocole http et du navigateur Mosaic fut un événement déterminant pour ce projet, en 1993. L’équipe comprit que l’Internet allait être le réseau idéal pour positionner leur produit. Après quelques travaux supplémentaires, en 1995, James Gosling fit une démonstration très importante d’un navigateur capable de montrer du contenu html mélangé à des applets. Le navigateur, appelé WebRunner fut rendu disponible sur l’Internet, et rapidement le seuil psychologique des 10 mille téléchargements fut atteint. Les choses s’enchaînèrent ensuite très vite. WebRunner devint HotJava, le site java.sun.com s’ouvrit au grand public, et l’annonce conjointe de Sun et Netscape d’intégrer la technologie Java dans leur navigateur lança définitivement le langage. Les versions se succédèrent alors :
  • 1996 : JDK 1.0
  • 1997 : JDK 1.1
  • 1998 : JDK 1.2, appelé Java 2
  • 2000 : JDK 1.3
  • 2002 : JDK 1.4
  • 2004 : JDK 1.5, appelé Java 5
  • 2006 : JDK 1.6, appelé Java 6
  • 2011 : JDK 1.7, appelé Java 7
  • 2014 : JDK 1.8, appelé Java 8.
  • septemnbre 2017 : JDK 9.
  • mars 2018 : JDK 10.
  • septembre 2018 : JDK 11.
  • mars 2019 : JDK 12.
On remarque qu'à partir de la version 9, Java sort une version majeure tous les six mois, ce qui est le rythme de sortie maintenant adopté. La possibilité d’exécuter le même code Java sur n’importe quelle machine, et sous n’importe quel système d’exploitation a été le premier souci des concepteurs de ce langage. L’objectif était de pouvoir télécharger des applets Java au travers de l’Internet, et de les exécuter dans son propre navigateur, la compatibilité absolue était donc nécessaire. Il est donc possible de compiler un programme Java sur une machine sous Windows, et d’exécuter ce code binaire sur un Macintosh. Voici une liste (non exhaustive !) des systèmes pour lesquels des machines Java existent : PC Windows et Linux, toute machine Unix, DEC sous VMS, IBM sous MVS, téléphones portables, PDA (PocketPC Palm OS), processeurs embarqués, cartes à puce. On peut se demander pourquoi un tel délai a été nécessaire pour produire Java 7. Finalement, de la version 2 à la version 6, Sun a réussi à conserver un rythme régulier d'une version majeure tous les deux ans : pourquoi quatre années entre Java 6 et Java 7. En fait la raison est assez simple. En 2009 Sun, société en graves difficultés financières depuis plus d'un an, annonce son rachat par Oracle. Cette procédure de rachat va en fait durer plus d'un an, durant lequel les développement de la plateforme Java ne progressent quasiment pas. Au premier degré, le rachat perturbe le rythme des sorties : la version 7 ne sort qu'en 2011, soit après cinq longues années d'attente. Techniquement la période n’est pas la bonne : en 2005 le débat "comment intégrer les lambdas expressions" en Java s'ouvre. La question n'est pas d'intégrer ou non cette technologie, mais porte bien sur le comment. Le délai dans la sortie de la version 7 met en sommeil ce débat, et cette intégration également. Rétrospectivement, ce retard n’est peut-être pas une si mauvaise chose, cela aura probablement permis de ne pas tomber dans certains écueils. En 2010, Oracle, nouvellement propriétaire de Sun, et donc de Java, se retrouve donc avec un problème à résoudre : quelle sera la prochaine version majeure de Java ? Et surtout : que mettra-t-on dans cette version ? Voilà quatre ans qu'il n’y a pas eu de version majeure, le projet Lambda est dans l'ornière, et les rumeurs commencent à courir : "Java est en train de devenir le nouveau Cobol", c'est-à-dire un langage du passé, condamné à disparaître à plus ou moins long terme. La réponse d’Oracle a été de sortir une version 7, avec ce qui était alors prêt à être publié. Donc une version 7 sans le projet Lambda. Cette version contient malgré tout de nombreux ajouts très intéressants : quelques modifications du langage, des mises à jour des API existantes, une nouvelle API I/O, un framework de calcul parallèle. Mais l'attente est déçue : les lambdas sont reportés pour la version 8, plus tard. La réaction de la blogosphère est lapidaire : Java 7 sans les lambdas déçoit. Un deuxième événement vient perturber les choses. 2012 devait être l’année de l’intégration du projet Lambda dans Java 8. Elle sera l'année de la correction de problèmes de sécurité dans Java 6 et 7. Ces problèmes arrivent jusque dans la presse grand public, l'image de Java est atteinte, et Oracle doit consacrer toutes les ressources disponibles aux correctifs. Java 8 prend du retard, la date de sortie annoncée est repoussée de 6 mois. C'est donc en 2014 que Java 8 sort. On peut considérer que l’intégration du projet Lambda, initialement prévue probablement pour 2008 a donc pris 6 ans de retard. Considérable pour un langage informatique. La possibilité d’exécuter le même code Java sur n’importe quelle machine, et sous n’importe quel système d’exploitation a été le premier souci des concepteurs de ce langage. L’objectif était de pouvoir télécharger des applets Java au travers de l’Internet, et de les exécuter dans son propre navigateur, la compatibilité absolue était donc nécessaire. Il est donc possible de compiler un programme Java sur une machine sous Windows, et d’exécuter ce code binaire sur un Macintosh. Voici une liste (non exhaustive !) des systèmes pour lesquels des machines Java existent : PC Windows et Linux, toute machine Unix, DEC sous VMS, IBM sous MVS, téléphones portables, PDA (PocketPC Palm OS), processeurs embarqués, cartes à puce.
Java langage & API
Retour au blog Java le soir
Cours & Tutoriaux