Exemple de polymorphisme

Soyez le premier à donner votre avis sur cette source.

Snippet vu 16 623 fois - Téléchargée 27 fois

Contenu du snippet

cette source a été pour moi un exercice pour appliquer le polymorphisme.
la particularité du polymorphisme est un fonctionnement différent d'une méthode selon l'objet manipulé.
la réalisation du polymorphisme passe par la création d' une classe abstraite, la création des classes qui etendent de la classe abstraite.
pour avoir un fonctionnement polymorphique une variable objet doit etre déclaré comme une variable de la classe abstraite et instancié comme un objet de la classe étendue.

Source / Exemple :


abstract class PorteLogique {

  /*une classe abstraite est une classe comportant des méthodes qui ne sont pas 
  définies dans la classe. elles sont définies dans la classe qui en étend*/
  
  boolean Entree1, Entree2, sortie;
  int num;
  String nom;
  PorteLogique porte;

  public PorteLogique(String nom) {
    this.nom = nom;
  }

  public void EtatEntree1(boolean entree) {
    Entree1 = entree;
    this.operation();
  }

  public void EtatEntree2(boolean entree) {
    Entree2 = entree;
    this.operation();
  }

  abstract void operation();
  
  //cette méthode est définie dans les classes "non","nonet","nonou","ou" et "et".

  public void relie(PorteLogique porte, int n) {
    this.porte = porte;
    num = n;
  }

  // affihe l etat de l entree ou de la sortie
  public void niveauEntree1() {
    System.out.println("Etat de l entree 1 de " + nom + " : " + Entree1);

  }

  public void niveauEntree2() {
    System.out.println("Etat de l entree 2 de " + nom + " : " + Entree2);

  }

  public void niveauSortie() {
    System.out.println("Etat de la sortie " + nom + " : " + sortie);
  }

  public void niveau() {
    this.niveauEntree1();
    this.niveauEntree2();
    this.niveauSortie();
  }

}

class Non extends PorteLogique {

  public Non(String nom){
      super(nom);
  }

  void operation() {
    boolean anciens;
    anciens = sortie;
    sortie = !Entree1;
    if (anciens != sortie) {
      if (num == 1) {
        porte.EtatEntree1(sortie);
      }
      if (num == 2) {
        System.out.println("cette porte n'a qu une seul entrée");
      }
    }
  }
}

class NonOu extends PorteLogique{

  public NonOu(String nom){
    super(nom);
  }

  void operation() {
    boolean anciens;
    anciens = sortie;
    sortie = ! (Entree1 || Entree2);
    if (anciens != sortie) {
      if (num == 1) {
        porte.EtatEntree1(sortie);
      }
      if (num == 2) {
        porte.EtatEntree2(sortie);
      }
    }
  }
}

class NonEt extends PorteLogique{

  public NonEt(String nom){
    super(nom);
  }

  void operation() {
    boolean anciens;
    anciens = sortie;
    sortie = ! (Entree1 && Entree2);
    if (anciens != sortie) {
      if (num == 1) {
        porte.EtatEntree1(sortie);
      }
      if (num == 2) {
        porte.EtatEntree2(sortie);
      }
    }
  }
}

class Ou extends PorteLogique {

  public Ou(String nom){
    super(nom);
  }

  public void operation() {
    boolean anciens;
    anciens = sortie;
    sortie = (Entree1 || Entree2);
    if (anciens != sortie) {
      if (num == 1) {
        porte.EtatEntree1(sortie);
      }
      if (num == 2) {
        porte.EtatEntree2(sortie);
      }
    }
  }
}

class Et extends PorteLogique{

  public Et(String nom){
    super(nom);
  }

   void operation() {
    boolean anciens;
    anciens = sortie;
    sortie = (Entree1 && Entree2);
    if (anciens != sortie) {
      if (num == 1) {
        porte.EtatEntree1(sortie);
      }
      if (num == 2) {
        porte.EtatEntree2(sortie);
      }
    }
  }
}

class test {
  public static void main(String arg[]) {

//selection des portes logiques
    PorteLogique p1 = new NonOu("p1");
    PorteLogique p2 = new Non("p2");
/* le principe du polymorphisme repose par la déclaration des objets comme étant
    des objets de la classe de base*/
//cablage
    p1.relie(p2, 1);

//simulation
    p1.EtatEntree1(false);
    p1.EtatEntree2(false);
    System.out.println("cas 1");
    p1.niveau();
    p2.niveau();
    p1.EtatEntree1(false);
    p1.EtatEntree2(true);
    System.out.println("cas 2");
    p1.niveau();
    p2.niveau();
    p1.EtatEntree1(true);
    p1.EtatEntree2(false);
    System.out.println("cas 3");
    p1.niveau();
    p2.niveau();
  }
}

A voir également

Ajouter un commentaire

Commentaires

Messages postés
2835
Date d'inscription
lundi 11 août 2003
Statut
Modérateur
Dernière intervention
16 décembre 2006
10
Oui mais tu es d'accord que le fait de mettre une classse en abstract n'est pas lié au polymorphisme (moi perso je l'ai compris comme ça dans ta description !), mais comme tu le dit d'obliger le dev. à surcharger toutes les méthodes virtuelles pures. L'abstraction provient tout droit du concept orienté objet, pour qui une classe ayant une définition générale ne doit pas être instanciée -> elle fait office d'interface (à ne pas confondre avec le mot clé interface de Java !) ... bon j'arrête là j'ai mal au doigts -> pour ceux qui veulent une explication complète -> google ou un bon livre ....
@+
Messages postés
357
Date d'inscription
jeudi 24 octobre 2002
Statut
Membre
Dernière intervention
30 mars 2011

Tu as raison qu'une simple classe parent et la redéfinition ou la définition des méthodes dans les classes qui en héritent peut suffire pour faire du polymorphisme. Mais la création d'une classe abstract est un mecanisme obligeant le programmeur à définir les méthodes dans les classe filles
Messages postés
2835
Date d'inscription
lundi 11 août 2003
Statut
Modérateur
Dernière intervention
16 décembre 2006
10
Es-tu vraiment sûr de ton coup ???
Pour pouvoir faire du polymorphisme il suffit d'une simple classe parent ! En fait 'virtual' (opposé à final) est le comportement par défaut d'une méthode... donc n'importe quelle classe dérivée peut faire du polymorphisme (et c'est pourquoi les performances JAVA ne sont pas au RDV, il existe cependant un petit mot clé qui évite le comportement polymorphique c'est f...)
Abstract ne sert pas à ça...
@+

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.