Introduction au Langage Java

Introduction au langage Java

• La caractéristique de simplicité du langage Java : dépouillé de mécanismes complexes (gestion des pointeurs, gestion de la mémoire, héritage multiple, …) pour une syntaxe familière aux programmeurs C et C++.

Caractéristiques de Java

• Orienté objet : tout est objet, les méthodes sont définies comme partie intrinsèque des classes.
• Orienté réseau et distribué : développement d'applications réparties, accès facile à des données distantes sur le réseau, et réalisation des applications client/serveur grâce aux classes paquetages de communication (java.net).
• Multitâche (multi-thread) : possibilité de concevoir des applications capables d'effectuer plusieurs actions (thread) en même temps.
• Dynamique : un programme Java charge les classes qu'il utilise en cours d'exécution, la modification d'une classe ne nécessite pas une recompilation de l'application.
• Robuste : les caractéristiques suivantes permettent d'atteindre l'objectif de la fiabilité des logiciels : typage fort, pas d'accès aux pointeurs, gestionnaire de la mémoire, mécanisme de gestion d'exception.
• Sécurisé : éviter d'exécuter du code dommageable, API destinés au cryptage, à la gestion de l'authentification, …
• Interprété, indépendant des architectures matérielles : le code produit par le compilateur n'est pas du code machine, mais un code intermédiaire (bytecode) simple et rapide à traduire en langage machine.

Compilation et exécution des programmes

• La compilation du code source Java produit un fichier bytecode (.class) qui peut être exécuté sur n'importe quelle plateforme supportant la machine virtuelle Java (JVM).
• La JVM lit les instructions en bytecode, les traduit dans le langage natif du processeur de l'ordinateur et lance leur exécution.

Environnement de développement

• La plateforme Java est composée de l'API, de la JVM et du système d'exploitation hôte.
• Le JDK (Java Development Kit) comprend toutes les classes du Java, un compilateur (javac.exe), une machine virtuelle (java.exe), un débogueur (jdb.exe), un générateur de documentation technique (javadoc.exe), un générateur de fichiers archives (jar.exe), une visionneuse d'applets (appletviewer.exe) et divers outils pour le RMI.
• Un IDE (Integrated Development Environment) propose des fonctionnalités telles que l'édition à coloration syntaxique, les assistants de préfabrication de code, l'explorateur de classes, l'aide en ligne, le débogueur graphique, le composeur d'interface graphique.

Structure d'un programme Java

• Un programme Java est constitué d'un ensemble de fichiers sources (extension .java) contenant des définitions de classes.
• Une classe est définie par son nom, ses attributs (données) et ses méthodes (fonctions).
• Un objet est créé à partir d'une classe et réside dans la mémoire centrale de l'ordinateur.
• Les fichiers sources peuvent contenir une ou plusieurs définitions de classes, mais une seule classe publique par fichier source.

Éléments d'une classe

• Les variables d'instance : elles conservent l'état de l'objet.
• Les constructeurs : ils servent à créer des objets (instances) de la classe.
• Les méthodes : elles déterminent le comportement des instances de la classe.
• Les conventions pour les identificateurs : les noms des classes commencent par une majuscule, les noms des variables et des méthodes commencent par une minuscule, les mots contenus dans un identificateur commencent par une majuscule.### Variables
• Les variables d'instance sont déclarées en dehors de toute méthode et conservent l'état d'un objet.
• Elles sont accessibles et partagées par toutes les méthodes de la classe.
• Les variables locales sont déclarées à l'intérieur d'une méthode et conservent une valeur utilisée pendant l'exécution de la méthode.
• Les variables locales ne sont accessibles que dans le bloc dans lequel elles ont été déclarées.

Déclaration et initialisation des variables

• La déclaration d'une variable indique au compilateur que le programme va utiliser une variable de ce nom et de ce type.
• Toute variable doit être déclarée avant d'être utilisée.
• La déclaration se fait à l'aide de la syntaxe suivante : Type NomVariable [=valeur d'initialisation];
• Les variables d'instance reçoivent automatiquement des valeurs par défaut si elles ne sont pas initialisées par le programmeur.

Création d'un objet

• La déclaration d'une variable destinée à référencer un objet ne suffit pas à créer cet objet.
• Pour créer un objet, il faut utiliser l'opérateur new.
• L'opérateur new procède en trois étapes :
  • Alloue dynamiquement la mémoire de l'objet.
  • Appelle la méthode constructeur et exécute le constructeur.
  • Retourne l'adresse de l'objet ainsi construit.

Méthodes

• Chaque objet dispose des méthodes définies au niveau de la classe.
• Les méthodes agissent sur les valeurs de l'objet tout en retournant rien (void).
• Une méthode s'exécute au sein d'un espace qui contient à la fois les variables de l'objet et les variables (arguments) de la fonction.

Définition d'une méthode

• Pour chaque méthode d'une classe, il faut indiquer :
  • Le niveau d'accessibilité (par exemple public).
  • Le type de la valeur de retour.
  • Le nom de la méthode et ses arguments formels avec leurs types.
• La spécification du nom, du type de retour, de la valeur d'accessibilité et des arguments d'une méthode s'appelle la signature de la méthode.

Constructeurs

• Un constructeur est une méthode spéciale qui permet de créer une instance d'une classe.
• Les caractéristiques d'un constructeur sont :
  • Il porte le nom de la classe.
  • Il n'est jamais appelé directement.
  • Il ne retourne pas de valeur, mais il ne faut pas indiquer void.
