Expose Groupe 4 Final

Expose d’informatique
REPUBLIQUE DU CAMEROUN REPUBLIC OF CAMEROON

MINISTERE DE L’ENSEIGNEMENT
PAIX-TRAVAIL-PATRIE PEACE-LABOUR-FATHERLAND
SUPERIEURE
MINISTERE DE L’ENSEIGNEMENT MINISTRY OF HIGHER EDUCATION
REPUBLIQUE DU CAMEROUN
SUPERIEURE AND RESEARCH
PAIX-TRAVAIL-PATRIE
UNIVERSITE DE YAOUNDE I NATIONAL ADVANCED SCHOOL OF
ECOLE
ECOLE NATIONALE
NATIONALE SUPERIEURE
SUPERIEURE ENGINEERING OF CAMEROUN
POLYTECHNIQUEDE
POLYTECHNIQUE DEYAOUNDE
YAOUNDE DEPARTEMENT OF CIVIL
DEPARTEMENT DE GENIE CIVIL ENGINEERING
EXPOSE D’INFORMATIQUE
(GROUPE 4)
PRESENTATION DES ELEMENTS DE

BASE EN JAVA : STRUCTURE
MINIMALE D’UN PROGRAMME
Presenté par:
 ABOSSOLO ZE ROGER
 BEYALA BABA SAMANTHA (SC)
 BIHOLONG FILS JACQUES (C)
 DJIDJE SUNE MANUEL
 NJIFON YOUSSOUF.R
 ONDOUA ASSEMBE
 SANA DJOPKANG
Sous la supervision de :
ING. ENYEGUE GERMAIN
Ingénieur chercheur à l’ENSPY
GROUPE 4-2122 1
DEDICACE
Ce document est dédié à :

Nos camarades de la
Promotion 2024 de GENIE
CIVIL
GROUPE 4-2122 2
REMERCIEMENTS
Nos remerciements vont à l’endroit de :

 Pr Remy Magloire Dieudonné ETOUA enseignant chercheur et directeur de
l’ENSPY pour notre admission au sein de cette institution ;
 Pr MANJIA Marcelline Blanche enseignant et chef de département de génie Civil
de l’ENSPY pour notre admission dans le prestigieux département de Génie civil ;
 ING. ENYEGUE Germain ingénieur de génie civil chercheur et informaticien pour
son encadrement durant la réalisation de cet exposé ;
 Nos camarades de la classe de 3 Génie civil promotion 2024
Tous ceux-là qui, de près ou de loin qui ont contribué à la réalisation de ce projet.
GROUPE 4-2122 3
RESUME
Durant tous nos travaux, nos recherches étaient centrées sur le thème <<présentation
des éléments de base en java : structure minimale d’un programme>>. Pour répondre à cette
problématique nous avons présenté les règles de base en java. Ensuite nous avons défini la
notion de classe et les différents types de classes sont les classes anonymes, les classes
publiques, les classes internes, classes membres, classes locales. Après nous sommes passés au
développement de la notion de type de données. A cet effet on peut alors citer les types
primitifs, les enveloppeurs, les types personnalisés et les bibliothèques. Maintenant qu’on
connait les types de données utilisées on peut définir les différentes opérations entre ces
différentes données qui sont des objets. Les types d’opérateurs en java sont : les opérateurs
d’assignation, les opérateurs logiques, les opérateurs de comparaison, opérateurs de calcul. La
notion d’éléments de base en java fait également appel aux instructions. Les types
d’instructions sont donc : les instructions simples et les instructions complexes. Pour terminer
nous avons présenté les différents types de méthodes parmi lesquels les méthodes des classes
et les méthodes d’instance et avons donné la structure minimale d’un programme.
GROUPE 4-2122 4
ABSTRACT
During the whole work, our research were based on the theme “Presentation of java’s
basic elements: minimal structure of a program”. To answer this program, we presented the
different data types which are; the primitives, wrappers, personnalised and libraries.
Furthermore, we presented the basic rules in java. We defined the notion of classes and the
different types of classes that is anonymous, public, internal, member and local classes. Now
that we know the data types used, we can define the different operations between these data
which are objects. The type of operators in java are: assignation operators, logical operators,
comparism operators and calculation operators. The notion of basic element in java brings out
two main types of instructions that is Simple and Complex instructions. Also, we presented the
different types of methods which are class and instance methods. Lastly, we gave the minimal
structure of a program.
GROUPE 4-2122 5
Table des matières
RESUME ............................................................................................................................................... 4
ABSTRACT ........................................................................................................................................... 5
INTRODUCTION................................................................................................................................. 9
A. PARTIE THEORIQUE .............................................................................................................. 10
Règles de base................................................................................................................................... 10
1. Règles syntaxiques .............................................................................................................. 10
2. Les mots réservés ................................................................................................................ 10
3. Les identificateurs ............................................................................................................... 10
4. Les commentaires................................................................................................................ 11
5. Règles de déclaration .......................................................................................................... 11
II. Notion de classe........................................................................................................................... 12
1. Syntaxe d'une classe ............................................................................................................ 12
2. Actions sur les classes ......................................................................................................... 12
3. Visibilité d’une classe .............................................................................................................. 14
4. Exemples de classes et syntaxes ......................................................................................... 14
III. Types de données....................................................................................................................... 17
1. Les données primitives........................................................................................................ 18
2. Les enveloppeurs ................................................................................................................. 19
3. Les types personnalisés ....................................................................................................... 19
4. Les bibliothèques ................................................................................................................. 20
IV. Les opérateurs........................................................................................................................... 21
1. Les opérateurs d’assignation.............................................................................................. 21
2. Opérateurs de calcul ou arithmétique ............................................................................... 22
3. Opérateurs logiques ............................................................................................................ 23
4. Les opérateurs relationnels ou de comparaison ............................................................... 23
5. Priorités des opérateurs ...................................................................................................... 24
V. Les instructions en java ............................................................................................................. 25
1. Instructions simples ............................................................................................................ 25
a. Les déclarations des variables et constantes ..................................................................... 25
b. Instructions d’affectation ................................................................................................... 26
c. Instruction de lecture .......................................................................................................... 26
d. Instruction d’affichage ....................................................................................................... 27
GROUPE 4-2122 6
2. Instructions complexes ....................................................................................................... 27

