PROGRAMMATION

ORIENTEE
OBJET(POO)
SOUS JAVA

Dr YANNOGO 1
Introduction à la
programmation
Définition:
• La programmation (ou développement logiciel) est le processus de
création d'instructions que les ordinateurs peuvent exécuter (langage
compris par la machine) pour accomplir des tâches spécifiques. Ces
instructions sont écrites dans un langage de programmation. C'est
grâce à la programmation que nous pouvons créer des logiciels, des
applications, des jeux vidéo, des sites web, des systèmes
d'exploitation et bien plus encore.
Exemple de langage de programmation: Python, Java , C, C++, etc.

2
Introduction à la
programmation
• Un programme informatique : est un ensemble d'instructions écrites
dans un langage de programmation que l'ordinateur peut comprendre
et exécuter pour accomplir une tâche précise. Ces instructions,
appelées code, définissent étape par étape ce que l'ordinateur doit
faire. Le programme informatique a une structure bien établie qui
varie en fonction du langage de programmation(Java, Python, html),
du style de programmation(style Orientée objet, style impératif).
Nous mettrons l’accent dans ce cours sur le langage de
programmation Java et le style Orientée objet.

3
Structure d’un programme
informatique
Un programme est constitué de plusieurs éléments :
• Instructions : Ce sont les actions que le programme demande à l'ordinateur
d'effectuer (par exemple, additionner des nombres, afficher un message, etc.).
• Variables : Ce sont des espaces dans lesquels sont stockées des données
temporaires utilisées par le programme.
• Conditions : Ce sont des décisions que le programme prend en fonction des
valeurs ou résultats (ex. : si un utilisateur est connecté, alors lui afficher une page
spécifique).
• Boucles : Ce sont des structures permettant de répéter certaines actions plusieurs
fois (ex. : afficher une liste de nombres).
• Fonctions : Ce sont des morceaux de code réutilisables qui accomplissent une
tâche spécifique.
4
Le Langage de programmation
Java
Introduction
Java est un langage de programmation qui a été créé par James
Gosling en 1995 chez Sun Microsystems (maintenant racheté par
Oracle). Ce langage est très populaire et utilisé dans de nombreux
domaines, comme le développement d'applications web, mobiles
(Android), de logiciels de bureau, et plus encore.
Java est un langage fortement typé(c’est-à-dire que toute variable
utilisée doit être déclaré avec son type) et orientée objet(on verra ce
que cela signifie un peu plus loin).

5
Matériel nécessaire pour
programmer en Java
Pour programmer en Java on a besoin de:
• Un IDE (Integrated Development Environment) est un logiciel qui te permet de
programmer plus facilement.
• Exemple d’IDE pour Java:
• IntelliJ IDEA est l'un des IDE les plus populaires pour Java. Il est très puissant, avec une
interface conviviale et de nombreuses fonctionnalités pour améliorer la productivité des
développeurs.
• Eclipse est un autre IDE très populaire pour le développement Java. Il est largement utilisé
dans l'industrie et offre de nombreuses fonctionnalités comme des outils de débogage et
des plugins.
• Le JDK(Java Development Kit) indispensable pour faire fonctionner un code java
• Téléchargeable à l’adresse: [Link]
windows

6
Comment installer IntelliJ IDEA
• Accéder au site de téléchargement :
• Ouvrez votre navigateur web et allez sur la page officielle d'IntelliJ
IDEA ici : [Link]
• Choisir la version gratuite (Community Edition) :
• Sur la page de téléchargement, vous verrez deux versions disponibles:
• Ultimate Edition (payante) : Version complète avec des fonctionnalités
supplémentaires pour les développeurs professionnels.
• Community Edition (gratuite) : Version de base, mais suffisante pour la
plupart des besoins de développement Java.
• Il ne vous reste plus qu'à installer le fichier d’installation téléchargé
7
Eléments de base à savoir en
java
• Chaque instruction se termine par un point-virgule(;)

