Catégorie : Non classé

L’abstraction consiste à cacher les détails d’implémentation et à ne montrer que ce qui est nécessaire. Les classes abstraites ne peuvent pas être instanciées directement.

Elle définit un modèle avec des méthodes abstraites qui doivent être implémentée « obligatoirement » par les classes dérivées.

Les interfaces sont des structures qui définissent un « contrat » qui ne contient que les signatures de la méthode (ex. nom, paramètre mais pas d’implémentations), les classes qui étendent une interface doivent obligatoirement fournir une implémentation complète des méthodes définies dans l’interface.

Exemple:

Dog dog = new Dog();
Cat cat = new Cat();

dog.Speak();
cat.Speak();

dog.Sleep();
cat.Sleep();

dog.Attack(50);

Console.Read();

interface IAttack
{
    void Attack(int damage);
}

abstract class Animal
{
    public abstract void Speak();

    public void Sleep()
    {
        Console.WriteLine("Sleeping...");
    }
}

class Dog : Animal, IAttack
{
    public override void Speak()
    {
        Console.WriteLine("Bark!");
    }

    public void Attack(int damage)
    {
        Console.WriteLine($"Dog hits with {damage} points of damage.");
    }
}

class Cat : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Meow!");
    }
}

Le polymorphisme est souvent considéré comme le troisième pilier d’une programmation orientée objet, après l’encapsulation et l’héritage. Le polymorphisme est le mot grec qui signifie « plusieurs formes » et il prend deux aspects distincts :

• Au moment de l’exécution, les objets d’une classe dérivée peuvent être traités comme des objets d’une classe de base dans les paramètres de méthode et les collections ou les tableaux. Lorsque ce polymorphisme intervient, le type déclaré de l’objet n’est plus identique à son type au moment de l’exécution.
• Les classes de base peuvent définir et implémenter des méthodes virtuelles, et les classes dérivées peuvent les substituer, ce qui signifie qu’elles fournissent leur propre définition et implémentation. Au moment de l’exécution, quand le code client appelle la méthode, le CLR recherche le type au moment de l’exécution et appelle cette substitution de la méthode virtuelle. Dans le code source, vous pouvez appeler une méthode dans une classe de base, et provoquer l’exécution d’une version de la classe dérivée de la méthode.
  (source)

Conclusion: Le polymorphisme est une propriété de la POO permettant aux méthodes d’avoir plusieurs comportements en fonction de la classe qui les utilise.

exemple:

Sword sword = new Sword("Claymore", 100);

Console.WriteLine(sword);

abstract class Weapon // "abstract" pour rendre impossible l'instanciation de la classe Weapon, et laisser les classes dérivées spécialiser leurs membres et méthodes.
{
    public string name { get; private set; } // exemple d'encapsulation
    public int price { get; private set; }

    public Weapon(string name, int price)
    {
        this.name = name;
        this.price = price;
    }

    public virtual void Damage() // mot clé "virtual" necessaire à la substitution de cette methode dans les objets hérités.
    {
        Console.WriteLine("10 pts of damage");
    }

    public override string ToString()
    {
        return $"Weapon: {name} | Price: {price} gold";
    }

}

class Sword : Weapon // exemple d'héritage
{
    public int durability { get; private set; }

    public Sword(string name, int price) : base(name, price)
    {
        this.durability = 60;
    }

    public override void Damage() // "override" pour substituer la méthode virtuelle
    {
        Console.WriteLine("25 pts of damage");
    }

    public override string ToString() 
    {
        return $"{base.ToString()} | Durability: {durability}";
    }
}