示例#1
0
        static void Main(string[] args)
        {
            IChien chien10    = new Chien(10, "Titus");
            IChien chien10Bis = new Chien(10, "Sosie de Titus");
            IChien chien20    = new Chien(20, "Chien20!");
            IChien chien30    = new Chien(30);
            IChien chien40    = new Chien(40);


            IChien[]    chiens      = new IChien[] { chien20, chien30, chien10, chien10Bis, chien40 }; //Tableau de IChien.
            ListeChiens listeChiens = new ListeChiens(chiens);

            Console.WriteLine(listeChiens.obtenir(chien10Bis).obtenirNom()); //Recherche par id (Résultat: chien10 (premier matchant l'id chien10Bis.id))

            Console.WriteLine(listeChiens.obtenirParIndex(3).obtenirNom());  //Recherche par index (Résultat: chien10Bis)

            //Console.WriteLine(listeChiens.obtenir(2).obtenirNom()); //NON ! interdit car la méthode parente est masquée par celle enfant (qui renvoie un ICaillou).


            Console.WriteLine(listeChiens.obtenir(1000).obtenirIdentifDuCaillou()); //1000
            //La ligne juste ci-dessus fonctionne!!? Bizarrement donc, car comme je disais :
            //  bien que ICaillou ne descende pas de IAnimal (contrainte posée dans Liste<T> where T: IAnimal)
            // La méthode    new ICaillou obtenir(Int32)  ré-implémentée dans ListeChiens est acceptée !!!!
            // alors que dans la parente Liste<T> elle a pour signature : T Obtenir(Int32),
            //   avec donc T dérivant normalement de IAnimal !!
            // A NOTER que cette ré-implémentation de obtenir(Int32), MASQUE celle parente, du fait du 'new' dans la signature
            //  (new obligatoire car seul le type de retour différe de celui parent, pour cette méthode).

            Console.WriteLine("OK");
            Console.ReadKey();
        }
示例#2
0
        static void Main(string[] args)
        {
            IChien oChien1 = new Chien(1980, "Polo");

            oChien1.addPrenom("Polux").addComment("Un bon chienchien ce Polo/Polux").setPoids(30);

            IChien oChien2 = new Chien(1975, "Frigo");

            //oChien2.addPrenom("Frigolux").setPoids(60).addComment("Un peu frileux ce Frigololux!"); //OK
            //  La ligne CI-DESSOUS est acceptée CAR :
            // J'ai redéfini dans Chien, la méthode setPoids pour stipuler qu'elle retourne bien un IChien et NON plus un IAnimal !
            // Ainsi ce sera bien la méthode addComment de IChien et non IAnimal qui sera appelée, laquelle redéfinie, renvoie bien un IChien
            // et non pas un IAnimal ! ce qui permet enfin, d'avoir l'appel à addPrenom autorisé ! Car un IAnimal n'a pas
            //de méthode addPrenom, mais un IChien si !
            oChien2.setPoids(60).addComment("Un peu frileux ce Frigololux!").addPrenom("Frigolux"); //Interdit puisque addComment ne renvoie pas un IChien mais un IAnimal.


            oChien1.showData();                          //overridée simplement (même signature) (mais la parente doit être virtual).

            oChien2.merge(oChien1).addPrenom("Biloute"); //<<<<<<<<< Appel à merge de IChien ! car je l'ai surchargée !
            oChien2.showData();                          //overridée simplement (même signature) (mais la parente doit être virtual).


            Console.WriteLine("OK");
            Console.ReadKey();
        }
示例#3
0
        /*
         * public new Int32 method2c(Int32 n, Int64 z)  //Ici il s'agit d'une SURCHARGE(type/nombre de params différant) :
         * {                                            //donc l'OPERATOR new est INUTILE. Mais passe à la compil.  .
         *  string localeVar = base.method2c(n) + " puis  CChild - method2c"; //On peut quand même appeler la méthode parente.
         *  Console.WriteLine(localeVar);
         *  return (10 * n);
         * }
         */
        /*
         * public new string method2d(Int32 n, Int64 z)  //Ici il s'agit d'une SURCHARGE(type/nombre de params différant) :
         * {                                            //donc l'OPERATOR new est INUTILE. Mais passe à la compil.  .
         *  string localeVar = base.method2d(n) + " puis  CChild - method2d"; //On peut quand même appeler la méthode parente.
         *  return (localeVar);
         * }
         */

        public string method2e(Chien chien)          //SURCHARGE de la méthode parente (type de param. différant bien qu'étant un type enfant).
        {
            string localeVar = base.method2e(chien); //On peut bien sûr appeler la méthode parente.

            Console.WriteLine(localeVar);
            return("CChild - method2e / " + chien.obtenirEspece() + "/" + chien.obtenirPrenom());
        }
