Expose Groupe 4 Final

Télécharger au format pdf ou txt
Télécharger au format pdf ou txt
Vous êtes sur la page 1sur 40

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
Expose d’informatique

DEDICACE

Ce document est dédié à :


Nos camarades de la
Promotion 2024 de GENIE
CIVIL

GROUPE 4-2122 2
Expose d’informatique

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
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

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
Expose d’informatique

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
Expose d’informatique

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
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.

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
Expose d’informatique

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
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

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
Expose d’informatique

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
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.

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
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).

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
Expose d’informatique

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
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.

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
Expose d’informatique

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
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.

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
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 :

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
Expose d’informatique

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
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

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
Expose d’informatique

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
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

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
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.

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
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 ;

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
Expose d’informatique

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
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

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
Expose d’informatique

 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
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.

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
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.

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
Expose d’informatique

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
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.

VII. Structure minimale d’un programme

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{……}

 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
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.

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
Expose d’informatique

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
Expose d’informatique

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
Expose d’informatique

 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
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

Vous aimerez peut-être aussi