• Les instructions sont exécutées blocs par blocs

• Le nom du fichier .java doit être le même que celui de la classe

publique

8
Les types de variables en Java
Quelques types de données de base en Java :
• int : pour les nombres entiers (ex. 5, -12).
• double : pour les nombres décimaux (ex. 3.14, -7.99).
• char : pour un seul caractère (ex. 'a', 'B').
• String : pour une chaîne de caractères (ex. "Bonjour", "Java").
• boolean : pour une valeur vraie ou fausse (ex. true ou false).

9
Les opérateurs en java
• Pour effectuer une addition on utilise le symbole +
• Pour effectuer une soustraction on utilise le symbole –
• Pour effectuer une multiplication on utilise le symbole *
• Pour effectuer une division on utilise le symbole /
• Si l’on cherche le reste de la division entre deux nombre on utilise le
symbole %
• Exemple: int a=10
int b=5
int reste=a%b

10
Déclaration des variables en
java
Pour déclarer une variable en java, on donne tout d’abord le type de la
variable, suivie du nom de la variable , sa valeur et l’on termine par un
point-virgule(;)
Exemple:
int age=25; : pour déclarer la variable age
double prix=12.34; : pour déclarer la variable prix
String nom=« Débora"; :pour déclarer la variable nom

11
Les commandes de base en Java
• La fonction [Link](): est utilisée pour afficher un
objet(variable, chaine de caractère, nombres,….)
Exemple: un programme qui affiche le texte « Bonjour tout le monde »

public class main {

public static void main(String[] args) {
[Link]("Bonjour tout le monde ");
}
}
12
Exercices d’application
• Ecrire un programme Java qui calcule la moyenne de 3 notes(note1=9,
note2=17 ,note3=7) et qui affiche le résultat.

• Ecrire un programme Java qui calcule le périmètre et l’aire d’une

surface rectangulaire de longueur 17.01 mètres et de largeur 10.20
mètres.

13
Solutions
• Solution exercice 1:
public class exercice1 {
public static void main(String[] args){
int note1=9;
int note2=17;
int note3=7;
int moyenne=(note1+note2+note3)/3;
[Link]("la moyenne des 3 notes est : "+ moyenne);
}
}
14
Solutions
• Solution exercice 2:
public class exercice2 {
public static void main(String[] args){
double longueur=17.01;
double largeur=10.20;
double perimetre=(longueur+largeur)*2;
double surface=longueur*largeur;
[Link]("Le périmètre est de : "+perimetre);
[Link]("La surface est de : "+surface);
}
}
15
Les structures de contrôle
• La fonction if(si): est une fonction qui permet d’exécuter une instruction
si la condition donnée est vrai
• La fonction else if (sinon si): est une fonction qui permet d’exécuter une
instruction si la condition première( le if) est faux
• La fonction else (sinon) qui permet d’exécuter une instruction si toutes
les conditions données plus haut sont fausses.
Exemple: if (score >= 90) { [Link]("A");
} else if (score >= 80) { [Link]("B");
} else { [Link]("C");
}
16
Les boucles
• La boucle for: La boucle for est utilisée lorsque l’on sait combien de
fois l’on veut répéter un bloc d'instructions.
• Syntaxe: for(initialisation; condition; mise-à-jour){
Bloc d’instruction à répéter
}
Exemple: afficher le chiffre 7, 3 fois
for(int i=0;i<3;i++){
[Link](7)
}