VI. Les méthodes ............................................................................................................................. 31
1. Les types de méthodes......................................................................................................... 31
2. Déclaration d’une méthode ................................................................................................ 32
3. Appel de méthode ................................................................................................................ 33
VII. Structure minimale d’un programme ................................................................................... 33
B. CAS PRATIQUE ........................................................................................................................ 35
1. Présentation du cas programme ........................................................................................ 35
CONCLUSION ................................................................................................................................... 39
GROUPE 4-2122 7
Liste des tableaux

Tableau 1 : Les types primitifs.............................................................................................................. 18
Tableau 2 : Enveloppeurs des types primitifs ....................................................................................... 19
Tableau 3 :Opérateurs d'assignation ..................................................................................................... 22
Tableau 4 : Opérateurs de calcul ........................................................................................................... 22
Tableau 5 : Opérateurs logiques............................................................................................................ 23
Tableau 6 : Opérateurs logiques............................................................................................................ 23
Tableau 7 : Opérateurs d'incrementation .............................................................................................. 24
Tableau 8 : Priorite des opérateurs........................................................................................................ 24
Liste des figures

Figure 1 Structure minimale d’un programme ...................................................................................... 34
Figure 2 Déclaration des variables et instanciation de la classe ........................................................... 36
Figure 3 Creation des matrices A et B .................................................................................................. 36
Figure 4 Affichage des matrices A et B ................................................................................................ 37
Figure 5 Somme de A et B ................................................................................................................... 37
Figure 6 Produit de A et B .................................................................................................................... 38
Figure 7 Utilisation des méthodes ......................................................................................................... 38
GROUPE 4-2122 8
INTRODUCTION
Dans le but de créer un langage applicable sur des petits appareils électroniques et
capable de s’exécuter sur n’importe quels systèmes d’exploitation, les ingénieurs JAMES
GOSLING et Patrick NAUGHTON ont conçu en 1995 un langage de programmation orienté
objet qu’ils ont appelé JAVA. C’est un langage simple, distribué, interprété, robuste, sécurisé
et dynamique. Comme la majorité des langages, le java possède un amas d’éléments qui ne
cesse de s’accroitre avec les versions récentes. A cet effet, quels sont les éléments de base de
ce langage ? De plus, quelle est la structure minimale requise pour un programme écrit en java
soit exécuté ? Afin de répondre à ces questions, il adviendra de présenter dans un premier temps
les éléments de base notamment les classes, les types de données, les opérateurs et les
méthodes, dans un second temps donner la structure minimale d’un code écrit en java et enfin
présenter un cas pratique qui illustre de façons explicite toutes ces notions.
GROUPE 4-2122 9
A. PARTIE THEORIQUE
I. Règles de base
1. Règles syntaxiques
Tout langage de programmation a des règles prédéfinies qu’il faut suivre lors de la
rédaction d’un programme afin que celui-ci soit exécuté et compilé. Comme règles nous
pouvons énumérer :
 Il faut absolument que chaque instruction se termine par un point-virgule.
 Les noms de classes doivent commencer par des lettres majuscules.
 La déclaration d’une variable se fait qu’une seule fois.
 Le java est sensible à la casse.
 Ne jamais utiliser les mots réservés comme identificateur.
 Le premier élément de tableau a pour indice 0.
2. Les mots réservés
Tout d’abord, qu’est-ce qu’un mot réservé ? Dans le langage de programmation java, les
mots réservés sont des mots qui ont des significations particulières. Ils ne peuvent pas être
utilisés comme noms de variables, un nom de classe, un nom de package, nom de méthode.
NB : Tous les mots réservés ne sont pas des mots clés
La liste de quelques mots réservés est :
abstract, assert, boolean, break, byte, case, catch, char, class, const continue, default,
do, double, else, extends, final, finally, float, for, goto if, implements, import, instance of,
int, interface, long, native, new, package, private, protected, public, return, short, static,
super, switch, synchronized, this, throw, throws, transient, try, void, volatile, while,…
3. Les identificateurs
Un identificateur est une séquence de lettres et de chiffres représentant des variables, des
constantes, des méthodes, des classes, des interfaces ainsi que des labels.
GROUPE 4-2122 10
REGLES DE NOMMAGE
 L’identificateur ne doit pas commencer par un chiffre

 IL ne doit pas contenir des caractères de ponctuation ni d’espace
 Après le premier caractère il peut contenir n’importe quelle combinaison de lettre.
 Dans la pratique, il n’y a pas de limite au nombre de caractères qu’un identificateur
java peut contenir
 Les identificateurs en Java sont sensibles à la casse, soleil et Soleil sont deux
identificateurs différents.
 Un mot-clé ne peut pas être utilisé comme un identifiant dans vos programmes.
4. Les commentaires
Un commentaire est une option qui permet d’insérer un texte qui ne sera pas compilé ni
interprété après exécution. Il est utile pour expliquer ce que fait le code source (expliquer
comment utiliser une classe ou une méthode, expliquer le choix des techniques effectuées,
expliquer ce qui devra être fait par la suite, donner une explication nécessaire à la
compréhension du code).
 Les formes de commentaires
En java, il existe plusieurs formes de commentaire qui sont entre autres :

 Le commentaire abrégé : qui est un commentaire sur une ligne. On utilise
généralement //
Sa syntaxe en java est:
// Commentaire à insérer.
Exemple : Int c ; //déclaration de la variable c
 le commentaire multilingue : qui est un commentaire sur plusieurs lignes.
Sa syntaxe de déclaration en java est:
/*commentaire à insérer*/
Exemple: /*cette fonction fait ……………
…………………de plusieurs variables*/

 le commentaire de documentation automatique : il permet d’insérer en commentaire
un document dans un programme java.
Sa syntaxe déclaration est:/**document à insérer*/
5. Règles de déclaration
Quelques règles de déclaration des variables sont :
GROUPE 4-2122 11
 Il est interdit de commencer une variable par un chiffre ou un symbole autre que le
signe $ ou le _.
 Ne pas commencer les variables par une majuscule, cela est réservé aux classes.
 Le nom d’une variable ne peut être un mot clé du langage
 Les noms des variables ne doivent pas contenir l’espace
II. Notion de classe
En Java, on appelle classe la structure d'un objet, c'est-à-dire la déclaration de l'ensemble

des entités qui composeront un objet ; un objet est donc "issu" d'une classe.
1. Syntaxe d'une classe
En java, les classes sont déclarées à l'aide du mot-clé class, suivi du nom de la classe
déclarée, suivi du corps de la classe entre accolades. Par convention, un nom de classe
commence par une majuscule.
public class MaClasse
// corps de la classe
Le fichier contenant cette déclaration doit avoir pour extension nom-classe.java. Un

