Dokuwiki

Outils pour utilisateurs

Outils du site

Piste :
perl:programmation_oriente_objet_utilisation

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentesRévision précédente
Prochaine révision		Révision précédente
perl:programmation_oriente_objet_utilisation [2009/03/15 00:52] – édition externe 127.0.0.1perl:programmation_oriente_objet_utilisation [2013/03/12 23:39] (Version actuelle) – root
Ligne 1: Ligne 1:
 +====== Objets ======
 +
 ====== 1. Programmation orientée objet ====== ====== 1. Programmation orientée objet ======
  
Ligne 6: Ligne 8:
  
 Cela implique dans un programme de se soucier de la donnée avant de la manipuler, comme on le fait déjà pour la déclaration et l'initialisation. La création d'un objet peut être considéré comme une initialisation sophistiquée et sur mesure : Cela implique dans un programme de se soucier de la donnée avant de la manipuler, comme on le fait déjà pour la déclaration et l'initialisation. La création d'un objet peut être considéré comme une initialisation sophistiquée et sur mesure :
 +<code perl>
   my $file = FileHandle->new(">sortie.txt"); # my $file; open($file, ">sortie.txt");   my $file = FileHandle->new(">sortie.txt"); # my $file; open($file, ">sortie.txt");
   my $line = $file->getline(); # my $line = <$file>;   my $line = $file->getline(); # my $line = <$file>;
   $file->close(); # close($file);   $file->close(); # close($file);
 +</code>
  
 ===== Classe et instance ===== ===== Classe et instance =====
Ligne 25: Ligne 29:
  
 Une classe est en général définie comme le cumul de fonctions de classes existantes, plus des nouvelles fonctionnalités. Cette conception "par couche", où l'on peut empiler les fonctions pour créer des classes plus sophistiquées (ou plus spécialisées) est appelée l'héritage. Une classe est en général définie comme le cumul de fonctions de classes existantes, plus des nouvelles fonctionnalités. Cette conception "par couche", où l'on peut empiler les fonctions pour créer des classes plus sophistiquées (ou plus spécialisées) est appelée l'héritage.
 +<code perl>
   my $mirza = Chien->new();   my $mirza = Chien->new();
   $mirza->aboie();   $mirza->aboie();
Ligne 31: Ligne 36:
   $medor->aboie(); # donc il peut en particulier aboyer, comme tout "Chien"   $medor->aboie(); # donc il peut en particulier aboyer, comme tout "Chien"
   $medor->attaque(); # mais il peut aussi attaquer!   $medor->attaque(); # mais il peut aussi attaquer!
 +</code>
  
 ====== 2. Utilisation des objets en Perl ====== ====== 2. Utilisation des objets en Perl ======
  
 La majorité des modules du répertoire CPAN sont fournis sous forme de classes, il faut donc en général commencer par instancier des objets pour pouvoir accéder à leurs fonctionnalités. Par convention (et il ne s'agit que d'une convention), le constructeur est en général est la méthode //new()//. Il y a bien sûr des exceptions : La majorité des modules du répertoire CPAN sont fournis sous forme de classes, il faut donc en général commencer par instancier des objets pour pouvoir accéder à leurs fonctionnalités. Par convention (et il ne s'agit que d'une convention), le constructeur est en général est la méthode //new()//. Il y a bien sûr des exceptions :
 +<code perl>
   use DBI;   use DBI;
      
   my $db = DBI->connect($dsn, $user, $password);   my $db = DBI->connect($dsn, $user, $password);
 +</code>
  
 Un objet en Perl est une référence sur une structure quelconque (scalaire, liste, tableau, etc), qu'on a en plus associé à une classe particulière (nous verrons comment en concevant nos propres objets). Ainsi ces deux éléments sont différents : Un objet en Perl est une référence sur une structure quelconque (scalaire, liste, tableau, etc), qu'on a en plus associé à une classe particulière (nous verrons comment en concevant nos propres objets). Ainsi ces deux éléments sont différents :
 +<code perl>
   my $mirza = Chien->new();   my $mirza = Chien->new();
   print "Ce chien s'appelle: ".$mirza->name(); # Il s'agit de la méthode 'name'   print "Ce chien s'appelle: ".$mirza->name(); # Il s'agit de la méthode 'name'
   print "Ce chien s'appelle: ".$mirza->{'name'}; # Il s'agit de l'élément 'name' du tableau %{$mirza}   print "Ce chien s'appelle: ".$mirza->{'name'}; # Il s'agit de l'élément 'name' du tableau %{$mirza}
 +</code>
  
 Il est assez courant que les paramètres d'un constructeur soient passés sous la forme d'un tableau (associatif), ceci rendant plus lisible l'utilisation de l'objet. Dans ce cas on veille bien à utiliser une référence vers un tableau : Il est assez courant que les paramètres d'un constructeur soient passés sous la forme d'un tableau (associatif), ceci rendant plus lisible l'utilisation de l'objet. Dans ce cas on veille bien à utiliser une référence vers un tableau :
 +<code perl>
   use DBIx::SearchBuilder::Handle;   use DBIx::SearchBuilder::Handle;
      
