Expose Groupe 4 Final
Expose Groupe 4 Final
Expose Groupe 4 Final
EXPOSE D’INFORMATIQUE
(GROUPE 4)
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 :
GROUPE 4-2122 1
Expose d’informatique
DEDICACE
GROUPE 4-2122 2
Expose d’informatique
REMERCIEMENTS
Tous ceux-là qui, de près ou de loin qui ont contribué à la réalisation de ce projet.
GROUPE 4-2122 3
Expose d’informatique
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
Expose d’informatique
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
Expose d’informatique
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
Expose d’informatique
GROUPE 4-2122 7
Expose d’informatique
GROUPE 4-2122 8
Expose d’informatique
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
Expose d’informatique
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.
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
Expose d’informatique
REGLES DE NOMMAGE
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).
5. Règles de déclaration
GROUPE 4-2122 11
Expose d’informatique
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
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.
// corps de la classe
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.
GROUPE 4-2122 12
Expose d’informatique
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) :
//…..
// sans l’import:
//…..
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
Expose d’informatique
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.
/*instructions diverses*/
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 :
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
a. Classes publiques
GROUPE 4-2122 14
Expose d’informatique
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).
…. // 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.
}
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
Expose d’informatique
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.
GROUPE 4-2122 16
Expose d’informatique
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.
Comparator<Marin> comparator =
new Comparator<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
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 :
GROUPE 4-2122 17
Expose d’informatique
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)
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
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
GROUPE 4-2122 18
Expose d’informatique
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.
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.
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
Expose d’informatique
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 :
4. Les bibliothèques
GROUPE 4-2122 20
Expose d’informatique
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
GROUPE 4-2122 21
Expose d’informatique
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
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 :
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
Expose d’informatique
3. Opérateurs logiques
GROUPE 4-2122 23
Expose d’informatique
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
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
Le tableau suivant donne les priorités entre les opérateurs en java dans l’ordre décroissant :
GROUPE 4-2122 24
Expose d’informatique
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.
1. Instructions simples
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
Expose d’informatique
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 ;
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
Nom_variable=valeur ;
Nom_variable=expression ;
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
Expose d’informatique
d. Instruction d’affichage
Syntaxe d’affichage
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 :
GROUPE 4-2122 27
Expose d’informatique
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
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
Expose d’informatique
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
Expose d’informatique
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.
…..
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 [ ] ;
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
Expose d’informatique
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.
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
Expose d’informatique
String leNom()
{ return nom ;}
Void decrisToi()
{
console.print(je suis une machine) ;
console.print(et je me nomme azer) ;
}
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 :
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
Expose d’informatique
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.
GROUPE 4-2122 33
Expose d’informatique
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{……}
GROUPE 4-2122 34
Expose d’informatique
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.
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
GROUPE 4-2122 35
Expose d’informatique
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 :
GROUPE 4-2122 36
Expose d’informatique
Figure 5:Somme de A et B
GROUPE 4-2122 37
Expose d’informatique
Produit
Figure 6 : Produit de A et B
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 :
GROUPE 4-2122 38
Expose d’informatique
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
Expose d’informatique
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