Vous êtes sur la page 1sur 32

POO 1/3

-
Introduction
à la Programmation Orientée Objet

Pierre Parrend
IUT Lumière Lyon II, 2005-2006
pierre.parrend@univ-lyon2.fr
Sommaire
● Les Langages de Programmation
● Premier Programme
● Les Objets
● Objets et Classes
● Ecrire une Classe
● Héritage
● Interfaces et Classes Abtraites

Janvier 2008 Programmation Orientée Objet 2


Les Langages de
Programmation
● 4 grandes familles
– Procédural
● Code Modulaire et Appels de Procédures
● Ada, C, Pascal, Perl, PHP, VB
– Fonctionnel
● Evaluation de fonctions mathématiques
● APL, Erlang, Haskell, ML, LISP, F#, Scheme, XSLT
– Logique
● Exploitation des propriétés de la Logique mathématique
● Prolog
– Objet
● Une application est en ensemble d'entités autonomes représentants
données et fonctions
Janvier 2008 Programmation Orientée Objet 3
● C++, C#, Java, Smalltalk
Les Langages de
Programmation
● Vers Java

Janvier 2008 Programmation Orientée Objet 4


Code
Mon Premier Programme
● HelloWorld ● HelloWorld dans le
monde Objet
public class HelloWorldClass
public class HelloWorld {
{ //constructeur
public static void main(String[] args) public HelloWorldClass(){/*initialisation*/}
{
System.out.println("Bonjour Monde"); private void bonjourMonde()
} {
} System.out.println("Hello World");
}

public static void main(String[] args)


{
HelloWorldClass objetPoli
=new HelloWorldClass();
objetPoli.bonjourMonde();
}
}

Janvier 2008 Programmation Orientée Objet 5


Ce qu'est un Objet
● Définition
– Entité cohérente composée de données et de fonctions
● Avoir et Etre
● Etat et Action
– Représentation en mémoire d'une entité de l'application

Janvier 2008 Programmation Orientée Objet 6


Code
Dialogue d'Objets
● Scénario Aéroport
– 3 Classes: Scenario, Avion, TourDeControle
– La classe Scenario crée l'environnement: Avions,
TourDeControle
– La classe Scenario lance le décollage et l'atterrisage des
avions
– Les Avions transmettent leur statut à la TourDeContrôle

Janvier 2008 Programmation Orientée Objet 7


Code
Dialogue d'Objets
● Scénario Aéroport
– Diagramme de Classes

Janvier 2008 Programmation Orientée Objet 8


Code
Dialogue d'Objets
● Scénario Aéroport
– Diagramme de Séquence

Scénario

init()
new()
TourDeControle
new()
Avion

decollage(
)
decollage()
informe()
atterrissage()
atterrissage()
informe()

Janvier 2008 Programmation Orientée Objet 9


Code
Dialogue d'Objets
package aeroport;//Package private void decollage() {
System.out.println("Décollage");
import java.util.ArrayList;//Imports de classes de Avion avionCourant;
l'API for(int i=0;i<avions.size();i++) {
avionCourant=(Avion)avions.get(i);
public class Scenario//Classe avionCourant.decollage();
{ }
//Données }
//configuration
private int nbAvions=5; private void atterrissage() {
System.out.println("Atterrissage");
//stockage des données Avion avionCourant;
private TourDeControle bigBoss; for(int i=0;i<avions.size();i++){
private ArrayList avions; avionCourant=(Avion)avions.get(i);
avionCourant.atterrissage();
//Méthodes }
private void init() }
{ //Méthode main
System.out.println("Initialisation"); public static void main(String[] args)
bigBoss=new TourDeControle(); {
avions=new ArrayList(); Scenario aeroport=new Scenario();
for(int i=0;i<nbAvions;i++) { aeroport.init();
avions.add(new Avion(i,bigBoss)); aeroport.decollage();
} aeroport.atterrissage();
} }
}
Janvier 2008 Programmation Orientée Objet 10
Code
Dialogue d'Objets
package aeroport;//Package package aeroport;//Package

public class Avion//Classe public class TourDeControle//Classe


