LikeGlue

The StoryCave

Dev blog

  • Bases de la POO: Abstraction

    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!");
    }
}

  • Bases de la POO: Polymorphisme


    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}";
    }
}

  • Bases de la POO : Encapsulation

    Encapsulation : Masquage de l’état interne et des fonctionnalités d’un objet et autorise uniquement l’accès via un ensemble public de fonctions. (source)

    Mots clés: public, private, protected, get;, set;

    Version 1 de l’accessibilité et protection des membres:

    public class Program
{
    static void Main()
    {
        Character character = new Character();
        character.Stats();
    }
    
}

public class Character
{
    private string name = "Gordon";
    private int healthPoints = 100;

    // méthode décomposée du get; set;
    public void SetName(string newName)
    {
        name = newName;
    }

    public string GetName()
    {
        return name;
    }

    public void SetHealthPoints(int newHp)
    {
        if (newHp < 0)
        {
            newHp = 0;
        }
        if (newHp > 100)
        {
            newHp = 100;
        }

        healthPoints = newHp;
    }

    public void Stats()
    {
        Console.WriteLine($"Name: {name} | HP: {healthPoints}");
        Console.Read();
    }
}

    Version 2 « optimisée » :

    public class Program
{
    static void Main()
    {
        Character character = new Character("Gordon", 100);
        character.Stats();
    }
    
}

public class Character
{
    public string name { get; private set; } // Il faut mettre ce champ en "public" pour proteger le set
    private int healthPoints = 100;

    public Character(string newName, int newHp)
    {
        name = newName;

        if (newHp < 0)
        {
            newHp = 0;
        }
        if (newHp > 100)
        {
            newHp = 100;
        }

        healthPoints = newHp;
    }

    public void Stats()
    {
        Console.WriteLine($"Name: {name} | HP: {healthPoints}");
        Console.Read();
    }
}

  • Bases de la POO : Héritage

    Apprentissage des principes de la programmation orientée objet.

    Encapsulation, héritage, abstraction et polymorphisme.

    Exemple d’héritage:

    namespace Heritage
{
    class Program
    {
        static void Main(string[] args)
        {
            CharacterClass newCharacter = new CharacterClass();
            
        }
    }
}

namespace Heritage
{
    public abstract class Entity
    {
        protected int strength;
        protected int dexterity;
        protected int willpower;
        protected int healthPoints;
        protected string name;
        protected string classType;
    }
}

namespace Heritage
{
    public class Character : Entity
    {
        private int level;
        private int experience;

        public Character()
        {
            classType = ClassName();
            level = 1;
            experience = 0;
            name = CharacterName();
            strength = CharacterStrength();
            dexterity = CharacterDexterity();
            willpower = CharacterWillpower();
            healthPoints = 5;
            //Console.WriteLine(Stats());
        }

        public static string CharacterName()
        {
            var random = new Random();

            var firstName = new List<string> { "Gordon", "John", "Kaneda", "François"};
            var lastName = new List<string> { "Freeman", "Carter", "Shotaro", "Deschamps"};

            int index1 = random.Next(firstName.Count);
            int index2 = random.Next(lastName.Count);

            string name = firstName[index1] + " " + lastName[index2];
            return name;
        }

        public static int CharacterStrength()
        {
            var random = new Random();
            int strength = random.Next(1, 4);
            return strength;
        }

        public static int CharacterDexterity()
        {
            var random = new Random();
            int dexterity = random.Next(1, 4);
            return dexterity;
        }

        public static int CharacterWillpower()
        {
            var random = new Random();
            int willpower = random.Next(1, 4);
            return willpower;
        }

        private string ClassName()
        {
            var random = new Random();
            var classes = new List<string> { "Wizard", "Thief", "Fighter" };
            int index = random.Next(classes.Count);
            string classType = classes[index];
            return classType;
        }

        public string Stats()
        {
            return $"Name: {name}\n" +
                   $"Class: {classType}\n" +
                   $"Level: {level}\n" +
                   $"XP: {experience}\n" +
                   $"STR: {strength}\n" +
                   $"DEX: {dexterity}\n" +
                   $"WIL: {willpower}\n" +
                   $"HP: {healthPoints}\n";
        }
    }
}

namespace Heritage
{
    public class CharacterClass : Character
    {
        public CharacterClass()
        {
            switch (classType)
            {
                case "Wizard":
                    willpower += 5;
                    break;
                case "Thief":
                    dexterity += 4;
                    healthPoints += 1;
                    break;
                case "Fighter":
                    strength += 3;
                    healthPoints += 3;
                    break;
            }
            Console.WriteLine(Stats());
        }
    }
}