Support de cours JAVA

Qu'est-ce que 'java?

Java est un langage de programmation orienté objet de haut niveau populaire, développé à
l'origine par Sun Microsystems et publié en 1995. Actuellement, Java appartient à Oracle et
plus de 3 milliards d'appareils exécutent Java. Java s'exécute sur diverses plates-formes, telles
que Windows, Mac OS et les différentes versions d'UNIX. Java est utilisé pour développer de
nombreux types d'applications logicielles telles que des applications mobiles, des applications
Web, des applications de bureau, des jeux et bien plus encore.

Applications Java
La dernière version de Java Standard Edition est Java SE 18. Avec l'avancement de Java et sa
popularité généralisée, plusieurs configurations ont été conçues pour s'adapter à différents
types de plates-formes. Par exemple : J2EE pour les applications d'entreprise, J2ME pour les
applications mobiles.

Les nouvelles versions J2 ont été renommées respectivement Java SE, Java EE et Java ME.
Java est garanti pour être Write Once, Run Anywhere.

• Multithread - Avec la fonction multithread de Java, il est possible d'écrire des

programmes capables d'effectuer plusieurs tâches simultanément. Cette fonctionnalité
de conception permet aux développeurs de créer des applications interactives qui
peuvent fonctionner sans problème.
• Interprété - Le code binaire Java est traduit à la volée en instructions machine natives
et n'est stocké nulle part. Le processus de développement est plus rapide et analytique
car la mise en relation est un processus incrémental et léger.
• Hautes performances − Avec l'utilisation de compilateurs Just-In-Time, Java permet
des performances élevées.
• Distribué - Java est conçu pour l'environnement distribué d'Internet.
• Dynamique - Java est considéré comme plus dynamique que C ou C++ car il est
conçu pour s'adapter à un environnement en évolution. Les programmes Java peuvent
contenir une grande quantité d'informations d'exécution qui peuvent être utilisées pour
vérifier et résoudre les accès aux objets lors de l'exécution.

Java - Présentation

Le langage de programmation Java a été initialement développé par Sun Microsystems, initié
par James Gosling et publié en 1995 en tant que composant central de la plate-forme Java de
Sun Microsystems (Java 1.0 [J2SE]).
La dernière version de Java Standard Edition est Java SE 8. Avec l'avancement de Java et sa
popularité généralisée, plusieurs configurations ont été conçues pour s'adapter à différents
types de plates-formes. Par exemple : J2EE pour les applications d'entreprise, J2ME pour les
applications mobiles.

Les nouvelles versions J2 ont été renommées respectivement Java SE, Java EE et Java ME.
Java est garanti pour être Write Once, Run Anywhere.

Java est -

• Orienté objet - En Java, tout est un objet. Java peut être facilement étendu car il est
basé sur le modèle Objet.
• Indépendant de la plate-forme - Contrairement à de nombreux autres langages de
programmation, notamment C et C ++, lorsque Java est compilé, il n'est pas compilé
dans une machine spécifique à la plate-forme, mais plutôt dans un code binaire
indépendant de la plate-forme. Ce code binaire est distribué sur le Web et interprété
par la machine virtuelle (JVM) sur la plate-forme sur laquelle il est exécuté.
• Simple − Java est conçu pour être facile à apprendre. Si vous comprenez le concept de
base de OOP Java, il serait facile à maîtriser.
• Sécurisé − Avec la fonction sécurisée de Java, il permet de développer des systèmes
sans virus et inviolables. Les techniques d'authentification sont basées sur le
chiffrement à clé publique.
• Architecture neutre - Le compilateur Java génère un format de fichier objet
indépendant de l'architecture, ce qui rend le code compilé exécutable sur de nombreux
processeurs, avec la présence du système d'exécution Java.
• Portable - Le fait d'être indépendant de l'architecture et de ne pas avoir d'aspects
dépendant de l'implémentation de la spécification rend Java portable. Le compilateur
en Java est écrit en ANSI C avec une limite de portabilité propre, qui est un sous-
ensemble POSIX.
• Robuste - Java s'efforce d'éliminer les situations sujettes aux erreurs en mettant
principalement l'accent sur la vérification des erreurs de compilation et la vérification
de l'exécution.
• Multithread - Avec la fonction multithread de Java, il est possible d'écrire des
programmes capables d'effectuer plusieurs tâches simultanément. Cette fonctionnalité
de conception permet aux développeurs de créer des applications interactives qui
peuvent fonctionner sans problème.
• Interprété - Le code binaire Java est traduit à la volée en instructions machine natives
et n'est stocké nulle part. Le processus de développement est plus rapide et analytique
car la mise en relation est un processus incrémental et léger.
• Hautes performances − Avec l'utilisation de compilateurs Just-In-Time, Java permet
des performances élevées.
• Distribué - Java est conçu pour l'environnement distribué d'Internet.
• Dynamique - Java est considéré comme plus dynamique que C ou C++ car il est
conçu pour s'adapter à un environnement en évolution. Les programmes Java peuvent
contenir une grande quantité d'informations d'exécution qui peuvent être utilisées pour
vérifier et résoudre les accès aux objets lors de l'exécution.
Hello World en utilisant la programmation Java.
Juste pour vous donner un peu d'enthousiasme pour la programmation Java, je vais vous
donner un petit programme Hello World de programmation C conventionnel, vous pouvez
l'essayer en utilisant le lien Demo.

Démo en direct
public class MyFirstJavaProgram {

/* This is my first java program.

* This will print 'Hello World' as the output
*/

public static void main(String []args) {

System.out.println("Hello World"); // prints Hello World
}
}

Histoire de Java
James Gosling a lancé un projet de langage Java en juin 1991 pour une utilisation dans l'un de
ses nombreux projets de décodeurs. La langue, initialement appelée «Oak» d'après un chêne
qui se trouvait à l'extérieur du bureau de Gosling, s'appelait également «Green» et a fini par
être renommée Java, à partir d'une liste de mots aléatoires.

Sun a publié la première implémentation publique sous le nom de Java 1.0 en 1995. Il
promettait Write Once, Run Anywhere (WORA), fournissant des temps d'exécution gratuits
sur les plates-formes populaires.

Le 13 novembre 2006, Sun a publié une grande partie de Java en tant que logiciel libre et
open source selon les termes de la licence publique générale GNU (GPL).

Le 8 mai 2007, Sun a terminé le processus, rendant tout le code de base de Java gratuit et
open source, à l'exception d'une petite partie du code dont Sun ne détenait pas les droits
d'auteur.

Outils dont vous aurez besoin

Pour exécuter les exemples abordés dans ce didacticiel, vous aurez besoin d'un ordinateur
Pentium 200 MHz avec un minimum de 64 Mo de RAM (128 Mo de RAM recommandés).

