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();
}
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();
}
/*
* 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());
}
//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());
}
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();
}
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();
}
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();
}