fichier peut contenir plusieurs déclarations de classes (ce n'est pas recommandé, il faut partir
du principe 1 classe = 1 fichier, pour des problèmes évidents de relecture du code, devoir
modifier du code où plusieurs classes sont écrites dans un seul fichier est le meilleur moyen de
faire n'importe quoi), mais il ne peut contenir qu'au plus une classe dite publique (dont le mot-
clé class est précédé de public, comme dans l'exemple ci-dessus). Le fichier doit
obligatoirement porter le même nom que cette classe publique : dans l'exemple ci-dessus, il
faudrait donc sauver notre classe dans un fichier nommé MaClasse.java.
2. Actions sur les classes
GROUPE 4-2122 12
a. Importer une classe
Un fichier .java peut commencer par une ou plusieurs déclarations d'import. Ces imports
ne sont pas indispensables, mais autorisent en particulier l'accès aux classes prédéfinies sans
avoir à spécifier leur chemin d'accès complet dans les collections de classes prédéfinies
(organisées en packages). Dans le code ci-dessous, on souhaite par exemple utiliser la classe
prédéfinie Vector (un type de données comparable à des tableaux dont la taille peut varier
dynamiquement). Dans la sous collection des classes prédéfinies ‘’java’’, cette classe se trouve
dans la sous-collection "util" (ou encore : cette classe est dans le package "java.util").
Sans import, il faut spécifier le nom complet de la classe (packages inclus) :
Public class MaClasse
//…..
Public static void main(string[] args)
// sans l’import:
Java.util.vector v = new java.util.vector() ;
//…..
b. Instancier une classe
Un objet peut être vu comme un ensemble de données regroupé à la manière des structures
de C ou des enregistrements de Pascal. Une classe définit un modèle d'objet. Chaque objet créé
à partir d'une classe est appelé instance de cette classe. L'ensemble de données internes d'un
objet, les champs de cet objet est spécifié par sa classe. Une classe peut en outre contenir :
d'une part, des constructeurs du code destiné à l'initialisation de ses instances au moment de
leur création ; d'autre part des méthodes du code destiné à la gestion des données internes de
chacune de ses instances. On dit que ces méthodes sont invocables sur les objets.
Les objets se manipulent à l'aide de variables appelées références. Une référence vers un
objet est l'analogue d'un pointeur vers celui-ci, au sens usuel de la notion de pointeur dans les
langages impératifs tels que C. On dit que cette référence pointe sur l'objet. Notez que par abus
de langage, on confond en pratique une référence vers un objet et l'objet lui-même. On parlera
ainsi de "l'objet r" plutôt que de "l'objet référencé par r" ou "l'objet pointé par r". Pour autant,
une référence vers un objet n'est pas l'objet lui-même : une référence peut ne pointer vers
aucun objet, en particulier si elle est déclarée sans être initialisée, ou si on lui affecte la valeur
de référence nulle notée null ; elle peut pointer successivement vers des objets différents au
GROUPE 4-2122 13
cours du temps ; d'autre part, deux références distinctes peuvent pointer vers le même objet.
Les champs de l'objet sont alors accessibles, et les méthodes de sa classe deviennent invocables
via l'une ou l'autre de ces deux références, avec le même effet.
Le type d'une référence spécifie la (ou même les) classe(s) des objets sur laquelle (lesquelles)
elle est susceptible de pointer. Une référence déclarée de type "référence vers MaClasse",
où MaClasse est le nom d'une classe, est susceptible de pointer vers n'importe quelle instance
de MaClasse.
MaClasse r; // declaration d’une reference de type “reference vers MaClasse’’
/*instructions diverses*/
r=new MaClasse() ; // creation d’une instance de MaClasse, puis référencement par

r
de l’objet crée
On peut déclarer une référence et lui faire immédiatement référencer une nouvelle instance,
créée dans cette déclaration :
MaClasse r=new MaClasse(); // on crée une instance de MaClasse, que l’on

référence par r
3. Visibilité d’une classe
Une classe a une visibilité :
 Public : le mot class est alors précédé de public, tout utilisateur qui importe le
paquetage peut utiliser la classe. Dans ce cas elle doit être définie dans un fichier qui a
pour nom le nom de la classe.
 Privée : le mot class est alors précédé de private, seules des classes définies dans le
même fichier peuvent utiliser cette classe.
 Paquetage accessible aux classes dans le même package
 Protégée : le mot class est précédé de protected , accessible aux classes du paquetage
et à toute classe dérivée en dehors du paquetage
4. Exemples de classes et syntaxes
a. Classes publiques
GROUPE 4-2122 14
Une classe publique est déclarée par le mot-clé public class. Elle doit être enregistrée
dans un fichier qui porte le même nom qu'elle, et son nom commence en général par une
majuscule, se différenciant en cela des identificateurs internes à une classe (champs et
méthodes).
Voici un exemple de déclaration de classe.
Exemple d'une classe publique
Public class Marin {
// Doit être écrite dans le fichier Marin.java !
…. // code de la classe
b. Classes internes
On ne peut pas avoir plus d'une classe publique dans un fichier donné. En revanche,
on peut ajouter d'autres classes, non publiques. La déclaration qui suit est légale, même si
elle n'est pas conseillée.
Exemple d'une classe interne
pubic class Marin {
// Doit être écrite dans le fichier Marin.java
...// code de la classe
Class Capitaine { // écrite dans le même fichier
…. // code de la classe capitaine
}
La classe Capitaine est une classe interne. On peut avoir autant de classes internes
qu'on le souhaite dans un fichier. Il est possible de ne pas avoir de classe publique dans un
fichier, et uniquement des classes internes. Ce genre de bizarreries est évidemment à
proscrire.
c. Classe membre
Une classe membre est une classe déclarée à l'intérieur d'une autre classe. Elle peut
être static ou non, final ou non, public, private ou protected. Voici un exemple de déclaration
d'une telle classe.
GROUPE 4-2122 15
Exemple : Classes membre de la classe Character
public final class Character { // déclarée dans le fichier java/lang/Character
... // code de la classe Character
public static class Subset {

... // code de la classe Subset
}
public static final class UnicodeBlock extends Subset {

... // code de la classe UnicodeBlock
}
}
d. Classes locales
Une classe locale est déclarée dans une méthode et donc ne fait pas partie des membres
de la classe qui contient cette méthode. Voici un exemple de déclaration d'une classe locale.
Exemple d'une classe locale
public class Marin implements Comparable<Marin> {
private String nom, prenom ;
public int compareTo(Marin marin) {
class MarinComparator implements Comparator<Marin> {
public int compare(Marin m1, Marin m2) {

int order = m1.nom.compareTo(m2.nom) ;
return order != 0 ? order : m1.prenom.compareTo(m2.prenom) ;
}
}
return (new MarinComparator()).compare(this, marin) ;

}
}
GROUPE 4-2122 16
e. Classes anonymes
Une classe anonyme peut être déclarée dans une méthode, comme une classe locale,
ou comme classe membre. La différence est qu'elle ne porte pas de nom, qu'elle utilise un
mécanisme de déclaration qui se fusionne avec son instanciation. Nous pouvons reprendre le
même exemple que celui vu au paragraphe précédent, mais au lieu de déclarer une
classe MarinComparator, nous pouvons déclarer une classe anonyme. Voyons ici un exemple
de classe anonyme locale.
Exemple d'une classe anonyme locale
public class Marin implements Comparable<Marin> {
private String nom, prenom ;
public int compareTo(Marin marin) {
Comparator<Marin> comparator =
new Comparator<Marin>() {
public int compare(Marin m1, Marin m2) {

int order = m1.nom.compareTo(m2.nom) ;
return order != 0 ? order : m1.prenom.compareTo(m2.prenom) ;
}
};
return comparator.compare(this, marin) ; } }
Comme on le voit, le code de la classe est écrit entre accolades, directement après
l'appel au constructeur. Cette technique est très utilisée dans la programmation de callbacks,
dans les interfaces graphiques et les appels asynchrones que l'on rencontre en programmation
Web. Elle est à utiliser avec précautions toutefois : il est très facile de rendre un code
complètement illisible par une utilisation déraisonnée des classes anonymes
III. Types de données
Java est un langage orienté objet, c’est à dire qu’il manipule les classes, ou plus
exactement des objets qui sont des instances de ces classes.
On recense 04 principales familles de types de données dans ce langage notamment :
 le type primitif(les données primitives)

 les enveloppeurs (Wrappers)
 les types personnalisés
 les bibliothèques
GROUPE 4-2122 17
1. Les données primitives
Les données manipulées avec Java, sont typées, c'est-à-dire que pour chaque donnée que
l'on utilise (dans les variables par exemple) il faut préciser le type de donnée, ce qui permet de
connaître l'occupation mémoire (le nombre d'octets) de la donnée ainsi que sa représentation,
cela peut être entre autres :
 des nombres entiers: (int)
 réels, c'est-à-dire à virgules (float)
De plus, le langage Java introduit un type de donnée appelée boolean. Ce type de variable
accepte deux états :
 True (vrai): correspondant à une valeur vraie
 False (faux): correspondant à une valeur fausse
En réalité, toutes les valeurs différentes de True sont considérées comme fausses (donc
considérées comme égales à False). Si la variable n'est pas initialisée, sa valeur par défaut
est False.
Voici un tableau répertoriant les primitives (types de données) de Java
Tableau 1 : Les types primitifs
Primitive Signification Taille en octets Plage de valeurs acceptées
Char Caractère 2 Valeur du jeu de caractères

Unicode (65000 caractères
possibles)
byte Entier très court 1 -128 a 127
Short Entier court 2 -32768 a 32767
Int Entier 4 -2147483648 a 2147483647
Long Entier long 8 -9223372036854775808 à
9223372036854775807
Float Flottant réel 4 -1.4*10-45 à 3.4*1038
Double Flottant double 8 4.9*10-324 à 1.7*10308
boolean Booléen 1 0 ou 1 (en réalité, toute autre
valeur
que 0 est considérée égale à
1)
GROUPE 4-2122 18
2. Les enveloppeurs
Chacun des types primitifs peut être "enveloppé" dans un objet provenant d'une classe
prévue à cet effet et appelée Wrapper (mot anglais signifiant enveloppeur). Les enveloppeurs
sont donc des objets représentant un type primitif.
Cette option présente plusieurs avantages mais aussi des inconvénients.
Parmi les avantages nous pouvons dire que :
 Les Wrapper peuvent être utilisés comme n'importe quel objet, ils ont donc leurs
propres méthodes.
Parmi les inconvénients, nous pouvons dire que :
 L'objet enveloppant utilise plus d'espace mémoire que le type primitif. Par exemple,
une int prend 4 octets en mémoire mais un Integer utilisera 32 octets sur une machine
virtuelle en 64 bits (20 octets en 32 bits).
 L'objet enveloppant est immuable, c'est- à- dire qu'il ne peut pas être modifié, toute
modification de sa valeur nécessite de créer un nouvel objet et de détruire l'ancien, ce
qui augmente le temps de calcul.
Voici la liste des enveloppeurs de chaque type primitif Java :
Tableau 2 : Enveloppeurs des types primitifs
Enveloppeur Type primitif

Character Char
Byte byte
Short short
Integer Int
Long long
Float float
Double double
Boolean boolean
3. Les types personnalisés
C’est tout simplement la possibilité de créer nos propres types de données.En effet, vu
qu’habituellement nous sommes acclimatés à traiter des données possédant plusieurs attributs,
déclarer une variable pour chaque type s’avère être assez pénible à gérer le niveau de
GROUPE 4-2122 19
programmation. De ce fait, pour pallier à ce problème, le java nous offre la possibilité de créer
nos propres types de données à partir des types préexistants.
Sa syntaxe de déclaration est quasiment la même que celle d’une classe (celle-ci demande en
plus des fonctions supplémentaires pour la question des attributs). Ainsi, elle est donnée par :
Public class « Nom_nouveau_type » {

Type 1 « identificateur1 »
Type 2 « identificateur2»
Type n « identificateur n »
Public « Nom_nouveau_type » (type1 argument 1, …...
type n argument n)
{
Instructions de modifications ;
}}
4. Les bibliothèques
En java, une bibliothèque désigne un élément d’outil de développement java constitué de

procédures et d’objets prédéfinis, utilisables de façon modulaire, et qui permet de bâtir des
applications sans avoir à programmer de code source java.
Autrement dit, c’est un ensemble de classes et de méthodes regroupé dans un fichier et
permettant d’effectuer des instructions élémentaires et/ou complexes dans un programme.
Elles contiennent des milliers de classes et de méthodes facilitant et accélérant le
développement.
Il existe plusieurs bibliothèques en java parmi lesquelles nous pouvons citer :
-JAXB : c’est une bibliothèque qui offre tous ce dont un développeur a besoin pour travailler
avec XML.
-Google guava conçu par l’ING. Joshua Bloch à Google, il couvre les utilitaires essentiels, les
collections, la manipulation de chaine….
-JACKSON : c’est une bibliothèque qui permet de traiter de façon simple et nette le type de
données en java. Elle propose également des liaisons de données et des annotations.
REMARQUE : Notion de conversion de types de données

La conversion de types de données ou transcryptage (en anglais) est le procédé qui
consiste à modifier un type de données déjà déclaré en un autre. Elle ne concerne que les
données primitives et les enveloppeurs.
GROUPE 4-2122 20
En java, il existe deux principaux modes de conversion notamment :

 la conversion implicite :
Elle consiste en une modification du type de donnée effectuée automatiquement par le
compilateur. Cela signifie que lorsque l’on va stocker dans une variable de type 1 une autre
variable de type 2, le compilateur ne retournera pas d’erreur mais effectuera une conversion
implicite de la donnée suivant des règles préétablies avant de l’affecter à la variable.
Exemple : La conversion d’un type primitif vers son WRAPPER est implicite.
int c ;
int b=7 ;
int c=b ;
 la conversion explicite :
Celle-ci consiste en une modification du type de donnée forcé. Cela signifie que l’on
utilise un opérateur dit de cast pour spécifier la conversion. L’opérateur de cast est tout
simplement le type de données, dans lequel on désire convertir une variable mis entre
parenthèses précédant la variable.
Exemple :
double c = 3,454;
int n = (int) c; (convertit la variable c en entier avant de l’affecter à n).
Notons que ce type de conversion s’accompagne bien évidement d’une perte de données.
IV. Les opérateurs
Un programme manipule des données, qu'elles soient stockées dans une variable ou
une constante, ou que ce soit des littéraux (caractères ou chaines de caractères). Les opérateurs
sont des symboles qui permettent d’exécuter une opération en java. Elles peuvent d’effectuer
des opérations arithmétiques, booléennes ou agir sur des chaines de caractères.
Ainsi en java on distingue quatre grandes familles d’opérateurs notamment ;
 les opérateurs d’assignation ou d’affectation
 les opérateurs de calcul ou arithmétiques
 les opérateurs logiques
 les opérateurs relationnels ou de comparaison
1. Les opérateurs d’assignation
GROUPE 4-2122 21
Les opérateurs d’assignation sont ceux qui permettent de simplifier les expressions en
considérant la variable de gauche comme étant le premier nombre de l’opération mais aussi la
variable dans laquelle il faudra mettre le résultat. Il permet d’affecter une valeur à une variable
lors de l’exécution d’un programme. En java, on recense deux types d’opérateurs d’affectation
notamment ;
 les opérateurs d’assignation usuelle ou simple;
Cet opérateur d’affectation(=) peut faire intervenir d’autre expression. Par exemple,
pour ajouter à une variable c la valeur k, on écrira c=c+k qui fait intervenir de façon explicite
l’addition(+) pour être exécutée.
 les opérateurs d’assignation élargie ;
Cet opérateur permet de simplifier les écritures contrairement à l’opérateur usuel. Par
exemple au lieu d’écrire c=c+k avec l’opérateur simplifié, on peut faire c+=k qui ajoute de
façon implicite la valeur k à c.
Le tableau ci-dessous présente les autres opérateurs du même type
Tableau 3 : Opérateurs d'assignation

opérateurs Effets
Affectation = Affecte la valeur d’une variable dans une autre
Addition += additionne 2 valeurs et stocke le résultat dans la variable
Soustraction-= soustraire 2 valeurs et stocke le résultat dans la variable
Multiplication *= multiplie 2 valeurs et stocke le résultat dans la variable
/= division Divise 2 valeurs et stocke le résultat dans la variable
Modulo %= Divise 2 valeurs et stocke le résultat dans la variable
2. Opérateurs de calcul ou arithmétique
Ce sont des opérateurs qui permettent d’effectuer des opérations de calcul comme
l’addition, la soustraction la multiplication…..entre les objets (variables et la constante).
Le tableau suivant récapitule les opérateurs de calcul en java :
Tableau 4:Opérateurs de calcul
opérateurs effets
Addition + Somme deux valeurs
Soustraction - Soustraire deux valeurs
Multiplication * Multiplie deux valeurs
Division / Calcule le quotient de la division de 02 valeurs
Modulo % Calcule le reste de la division de 02 valeurs
GROUPE 4-2122 22
3. Opérateurs logiques
Ce sont des opérateurs qui permettent d’effectuer des opérations logiques

comme le ET logique ou le OU logique……
En algorithmique et en Java, ils permettent de vérifier si plusieurs conditions sont vrai.
Le tableau ci-dessous récapitule les opérateurs logiques java :
Tableau 5: Opérateurs logiques

opérateurs effets
OU logique II Retourne True si au moins une des 2
conditions vaut True (ou false sinon)
ET logique && Retourne true si les 2 conditions valent True
NEGATION logique! Retourne True si la variable vaut false et false
si elle vaut True
4. Les opérateurs relationnels ou de comparaison
Elles permettent de comparer deux éléments ou de donner une relation entre

deux objets (variable, constante)
Le tableau suivant recense les principaux opérateurs de comparaison en java :
Tableau 6 : Les opérateurs logiques

opérateurs Effets
Opérateur d’égalité == Compare deux valeurs et vérifie leur egalite
Opérateur d’infériorité stricte < Vérifie qu’une variable est strictement
inférieure a une variable
Opérateur de supériorite stricte > Verifie qu’une variable est strictement
supérieure a une variable
Opérateur d’infériorite <= Vérifie qu’une variable est strictement
inférieure ou égale à une variable
Opérateur de supériorite >= Vérifie qu’une variable est strictement
supérieure ou égale à une variable
Opérateur de difference != Vérifie qu’une variable est différente d’une
valeur
Remarque : En java on retrouve aussi les opérateurs d’incrémentation qui permettent de

facilement augmenter ou diminuer d'une unité la valeur variable. Ces opérateurs sont très utiles
GROUPE 4-2122 23
pour des structures telles que des boucles, qui ont besoin d'un compteur (variable qui augmente
d’un en un).
Ainsi un opérateur de type c++ permet de remplacer des notations lourdes telles que c=c+1 ou
bien c+ = 1.
Le tableau suivant récapitule les opérateurs d’incrémentation en java
Tableau 7:Les opérateurs d'incrémentation
Les opérateurs d’incrementation Effets

++ Augmente d’une unité la variable
-- Diminue d’une unité la variable
Remarque :
Cependant, il existe une différence entre a++ (post incrémentation) ou ++a (pré-
incrémentation) qui se fait ressentir lorsque l'on combine plusieurs opérations. De ce fait, avec
c++ on utilise la valeur de c puis on ajoute 1, alors qu'avec ++c on ajoute d'abord 1, puis on
utilise le résultat. Il en va de même pour –c et c--.
Exemple (pour c=7) :
Int b=c++;
c’est initialisé à 7, b est également affecté de la valeur 7 puis c’est incrémenté à 8
Int b=++c;
c’est incrémenté à 8, puis b est initialisé à 8
5. Priorités des opérateurs
Le tableau suivant donne les priorités entre les opérateurs en java dans l’ordre décroissant :
Tableau 8 : Priorité des opérateurs

Les parentheses ()
Les operateurs d’incrementation ++ et --
Les opérateurs de multiplication, division et * / et %
modulo
Les opérateurs d’addition et soustraction + et -
Les opérateurs de décalage << >>
Les opérateurs de comparaison < > <= >=
Les opérateurs d’égalite == et !=
L’opérateur ou exclusif ^
GROUPE 4-2122 24
L’opérateur ET &
L’opérateur OU I
L’opérateur ET logique &&
L’opérateur OU logique II
Les opérateurs d’assignement = += et -=
NB : Les parenthèses ayant une forte priorité, l’ordre d’interprétation des opérateurs peut être
modifie par des parenthèses.
V. Les instructions en java
1. Instructions simples
a. Les déclarations des variables et constantes
 variables
Une variable est tout objet dont le contenu est susceptible de changer lors de l’exécution
d’un programme. Elle possède un nom et à un instant donné une valeur. La déclaration d’une
variable doit contenir deux choses : un nom et le type de données qu’elle peut contenir. Une
variable est utilisable dans le bloc ou elle est définie.
La déclaration de la variable sert à définir son type et par conséquent la manière dont elle
sera représentée en mémoire. En fonction des types de variable, nous avons différentes syntaxes
à respecter :
 Les types élémentaires ou types primitifs déclarés sous la forme :
Type_elementaire nomvariable ;
Si nous avons plusieurs variables de types différents,
Type_élémentaire nomvariable1 ;
Type_élémentaire nomvariable2 ;
Exemple:
long nombre ;
int compteur ;
string chaine ;
Dans le cas de plusieurs variables de même type, on suit la syntaxe :
Type_élémentaire nomvariable1,nomvariable2,…..,nomvariablen ;
exemple illustratif : int x, y,z ;
GROUPE 4-2122 25
Il est également possible de déclarer une variable en l’initialisant directement. Pour se faire,
on utilise la syntaxe suivante:
type_variable nomvariable=valeur ;
Exemple : int nombre1=0 ;

Les classes personnalisées (plus souvent déclarées sous la forme d’une classe).
En supposant que la classe ait déjà été créée.
La syntaxe de déclaration est :
Nom_classe :nom_variable ;
 Constantes
Pour signaler qu’une variable est constante, on utilise le mot réservé « final » lors de sa
déclaration.
Exemples: final int faces =6 ;
final double pi=3.14 ;
b. Instructions d’affectation
Pour affecter une valeur à une variable, on utilise la syntaxe suivante :
Nom_variable=valeur ;
Nom_variable=expression ;
 « expression » peut être un calcul

 La «valeur» ou «expression» doit être de même type que nom_variable .
Exemple : nombre=3 ;
total_facture=total_facture*0.17 ;
c. Instruction de lecture
Pour lire la valeur d’une variable, il faut tout d’abord importer la bibliothèque
java.until.scanner dans laquelle se trouve les classes et méthodes nécessaires. Ceci grâce à la
syntaxe import java.until.scanner.
GROUPE 4-2122 26
Dans le main de notre classe on saisit l’instruction :

scanner «identificateur de lecture»= new scanner(system.in) nous permettant de définir
l’identificateur et d’effectuer la lecture. Ainsi pour lire une information à l’écran, on utilise la
syntaxe :
« nom_variable »= «identificateur lecture». « type_variable_a_recuperer »() ;
Exemple : on peut écrire
Import java.until.scanner ;
Dans main.
Scanner clavier=new Scanner(system.in);
String age ;
age=clavier.nextInt();
d. Instruction d’affichage
 Syntaxe d’affichage
Pour afficher un texte à l’écran, il suffit juste d’utiliser la syntaxe suivante:

 System.out.println(‘’expression’’) ;pour afficher exactement l’ «expression» entre
guillemet avec retour chariot
 System.out.print(‘’expression’’) ; pour afficher exactement « expression » sans
retour chariot
 System.out.println(nomvariable) ; ici s’affiche le contenu de la variable
« nomvariable » avec retour chariot.
 System.out.print(nomvariable) affiche le contenu de la variable sans retour chariot.
2. Instructions complexes
a. Structures de contrôle
C’est une instruction particulière d’un langage de programmation impératif pouvant dévier
le flot de contrôle du programme la contenant lorsqu’elle est exécutée.
Les principales instructions de contrôle en java sont :
 Les structures conditionnelles
GROUPE 4-2122 27
Les structures conditionnelles ce sont les instructions qui permettent de tester si une
condition est vraie ou non. Ces structures peuvent être associées à des structures qui se répètent
suivant la réalisation de la condition appelées des structures de boucle.
 L’ instruction If
C’est une structure de test. Elle permet d’exécuter ou pas certaines instructions
If (condition)
//code
 L’instruction If else
Elle permet d’exécuter une autre série d’instructions en cas de non réalisation de la
condition. La syntaxe est :
If ( condition) {
Liste d’instructions
Else{ Autres series d’instructions
 L’instruction Switch
L’expression switch permet d’effectuer une sélection parmi plusieurs valeurs. Elle
évalue l’expression entre parenthèses et la compare dans l’ordre avec les valeurs des lignes
case. Si un est identique alors il commence à exécuter la ligne d’instruction qui suit. Une case
représente un point à partir duquel l’exécution du code commence. On utilise donc
l’instruction break pour isoler chaque case mais on peut ne pas le mettre si on veut le même
traitement pour chaque case. Si aucune case ne correspond à notre condition on peut ajouter un
cas default qui se place par convention à la fin.
GROUPE 4-2122 28
 Les structures itératives
 La boucle while
While (Boolean)
…. // code a executer
Le code est exécuté tant que le booléen est vrai. Si avant l’instruction while, le booléen
est faux, alors le code de la boucle ne sera jamais exécuté.
Code  Do while
Do {
…..
} while (Boolean)
Cette boucle est au moins exécutée une fois quelque soit la valeur du booléen
Les instructions à l’intérieur de la boucle sont exécutées tant que les conditions sont
respectées.
 La boucle for
GROUPE 4-2122 29
C’est une structure de contrôle qui permet de répéter l’exécution d’une séquence
d’instructions tant que le compteur n’est pas atteint. Ici on connait le nombre de fois qu’on veut
exécuter le code.
For (initialisation; condition; modification) {
…..
L’initialisation; condition; modification de l’index sont optionnelles. Dans

l’initialisation on peut déclarer une variable qui servira d’index et qui sera dans ce cas locale à
la boucle.
b. Tableaux
En java un tableau est une structure de données contenant un groupe d’éléments tous du même
type avec des adresses consécutives sur la mémoire. Le premier élément d’un tableau est d’indice 0. Du
point de vue de sa déclaration, un tableau se comporte comme un objet. Il existe deux façons différentes
de déclarer une variable de type tableau.
Type [ ] nom_tableau ;
ou
Type nom_tableau [ ] ;
NB : Ces 2 déclarations sont équivalentes.
 Les tableaux multidimensionnels
En java, il est possible de créer des tableaux de tableaux : tableaux dont les éléments
sont eux même des tableaux. Cette possibilité permet notamment de disposer de tableaux
irréguliers. Leur déclaration se fait similairement à celle de tableaux mais en augmentant le
nombre de [ ] (suivant la dimension souhaité).
Par exemple les déclarations :
Type nom_tableau [ ] [ ]; ou
Type [ ] nom_tableau [ ] ;
Type [ ] nom_tableau ;
GROUPE 4-2122 30
Les trois déclarations données plus haut sont équivalentes. Elles déclarent que nom
tableau est une référence à un tableau dont chaque élément est lui-même une référence à un
tableau.
VI. Les méthodes
Les méthodes ou fonctions représentent une encapsulation des instructions qui

déterminent le fonctionnement d’une classe. Sans méthodes pour agir, une classe ne fait rien
de particulier dans ce cas elle ne fait que contenir des attributs. En java on distingue deux types
de méthodes : méthode de classe et méthode d’instance.
1. Les types de méthodes
a. Méthode de classe
Une méthode de classe ou méthode statique est une méthode qui n’agit pas sur des
variables d’instances mais uniquement sur des variables de classe. Elle présente les
caractéristiques suivantes.
- Elle peut être appelée même sans avoir instanciée la classe.
- Elle peut accéder uniquement des variables et méthodes statique
- Dans la déclaration le nom de la méthode est toujours précède du mot clé static.
- Elle peut être appelé avec la notation classe.methode() ou lieu de objet.methode
main, la methode valeur absolue math.abs()
b. Méthode d’instance
Ce sont des méthodes qui prennent en paramètre des variables d’instance ou objet, donc
pour utiliser une méthode d’instance, on doit préalablement instancier la classe : créer l’objet
de la classe.
En général, les méthodes d’instance
 S’adressent directement à un objet et non à sa classe System.out.println(salut) ; on
envoi le message println a l’objet system.out avec un argument de type string
 Agissent sur l’état (variables privées) de l’objet.
GROUPE 4-2122 31
String leNom()
{ return nom ;}
voidchangeNom( string nouveauNom)

{ nom= nouveauNom ;}
 Permettent de demander à l’objet d’effectuer une action, de procéder à un calcul
Void decrisToi()
{
console.print(je suis une machine) ;
console.print(et je me nomme azer) ;
}
2. Déclaration d’une méthode
Avant d’être utilisée, une méthode doit être définie car pour l’appeler dans une classe,
il faut que le compilateur la connaisse, c’est- à- dire qu’il connaisse son nom, ses arguments et
les instructions qu’elle contient. La définition d’une méthode s’appelle ‘’declaration’’.la
déclaration d’une fonction se fait selon la syntaxe suivante :
Qualificateur TypeDeRetour nomDeLaMethode (Type1 argument1,

Type2 argument2, …, Typen argumentn) {
Liste des instructions
Remarques:
 Les qualificateurs sont des mots-clés permettant de modifier la visibilité ou le
fonctionnement d’une méthode, nous n’en utiliserons pour l’instant qu’un seul, le mot-
clé static permettant de designer la méthode qu’il qualifie comme une méthode de
classe dans la classe ou elle est déclarée. Une méthode n’est pas nécessairement
qualifiée donc ce mot-clé peut être omis.
GROUPE 4-2122 32
 TypeDeRetour représente le type de valeur que la méthode va retourner, cela peut être
un type primitif une classe, ou alors le mot-clé void si la méthode ne retourne aucune
valeur.
 Le nom de la méthode suit les mêmes règles que les noms de variables (voir à la partie
des règles de déclarations des variables).
 Les arguments sont facultatifs, mais s’il n’y a pas d’arguments, les parenthèses doivent
rester présentes.
 Il ne faut pas oublier de refermer les parenthèses les accolades 9 se ferment
automatiquement pour l’environnement éclipse).
Une fois cette étape franchie, votre méthode ne s’exécutera pas tant que l’on ne fait pas appel
à elle quelque part dans la classe.
Exemple
- Méthode sans paramètres
int calculer () {…..}
boolean tester () {…}
- Méthode avec paramètres
int calculer(int x, int y) {…….}
boolean tester(int x) {….}
3. Appel de méthode
Pour exécuter une méthode, il suffit de faire appel à elle en écrivant l’objet auquel elle
s’applique (celui qui contient les données) le nom de la méthode (en respectant les casses),
suivie de ses arguments entre parenthèses
objet.nomDeLaMethode(argument1,argument2,….)
Remarques
 Si vous exécutez une méthode sur l’objet courant (this), c’est-à-dire que vous utilisez
dans une classe. Une méthode de la même classe dans il est inutile de préciser que this
est l’objet auquel s’applique la méthode.
 Si jamais vous avez défini des arguments dans la déclaration de la méthode, il faudra
veiller à les inclure lors de l’appel de la méthode (le même nombre d’argument séparés
par des virgules) mais sans avoir à préciser leur type.
VII. Structure minimale d’un programme
GROUPE 4-2122 33
Comme tout autre langage, le java nécessite un minimum écrit dans le code source d’un
programme afin d’être exécuté.
Ainsi, un programme java est constitué au minimum de :
 Une classe basique : de préférence avec une visibilité publique (tout utilisateur qui
importe le paquetage peut utiliser la classe)
La syntaxe d’écriture d’une classe est :
Public_class_nom dela classe{……}
 La méthode principale : ‘’main’’,elle doit absolument être présentée dans tout

programme java. Sa convention d’écriture est :
Public static void main(string[] args)
Par ailleurs il est conseillé d’associer à la méthode principale l’argument
String[]args suivie de l’extension throwns exception pour gérer les cas particulier et
exceptions afin de faciliter le développement.
 Au moins une instruction : en effet pour qu’un programme s’exécute, il faut qu’il
contient au moins une instruction car n’oublions pas l’ordinateur ne fait qu’exécuter
des instructions.
La figure ci-dessous illustre la structure minimale d’un programme java
Figure 1 Structure minimale d’un programme
GROUPE 4-2122 34
B. CAS PRATIQUE
Introduction
En génie civil, les problèmes tels que le calcul de la flèche d’une poutre soumise à une
flexion, la manipulation des matrices de rigidité, le dimensionnement des
structures...nécessitent l’utilisation des matrices. De ce fait, dans notre cas pratique, il sera
question de concevoir un programme qui calcule la somme et le produit de deux matrices
carrées de taille n*n (n : entier naturel quelconque) afin de faciliter la manipulation des
matrices.
 Données entrées :
Les entrées sont une matrice A de taille n*n et une matrice B de taille n*n.
 Données de sorties :
Une matrice S de taille n*n somme de A et B, une matrice P de taille n*n produit de A et B.
1. Présentation du cas programme
Pour la réalisation de ce programme, on commence par créer une classe Matrice dans
laquelle sera créé les différentes méthodes permettant d’effectuer les opérations sur les
matrices.
2. Initialisation
Ici il s’agira d’importer la méthode de lecture par la syntaxe :

Import java.util.Scanner
Puis on passe à la déclaration des différentes variables qui seront utilisées dans la suite
du programme. Cela est illustré par :
GROUPE 4-2122 35
Figure 2 : Déclaration des variables et instanciation de la classe
3. Création des matrices
Il s’agit ici de créer les paramètres d’entrée : les deux matrices A et B. Cela se fait
comme ci-dessous :
Figure 3 Creation des matrices A et B
GROUPE 4-2122 36
4. Affichage des matrices A et B
Figure 4 : Affichage des matrices A et B
5. Création des méthodes somme et produit

Il s’agit ici de créer les méthodes permettant d’effectuer la somme et le produit de A et
B
 Somme
Figure 5:Somme de A et B
GROUPE 4-2122 37
 Produit
Figure 6 : Produit de A et B
6. Utilisation des méthodes
Ici il est judicieux de tout d’abord créer une nouvelle classe application dans un
nouveau fichier du même paquetage que la classe matrice. Elle nous permettra d’exécuter nos
différentes méthodes :
Figure 7 : Utilisation des méthodes
GROUPE 4-2122 38
CONCLUSION
Arrivée au terme de notre exposé, il était question pour nous de présenter les éléments
de base en java et donner le minimum requis pour un programme dans ce langage. De ceci, il
en ressort que le java, langage de programmation oriente objet possède plusieurs composantes
de bases notamment ; les classes, les types de données, les instructions, les opérateurs et les
méthodes. Par ailleurs, le développement d’un programme en java nécessite le respect d’un
certains nombres de règles de base afin que celui-ci soit compilé. Aussi, pour être exécuté, un
code source doit obligatoirement avoir une structure minimale.
GROUPE 4-2122 39
BIBLIOGRAPHIE
 https://www.jmdoudoux.fr/java/dej/chap-syntaxe.htm
 http://blog.paumard.org/cours/java/chap05-noms-
operateurs-tableaux.html
 https://developpement-informatique.com
 https://openclassrooms.com
 https://ec.ccm2.net
 https://www.commentcamarche.net
 https://web.maths.unsw.edu.au
 https://rmdiscala.developpez.com
 https://fr.slideshare.net/amir soussi1/chapitre3
GROUPE 4-2122 40

Expose Groupe 4 Final

Transféré par

Droits d'auteur :

Formats disponibles

Expose Groupe 4 Final

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Expose Groupe 4 Final

Transféré par

Droits d'auteur :

Formats disponibles

Expose d’informatique

REPUBLIQUE DU CAMEROUN REPUBLIC OF CAMEROON

DEPARTEMENT DE GENIE CIVIL ENGINEERING

PRESENTATION DES ELEMENTS DE

ING. ENYEGUE GERMAIN

Ingénieur chercheur à l’ENSPY

Ce document est dédié à :

Nos remerciements vont à l’endroit de :

Table des matières

2. Instructions complexes ....................................................................................................... 27

Liste des tableaux

Liste des figures

2. Les mots réservés

 L’identificateur ne doit pas commencer par un chiffre

 Les formes de commentaires

En java, il existe plusieurs formes de commentaire qui sont entre autres :

…………………de plusieurs variables*/

Quelques règles de déclaration des variables sont :

II. Notion de classe

En Java, on appelle classe la structure d'un objet, c'est-à-dire la déclaration de l'ensemble

1. Syntaxe d'une classe

public class MaClasse

Le fichier contenant cette déclaration doit avoir pour extension nom-classe.java. Un

2. Actions sur les classes

a. Importer une classe

Public class MaClasse

Public static void main(string[] args)

Java.util.vector v = new java.util.vector() ;

b. Instancier une classe

MaClasse r; // declaration d’une reference de type “reference vers MaClasse’’

r=new MaClasse() ; // creation d’une instance de MaClasse, puis référencement par

MaClasse r=new MaClasse(); // on crée une instance de MaClasse, que l’on

3. Visibilité d’une classe

Une classe a une visibilité :

4. Exemples de classes et syntaxes

Voici un exemple de déclaration de classe.

Exemple d'une classe publique

Public class Marin {

// Doit être écrite dans le fichier Marin.java !

Exemple d'une classe interne

pubic class Marin {

// Doit être écrite dans le fichier Marin.java

...// code de la classe

Class Capitaine { // écrite dans le même fichier

…. // code de la classe capitaine

Exemple : Classes membre de la classe Character

public final class Character { // déclarée dans le fichier java/lang/Character

... // code de la classe Character

public static class Subset {

public static final class UnicodeBlock extends Subset {

Exemple d'une classe locale

public class Marin implements Comparable<Marin> {

private String nom, prenom ;

public int compareTo(Marin marin) {

class MarinComparator implements Comparator<Marin> {

public int compare(Marin m1, Marin m2) {

return (new MarinComparator()).compare(this, marin) ;

Exemple d'une classe anonyme locale

public class Marin implements Comparable<Marin> {