17
Les boucles
• La boucle while( Tant que): La boucle while est utilisée lorsque l’on veut répéter des
instructions tant qu'une condition est vraie. La condition est vérifiée avant d'exécuter le
bloc d'instructions. Si la condition est fausse dès le début, le code à l'intérieur de la boucle
ne s'exécute pas du tout.
• Syntaxe:
Initialisation
while(condition){
Bloc d’instruction;
}
Exemple: afficher le chiffre 7, 3 fois:
Int i=0
while(i<3){
[Link](7);
} 18
Les tableaux
Les tableaux en Java sont des structures de données permettant de stocker
plusieurs valeurs de même type dans une seule variable. Un tableau est
essentiellement une collection d'éléments indexés, où chaque élément est
accessible via un indice.
• Syntaxe de déclaration d’un tableau:
Type d’éléménts que va contenir le tableau suivie de [] nom de la variable
Exemple: tableau de nombres entiers:
Int[] tableau;
• Après être déclaré, un tableau doit être initialisé en précisant le nombre
d’éléments qu’il doit contenir. L'initialisation se fait avec le mot-clé new et la
taille du tableau.
Exemple: int[] tableau; //déclaration
tableau= new int[5];// initialisation 19
Les tableaux
• si on connaît déjà les valeurs, on peut directement initialiser le
tableau avec des éléments spécifiques.
Exemple:int[] tableau = {1, 2, 3, 4, 5}; // tableau contenant les valeurs
1, 2, 3, 4, 5
• Les éléments du tableau sont indexés, l'index commence à 0.
L'élément à l'index 0 est le premier, l'élément à l'index 1 est le
deuxième, et ainsi de suite.
Exemple: soit le tableau précédent:
[Link](tableau[0]) //affiche l’élément du tableau d’index 0
c’est-à-dire 1
20
Les tableaux
• On peut également modifier un élément d’un tableau grâce à son index.
Exemple: int[] tableau = {1, 2, 3, 4, 5};
tableau[0]=10; // 1 devient 10
• La méthode [Link] : retourne la taille du tableau(le nombre d’élément
que le tableau contient)
Exemple: [Link]([Link]); // affiche 5 car le tableau a 5
éléments
• On peut aussi parcourir les éléments d’un tableau à l’aide d’une boucle for:
• Exemple: for(int i=0; i<[Link]; i++){
[Link](tableau[i]);
}
21
Les tableaux
• Une autre méthode de parcours de tableau existe:
• La méthode for-each: qui permet de parcourir tous les élément de la liste

• Syntaxe:
for(type element : tableau){
Bloc d’instruction;
}
• Exemple: afficher tous les éléments d’une liste de nombre
for(int element : tableau){
[Link](element);
}
22
Exercice d’application
1. Déclarez le tableau suivant: tableau={1, 2, 3, 4, 9, 12.9, 22, 17}

2. Changer les 3 premiers nombres en leur double(x2)

3. Afficher les 3 nouveaux premiers nombres

4. Afficher le dernier nombre de la liste

5. Afficher la taille de la liste