{ {
//Données //Constructeur
private int id; public TourDeControle()
private TourDeControle tdc; {
System.out.println(">> TourDeControle créée");
//Constructeur }
public Avion(int identifiant, TourDeControle tdc)
{ //Méthode
this.id=identifiant; public void informe(String message, int idAvion)
this.tdc=tdc; {
System.out.println("* Avion "+id+" created *"); String information="L'Avion "+idAvion+
} " a transmis le message suivant: "+message+".";
//Méthodes System.out.println(">> "+information);
public void decollage() }
{ }
tdc.informe("Décollage en cours",this.id);
}

public void atterrissage()


{
tdc.informe("Atterrisage en cours",this.id);
}
}
Janvier 2008 Programmation Orientée Objet 11
Objets et Classes
● Classe: Définition d'un Type d'Objets
– Vue statique
– Ce qu'on programme
● Objet: Instanciation d'une classe
– Vue dynamique
– Ce qu'on exécute

Janvier 2008 Programmation Orientée Objet 12


Objets et Classes
● Cycle de Vie d'un Objet

1) Déclaration 2) Instanciation
Public void maMethod() Allocation d'espace mémoire
association du nom à l'objet
de variable avec un Type {
HelloWorldClass objetPoli 3) Initialisation
Appel au constructeur de
l'Objet
= new HelloWorldClass();
}

4) destruction
Par le Garbage Collector

Janvier 2008 Programmation Orientée Objet 13


Objets et Classes
● Type et Classes
– Les Classes définissent des Types de Données
● Types de Données en Java
– Types basiques
● Boolean, short, int, long, float, double
– Interfaces
● API Java et définies par l'application
● Définition de types
● Ex: List, Iterable, Collection
– Classes
● API Java et définies par l'application
● Ex: System, Runtime, ArrayList, HelloWorldClass
Janvier 2008 Programmation Orientée Objet 14
Ecrire une Classe
● Package
– Première ligne du fichier
package commande;

● Imports de Classes
– Classes utilisées par la classe en cours
import java.io.File;
import java.lang.System;
● Nom de Classe
– C'est le nom du fichier dans lequel la classe est enregistrée
● Panier.java

public class Panier{}


Janvier 2008 Programmation Orientée Objet 15
Ecrire une Classe
● Membres d'une classe
– Attributs
public class Panier{
private ArrayList produits;
private int idClient;
...
}

– Methodes

public class Panier{


...
public void addProduit(int idProduit, int quantite){...}
public ArrayList getProduits(){...}
}

Janvier 2008 Programmation Orientée Objet 16


Ecrire une Classe
● Méthodes particulières
– Constructeur
public class Panier{
...
public Panier(int idClient){
this.idClient=idClient;
}
...
}
– main public class HelloWorld{

public static void main(String[] args)


{
System.out.println(“HelloWorld”);
}
}
Janvier 2008 Programmation Orientée Objet 17
Ecrire une Classe
● Visibilité
private
protected

- public protected default private


Classe X X X X
# Package X X X
+ Classe Fille X X
Autres X

public

default
(package protected)

Janvier 2008 Programmation Orientée Objet 18


Ecrire une Classe
● Domaine de définition des variables
– Variables: globales, de méthodes, locales

Janvier 2008 Programmation Orientée Objet 19


Héritage
● Principe
– Mise en commun de code entre plusieurs classes similaires
● Coder l'héritage
package geometrie;

public class Figure{...}

public class Carre extends Figure {}

public class Rectangle extends Figure {}

public class Carre extends Figure


{
public Carre(...)
{
super(...);
}
}
Janvier 2008 Programmation Orientée Objet 20
Héritage
● Définitions
– Héritage: mécanisme d'extension de classe. Une Classe Fille
qui hérite d'une classe mère a accès à l'ensemble de ses
membres (hors membres privés), et peut les compléter et/ou
les redéfinir.

Janvier 2008 Programmation Orientée Objet 21


Héritage
● Définitions (Suite)
– Généralisation: c'est le mécanisme symétrique de l'Héritage.
La généralisation consiste à définir une classe mère qui
contient le code commun à plusieurs classes filles.
– Polymorphisme: plusieurs classes filles différentes peuvent
ête manipulées de manière transparente sous forme d'une
instance du type de la classe mère. C'est le polymorphisme (1
classe peuvent être définie de plusieurs manières différentes
et être utilisée de la même façon)

Janvier 2008 Programmation Orientée Objet 22


Héritage
● Example

Janvier 2008 Programmation Orientée Objet 23