Vous aurez également besoin des logiciels suivants −

• Système d'exploitation Linux 7.1 ou Windows XP/7/8

• JavaJDK 8
• Tout autre éditeur de texte
Configuration de l'environnement

Configuration de l'environnement local

Si vous souhaitez toujours configurer votre environnement pour le langage de programmation
Java, cette section vous explique comment télécharger et configurer Java sur votre machine.
Voici les étapes pour configurer l'environnement.

Java SE est disponible gratuitement à partir du lien Télécharger Java . Vous pouvez
télécharger une version basée sur votre système d'exploitation.

Suivez les instructions pour télécharger Java et exécutez le .exe pour installer Java sur votre
machine. Une fois que vous avez installé Java sur votre machine, vous devrez définir des
variables d'environnement pour pointer vers les répertoires d'installation corrects -

Configuration du chemin pour Windows

En supposant que vous avez installé Java dans le répertoire c:\Program Files\java\jdk −

• Faites un clic droit sur 'Poste de travail' et sélectionnez 'Propriétés'.

• Cliquez sur le bouton "Variables d'environnement" sous l'onglet "Avancé".
• Maintenant, modifiez la variable 'Path' afin qu'elle contienne également le chemin vers
l'exécutable Java. Par exemple, si le chemin est actuellement défini sur
'C:\WINDOWS\SYSTEM32', modifiez votre chemin pour lire
'C:\WINDOWS\SYSTEM32;c:\Program Files\java\jdk\bin'.

Configuration du chemin pour Linux, UNIX, Solaris, FreeBSD

La variable d'environnement PATH doit être définie pour pointer vers l'endroit où les binaires
Java ont été installés. Reportez-vous à la documentation de votre shell, si vous avez des
difficultés à le faire.

Par exemple, si vous utilisez bash comme shell, vous ajouterez la ligne suivante à la fin de
votre '.bashrc : export PATH = /path/to/java:$PATH'

Éditeurs Java populaires

Pour écrire vos programmes Java, vous aurez besoin d'un éditeur de texte. Il existe des IDE
encore plus sophistiqués disponibles sur le marché. Mais pour l'instant, vous pouvez envisager
l'un des éléments suivants -

• Netbeans - Un IDE Java open-source et gratuit qui peut être téléchargé à partir de
https://www.netbeans.org/index.html .
• Eclipse - Un IDE Java développé par la communauté open-source eclipse et peut être
téléchargé à partir de https://www.eclipse.org/ .
Syntaxe de base

Lorsque nous considérons un programme Java, il peut être défini comme une collection
d'objets qui communiquent en invoquant les méthodes de l'autre. Voyons maintenant
brièvement ce que signifient les variables de classe, d'objet, de méthode et d'instance.

• Objet - Les objets ont des états et des comportements. Exemple : Un chien a des états
- couleur, nom, race ainsi que des comportements tels que remuer la queue, aboyer,
manger. Un objet est une instance d'une classe.
• Classe - Une classe peut être définie comme un modèle/plan directeur qui décrit le
comportement/l'état que l'objet de son type prend en charge.
• Méthodes - Une méthode est essentiellement un comportement. Une classe peut
contenir plusieurs méthodes. C'est dans les méthodes où les logiques sont écrites, les
données sont manipulées et toutes les actions sont exécutées.
• Variables d'instance - Chaque objet a son ensemble unique de variables d'instance.
L'état d'un objet est créé par les valeurs affectées à ces variables d'instance.

Premier programme Java

Regardons un code simple qui imprimera les mots Hello World .

Exemple
Démo en direct

public class MyFirstJavaProgram {

/* This is my first java program.

* This will print 'Hello World' as the output
*/

public static void main(String []args) {

System.out.println("Hello World"); // prints Hello World
}
}

Syntaxe de base
À propos des programmes Java, il est très important de garder à l'esprit les points suivants.

• Sensibilité à la casse - Java est sensible à la casse, ce qui signifie que l'identifiant
Hello et hello auraient une signification différente en Java.
• Noms de classe − Pour tous les noms de classe, la première lettre doit être en
majuscule. Si plusieurs mots sont utilisés pour former un nom de classe, la première
lettre de chaque mot intérieur doit être en majuscule.

Exemple : classe MaPremièreClasseJava

• Noms de méthode - Tous les noms de méthode doivent commencer par une lettre
minuscule. Si plusieurs mots sont utilisés pour former le nom de la méthode, la
première lettre de chaque mot intérieur doit être en majuscule.
 Exemple : public void myMethodName()

• Nom du fichier programme - Le nom du fichier programme doit correspondre

exactement au nom de la classe.

Lors de l'enregistrement du fichier, vous devez l'enregistrer en utilisant le nom de la

classe (rappelez-vous que Java est sensible à la casse) et ajouter '.java' à la fin du nom
(si le nom du fichier et le nom de la classe ne correspondent pas, votre programme ne
compilera pas ).

Mais veuillez noter que si vous n'avez pas de classe publique présente dans le fichier,
le nom du fichier peut être différent du nom de la classe. Il n'est pas non plus
obligatoire d'avoir une classe publique dans le fichier.

Exemple : supposons que "MyFirstJavaProgram" est le nom de la classe. Ensuite, le

fichier doit être enregistré sous 'MyFirstJavaProgram.java'

• public static void main(String args[]) - Le traitement du programme Java commence

à partir de la méthode main() qui est une partie obligatoire de chaque programme Java.

Types de données
Les variables ne sont rien d'autre que des emplacements de mémoire réservés pour stocker des
valeurs. Cela signifie que lorsque vous créez une variable, vous réservez de l'espace dans la
mémoire.

En fonction du type de données d'une variable, le système d'exploitation alloue de la mémoire

et décide ce qui peut être stocké dans la mémoire réservée. Par conséquent, en affectant
différents types de données aux variables, vous pouvez stocker des entiers, des décimales ou
des caractères dans ces variables.

Il existe deux types de données disponibles en Java -

• Types de données primitifs

• Types de données de référence/d'objet

Types de données primitifs

Il existe huit types de données primitifs pris en charge par Java. Les types de données
primitifs sont prédéfinis par le langage et nommés par un mot clé. Examinons maintenant en
détail les huit types de données primitifs.

Byte

• Le type de données d'octet est un entier de complément à deux signé de 8 bits

• La valeur minimale est -128 (-2^7)
• La valeur maximale est 127 (inclus)(2^7 -1)
• La valeur par défaut est 0
 • Le type de données Byte est utilisé pour économiser de l'espace dans les grands
tableaux, principalement à la place des entiers, car un octet est quatre fois plus petit
qu'un entier.
• Exemple : octet a = 100, octet b = -50

Short

• Le type de données court est un entier de complément à deux signé de 16 bits