示例#4
0
        //Surcharge d'une méthode parente virtual :
        public void method1d(Chien chien)            //le mot-clef OVERRIDE étant ici INTERDIT, car la signature n'est PAS
        {                                            // Exactement la même que celle parente.
                                                     // IL S'AGIRA donc ici en fait D'UNE SIMPLE SURCHARGE (params différant) !!!
                                                     //Peu importe le type de retour (d'ailleurs différent ici).
            string localeVar = base.method1d(chien); //On peut bien sûr appeler la méthode parente.

            Console.WriteLine(localeVar);
            Console.WriteLine("CChild - method1d / " + chien.obtenirEspece() + "/" + chien.obtenirPrenom());
        }
示例#5
0
        static void Main(string[] args)
        {
            Chien         monChien       = new Chien();
            InfoSupplChat infoSupplChat1 = new InfoSupplChat();

            infoSupplChat1.infoSpecial1 = "Chat1 gentil!!";
            InfoSupplChat infoSupplChat2 = new InfoSupplChat();

            infoSupplChat2.infoSpecial1 = "Chat2 pas sympa!!";
            Chat monChat1 = new Chat(12, infoSupplChat1);
            Chat monChat2 = new Chat(14, infoSupplChat2);

            List <IAnimal> animaux = new List <IAnimal>()
            {
                monChien, monChat1
            };

            animaux.Add(monChat2);

            //SERIALISATION
            string animauxToString = JsonConvert.SerializeObject(animaux);         //J'ai installé pour ça le Nugget NewonSoft.Json

            Console.WriteLine("List<IAnimal> sérialisée: \n\n" + animauxToString); //OK
            Console.ReadKey();


            //DESERIALISATION : ci-dessous, CAST IMPOSSIBLE de la caîne sérialisée, en List<IAnimal>, car IAnimal étant un type abstrait
            //                  il ne peut être instancié !!!
            //List<IAnimal> animaux2 = JsonConvert.DeserializeObject<List<IAnimal>>(animauxToString); //J'ai installé pour ça le Nugget NewonSoft.Json

            List <Chat> chats = new List <Chat>()
            {
                monChat1, monChat2
            };
            string chatsToString = JsonConvert.SerializeObject(chats); //J'ai installé pour ça le Nugget NewonSoft.Json

            Console.WriteLine("\n\n\n\n");
            Console.WriteLine("List<Chat> sérialisée: \n\n" + chatsToString + "\n\n\n"); //OK

            Console.WriteLine("LECTURE List<Chat> Désérialisée :\n\n");
            List <Chat> chats2 = JsonConvert.DeserializeObject <List <Chat> >(chatsToString); //J'ai installé pour ça le Nugget NewonSoft.Json

            foreach (Chat chat in chats2)
            {
                Console.WriteLine(chat.poids);
                chat.crier();
                chat.allerALaLitiere();
                Console.WriteLine("chat.getInfoSuppl().infoSpecial1: " + chat.getInfoSuppl().infoSpecial1);
                Console.WriteLine("chat.getInfoSuppl().infoSpecial2: " + chat.getInfoSuppl().infoSpecial2);
                Console.WriteLine("\n\n");
            }
            ;

            Console.WriteLine("OK");
            Console.ReadKey();
        }