23
Correction de l’exercice
d’application
public class ExerciceApplication {
public static void main(String[] args){
double [] tableau={1, 2, 3, 4, 9, 12.9, 22, 17};
for(int i=0;i<3;i++){
tableau[i]=tableau[i]*2;}
for(int i=0;i<3;i++){
[Link]("les éléments du tableau sont :"+tableau[i]);}
[Link]("le dernier nombre de la liste
est :"+tableau[[Link]-1]);
[Link]("Le tableau compte "+[Link]+" éléments");
}
24
Programmation Orientée
Objet(bases)
• La programmation orientée objet (POO) est un style de
programmation qui repose sur l’utilisation d'objets pour organiser et
structurer le code. Contrairement à la programmation procédurale, où
l'accent est mis sur les fonctions et les actions à exécuter, la POO
place les objets au centre du développement.
• Un objet est une instance d'une classe, qui est comme un plan de
construction (ou un modèle). Une classe définit les propriétés et les
comportements des objets, tandis qu'un objet est une instance
concrète de cette classe

25
Programmation Orientée
Objet(bases)
Exemple: Si nous voulons créer une classe personne(c’est-à-dire un
modèle de personne) alors les personnes qui auront les mêmes
comportements, les mêmes attributs que ce modèle de personne que
nous souhaitons créer seront des objets de cette classe en question.
Soit la classe Personne, ayant les attributs suivants: mince, grand , beau
et les fonctions : manger, courir, sauter
Si Bouba est mince, grand et beau et que Bouba mange court et saute
alors Bouba est un objet de la classe Personne.
NB: manger , courir et sauter constituent les méthodes de la classe
Personne
26
Programmation Orientée
Objet(avancée)
Nous verrons dans cette partie quelques concepts clés de la
programmation orientée objet:
• L’Encapsulation : L'encapsulation est le concept qui consiste à cacher
l'état interne d'un objet et à ne permettre l'accès à cet état que via
des méthodes (appelées méthodes d'accès ou getter et setter).Cela
permet de protéger les données de l'objet et de les rendre plus sûres.
En java on effectue une encapsulation grâce à la méthode private.

27
Programmation Orientée
Objet(avancée)
Les getters et setters sont des méthodes spéciales en programmation
orientée objet, utilisées pour accéder ou modifier les valeurs des
attributs d'un objet. Ils sont essentiels pour appliquer le principe de
l'encapsulation.
.Les getters permettent d’avoir accès aux données grâce à la méthode
getAttribut()
• Les setters permettent de modifier la valeur d’un attribut grâce à la
méthode setAttribut() et à la méthode [Link](valeur de
l’attribut)

28
Programmation Orientée
Objet(avancée)
Exemple d’utilisation du private pour l’encapsulation:
• Créons un fichier [Link] où nous allons créer une classe personne(un
modèle de personne):
public class Personne {
private String nom; //premier attribut de la classe personne son nom(caché)
public String getNom(){ //le getter
return nom;
}
public void setNom(String nom){
[Link](nom); //le setter
}
} 29
Programmation Orientée
Objet(avancée)
Exemple d’utilisation du private pour l’encapsulation:
Maintenant créons un fichier [Link] où nous allons créer notre premier objet de la
classe personne et lui donner le nom Bouba.
NB: Pour créer un nouvel objet d’une classe on utilise la fonction new()
public class Bouba {
public static void main(String[] args){
Personne personne1=new Personne(); // Une nouvelle personne est créer
[Link]("Bouba"); // On vient de lui donner le nom de Bouba
String nom_de_personne1= [Link](); // on stocke le nom de bouba dans
une variable
[Link]("La personne1 se nomme "+ nom_de_personne1);
}
30
}
Programmation Orientée
Objet(avancée)
L'héritage est un autre concept fondamental en programmation
orientée objet (POO) qui permet à une classe enfant (ou sous-classe) de
hériter des propriétés et des comportements (méthodes) d'une classe
parent (ou super-classe). En Java, l'héritage est implémenté grâce au
mot-clé extends.
Exemple: si l’on crée une classe animal(super classe), une classe chien
hériterait de la classe animal car le chien est un animal.

31
Programmation Orientée
Objet(avancée)
Exemple d’utilisation de l’héritage:
Créons un fichier [Link] qui sera la super-classe avec les fonctions manger et courir.
public class animal {
public void manger(){
[Link]("L'animal mange");}
public void courir(){ [Link]("l'animal court"); }
private String nom;
public String getNom(){
return nom; }
public void setNom(String nom) {
[Link] = nom;}
} 32
Programmation Orientée
Objet(avancée)
Nous allons maintenant créer notre classe chien qui héritera de la classe
animal à l’aide d’un fichier [Link]:
public class chien extends animal{ //héritage effectuée
public void aboyer(){
[Link]("le chien aboie");
}
}
NB: L’héritage ainsi effectuée, tout objet de la classe chien héritera des
fonctions de la classe animal(manger, courir, nom) et de la classe
chien(aboyer).
33
Programmation Orientée
Objet(avancée)
Créons maintenant un nouvel objet de notre classe chien afin de vérifier que l’héritage
s’est bien éffectué à l’aide d’un fichier premier_chien.java:
public class premier_chien {
public static void main(String[] args){
chien premier_chien=new chien();
premier_chien.setNom("Milou"); //Donner un nom à notre chien
String nom_premier_chien=premier_chien.getNom();
[Link]("Le nom du premier chien est "+nom_premier_chien);
premier_chien.aboyer(); // appel de la fonction aboyer
premier_chien.courir(); // appel de la fonction courir
premier_chien.manger(); // appel de la fonction manger
}
34
}
Programmation Orientée
Objet(avancée)
On peut également redéfinir la méthode d’une classe parent grâce à la fonction
@Override:
Redéfinissons la méthode manger() de la classe animal pour l’adapter à la classe chien:
public class chien extends animal{
public void aboyer(){
[Link]("le chien aboie");}
@Override
public void manger(){
[Link]("le chien mange de la viande"); }
}
NB: Lorsqu’un nouvel objet de la classe chien fera appel à la fonction manger, c’est le
message « le chien mange de la viande qui s’affichera » 35
Programmation Orientée
Objet(avancée)
Lorsque l’on crée une super classe, on n’est pas toujours obligée de
définir toutes les méthodes de la classe; on peut créer des méthodes
abstraites. Une méthode abstraite est une méthode qui n'a pas de
corps, c'est-à-dire qu'elle est déclarée mais n'est pas définie (elle n'a
pas d'implémentation). C'est à la classe dérivée (ou sous-classe ou
encore classe enfant) de fournir une implémentation de cette méthode.
Les méthodes abstraites sont créée grâce au mot clé abstract.
NB: Une méthode abstraite ne peut être créer dans une classe qui ne
l’est pas.

36
Programmation Orientée
Objet(avancée)
Exemple de création de méthodes abstraites:
Créons la classe animal de façon à ce que toutes ses méthodes soient
abstraites:
public abstract class animales {
public abstract void manger();
public abstract void courir();
}
Ces méthodes seront définies dans les classes enfant(chien) grâce au
mot clé @Override
37
Exercice d’application
• Créer une classe Animal avec les attributs nom et age.
• Créer une méthode seDeplacer() dans la classe Animal pour afficher
un message générique sur le déplacement de l'animal.
• Créer deux sous-classes Chien et Chat qui héritent de Animal.
• Chaque sous-classe aura un comportement spécifique (par exemple,
aboyer() pour le Chien et miauler() pour le Chat).
• Redéfinir la méthode seDeplacer() pour afficher un comportement
spécifique du déplacement de l'animal (par exemple, "le chien court",
"le chat saute").

38
Correction de l’exercice
• Création de la classe animal:
public class animale {
public void seDeplacer(){
[Link]("l'animal se déplace");}
private String nom;
public String getNom() {
return nom;}
public void setNom(String nom) {
[Link] = nom;}
private int age;
public int getAge() {
return age;}
public void setAge(int age) {
[Link] = age;} 39
Correction de l’exercice
• Création de la classe chien
public class chien extends animale{
@Override
public void seDeplacer(){
[Link]("le chien "+getNom()+" court")
}
public void aboyer(){
[Link]("le chien "+getNom()+" aboie");}
}
40
Correction de l’exercice
• Création de la classe chat
public class chat extends animale{
@Override
public void seDeplacer(){
[Link]("le chat "+getNom()+" saute"
}
public void miauler(){
[Link]("le chat "+getNom()+" miaule" );
}
} 41
Correction de l’exercice
• Création d’un nouveau chat et d’un nouveau chien(classe qui sera exécuté):
public class NouveauChienChat {
public static void main (String[] args){
chien Rex=new chien();
chat cat=new chat();
[Link]("Rex");
[Link]("cat");
[Link]();
[Link]();
[Link]();
[Link]();}
} 42
Merci pour votre
attention!!!
43