• Si le programmeur ne définit pas de constructeur, le compilateur en rajoute un appelé constructeur par défaut qui ne fait rien.

This

• Le mot clé this est utilisé dans les deux cas suivants :
  • Pour référencer l'objet courant.
  • Pour représenter un des constructeurs de l'objet courant.
• This est interdit de modification.

Types primitifs

• Les types primitifs de Java permettent de manipuler des nombres entiers, des nombres réels, des caractères et des booléens.
• Les types primitifs sont :
  • byte (8 bits, entier signé).
  • short (16 bits, entier signé).
  • int (32 bits, entier signé).
  • long (64 bits, entier signé).
  • float (32 bits, virgule flottante).
  • double (64 bits, virgule flottante).
  • boolean (1 bit, true ou false).
  • char (16 bits, non signé, Unicode).

Types composites

• Des classes d'emballage ont été prévues afin d'envelopper les types primitifs dans des objets.
• Les types composites sont :
  • Byte (enveloppe byte).
  • Short (enveloppe short).
  • Integer (enveloppe int).
  • Long (enveloppe long).
  • Float (enveloppe float).
  • Double (enveloppe double).
  • Boolean (enveloppe boolean).
  • Character (enveloppe char).

Opérateurs

• Les opérateurs arithmétiques sont : +, -, *, /, %.
• Les opérateurs d'affectation sont : =, +=, -=, *=, /=, %=.
• Les opérateurs unaires sont : ++, --.
• Les opérateurs de comparaison logique sont : ==, !=, >, <, >=, <=.
• Les opérateurs logiques sur des booléens sont : !, &&, ||.
• Les opérateurs ternaires sont : ?.

Transtypage

• Le transtypage est l'opération qui consiste à stocker dans une variable une valeur d'un autre type.

• Le transtypage implicite est possible lorsque l'on fait entrer le contenu d'une variable d'un type plus petit vers un type plus grand.

• La conversion implicite doit se faire suivant la hiérarchie suivante :

  • byte -> short -> int -> long -> float -> double.
  • char -> int -> long -> double.

• Java refuse par exemple, de convertir implicitement une valeur de type float en int.### Transtypage

• Il existe deux types de transtypage : implicite et explicite

• Exemple de transtypage implicite : long y = x; où x est un entier

• Exemple de transtypage explicite : int y = (int) 60.58; où la valeur 60 est affectée à y avec perte d'information

Instruction conditionnelle

• La structure d'une instruction conditionnelle if est : if (expression booléenne) {instructions} else {instructions}
• Exemple d'instruction conditionnelle if : if (age < 18) {System.out.println("Vous êtes mineur");} else {System.out.println("Vous êtes majeur");}
• La structure d'une instruction conditionnelle switch est : switch (expression) {case valeur1: instructions; break; case valeur2: instructions; break; ... default: instructions; break;}
• Exemple d'instruction conditionnelle switch : switch (choix) {case 'o': System.out.println("Ouverture du fichier"); break; case 'f': System.out.println("Fermeture du fichier"); break; ...}

Instruction iterative

• Les instructions iteratives sont : while et do ... while
• La structure d'une instruction while est : while (expression booléenne) {instructions;}
• La structure d'une instruction do ... while est : do {instructions;} while (expression booléenne);
• Exemple d'instruction while : int taille = 130; while (taille > 230) {System.out.println("la valeur saisie doit être inférieure à 230");}
• Exemple d'instruction do ... while : do {System.out.println("la valeur saisie doit être inférieure à 230");} while (taille > 230);

Instruction d'interruption

• Les instructions d'interruption sont : break et continue
• break permet de sortir d'une boucle
• continue permet de sortir d'une boucle, mais en retournant à la condition booléenne
• Exemple d'instruction d'interruption : for (int j = 0; j < 20; j++) {if (j == 4) continue; System.out.println("Valeur de j : " + j); if (j == 6) break;}

Tableaux

• Un tableau est un objet qui permet de regrouper plusieurs éléments de même type
• La taille du tableau est définie au moment de sa création et ne peut plus être changée par la suite
• Les éléments d'un tableau sont initialisés à 0 pour les valeurs numériques, à false pour les booléens et à null pour les objets
• L'accès aux éléments d'un tableau se fait en spécifiant un nombre entier indexé à partir de 0
• Un tableau a un attribut length qui retourne la taille du tableau
• Exemple de déclaration de tableau : int[] tableauDEntiers; ou int tableauDEntiers[];
• Exemple d'initialisation de tableau : int[] tabDeInt = {10, 5, 6};

Tableaux multidimensionnels

• Les tableaux multidimensionnels sont des "tableaux de tableaux"
• Le nombre de dimensions est sans limite
• Exemple de tableau multidimensionnel : int[][] tab1 = new int[2][6];

Membres de classe

• Une variable de classe est stockée dans la classe et existe dès que la classe est chargée
• Une variable de classe est globale à toutes les instances de la classe
• Une variable de classe est déclarée à l'aide du modificateur static
• Une méthode de classe est appelée directement par la classe, sans nécessiter d'objet
• Une méthode de classe exécute une action indépendante d'une instance particulière de la classe
• Exemple de méthode de classe : public static double max(double x, double y) {if (x > y) return x; else return y;}

Bloc d'initialisation static

• Un bloc d'initialisation static permet d'initialiser les variables static complexes
• Il est exécuté une seule fois, quand la classe est chargée en mémoire
• Exemple de bloc d'initialisation static : static {for (int i = 0; i < tab.length; i++) {tab[i] = 2 * i;}}