Loading presentation...

Present Remotely

Send the link below via email or IM

Copy

Present to your audience

Start remote presentation

  • Invited audience members will follow you as you navigate and present
  • People invited to a presentation do not need a Prezi account
  • This link expires 10 minutes after you close the presentation
  • A maximum of 30 users can follow your presentation
  • Learn more about this feature in our knowledge base article

Do you really want to delete this prezi?

Neither you, nor the coeditors you shared it with will be able to recover it again.

DeleteCancel

Make your likes visible on Facebook?

Connect your Facebook account to Prezi and let your likes appear on your timeline.
You can change this under Settings & Account at any time.

No, thanks

Algo POO FISA EIGSI

Support de cours Introduction à la POO, EIGSI La Rochelle
by

Amandine Duffoux

on 9 March 2016

Comments (0)

Please log in to add your comment.

Report abuse

Transcript of Algo POO FISA EIGSI

public double moyenne (void)
{
double moyenne=0;


for (int i=0; i<notes.length; i++)
moyenne = moyenne + notes[i];
moyenne = moyenne / notes.length;

return (moyenne);
}
class Etudiant {
id;
nom;
prénom;
couleurcheveux;
age;
nextId;
public
private
private
private
private
private
private
private

static

final

String
ECOLE = "
EIGSI
" ;
Int
String
String
String
Int
Int
Programmation Orientée Objet
Java
Etienne CARNOVALI
Amandine DUFFOUX
Pour nous contacter:
nom@eigsi.fr
Introduction
Classes
et objets
Héritage
Conclusion
plan de travail
I.
II.
III.
IV.
V.
Une
classe
est un modèle utilisé pour créer plusieurs
objets
présentant des caractéristiques communes.
Une classe
définit
les fonctionnalités d'un objet
Une instance
réalise
ces fonctionnalités
Le but : utiliser des outils faciles à développer et réutilisables
l'
héritage
est un lien entre deux classes qui permet, sans redéfinir la classe initiale, d'utiliser les variables et méthodes déjà implémentées.
Un chien est un animal familier, il a donc toutes les caractéristiques des animaux familiers, il peut même en avoir de supplémentaires
L'héritage porte sur :
* les classes
* les instances des classes
* les variables
* les constructeurs
* les méthodes
Définition
Exemple
Réalisation
Merci pour votre attention
Des questions ??
=)
= Objets possédant une structure interne et un comportement, capable de communiquer avec d'autres objets
En conclusion :

Encapsulation des données : Sécurisation et transparence pour l'utilisateur

Utilisation et réutilisation de code simplifié (héritage)

Spécifications d'interface mises à disposition
Références
bibliographie:
karim jaafar.Développement JEE 5 avec eclipse Europa.
Jean Michel Doudoux.Développons en java.
webliographie:
Hugues Fauconnier, Cours de POO en Java, L3 Université de Jussieu
http://www.liafa.jussieu.fr/~hf/verif/ens/an08-09/poo/L3.POO.html
La POO en Java expliquée à des enfants, génial :
http://java.developpez.com/livres/javaEnfants/?page=classes#LV
le site du zero:
http://www.siteduzero.com/informatique/java/tutoriels
Un
objet
est une
instance
d'une classe donnée
IHM
Par exemple :
Techniquement :
- Classe = Type
* regrouper des données et des méthodes
* variables de classe
* Méthodes de classe
- Instance (objet)
* Variables d'instance