• La valeur minimale est -32 768 (-2^15)
• La valeur maximale est 32 767 (inclus) (2^15 -1)
• Le type de données court peut également être utilisé pour économiser de la mémoire
en tant que type de données octet. Un court est 2 fois plus petit qu'un entier
• La valeur par défaut est 0.
• Exemple : court s = 10000, court r = -20000

Int

• Le type de données Int est un entier 32 bits signé en complément à deux.

• La valeur minimale est - 2 147 483 648 (-2^31)
• La valeur maximale est 2 147 483 647 (inclus) (2^31 -1)
• Integer est généralement utilisé comme type de données par défaut pour les valeurs
intégrales, sauf en cas de problème de mémoire.
• La valeur par défaut est 0
• Exemple : int a = 100000, int b = -200000

long

• Le type de données long est un entier de complément à deux signé de 64 bits

• La valeur minimale est -9 223 372 036 854 775 808 (-2^63)
• La valeur maximale est 9 223 372 036 854 775 807 (inclus)(2^63 -1)
• Ce type est utilisé lorsqu'une plage plus large que int est nécessaire
• La valeur par défaut est 0L
• Exemple : long a = 100000L, long b = -200000L

float

• Le type de données flottant est une virgule flottante IEEE 754 32 bits simple précision
• Float est principalement utilisé pour économiser de la mémoire dans de grands
tableaux de nombres à virgule flottante
• La valeur par défaut est 0.0f
• Le type de données flottant n'est jamais utilisé pour des valeurs précises telles que la
devise
• Exemple : float f1 = 234.5f

double

• le type de données double est une virgule flottante IEEE 754 64 bits double précision
• Ce type de données est généralement utilisé comme type de données par défaut pour
les valeurs décimales, généralement le choix par défaut
 • Le type de données double ne doit jamais être utilisé pour des valeurs précises telles
que la devise
• La valeur par défaut est 0.0d
• Exemple : double d1 = 123,4

boolean

• le type de données booléen représente un bit d'information

• Il n'y a que deux valeurs possibles : true et false
• Ce type de données est utilisé pour les indicateurs simples qui suivent les conditions
vrai/faux
• La valeur par défaut est false
• Exemple : un booléen = vrai

char

• le type de données char est un seul caractère Unicode 16 bits

• La valeur minimale est '\u0000' (ou 0)
• La valeur maximale est '\uffff' (ou 65 535 inclus)
• Le type de données Char est utilisé pour stocker n'importe quel caractère
• Exemple : caractère lettreA = 'A'

Types de données de référence

• Les variables de référence sont créées à l'aide de constructeurs définis des classes. Ils
sont utilisés pour accéder aux objets. Ces variables sont déclarées d'un type spécifique
qui ne peut pas être modifié. Par exemple, Employé, Chiot, etc.
• Les objets de classe et divers types de variables de tableau relèvent du type de données
de référence.
• La valeur par défaut de toute variable de référence est nulle.
• Une variable de référence peut être utilisée pour référencer n'importe quel objet du
type déclaré ou de n'importe quel type compatible.
• Exemple : Animal animal = new Animal("girafe");

Littéraux Java
Un littéral est une représentation dans le code source d'une valeur fixe. Ils sont représentés
directement dans le code sans aucun calcul.

Les littéraux peuvent être affectés à n'importe quelle variable de type primitif. Par exemple -

byte a = 68;
char a = 'A';

byte, int, long et short peuvent également être exprimés dans les systèmes de nombre décimal
(base 10), hexadécimal (base 16) ou octal (base 8).

Le préfixe 0 est utilisé pour indiquer l'octal et le préfixe 0x indique l'hexadécimal lors de
l'utilisation de ces systèmes de numération pour les littéraux. Par exemple -
int decimal = 100;
int octal = 0144;
int hexa = 0x64;

Les littéraux de chaîne en Java sont spécifiés comme ils le sont dans la plupart des autres
langages en entourant une séquence de caractères entre une paire de guillemets doubles. Des
exemples de littéraux de chaîne sont -

Exemple
"Hello World"
"two\nlines"
"\"This is in quotes\""

Les types de littéraux chaîne et char peuvent contenir n'importe quel caractère Unicode. Par
exemple -

char a = '\u0001';
String a = "\u0001";

Le langage Java prend également en charge quelques séquences d'échappement spéciales pour
les littéraux String et char. Ils sont −

Notation Personnage représenté

\n Nouvelle ligne (0x0a)

\r Retour chariot (0x0d)

\F Saut de page (0x0c)

\b Retour arrière (0x08)

\s Espace (0x20)

\t languette

\" Double citation

\' Simple citation

\\ barre oblique inverse

\ddd Caractère octal (ddd)

\uxxxx Caractère UNICODE hexadécimal (xxxx)

Types de variables
Une variable nous fournit un stockage nommé que nos programmes peuvent manipuler.
Chaque variable en Java a un type spécifique, qui détermine la taille et la disposition de la
mémoire de la variable ; la plage de valeurs pouvant être stockées dans cette mémoire ; et
l'ensemble des opérations pouvant être appliquées à la variable.

Vous devez déclarer toutes les variables avant de pouvoir les utiliser. Voici la forme de base
d'une déclaration de variable -

data type variable [ = value][, variable [ = value] ...] ;

Ici, le type de données est l'un des types de données de Java et la variable est le nom de la
variable. Pour déclarer plusieurs variables du type spécifié, vous pouvez utiliser une liste
séparée par des virgules.

Voici des exemples valides de déclaration de variable et d'initialisation en Java -

Exemple
int a, b, c; // Declares three ints, a, b, and c.
int a = 10, b = 10; // Example of initialization
byte B = 22; // initializes a byte type variable B.
double pi = 3.14159; // declares and assigns a value of PI.
char a = 'a'; // the char variable a iis initialized with value 'a'

Ce chapitre explique les différents types de variables disponibles dans le langage Java. Il
existe trois types de variables en Java -

• Variables locales
• Variables d'instance
• Variables de classe/statiques

Variables locales
• Les variables locales sont déclarées dans des méthodes, des constructeurs ou des
blocs.
• Les variables locales sont créées lorsque la méthode, le constructeur ou le bloc est
entré et la variable sera détruite une fois qu'elle quitte la méthode, le constructeur ou le
bloc.
• Les modificateurs d'accès ne peuvent pas être utilisés pour les variables locales.
• Les variables locales ne sont visibles que dans la méthode, le constructeur ou le bloc
déclaré.
• Les variables locales sont implémentées au niveau de la pile en interne.
• Il n'y a pas de valeur par défaut pour les variables locales, donc les variables locales
doivent être déclarées et une valeur initiale doit être assignée avant la première
utilisation.
Exemple

Ici, l'âge est une variable locale. Ceci est défini dans la méthode pupAge() et sa portée est
limitée à cette seule méthode.

