1.    Java et la programmation orientée objet


La programmation orientée objet (POO), ou programmation par objet, est un paradigme de programmation informatique élaboré par Alan Kay dans les années 1970. Elle possède de nombreuses vertus universellement reconnues. Elle se fonde sur la programmation structurée. Elle a pour objectif de contribuer à la fiabilité des logiciels et de faciliter la réutilisation de code existant.

Elle se base sur quelques concepts fondamentaux qui sont très importants pour comprendre le paradigme. 

1.1       Objet et classe

Un objet représente un agglomérat logiciel de données et de fonctions qui agissent sur ces données. Les fonctions sont appelées des méthodes. Les méthodes peuvent être appelées – elles reçoivent des messages. Après quand elles finissent leur exécution, elles retournent des résultats – elles envoient des réponses



Fig. 1.1 Objet dans POO

Le concept de classe correspond simplement à la généralisation de la notion de type que l’on rencontre dans les langages classiques. Une classe représente un patron (modèle, prototype) qui définit le type de l’objet. Chaque objet représente une instance spécifique de la classe qui possède ses données propres.


1.2       L’encapsulation des données

Le concept introduit une différence entre la visibilité des différents composants - données et  méthodes pour l’extérieur de la classe. C’est un processus d’agrégation de l’objet en deux parties:
•    Partie interne, constituée principalement des données. Cette partie est inaccessible ou cachée, aux objets qui n’appartiennent pas à la même classe. Elle est protégée de toute altération venant de l’extérieur. Elle pourrait être transformée à tout moment sans affecter les autres parties du programme
•    Partie externe, constituée principalement des méthodes. Cette partie représente l’interface de l’objet vis-à-vis le reste du programme.




Fig. 1.2 Encapsulation des données

1.3       L’héritage

 Le concept permet de définir une nouvelle classe (sous classe, classe dérivée) à partir d’une classe existante (super classe, classe de base) qu’on réutilise en bloc. Dans la classe dérivée on ajoute de nouvelles données et de nouvelles méthodes. La nouvelle classe hérite des propriétés et des aptitudes de l’ancienne. Elle peut ainsi s’appuyer sur des réalisations antérieures et les spécialiser à volonté.

Il faut noter que la classe dérivée a toutes les propriétés et le même comportement que la classe de base et elle peut la remplacer dans les programmes. Très souvent on parle d’héritage comme une relation de type "is a". Ça veut dire que si dans le programme on a besoin d’un objet de classe de base, on peut toujours le remplacer par un objet d’une de ces classes dérivées. 

Le contraire n’est pas vrai – si on a besoin d’un objet d’une classe dérivée, on ne peut pas utiliser un objet d’une classe de base. La dernière ne possède pas toutes les propriétés et le comportement de sa classe dérivée.

L'héritage facilite largement la réutilisation des produits existants, d’autant plus qu’il peut être réitéré autant de fois que nécessaire (la classe C peut hériter de B, qui elle-même hérite de A). Une classe peut avoir plusieurs classes dérivées. Par contre en Java une classe ne peut avoir qu’une seule classe de base. En réitérant plusieurs fois la technique d’héritage on peut arriver à la création des arbres d’héritage.


Fig. 1.3 Arbre d’héritage

1.4       Le polymorphisme

Une classe peut "redéfinir" (c’est-à-dire modifier) certaines des méthodes héritées de sa classe de base. Cette possibilité est la clé de ce que l’on nomme le "polymorphisme", c’est-à-dire la possibilité de traiter de la même manière des objets de types différents. Cette possibilité est réservée aux objets issus de classes dérivées d’une même classe de base. Plus précisément, on utilise chaque objet comme s’il était de cette classe de base, mais son comportement effectif dépend de sa classe effective (dérivée de cette classe de base). Ce comportement dépend en particulier de la manière dont ses propres méthodes ont été redéfinies. Le polymorphisme permet d’ajouter de nouveaux objets dans un scénario préétabli et, éventuellement, écrit avant d’avoir connaissance du type exact de ces objets

1.5           Le langage Java - introduction

1.5.1    Généralités

Le langage reprend en grande partie la syntaxe des langages C et C++. Java a supprimé des concepts les plus subtils et à la fois les plus déroutants du C et C++:

•    L’arithmétique des pointeurs n’existe pas.
•    Il n’y a pas d’héritage multiple au niveau des classes. Il était remplacé par l’implémentation des interfaces.
•    Pas de surcharge des types primitifs et des opérateurs. Il n’est pas possible de redéfinir ce qui est un entier, un nombre flottant, une addition etc.
•    Il y a un mécanisme de la libération automatique de la mémoire non utilisée (Garbage Collector).

Les concepteurs ont privilégié l’approche orientée objet de sorte qu’en Java, tout est objet à l’exception des types primitifs (nombres entiers, nombres à virgule flottante, etc.)