Toute classe hérite de la classe
Object
class Etudiant {
id;
nom;
prénom;
couleurcheveux;
age;
nextId;
public
Modificateur de classe : il précède la déclaration de la classe
* public (par défaut package)
* abstract (incomplète, pas d'instance)
* final (pas d'extension possible)
private
private
private
private
private
private
Modificateur de champ : il précède la déclaration du champ
* private
* protected
* public
* package
Int
String
String
String
Int
Int
static
Modificateur :
* static : variable de classe
* final : constante
private

static

final

String
ECOLE = "
EIGSI
" ;
A vous de jouer !
On souhaite réaliser une application gérant des robots dans un monde en 2D.
* Monde (dans lequel vont évoluer les robots) :
- tableau à 2 dimensions de max 20 sur 30
- largeur
- longueur
* Robot (qui va évoluer dans l'espace en 2D) :
- numéro
- nom
- position en X
- position en Y
- se déplace dans un monde M
- nb robots créés
Static
* une variable (méthode) déclarée static est une variable(méthode) de classe : elle est associée à la classe (pas à une instance particulière)
* statique parce qu'elle est créée à la compilation (au contraire de dynamique : à l'exécution)
}
Création, vie et mort des objets : constructeurs, setties, getties et destructeurs...
création d'une instance
le constructeur
Mort
- appelé par l'opérateur new pour créer une instance de la classe (objet)
- initialise les objets
- constructeur par défaut
* porte le même nom que la classe
* n'a pas de type de retour
* peut avoir des paramètres
(surcharge)
plus de référence à cet objet : utilisation du garbage collector ou
protected void finalize() throws throwable
l'utilisation : les accesseurs (getties)
fonction membre permettant de récupérer le contenu d'une donnée membre en accès privé
* doit avoir comme type de retour le type de la variable à renvoyer
* ne possède pas forcement d'argument
l'utilisation : les mutateurs (setties)
fonction membre permettant de modifier le contenu d'une donnée membre en accès privé
* a comme paramètre la valeur à assigner à la donnée membre qui est donc du type de la donnée membre
* ne renvoie pas nécessairement de valeur (void)
Modificateur de classe : il précède la déclaration de la classe
* public (par défaut package)
* abstract (incomplète, pas d'instance)
* final (pas d'extension possible)
Modificateur de champ : il précède la déclaration du champ
* private
* protected
* public
* package
A vous de jouer !
Référence
Une variable est en général une référence à un objet :
- type primitif : directement une valeur
- type référence : référence à un objet (existant ou créé via new)
* utilisation de l'opérateur new
exemple :
Etudiant toto = new Etudiant()
* création par
référence
* l'opérateur new appelle alors le constructeur de la classe
A vous de jouer !
public class A{
int i=0;

public static void main(){
int i=0;
int j=0;
//(i==j) ?
A a;
A b = new A();
a=b;
//a? b?
//(a==b)?
b = new A();
//a? b?
//(a==b)?
//(a.i==b.i)?
}}
Ajoutez les constructeurs pour Monde et pour Robot
private

static

final

String
ECOLE = "
EIGSI
" ;

/**
*Constructeurs
*/

public Int getId () { return(id);}
public String getNom() { return (nom);}
public String getPrenom {return (prenom);}
public String getCouleurCheveux {return (couleurCheveux);}
public Int getAge () {return (age);}
class Etudiant {
id;
nom;
prénom;
couleurcheveux;
age;
nextId;
public
private
private
private
private
private
private
Int
String
String
String
Int
Int
A vous de jouer !
public void setNom(String n) { nom = n;}
public void setPrenom(String p) {prenom=p;}
public void setCoulC(String cc){couleurCheveux=cc;}
public void setAge(Int a) {age = a;}
l'utilisation : les méthodes
= fonctions vues en algo
Modificateurs :
* contrôle d'accès (cf variables)
* abstract
* static : n'a pas accès aux variables d'instances
* final : ne peut pas être
remplacée
static
Modificateur :
* static : variable de classe
* final : constante
Static
* une variable (méthode) déclarée static est une variable(méthode) de classe : elle est associée à la classe (pas à une instance particulière)
* statique parce qu'elle est créée à la compilation (au contraire de dynamique : à l'exécution)
static
Modificateur :
* static : variable de classe
* final : constante
Static
* une variable (méthode) déclarée static est une variable(méthode) de classe : elle est associée à la classe (pas à une instance particulière)
* statique parce qu'elle est créée à la compilation (au contraire de dynamique : à l'exécution)
private double notes[];
/**
* Fonction permettant de changer de couleur de cheveux
*/
Pour Monde, un constructeur devra avoir comme paramètres la largeur et la longueur
et initialisera les valeurs de
l'ensemble du tableau à -1 (signifiant
qu'aucun robot n'est présent)
Pour Robot, vous devez au minimum proposer un constructeur "complet".
A vous de jouer !
if (notes.length != 0)
{



}

//Constructeur par défaut (incrémente id)
private Etudiant() {id = nextId++;}
/**
* Constructeur complet
* @param nom nom de l'étudiant
* @param prenom prénom de l'étudiant
* @param coulc couleur des cheveux de l'étudiant
* @param age age de l'étudiant
*/
public Etudiant (Etudiant etu) {
id = nextId++;
nom = etu.nom;
prenom = etu.prenom;
couleurCheveux = etu.couleurCheveux;
age = etu.age;
}
public Etudiant(String nom, String prenom, String coulc, int age) {
id = nextId++;
nom = nom;
prenom = prenom;
couleurcheveux = coulc;
age = age ;
}
/**
* Constructeur partiel
* @param nom nom de l'étudiant
*/
public Etudiant(String nom) {this(nom, null, null, 0);}
/**
* Constructeur par recopie (avec nouvel id)
* @param etu Etudiant à recopier
*/
/**
* Fonction calculant la moyenne des notes de l'étudiant
* @return la moyenne
*/
A vous de jouer !
Ajoutez les méthodes suivantes à Monde
* public boolean estLibre (int x, int y) :
renvoie true si la case x,y est libre, false sinon
* public void libere (int x, int y) :
libère la case correspondante
* public void occupe(int x, int y, int id) :
indique que la case x,y est occupée par le robot id
* public void affiche() :
affiche l'environnement en mode console
A vous de jouer !
Ajoutez la méthode suivante à Robot
* public void vaEn (int x, int y) :
permet de déplacer le robot en x,y
(si la case est libre)
Une fonction d'affichage des coordonnées du robot peut être
ajoutée pour le test de cette classe.

Testez ces différentes
classes dans une classe Jeu en créant un monde virtuel et en faisant évoluer plusieurs robots
public void allerChezLeCoiffeur (void)
{
System.out.println("Quelle couleur voulez-vous ?");
string nouvelleCouleur = StdInput.readlnString();
setCoulC(nouvelleCouleur);
}
Créez une classe test2 :
Incrémentez une variable statique et une variable dynamique via des fonctions et analysez la différence
Créez une classe test avec une méthode main et testez les égalités de valeur statiques et dynamiques.
public class Test2{
int id;
public void incId()
{id++;
//id?
}
public static void addi(int i)
{i++;
//i?
}
public static void main(){
int i=100;
//i ?
addi(i);
//i ?
Test2 t2 = new Test2();
t2.id = 100;
//id ?
incId();
//id ?
}
}
abstract ?
Animal familier
race
Plutôt que de modifier une classe existante, qui est peut-être soigneusement testée et déjà utilisée, l’héritage permet de traiter cette classe comme un module intégré qui peut être étendu à l’aide de propriétés et de méthodes supplémentaires.
Attention !!

Une classe ne peut pas hériter de plusieurs classes.
Principaux avantages :

* permet de réutiliser le code d’une classe de base sans modifier le code existant.
* ne nécessite pas de modifier les modes d’interaction des autres classes avec la classe
de base.
La classe existante est appelée classe de base ou
classe mère
, la nouvelle classe est appelée classe dérivée ou
classe fille
.
L’héritage est une forme de réutilisation du code qui permet aux programmeurs de développer de nouvelles classes à partir de classes existantes.
Qu'est ce que l'héritage ?
Héritage
Instances
Variables
Méthodes
Constructeurs
Contrôle d'accès
Quand B est une extension de A, un objet de B est un objet de A avec des propriétés supplémentaires
+ d'autres !
Tout objet de B a toutes les propriétés d'un objet de A
Un objet B peut être considéré comme un objet A
Si B extends A :
* B peut ajouter des variables
Si le nom est identique, cela
occultera
la variable de même nom dans A !
* Les variables de A sont toutes présentes pour un objet de B
mais certaines peuvent être cachées ou non accessibles !
* c'est le nom de la variable qui est pris en compte
pas le type, ni les droits d'accès !
* dans un contexte donné, une seule déclaration peut correspondre à un nom de variable (affectation à la compilation)
Si B extends A :
* Les méthodes de A sont des méthodes de B
* B peut ajouter de nouvelles méthodes si la
signature
est différente
* B peut redéfinir des méthodes si la
signature
est identique
Mais elles peuvent ne pas être accessibles :
private !
Signature :
nom + paramètres
On peut toujours appeler la méthode de la superclasse grâce à la fonction super, par ex : super.calculMoyenne()
On n'a pas besoin de redéfinir un constructeur, généralement on cherche juste à le compléter avec les nouveaux éléments, on peut donc faire appel au constructeur de la superclasse avec
super()
* Le modificateur final interdit la redéfinition pour une méthode
* Une variable avec modificateur final peut être occultée
* protected : accès dans les classes dérivées
* Une méthode redéfinie peut élargir l'accès mais pas le restreindre
class EtuFA extends Etudiant {
private

Entreprise
entreprise;
private

int[]
notesEnt;
private

static

final

String
CFA="
EIA
";

//Constructeur par défaut
public EtuFA(){
super()
;
entreprise = null;
for (int i=0; i<nb; i++)
notes_ent[i] = 0;
}
private

int[]
notes;
//calcul de la moyenne
public double moyenne (){
double resAcademic, resEnt=0;
//puis-je utiliser super.moyenne ?
resAcademic = super.moyenne();
for (int i=0;i<nb;i++)
resEnt=resEnt+notesEnt[];
resEnt = resEnt/nb;
return ((resAcademic+resEnt)/2);
}
dire()
Full transcript