Ligne 53: Ligne 63:
   Database => "my_test_db"   Database => "my_test_db"
   });   });
 +</code>
  
 Profitez de l'héritage: quand vous manipulez un objet de la classe **Toto**, vous avez le droit d'utiliser les méthodes de tout ses "parents". Profitez de l'héritage: quand vous manipulez un objet de la classe **Toto**, vous avez le droit d'utiliser les méthodes de tout ses "parents".
 +
 +
 +===== Exemple =====
 +==== Création d'un module ====
 + 
 +  * **Fichier classe : //modules/joueur.pm//**
 +<code perl joueur.pm>
 +package joueur;
 +
 +use strict;
 +use warnings;
 +
 +our $info="Fichier classe : " . __FILE__ . "\nNom classe : " . __PACKAGE__ . "\nLigne : " . __LINE__ . "\n\n";
 +
 +#constructeur
 +sub new {
 +        my ( $classe, $nom ) = @_; #on passe les données au constructeur
 +
 +        my $this = {
 +                "joueur" => "$nom",
 +                "x" => 0,
 +                "y" => 0
 +        };
 +
 +        bless( $this, $classe ); #lie la référence à la classe
 +        return $this; #on retourne la référence consacrée
 +}
 +
 +sub avance {
 +        my ( $this, $nb_case ) = @_;
 +        $this->{y} += $nb_case;
 +}
 +
 +sub recule {
 +        my ( $this, $nb_case ) = @_;
 +        $this->{y} -= $nb_case;
 +}
 +
 +sub tourne_gauche {
 +        my ( $this, $nb_case ) = @_;
 +        $this->{x} -= $nb_case;
 +}
 +
 +sub tourne_droite {
 +        my ( $this, $nb_case ) = @_;
 +        $this->{x} += $nb_case;
 +}
 +
 +sub position {
 +        my $this = shift;
 +        print "Joueur $this->{joueur} se situe x=$this->{x} y=$this->{y}\n";
 +}
 +
 +sub AUTOLOAD
 +{
 +        our $AUTOLOAD;
 +        print "ERREUR : La fonction $AUTOLOAD n'a pas été définie !\n";
 +}
 +
 +# Destructeur
 +sub DESTROY {
 +        my $this = shift;
 +        print "$this->{joueur} : Partie terminée...\n";
 +}
 +
 +1;
 +</code>
 +
 +==== Utilisation du module et de ses classes ====
 +  * **Programme principal :**
 +<code perl mail.pl>
 +#!/usr/bin/perl -w
 +
 +use lib "./modules";
 +use joueur;
 +
 +print $joueur::info;
 +
 +my $p1 = joueur->new("Joueur1");
 +my $p2 = joueur->new("Joueur2");
 +
 +$p1->avance(3);
 +$p1->avance(8);
 +$p1->tourne_gauche(10);
 +$p1->recule(6);
 +$p1->tourne_droite(5);
 +
 +$p2->avance(8);
 +$p2->avance(4);
 +$p2->tourne_gauche(1);
 +$p2->recule(5);
 +$p2->tourne_droite(9);
 +
 +$p1->position;
 +$p2->position;
 +
 +$p2->mourir;
 +</code>
  
perl/programmation_oriente_objet_utilisation.1237078351.txt.gz · Dernière modification : (modification externe)