public class Test {

public void pupAge() {
int age = 0;
age = age + 7;
System.out.println("Puppy age is : " + age);
}

public static void main(String args[]) {

Test test = new Test();
test.pupAge();
}
}

Cela produira le résultat suivant -

Sortie
Puppy age is: 7

Exemple

L'exemple suivant utilise l'âge sans l'initialiser, il donnerait donc une erreur au moment de la
compilation.

public class Test {

public void pupAge() {
int age;
age = age + 7;
System.out.println("Puppy age is : " + age);
}

public static void main(String args[]) {

Test test = new Test();
test.pupAge();
}
}

Cela produira l'erreur suivante lors de la compilation -

Sortie
Test.java:4:variable number might not have been initialized
age = age + 7;
^
1 error

Variables d'instance
• Les variables d'instance sont déclarées dans une classe, mais en dehors d'une méthode,
d'un constructeur ou de tout bloc.
• Lorsqu'un espace est alloué à un objet dans le tas, un emplacement pour chaque valeur
de variable d'instance est créé.
 • Les variables d'instance sont créées lorsqu'un objet est créé avec l'utilisation du mot
clé 'new' et détruites lorsque l'objet est détruit.
• Les variables d'instance contiennent des valeurs qui doivent être référencées par
plusieurs méthodes, constructeurs ou blocs, ou des parties essentielles de l'état d'un
objet qui doivent être présentes dans toute la classe.
• Les variables d'instance peuvent être déclarées au niveau de la classe avant ou après
utilisation.
• Des modificateurs d'accès peuvent être donnés pour les variables d'instance.
• Les variables d'instance sont visibles pour toutes les méthodes, constructeurs et blocs
de la classe. Normalement, il est recommandé de rendre ces variables privées (niveau
d'accès). Cependant, la visibilité des sous-classes peut être donnée pour ces variables à
l'aide de modificateurs d'accès.
• Les variables d'instance ont des valeurs par défaut. Pour les nombres, la valeur par
défaut est 0, pour les booléens, elle est fausse et pour les références d'objet, elle est
nulle. Les valeurs peuvent être affectées lors de la déclaration ou dans le constructeur.
• Les variables d'instance sont accessibles directement en appelant le nom de la variable
à l'intérieur de la classe. Cependant, dans les méthodes statiques (lorsque les variables
d'instance sont accessibles), elles doivent être appelées en utilisant le nom complet.
ObjectReference.VariableName .

Exemple
import java.io.*;
public class Employee {

// this instance variable is visible for any child class.

public String name;

// salary variable is visible in Employee class only.

private double salary;

// The name variable is assigned in the constructor.

public Employee (String empName) {
name = empName;
}

// The salary variable is assigned a value.

public void setSalary(double empSal) {
salary = empSal;
}

// This method prints the employee details.

public void printEmp() {
System.out.println("name : " + name );
System.out.println("salary :" + salary);
}

public static void main(String args[]) {

Employee empOne = new Employee("Ransika");
empOne.setSalary(1000);
empOne.printEmp();
}
}

Cela produira le résultat suivant -

Sortie
name : Ransika
salary :1000.0

Variables de classe/statiques
• Les variables de classe également appelées variables statiques sont déclarées avec le
mot-clé static dans une classe, mais en dehors d'une méthode, d'un constructeur ou
d'un bloc.
• Il n'y aurait qu'une seule copie de chaque variable de classe par classe, quel que soit le
nombre d'objets créés à partir de celle-ci.
• Les variables statiques sont rarement utilisées autrement qu'en tant que constantes. Les
constantes sont des variables déclarées publiques/privées, finales et statiques. Les
variables constantes ne changent jamais de leur valeur initiale.
• Les variables statiques sont stockées dans la mémoire statique. Il est rare d'utiliser des
variables statiques autres que déclarées finales et utilisées comme constantes
publiques ou privées.
• Les variables statiques sont créées au démarrage du programme et détruites à l'arrêt du
programme.
• La visibilité est similaire aux variables d'instance. Cependant, la plupart des variables
statiques sont déclarées publiques car elles doivent être disponibles pour les
utilisateurs de la classe.
• Les valeurs par défaut sont identiques à celles des variables d'instance. Pour les
nombres, la valeur par défaut est 0 ; pour les booléens, c'est faux ; et pour les
références d'objet, il est nul. Les valeurs peuvent être affectées lors de la déclaration
ou dans le constructeur. De plus, des valeurs peuvent être affectées dans des blocs
d'initialisation statiques spéciaux.
• Les variables statiques sont accessibles en appelant avec le nom de classe
ClassName.VariableName .
• Lors de la déclaration de variables de classe comme public static final, les noms de
variables (constantes) sont tous en majuscules. Si les variables statiques ne sont pas
publiques et finales, la syntaxe de dénomination est la même que celle des variables
d'instance et locales.

Exemple
import java.io.*;
public class Employee {

// salary variable is a private static variable

private static double salary;

// DEPARTMENT is a constant
public static final String DEPARTMENT = "Development ";

public static void main(String args[]) {

salary = 1000;
System.out.println(DEPARTMENT + "average salary:" + salary);
}
}

Cela produira le résultat suivant -

Sortie
Development average salary:1000

Remarque − Si les variables sont accessibles à partir d'une classe extérieure, la constante doit
être accessible en tant que Employee.DEPARTMENT

Boucle
For, While, Do … while

Condition
If, if … else, switch

Tableau
Pour utiliser un tableau dans un programme, vous devez déclarer une variable pour référencer
le tableau et vous devez spécifier le type de tableau auquel la variable peut faire référence.
Voici la syntaxe pour déclarer une variable tableau -

Syntaxe
dataType[] arrayRefVar; // preferred way.
or
dataType arrayRefVar[]; // works but not preferred way.

Remarque − Le style dataType[] arrayRefVar est préféré. Le style dataType

arrayRefVar[] vient du langage C/C++ et a été adopté en Java pour accueillir les
programmeurs C/C++.

Exemple

Les extraits de code suivants sont des exemples de cette syntaxe -

double[] myList; // preferred way.

or
double myList[]; // works but not preferred way.

Création de tableaux
Vous pouvez créer un tableau en utilisant le nouvel opérateur avec la syntaxe suivante -

Syntaxe
arrayRefVar = new dataType[arraySize];

La déclaration ci-dessus fait deux choses -

• Il crée un tableau en utilisant new dataType[arraySize].

• Il affecte la référence du tableau nouvellement créé à la variable arrayRefVar.
La déclaration d'une variable de tableau, la création d'un tableau et l'attribution de la référence
du tableau à la variable peuvent être combinées dans une seule instruction, comme indiqué ci-
dessous -

dataType[] arrayRefVar = new dataType[arraySize];

Alternativement, vous pouvez créer des tableaux comme suit -

dataType[] arrayRefVar = {value0, value1, ..., valuek};

Les éléments du tableau sont accessibles via l' index . Les indices de tableau sont basés sur 0 ;
c'est-à-dire qu'ils commencent de 0 à arrayRefVar.length-1 .

Exemple

L'instruction suivante déclare une variable de tableau, myList, crée un tableau de 10 éléments
de type double et attribue sa référence à myList -

double[] myList = new double[10];

Tableaux de traitement
Lors du traitement des éléments d'un tableau, nous utilisons souvent une boucle for ou
foreach car tous les éléments d'un tableau sont du même type et la taille du tableau est
connue.

Exemple

Voici un exemple complet montrant comment créer, initialiser et traiter des tableaux -

public class TestArray {

public static void main(String[] args) {

double[] myList = {1.9, 2.9, 3.4, 3.5};

// Print all the array elements

for (int i = 0; i < myList.length; i++) {
System.out.println(myList[i] + " ");
}

// Summing all elements

double total = 0;
for (int i = 0; i < myList.length; i++) {
total += myList[i];
}
System.out.println("Total is " + total);

// Finding the largest element

double max = myList[0];
for (int i = 1; i < myList.length; i++) {
if (myList[i] > max) max = myList[i];
}
System.out.println("Max is " + max);
}
}

Cela produira le résultat suivant -

Sortie
1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

Les boucles foreach

JDK 1.5 a introduit une nouvelle boucle for connue sous le nom de boucle foreach ou boucle
for améliorée, qui vous permet de parcourir séquentiellement le tableau complet sans utiliser
de variable d'index.

Exemple

Le code suivant affiche tous les éléments du tableau myList −

public class TestArray {

public static void main(String[] args) {

double[] myList = {1.9, 2.9, 3.4, 3.5};

// Print all the array elements

for (double element: myList) {
System.out.println(element);
}
}
}

Cela produira le résultat suivant -

Sortie
1.9
2.9
3.4
3.5

Passer des tableaux aux méthodes

Tout comme vous pouvez transmettre des valeurs de type primitif à des méthodes, vous
pouvez également transmettre des tableaux à des méthodes. Par exemple, la méthode suivante
affiche les éléments dans un tableau int -

Exemple
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
Vous pouvez l'invoquer en passant un tableau. Par exemple, l'instruction suivante appelle la
méthode printArray pour afficher 3, 1, 2, 6, 4 et 2 -

Exemple
printArray(new int[]{3, 1, 2, 6, 4, 2});

Méthodes
Une méthode Java est une collection d'instructions qui sont regroupées pour effectuer une
opération. Lorsque vous appelez le System.out. println() , par exemple, le système exécute en
fait plusieurs instructions afin d'afficher un message sur la console.

Vous allez maintenant apprendre à créer vos propres méthodes avec ou sans valeurs de retour,
à invoquer une méthode avec ou sans paramètres et à appliquer l'abstraction de méthode dans
la conception du programme.

Méthode de création
Considérant l'exemple suivant pour expliquer la syntaxe d'une méthode -

Syntaxe

public static int methodName(int a, int b) {

// body
}

Ici,

• public statique − modificateur

• int - type de retour
• methodName - nom de la méthode
• a, b − paramètres formels
• int a, int b − liste de paramètres

La définition de méthode se compose d'un en-tête de méthode et d'un corps de méthode. La

même chose est montrée dans la syntaxe suivante -

Syntaxe

modifier returnType nameOfMethod (Parameter List) {

// method body
}

La syntaxe ci-dessus comprend -

• modifier - Il définit le type d'accès de la méthode et son utilisation est facultative.

• returnType - La méthode peut renvoyer une valeur.
• nameOfMethod - Il s'agit du nom de la méthode. La signature de la méthode se
compose du nom de la méthode et de la liste des paramètres.
 • Liste de paramètres - La liste des paramètres, c'est le type, l'ordre et le nombre de
paramètres d'une méthode. Ceux-ci sont facultatifs, la méthode peut contenir zéro
paramètre.
• corps de la méthode - Le corps de la méthode définit ce que la méthode fait avec les
instructions.

Exemple

Voici le code source de la méthode définie ci-dessus appelée min() . Cette méthode prend
deux paramètres num1 et num2 et renvoie le maximum entre les deux -

/** the snippet returns the minimum between two numbers */

public static int minFunction(int n1, int n2) {

int min;
if (n1 > n2)
min = n2;
else
min = n1;

return min;
}

Appel de méthode
Pour utiliser une méthode, il faut l'appeler. Il existe deux manières d'appeler une méthode,
c'est-à-dire que la méthode renvoie une valeur ou ne renvoie rien (pas de valeur de retour).

Le processus d'appel de méthode est simple. Lorsqu'un programme invoque une méthode, le
contrôle du programme est transféré à la méthode appelée. Cette méthode appelée rend
ensuite le contrôle à l'appelant dans deux conditions, lorsque -

• l'instruction return est exécutée.

• il atteint l'accolade fermante de fin de méthode.

Les méthodes renvoyant void sont considérées comme un appel à une instruction. Prenons un
exemple -

System.out.println("This is tutorialspoint.com!");

La méthode renvoyant la valeur peut être comprise par l'exemple suivant -

int result = sum(6, 9);

Voici l'exemple pour montrer comment définir une méthode et comment l'appeler -

Exemple

public class ExampleMinNumber {

public static void main(String[] args) {

int a = 11;
int b = 6;
 int c = minFunction(a, b);
System.out.println("Minimum Value = " + c);
}

/** returns the minimum of two numbers */

public static int minFunction(int n1, int n2) {
int min;
if (n1 > n2)
min = n2;
else
min = n1;

return min;
}
}

Cela produira le résultat suivant -

Sortie

Minimum value = 6

Le void
Le mot-clé void nous permet de créer des méthodes qui ne retournent pas de valeur. Ici, dans
l'exemple suivant, nous considérons une méthode void methodRankPoints . Cette méthode est
une méthode void, qui ne renvoie aucune valeur. L'appel à une méthode void doit être une
instruction, c'est-à-dire methodRankPoints(255.7); . Il s'agit d'une instruction Java qui se
termine par un point-virgule, comme illustré dans l'exemple suivant.

Exemple

public class ExampleVoid {

public static void main(String[] args) {

methodRankPoints(255.7);
}

public static void methodRankPoints(double points) {

if (points >= 202.5) {
System.out.println("Rank:A1");
}else if (points >= 122.4) {
System.out.println("Rank:A2");
}else {
System.out.println("Rank:A3");
}
}
}

Cela produira le résultat suivant -

Sortie

Rank:A1
Passer des paramètres par valeur
Tout en travaillant sous le processus d'appel, les arguments doivent être passés. Ceux-ci
doivent être dans le même ordre que leurs paramètres respectifs dans la spécification de la
méthode. Les paramètres peuvent être passés par valeur ou par référence.

Passer des paramètres par valeur signifie appeler une méthode avec un paramètre. Grâce à
cela, la valeur de l'argument est transmise au paramètre.

Exemple

Le programme suivant montre un exemple de passage de paramètre par valeur. Les valeurs
des arguments restent les mêmes même après l'invocation de la méthode.

public class swappingExample {

public static void main(String[] args) {

int a = 30;
int b = 45;
System.out.println("Before swapping, a = " + a + " and b = " + b);

// Invoke the swap method

swapFunction(a, b);
System.out.println("\n**Now, Before and After swapping values will be
same here**:");
System.out.println("After swapping, a = " + a + " and b is " + b);
}

public static void swapFunction(int a, int b) {

System.out.println("Before swapping(Inside), a = " + a + " b = " +
b);

// Swap n1 with n2
int c = a;
a = b;
b = c;
System.out.println("After swapping(Inside), a = " + a + " b = " + b);
}
}

Cela produira le résultat suivant -

Sortie

Before swapping, a = 30 and b = 45

Before swapping(Inside), a = 30 b = 45
After swapping(Inside), a = 45 b = 30

**Now, Before and After swapping values will be same here**:

After swapping, a = 30 and b is 45

Surcharge de méthode
Lorsqu'une classe a deux méthodes ou plus portant le même nom mais des paramètres
différents, on parle de surcharge de méthode. C'est différent de l'écrasement. En surcharge,
une méthode a le même nom de méthode, le même type, le même nombre de paramètres, etc.

Considérons l'exemple discuté précédemment pour trouver des nombres minimaux de type
entier. Si, disons que nous voulons trouver le nombre minimum de type double. Ensuite, le
concept de surcharge sera introduit pour créer deux ou plusieurs méthodes avec le même nom
mais des paramètres différents.

L'exemple suivant explique la même chose -

Exemple

public class ExampleOverloading {

public static void main(String[] args) {

int a = 11;
int b = 6;
double c = 7.3;
double d = 9.4;
int result1 = minFunction(a, b);

// same function name with different parameters

double result2 = minFunction(c, d);
System.out.println("Minimum Value = " + result1);
System.out.println("Minimum Value = " + result2);
}

// for integer
public static int minFunction(int n1, int n2) {
int min;
if (n1 > n2)
min = n2;
else
min = n1;

return min;
}

// for double
public static double minFunction(double n1, double n2) {
double min;
if (n1 > n2)
min = n2;
else
min = n1;

return min;
}
}

Cela produira le résultat suivant -

Sortie

Minimum Value = 6
Minimum Value = 7.3
La surcharge des méthodes rend le programme lisible. Ici, deux méthodes portent le même
nom mais avec des paramètres différents. Le nombre minimum de types entiers et doubles est
le résultat.

Objet et Classe
• Objet - Les objets ont des états et des comportements. Exemple : Un chien a des états
- couleur, nom, race ainsi que des comportements - remuer la queue, aboyer, manger.
Un objet est une instance d'une classe.
• Classe - Une classe peut être définie comme un modèle/plan directeur qui décrit le
comportement/l'état que l'objet de son type prend en charge.

Objets en Java
Examinons maintenant en profondeur ce que sont les objets. Si nous considérons le monde
réel, nous pouvons trouver de nombreux objets autour de nous, des voitures, des chiens, des
humains, etc. Tous ces objets ont un état et un comportement.

Si nous considérons un chien, alors son état est - nom, race, couleur, et le comportement est -
aboiement, remuant la queue, courant.

Si vous comparez l'objet logiciel avec un objet du monde réel, ils ont des caractéristiques très
similaires.

Les objets logiciels ont également un état et un comportement. L'état d'un objet logiciel est
stocké dans des champs et le comportement est affiché via des méthodes.

Ainsi, dans le développement logiciel, les méthodes fonctionnent sur l'état interne d'un objet
et la communication objet à objet se fait via des méthodes.

Cours en Java
Une classe est un plan à partir duquel des objets individuels sont créés.

Voici un exemple de classe.

Exemple
public class Dog {
String breed;
int age;
String color;

void barking() {
}

void hungry() {
}

void sleeping() {
 }
}

Une classe peut contenir n'importe lequel des types de variables suivants.

• Variables locales - Les variables définies à l'intérieur des méthodes, des constructeurs
ou des blocs sont appelées variables locales. La variable sera déclarée et initialisée
dans la méthode et la variable sera détruite lorsque la méthode sera terminée.
• Variables d'instance - Les variables d'instance sont des variables au sein d'une classe
mais en dehors de toute méthode. Ces variables sont initialisées lors de l'instanciation
de la classe. Les variables d'instance sont accessibles depuis n'importe quelle méthode,
constructeur ou bloc de cette classe particulière.
• Variables de classe - Les variables de classe sont des variables déclarées dans une
classe, en dehors de toute méthode, avec le mot-clé static.

Une classe peut avoir n'importe quel nombre de méthodes pour accéder à la valeur de divers
types de méthodes. Dans l'exemple ci-dessus, aboyer(), faim() et dormir() sont des méthodes.

Voici quelques-uns des sujets importants qui doivent être abordés lors de l'examen des classes
du langage Java.

Constructeurs
Lors de la discussion sur les classes, l'un des sous-sujets les plus importants serait les
constructeurs. Chaque classe a un constructeur. Si nous n'écrivons pas explicitement un
constructeur pour une classe, le compilateur Java construit un constructeur par défaut pour
cette classe.

Chaque fois qu'un nouvel objet est créé, au moins un constructeur sera appelé. La règle
principale des constructeurs est qu'ils doivent avoir le même nom que la classe. Une classe
peut avoir plusieurs constructeurs.

Voici un exemple de constructeur -

Exemple
public class Puppy {
public Puppy() {
}

public Puppy(String name) {

// This constructor has one parameter, name.
}
}

Java prend également en charge les classes Singleton où vous ne pourrez créer qu'une seule
instance d'une classe.

Remarque - Nous avons deux types de constructeurs différents. Nous allons discuter des
constructeurs en détail dans les chapitres suivants.

Création d'un objet

Comme mentionné précédemment, une classe fournit les plans des objets. Donc,
fondamentalement, un objet est créé à partir d'une classe. En Java, le nouveau mot clé est
utilisé pour créer de nouveaux objets.

Il y a trois étapes lors de la création d'un objet à partir d'une classe -

• Déclaration - Une déclaration de variable avec un nom de variable avec un type

d'objet.
• Instanciation - Le mot clé 'new' est utilisé pour créer l'objet.
• Initialisation - Le mot clé 'new' est suivi d'un appel à un constructeur. Cet appel
initialise le nouvel objet.

Voici un exemple de création d'un objet -

Exemple
public class Puppy {
public Puppy(String name) {
// This constructor has one parameter, name.
System.out.println("Passed Name is :" + name );
}

public static void main(String []args) {

// Following statement would create an object myPuppy
Puppy myPuppy = new Puppy( "tommy" );
}
}

Si nous compilons et exécutons le programme ci-dessus, il produira le résultat suivant -

Sortie
Passed Name is :tommy

Accès aux variables d'instance et aux méthodes

Les variables d'instance et les méthodes sont accessibles via des objets créés. Pour accéder à
une variable d'instance, voici le chemin complet -

/* First create an object */

ObjectReference = new Constructor();

/* Now call a variable as follows */

ObjectReference.variableName;

/* Now you can call a class method as follows */

ObjectReference.MethodName();

Exemple

Cet exemple explique comment accéder aux variables d'instance et aux méthodes d'une classe.

public class Puppy {

int puppyAge;

public Puppy(String name) {

 // This constructor has one parameter, name.
System.out.println("Name chosen is :" + name );
}

public void setAge( int age ) {

puppyAge = age;
}

public int getAge( ) {

System.out.println("Puppy's age is :" + puppyAge );
return puppyAge;
}

public static void main(String []args) {

/* Object creation */
Puppy myPuppy = new Puppy( "tommy" );

/* Call class method to set puppy's age */

myPuppy.setAge( 2 );

/* Call another class method to get puppy's age */

myPuppy.getAge( );

/* You can access instance variable as follows as well */

System.out.println("Variable Value :" + myPuppy.puppyAge );
}
}

Si nous compilons et exécutons le programme ci-dessus, il produira le résultat suivant -

Sortie
Name chosen is :tommy
Puppy's age is :2
Variable Value :2

Heritage
L'héritage peut être défini comme le processus par lequel une classe acquiert les propriétés
(méthodes et champs) d'une autre. Avec l'utilisation de l'héritage, les informations sont
rendues gérables dans un ordre hiérarchique.

La classe qui hérite des propriétés de other est appelée sous-classe (classe dérivée, classe
enfant) et la classe dont les propriétés sont héritées est appelée superclasse (classe de base,
classe parent).

le mot-clé EXTEND
extend est le mot clé utilisé pour hériter des propriétés d'une classe. Voici la syntaxe du mot
clé extend.

Syntaxe

class Super {
.....
.....
}
class Sub extends Super {
.....
.....
}

Exemple de code
Voici un exemple démontrant l'héritage Java. Dans cet exemple, vous pouvez observer deux
classes, à savoir Calculation et My_Calculation.

En utilisant le mot clé extend, My_Calculation hérite des méthodes addition() et Subtraction()
de la classe Calculation.

Copiez et collez le programme suivant dans un fichier nommé My_Calculation.java

Exemple

Démo en direct

class Calculation {
int z;

public void addition(int x, int y) {

z = x + y;
System.out.println("The sum of the given numbers:"+z);
}

public void Subtraction(int x, int y) {

z = x - y;
System.out.println("The difference between the given numbers:"+z);
}
}

public class My_Calculation extends Calculation {

public void multiplication(int x, int y) {
z = x * y;
System.out.println("The product of the given numbers:"+z);
}

public static void main(String args[]) {

int a = 20, b = 10;
My_Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);
demo.multiplication(a, b);
}
}

Compilez et exécutez le code ci-dessus comme indiqué ci-dessous.

javac My_Calculation.java
java My_Calculation

Après avoir exécuté le programme, il produira le résultat suivant -

Sortie

The sum of the given numbers:30

The difference between the given numbers:10
The product of the given numbers:200

Dans le programme donné, lorsqu'un objet de la classe My_Calculation est créé, une copie
du contenu de la superclasse est faite à l'intérieur de celui-ci. C'est pourquoi, en utilisant
l'objet de la sous-classe, vous pouvez accéder aux membres d'une super-classe.

La variable de référence Superclass peut contenir l'objet de sous-classe, mais en utilisant cette
variable, vous ne pouvez accéder qu'aux membres de la superclasse, donc pour accéder aux
membres des deux classes, il est recommandé de toujours créer une variable de référence à la
sous-classe.

Si vous considérez le programme ci-dessus, vous pouvez instancier la classe comme indiqué
ci-dessous. Mais en utilisant la variable de référence de la superclasse ( cal dans ce cas), vous
ne pouvez pas appeler la méthode multiplication() , qui appartient à la sous-classe
My_Calculation.

Calculation demo = new My_Calculation();

demo.addition(a, b);
demo.Subtraction(a, b);

Remarque − Une sous-classe hérite de tous les membres (champs, méthodes et classes
imbriquées) de sa superclasse. Les constructeurs ne sont pas des membres, ils ne sont donc
pas hérités par les sous-classes, mais le constructeur de la superclasse peut être appelé à partir
de la sous-classe.

Le mot clé SUPER

Le mot-clé SUPER est similaire au mot-clé THIS. Voici les scénarios où le mot-clé super est
utilisé.

• Il est utilisé pour différencier les membres de la superclasse des membres de la sous-
classe, s'ils ont les mêmes noms.
• Il est utilisé pour invoquer le constructeur de la superclasse à partir de la sous-classe.
Différencier les membres

Si une classe hérite des propriétés d'une autre classe. Et si les membres de la superclasse ont
les mêmes noms que la sous-classe, pour différencier ces variables, nous utilisons le mot-clé
super comme indiqué ci-dessous.

super.variable
super.method();

Exemple de code

Cette section vous propose un programme qui illustre l'utilisation du mot-clé super .

Dans le programme donné, vous avez deux classes à savoir Sub_class et Super_class , toutes
deux ont une méthode nommée display() avec différentes implémentations et une variable
nommée num avec des valeurs différentes. Nous invoquons la méthode display() des deux
classes et imprimons la valeur de la variable num des deux classes. Ici, vous pouvez observer
que nous avons utilisé le mot clé super pour différencier les membres de la superclasse de la
sous-classe.

Copiez et collez le programme dans un fichier avec le nom Sub_class.java.

Exemple

class Super_class {
int num = 20;

// display method of superclass

public void display() {
System.out.println("This is the display method of superclass");
}
}

public class Sub_class extends Super_class {

int num = 10;

// display method of sub class

public void display() {
System.out.println("This is the display method of subclass");
}

public void my_method() {

// Instantiating subclass
Sub_class sub = new Sub_class();

// Invoking the display() method of sub class

sub.display();

// Invoking the display() method of superclass

super.display();

// printing the value of variable num of subclass

System.out.println("value of the variable named num in sub class:"+
sub.num);

// printing the value of variable num of superclass

 System.out.println("value of the variable named num in super class:"+
super.num);
}

public static void main(String args[]) {

Sub_class obj = new Sub_class();
obj.my_method();
}
}

Compilez et exécutez le code ci-dessus en utilisant la syntaxe suivante.

javac Super_Demo
java Super

Lors de l'exécution du programme, vous obtiendrez le résultat suivant -

Sortie

This is the display method of subclass

This is the display method of superclass
value of the variable named num in sub class:10
value of the variable named num in super class:20

Invoquer le constructeur de superclasse

Si une classe hérite des propriétés d'une autre classe, la sous-classe acquiert automatiquement
le constructeur par défaut de la superclasse. Mais si vous voulez appeler un constructeur
paramétré de la superclasse, vous devez utiliser le mot-clé super comme indiqué ci-dessous.

super(values);

Exemple de code

Le programme donné dans cette section montre comment utiliser le mot clé super pour
invoquer le constructeur paramétré de la superclasse. Ce programme contient une superclasse
et une sous-classe, où la superclasse contient un constructeur paramétré qui accepte une
valeur entière, et nous avons utilisé le mot clé super pour invoquer le constructeur paramétré
de la superclasse.

Copiez et collez le programme suivant dans un fichier nommé Subclass.java

Exemple

Démo en direct

class Superclass {
int age;

Superclass(int age) {
this.age = age;
}

public void getAge() {

 System.out.println("The value of the variable named age in super
class is: " +age);
}
}

public class Subclass extends Superclass {

Subclass(int age) {
super(age);
}

public static void main(String args[]) {

Subclass s = new Subclass(24);
s.getAge();
}
}

Compilez et exécutez le code ci-dessus en utilisant la syntaxe suivante.

javac Subclass
java Subclass

Lors de l'exécution du programme, vous obtiendrez le résultat suivant -

Sortie

The value of the variable named age in super class is: 24

Envoi mail
Envoyer un e-mail à l'aide de votre application Java est assez simple, mais pour commencer,
vous devez avoir JavaMail API et Java Activation Framework (JAF) installés sur votre
machine.

• Vous pouvez télécharger la dernière version de JavaMail (Version 1.2) à partir du site
Web standard de Java.
• Vous pouvez télécharger la dernière version de JAF (Version 1.1.1) à partir du site
Web standard de Java.

Téléchargez et décompressez ces fichiers, dans les répertoires de niveau supérieur

nouvellement créés, vous trouverez un certain nombre de fichiers jar pour les deux
applications. Vous devez ajouter les fichiers mail.jar et activation.jar dans votre
CLASSPATH.

Envoyer un e-mail simple

Voici un exemple pour envoyer un e-mail simple depuis votre machine. Il est supposé que
votre localhost est connecté à Internet et suffisamment capable pour envoyer un e-mail.

Exemple
// File Name SendEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendEmail {

public static void main(String [] args) {

// Recipient's email ID needs to be mentioned.
String to = "[email protected]";

// Sender's email ID needs to be mentioned

String from = "[email protected]";

// Assuming you are sending email from localhost

String host = "localhost";

// Get system properties

Properties properties = System.getProperties();

// Setup mail server

properties.setProperty("mail.smtp.host", host);

// Get the default Session object.

Session session = Session.getDefaultInstance(properties);

try {
// Create a default MimeMessage object.
MimeMessage message = new MimeMessage(session);

// Set From: header field of the header.

message.setFrom(new InternetAddress(from));

// Set To: header field of the header.

message.addRecipient(Message.RecipientType.TO, new
InternetAddress(to));

// Set Subject: header field

message.setSubject("This is the Subject Line!");

// Now set the actual message

message.setText("This is actual message");

// Send message
Transport.send(message);
System.out.println("Sent message successfully....");
} catch (MessagingException mex) {
mex.printStackTrace();
}
}
}

Compilez et exécutez ce programme pour envoyer un simple e-mail −

Sortie
$ java SendEmail
Sent message successfully....

Si vous souhaitez envoyer un e-mail à plusieurs destinataires, les méthodes suivantes seront
utilisées pour spécifier plusieurs identifiants d'e-mail -
void addRecipients(Message.RecipientType type, Address[] addresses)
throws MessagingException

Voici la description des paramètres −

• type − This would be set to TO, CC or BCC. Here CC represents Carbon Copy and
BCC represents Black Carbon Copy. Example: Message.RecipientType.TO
• addresses − This is an array of e-mail ID. You would need to use InternetAddress()
method while specifying email IDs.

Envoyer une pièce jointe dans un e-mail

Voici un exemple pour envoyer un e-mail avec pièce jointe depuis votre machine. Ici, il est
supposé que votre localhost est connecté à Internet et suffisamment capable pour envoyer un
e-mail.

Exemple
// File Name SendFileEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendFileEmail {

public static void main(String [] args) {

// Recipient's email ID needs to be mentioned.
String to = "[email protected]";

// Sender's email ID needs to be mentioned

String from = "[email protected]";

// Assuming you are sending email from localhost

String host = "localhost";

// Get system properties

Properties properties = System.getProperties();

// Setup mail server

properties.setProperty("mail.smtp.host", host);

// Get the default Session object.

Session session = Session.getDefaultInstance(properties);

try {
// Create a default MimeMessage object.
MimeMessage message = new MimeMessage(session);

// Set From: header field of the header.

message.setFrom(new InternetAddress(from));

// Set To: header field of the header.

message.addRecipient(Message.RecipientType.TO,new
InternetAddress(to));

// Set Subject: header field

 message.setSubject("This is the Subject Line!");

// Create the message part

BodyPart messageBodyPart = new MimeBodyPart();

// Fill the message

messageBodyPart.setText("This is message body");

// Create a multipar message

Multipart multipart = new MimeMultipart();

// Set text message part

multipart.addBodyPart(messageBodyPart);

// Part two is attachment

messageBodyPart = new MimeBodyPart();
String filename = "file.txt";
DataSource source = new FileDataSource(filename);
messageBodyPart.setDataHandler(new DataHandler(source));
messageBodyPart.setFileName(filename);
multipart.addBodyPart(messageBodyPart);

// Send the complete message parts

message.setContent(multipart );

// Send message
Transport.send(message);
System.out.println("Sent message successfully....");
} catch (MessagingException mex) {
mex.printStackTrace();
}
}
}

Compilez et exécutez ce programme pour envoyer un e-mail HTML −

Sortie
$ java SendFileEmail
Sent message successfully....

Partie d'authentification de l'utilisateur

S'il est nécessaire de fournir un ID utilisateur et un mot de passe au serveur de messagerie à
des fins d'authentification, vous pouvez définir ces propriétés comme suit :

props.setProperty("mail.user", "myuser");
props.setProperty("mail.password", "mypwd");