Bonjours,
je suis en train de lire le tuto java mais plusieurs points me parraissent flou :
- Qu'entend on par "type" d'un objet ?
- Je n'arrive pas à comprendre la polymorphose d'une méthode, si quelqu'un pouvais essayer de m'expliquer autrement

Bonsoir,

Le type d'un objet c'est savoir si l'objet est un nombre, une chaine ou encore d'un type que tu as créé, c'est-à-dire une classe.

MaClasse obj = new MaClasse(); // obj est un objet de type MaClasse

Pour la méthode polymorphe, j'ai commencé à taper une explication mais elle n'était pas suffisamment claire. C'est pas évident de bien expliquer sans être compliqué.. Je te propose donc de lire ceci.

++

Polymorphisme:

Admettons que tu as deux classes chien et chat qui sont les class filles d'une class Animaux ou bien implémentent une interface Animaux (au choix).
On suppose que le chien et le chat ont des méthodes en commun, mais qu'ils ne se nourissent pas de la meme facon.

L'intéret sera de déclarer une methode manger comme abstract dans la class Animaux si Animaux est une class, soit normalement si Animaux est une interface et de definir cette methode (manger) dans la class chien et chat.

Par la suite tu pourras avoir une List contenant des object de type Animaux.
Quand tu appeleras Animaux.manger(), alors la le programme se chargera tout seul de définir si cet animal est un chien ou un chat, et d'appeller la bonne méthode manger en conséquence!

j'espere avoir été clair

un petit exemple:

public abstract class Animaux{
 public abstract void manger();
}

Ou bien:

public interface Animaux{
 public void manger();
}

Ensuite les classes Chien et chat

public class Chien extends Animaux{ //ou impléments Animaux
 public void manger(){
  System.out.println("Le chien mange");
 }
}

public class Chat extends Animaux{ //ou impléments Animaux
 public void manger(){
  System.out.println("Le chat mange");
 }
}

Et enfin dans ton code tu pourras faire:

public class test {
 public static void main(){
  //on a une liste qui contient des Animaux
  ArrayList<Animaux> lesBestioles = new ArrayList<Animaux>();
  //on suppose qu'elle est remplie
  lesBestioles .get(0).manger();/*on appel la methode manger sur un objet dont on ne connais pas le type réellement    (chien ou chat) mais le programme s'adaptera et determinera la bonne methode à appeller en fonction de l'objet contenu dans l'arraylist*/
 }
}

Bonjour,

Il n'est pas nécessaire que la méthode manger soit abstraite. Il pourrait y avoir un comportement de base pour tous les animaux. Les classes qui héritent pourraient exécuter le comportement de base puis un comportement spécifique à la classe.

Exemmle:

public class Animaux {
    public void manger() {
        System.out.println("L'animal mange");
    }
}

public class Chat extends Animaux {

    public void manger() {
        super.manger(); // on exécute la méthode 'manger' de la classe mère
        System.out.println("Le chat miaule après avoir mangé"); // ensuite, un code propre à la classe 'Chat'
    }

public class Chien extends Animaux {

    public void manger() {
        System.out.println("Le chien mange"); // la méthode 'manger' de la classe mère n'est pas exécutée
    }

public class Test {   // un nom de classe commence par une majuscule 

 public static void main(){
  //on a une liste qui contient des Animaux
  List<Animaux> lesBestioles = new ArrayList<Animaux>();
  //on suppose qu'elle est remplie
  Iterator<Animal> it = listeAnimaux.iterator();
  while (it.hasNext()) {
    it.next().manger(); // la méthode est polymorphe. La méthode 'manger' correspondant au type de l'objet trouvé sera exécutée. C'est le polymorphisme. 
  }
}

Une interface permet aussi de profiter du polymorphisme sans qu'il y ait héritage. Mais, dans cet exemple, l'héritage est tout indiqué, il n'est pas utile d'utiliser une interface.

++

Citation : Weiouch

Une interface permet aussi de profiter du polymorphisme sans qu'il y ait héritage

Dans le tuto (lien) on trouve :

Citation

On peut dire que les méthodes polymorphes sont typiques des classes héritées !

Visiblement, d'après ce que tu dis, c'est inexact.

Peut-être pourriez-vous faire un commentaire à ce sujet sur le chapitre en question, ou contacter l'auteur pour qu'il corrige ça ?

(Si je ne le fais pas directement, c'est parce que je ne connais pas Java, et ne suis donc pas le plus adapté pour suggérer des reformulations à ce sujet)

Re,

Pas de problème. Je vais d'ailleurs le montrer ici par un exemple.

Voici l'interface I_AnimalDomestique:

public interface I_AnimalDomestique {

    void jouer(); // ou public abstract jouer();

}

Rappel: les méthodes d'une interface sont par défaut abstraites et publiques.

La classe Chat implémente l'interface I_AnimalDomestique

public class Chat extends Animal implements I_AnimalDomestique{

    public void manger() {
        super.manger();
        System.out.println("Le chat miaule après avoir mangé");
    }

    public void jouer() {
        System.out.println("Le chat joue");
    }   
}

La classe Chien implémente I_AnimalDomestique

public class Chien extends Animal implements I_AnimalDomestique{

    public void manger() {
        System.out.println("Le chien mange");
    }

    public void jouer() {
        System.out.println("Le chien joue");
    } 
}

Voici un exemple d'utilisation

//Une liste chaînée qui contient des références de 'type' I_AnimalDomestique
List<I_AnimalDomestique> animauxDomestiques = new LinkedList<I_AnimalDomestique>();

// On ajoute dans la liste des objets de type Chat et Chien
// Ceci n'est possible qu'avec des objets dont la classe implémente l'interface I_AnimalDomestique
animauxDomestiques.add(new Chat());
animauxDomestiques.add(new Chien());

// Un itérateur mono-directionnel pour parcourir la liste
// 
Iterator<I_AnimalDomestique> it = animauxDomestiques.iterator();
while (it.hasNext()) {
    it.next().jouer(); 
    // Polymorphisme en action. 
    // La méthode exécutée dépend du type de l'objet au moment de l'exécution du programme
}

Le chat joue
Le chien joue

Il y aurait beaucoup à dire pour être vraiment précis. J'ai contacté l'auteur du tutoriel pour signaler quelques remarques sur la section des conteneurs. Je vais également discuter de ce point avec lui dès qu'il me répondra.

Au final, le polymorphisme est possible lorsqu'il y a héritage OU implémentation d'interface ET redéfinition de méthode.

++