Un des atouts majeurs de Java c’est sa portabilité. La compilation d’un code source produit, non pas des instructions machine, mais un code intermédiaire nommé "byte code" ou "pseudo code". D’une part, ce code est exactement le même, quel que soient le compilateur et l’environnement concernés. D’autre part, il est exécutable dans toute implémentation disposant du logiciel d’interprétation nommé machine virtuelle (MV) Java (Java Virtual Machine- JVM) – Fig. 1.4.

Fig. 1.4 Portabilité Java


De surcroît, Java définit exactement les caractéristiques des types primitifs servant à représenter les caractères, les entiers et les flottants. Cela concerne non seulement la taille de l’emplacement mémoire, mais aussi le comportement arithmétique correspondant. Ainsi, quelle que soit la machine, une valeur de type "float" (réel) aura exactement la même taille, les mêmes limites et la même précision.

Les fichiers .class ont un format bien défini, dans lequel on conserve aussi les noms des méthodes et des attributs. Certains outils existent sur le marché pour décompiler les classes. C’est efficace, mais pas très légal.

On voit sur la Fig. 1.5 que pendant l’étape de l’exécution le pseudo code est converti vers le code interne de la machine. Il y a deux possibilités – interpréter le pseudo code ou bien optimiser l'exécution en compilant à la volée le pseudo-code en code machine – compilation JIT ("Just In Time").

Fig. 1.5. Compilation est exécution des programmes Java

Dans ce cours nous allons utiliser souvent le concept "Plateforme Java". La plupart des plateformes sont combinaison entre le système d'exploitation et le hardware. La plateforme Java  est software plateforme qui travaille sur différents hardware plateformes.

La plateforme Java a deux composants:

·       Java Virtual Machine

·       Java Application Programming Interface (API)

API - c'est une large collection de software composants groupés en bibliothèques appelées packages

Fig. 1.6 Plateforme Java


1.5.2    Évolutions de Java


•    JDK 1.0 (1996) –  Version initiale.
•    JDK 1.1 (1997) – De  nombreux ajouts.
•    J2SE 1.2 (1998) – Nom  de code Playground. Cette version et les suivantes 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 J2EE (Java 2 Platform, Enterprise Edition) et de la version J2ME (Java 2 Platform, Micro Edition). Plusieurs ajouts. Pour la première fois, la machine virtuelle Java de Sun inclut un compilateur « Juste à temps » (Just in Time).
•    J2SE 1.3             2000     Nom de code Kestrel.
•    J2SE 1.4             2002     Nom de code Merlin.
•    J2SE 5.0             2004     Nom de code Tiger, ajoute un nombre significatif de nouveautés au langage :
•    Java SE 6            2006     Nom de code Mustang. Avec cette version, Sun remplace le nom J2SE par Java SE.
•    Java SE 7            2011     Nom de code Dolphin. Il s’agit de la première version sous la licence GPL.
•    Java SE 8 (LTS)  2014     Nom de code Spider     Support Until  At least May 2026 (public updates for development and personal use indefinitely)
•    Java SE 9            2018
•    Java SE 10          March 20, 2018
•    Java SE 11 (LTS)  September 25, 2018                   Support Until  At least October 2024
•    Java SE 12            March 19, 2019
•    Java SE 13            September 17, 2019
•    Java SE 14            March 17, 2020
•    Java SE 15            September 15, 2020[42]
•    Java SE 16            March 16, 2021
•    Java SE 17 (LTS)  September 14, 2021                     Support Until  At least September 2029
•    Java SE 18            March 2022
•    Java SE 19            September 20, 2022
•    Java SE 20            March  21, 2022 
•    Java SE 21 (LTS)  September 19, 2023

Depuis  Septembre 2021, Java 8, 11, 17 et 21 sont déclarés Long-Term Support (LTS) versions

1.5.3    Premier exemple de programme Java

public class Bienvenue{
                      public static void main (String [] args){
                            System.out.println("bienvenue a la programmation Java");
                      }
}

1.6           Eléments du lexique

mots clés

abstract

assert

boolean

break

byte

case

catch

char

class

const

continue

default

do

double

else

extends

final

finally

float

for

goto

if

implements

import

instanceof

int

interface

long

native

new

null

package

private

protected

public

return

short

static

super

switch

synchronized

this

throw

throws

transient

try

void

volatile

while


1.6.2    Les commentaires

public class Bienvenue{
           public static void main (String [] args){  
/* La ligne déclare
                                                                                                  le point d’entré du
                                                                                                  programme 
*/
                            System.out.println("bienvenue a la programmation Java");
           }
}

public class Bienvenue{
    public static void main (String [] args){ // Déclaration du point d’entré
        System.out.println("bienvenue a la programmation Java");
    }
}

public class Bienvenue{   
/*
    public static void main (String [] args){ // Déclaration du point d’entré
        System.out.println("bienvenue a la programmation Java");
    }
*/