示例#6
0
        static void Main(string[] args)
        {
            CChild ch1    = new CChild();
            Animal animal = new Animal("Elephant");
            Chien  dog    = new Chien("Pitbull", "Brutus");

            //---- Méthodes virtual dans la classe parente -----
            Console.WriteLine(ch1.method1(10));   //Appelle bien celle overridant.
            Console.WriteLine(ch1.method1b(10));  //Appelle bien celle de l'enfant (non override mais avec operator 'new').
            Console.WriteLine("\n\n");


            //---- Surcharges ------
            Console.WriteLine(ch1.method2(10)); //Appelle la méthode parente car les paramètres ne correspondent pas à celle surchargée.
            Console.WriteLine(ch1.method2b(5)); //Appelle la méthode parente car les paramètres ne correspondent pas à celle surchargée.
            //Console.WriteLine(ch1.method2c(5)); //Appellerait bien la méthode parente car les paramètres ne correspondent pas à celle surchargée.
            //Console.WriteLine(ch1.method2d(5)); //Appellerait bien la méthode parente car les paramètres ne correspondent pas à celle surchargée.
            Console.WriteLine(ch1.method2e(animal));        //Appelle la méthode parente car paramètre de type Animal (et non de type Chien).
            Console.WriteLine(ch1.method2e(dog as Animal)); //Appelle la méthode parente car paramètre de type Animal (et non de type Chien).
            Console.WriteLine(ch1.method1c(animal));        //Appelle la méthode parente car paramètre de type Animal (et non de type Chien).
            Console.WriteLine(ch1.method1c(dog as Animal)); //Appelle la méthode parente car paramètre de type Animal (et non de type Chien).
            Console.WriteLine(ch1.method1d(animal));        //Appelle la méthode parente car paramètre de type Animal (et non de type Chien).
            Console.WriteLine(ch1.method1d(dog as Animal)); //Appelle la méthode parente car paramètre de type Animal (et non de type Chien).
            Console.WriteLine("\n\n");

            Console.WriteLine(ch1.method2(10, 100)); //Appelle bien la méthode enfant surcharge, car les paramètres correspondent bien.
            Console.WriteLine(ch1.method2b(5, 50));  //Appelle bien la méthode enfant surcharge, car les paramètres correspondent bien.
            //Console.WriteLine(ch1.method2c(5, 50));  //Appellerait bien la méthode enfant surcharge, car les paramètres correspondent bien.
            //Console.WriteLine(ch1.method2d(5, 50));  //Appellerait bien la méthode enfant surcharge, car les paramètres correspondent bien.
            Console.WriteLine(ch1.method2e(dog)); //Appelle bien la méthode enfant surcharge, car paramètre de type Chien (et non juste de type Animal).
            Console.WriteLine(ch1.method1c(dog)); //Appelle bien la méthode enfant surcharge, car paramètre de type Chien (et non juste de type Animal).
            ch1.method1d(dog);                    //Appelle bien la méthode enfant surcharge, car paramètre de type Chien (et non juste de type Animal).
            Console.WriteLine("\n\n");



            //----- Méthodes avec operator 'new' obligatoire dans la classe enfant ------
            Console.WriteLine(ch1.method3(10));
            Console.WriteLine(ch1.method3b(200));

            Console.WriteLine(ch1.method1e().obtenirEspece());
            Console.WriteLine(ch1.method1e().obtenirPrenom());
            Console.WriteLine("\n\n");



            Console.WriteLine("OK");
            Console.ReadKey();
        }
示例#7
0
        static void Main(string[] args)
        {
            IChien oChien1 = new Chien(1980, "Polo");
            oChien1.addPrenom("Polux").addComment("Un bon chienchien ce Polo/Polux").setPoids(30);

            IChien oChien2 = new Chien(1975, "Frigo");
            oChien2.addPrenom("Frigolux").setPoids(60).addComment("Un peu frileux ce Frigololux!");
            //La ligne CI-DESSOUS est acceptée CAR :
            // J'ai redéfini dans Chien, la méthode setPoids pour stipuler qu'elle retourne bien un IChien et NON plus un IAnimal !
            // Ainsi ce sera bien la méthode addComment de IChien et non IAnimal qui srea appelée, laquelle redéfinie, renvoie bien un IChien
            // et non pas un IAnimal ! ce qui permet enfin, d'avoir l'appel à addPrenom autorisé !
            oChien2.setPoids(60).addComment("Un peu frileux ce Frigololux!").addPrenom("Frigolux"); //Interdit puisque addComment ne renvoie pas un IChien mais un IAnimal.

            oChien1.showData();
            oChien2.merge(oChien1).addPrenom("Biloute"); //<<<<<<<<< Appel à merge, pour démontrer que je peux me servir de _merge() de la parente.
            oChien2.showData();
                       

            Console.WriteLine("OK");
            Console.ReadKey();
        }