Héritage
● Example
package geometrie; package geometrie;
//classe mère //classe fille
public class Figure { public class Carre extends Figure {

public String nom; public int largeur;


public String couleur;
public int surface; public Carre(String nom,
String couleur, int largeur)
public Figure(String nom, {
String couleur, int surface) super(nom, couleur,largeur*largeur);
{ this.largeur=largeur;
this.nom=nom; }
this.couleur=couleur;
this.surface=surface; public void demo()
} {
this.printProprietes();
public void printProprietes() { System.out.println(“surface: ”+
System.out.println("****"); this.getSurface());
System.out.println("nom de la figure: " }
+nom);
System.out.println("couleur: "+couleur); //exemple de method surchargee – redondant
} public int getSurface(){
return largeur*largeur;
public int getSurface() { }
Janvier 2008 Programmation Orientée Objet 24
return surface; }
}
}
Héritage
● Example
public class Test
{
public static void main(String[] args)
{
System.out.println("Test – Geometrie");
//heritage simple
Carre monCarre
=new Carre("roue", "rouge",25);
System.out.println("Surface: "
+monCarre.getSurface());
monCarre.printProprietes();

Rectangle monRectangle
=new Rectangle("piscine","Vert",3,5);
monRectangle.printProprietes();

//Polymorphisme
Figure fig
=new Carre("jacques", "bleu", 4);
fig.printProprietes();
}
Janvier 2008 } Programmation Orientée Objet 25
Interfaces et Classes
Abstraites
● Example

Janvier 2008 Programmation Orientée Objet 26


Interfaces et Classes
Abstraites
● Principe
● Coder les Interfaces
public interface List{
//define method signature
public Object[] toArray();
}

public class ArrayList implements List{


Object[] dataArray;
public Object[] toArray(){
//code
return this.dataArray;
}
}

Janvier 2008 Programmation Orientée Objet 27


Interfaces et Classes
Abstraites
● Coder les Classes Abstraites

public abstract class AbstractList implements List{


//define constructor
public AbstractList(){//code}

abstract public Object get(int index);

public List subList(int indexFrom, int indexTo){//code}


}

Janvier 2008 Programmation Orientée Objet 28


Interfaces et Classes
Abstraites
● Définitions: Interfaces, Classes Abstraites
● Interface: Définition fonctionnelle d'un type de donnée.
● Une interface définit les membres (variables,
méthodes) que devront implémenter les classes de ce
type. Une classe peut implémenter plusieurs
interfaces, et donc être de plusieurs types. Les
interfaces peuvent, comme l'héritage, être utilisées
pour le polymorphisme.
● Une interface ne peut pas être instanciée (= utilisée
comme objet).

Janvier 2008 Programmation Orientée Objet 29


Interfaces et Classes
Abstraites
● Définitions: Interfaces, Classes Abstraites
● Classe Abstraite: Classe Mère qui définit partiellement le
comportement des ses Classes Filles, en particulier par le
biais de méthodes abstraites, définies mais non implémentées.
● Signature d'une méthode: définition du nom, type de retour,
type et nombre des paramètres, visibilité d'une méthode.

Janvier 2008 Programmation Orientée Objet 30


Code
HelloWorld Expliqué
● String[] args public class HelloWorld
{
– Tableau d'arguments public static void main(String[] args)
{
– Auquels on accède par args[i] System.out.println("Bonjour Monde");
}
● static }

– Accès sur la classe (et non sur l'objet)


● void
– Pas de donnée retournée par la function
● System.out.println
– Affichage sur la sortie standard du Système

Janvier 2008 Programmation Orientée Objet 31


Exercice
Dialogue d'Objets
● Ecrire un programme simple qui réponde au cahier
des charges suivant:
– Une classe 'GestionClient'
● Avec une méthode ajoutClient(), qui crée un client, et affiche ses propriétés
– Une Classe 'Client'
● Initialisé avec un nom (de type String), un identifiant (de type int)
● Une méthode 'afficher', qui affiche les propriétés du client (nom, identifiant)
– Une Classe Scenario
● Avec une méthode main
● Créer les clients suivants par le biais de 'GestionClient':
– Gérard, identifiant=1
– Amandine, identifiant=2;

Janvier 2008 Programmation Orientée Objet 32

Vous aimerez peut-être aussi