public class Animal
{
public virtual void MakeSound() { Console.WriteLine("Animal"); }
}
public class Dog : Animal {
public override void MakeSound() { Console.WriteLine("Dog"); }
}
Animal myAnimal = new Dog();
myAnimal.MakeSound();
1. Quelle est la sortie du code suivant ?
Le mot-clé virtual permet à la méthode de la classe de base d'être remplacée dans les classes dérivées. Ici, la méthode MakeSound() est remplacée dans la classe Dog, donc la sortie est Dog.
2. Quelle est la sortie du code suivant ?
public class Person
{
public string Name { get; set; } } public class Employee : Person { public int Id { get; set; } }
Employee emp = new Employee { Name = "John", Id = 123 }; Console.WriteLine(emp.Name);
La propriété Name est héritée de la classe de base Person, donc elle est accessible et retourne la valeur "John".
3. Quelle est la sortie du code suivant ?
public class Base
{ public int Value = 5; } public class Derived : Base { public int Value = 10; }
Base obj = new Derived(); Console.WriteLine(obj.Value);
Les membres de la classe dérivée cachent les membres de la classe de base. Ici, Value dans Derived cache Value dans Base, mais obj est de type Base, donc Value est celui de Base.
4. Quelle est la sortie du code suivant ?
public class Test
{ public static void Method(int x) { Console.WriteLine(x); } public static void Method(string x) { Console.WriteLine(x); }
}
Test.Method(10); Test.Method("Hello");
Le code utilise la surcharge de méthode pour appeler Method() avec un int et une string.
5. Quelle est la sortie du code suivant ?
public class Example
{
public void Print(params int[] numbers) { foreach (var number in numbers) Console.Write(number + " "); }
}
Example example = new Example(); example.Print(1, 2, 3);
Le mot-clé params permet à une méthode d'accepter un nombre variable d'arguments.
6. Quelle est la sortie du code suivant ?
public class Data
{
public int Value { get; set; } }
Data data1 = new Data { Value = 100 }; Data data2 = data1; data2.Value = 200; Console.WriteLine(data1.Value);
Les objets sont passés par référence, donc les modifications apportées à data2 affectent également data1.
7. Quelle est la sortie du code suivant ?
public class Parent { public virtual void Display() { Console.WriteLine("Parent"); } } public class Child : Parent { public override void Display() { Console.WriteLine("Child"); } }
Parent p = new Parent(); Parent c = new Child(); p.Display(); c.Display();
La méthode Display() est appelée en fonction du type de l'objet référencé, donc p appelle la méthode de Parent et c appelle celle de Child.
8. Quelle est la sortie du code suivant ?
public class Test { public static void Show(T item) { Console.WriteLine(item); } } Test.Show(5); Test.Show("Hello");
La méthode générique affiche les éléments en fonction de leur type spécifié.
9. Quelle est la sortie du code suivant ?
public class Calculator { public int Add(int a, int b) { return a + b; } public double Add(double a, double b) { return a + b; } } Calculator calc = new Calculator(); Console.WriteLine(calc.Add(5, 10)); Console.WriteLine(calc.Add(5.5, 10.5));
Les méthodes surchargées sont appelées en fonction des types des arguments passés.
10. Quelle est la sortie du code suivant ?
public class Base { public int Value = 5; } public class Derived : Base { public new int Value = 10; } Base obj = new Derived(); Console.WriteLine(obj.Value);
Le mot-clé new cache le membre de la classe de base mais ne le remplace pas. Ici, obj est de type Base, donc il accède à la valeur 5.
11. Quelle est la sortie du code suivant ?
public class Person { public string Name { get; set; } } public class Employee : Person { public new string Name { get; set; } } Employee emp = new Employee { Name = "John" }; Console.WriteLine(emp.Name);
La propriété Name dans Employee cache celle de la classe de base mais est accessible à travers le type Employee.
12. Quelle est la sortie du code suivant ?
public class Base { public virtual void Print() { Console.WriteLine("Base"); } } public class Derived : Base { public override void Print() { Console.WriteLine("Derived"); } } Base obj = new Base(); obj.Print(); obj = new Derived(); obj.Print();
La méthode Print() est remplacée dans la classe dérivée. Ici, le type d'objet détermine la méthode qui est appelée.
13. Quelle est la sortie du code suivant ?
public class Program {
public static void Main() { object obj = "Hello"; string str = (string)obj; Console.WriteLine(str); }
La conversion de type object à string est valide et renvoie la chaîne Hello.
14. Quelle est la sortie du code suivant ?
public class Test {
public static void Display(string s = "Default") { Console.WriteLine(s); }
}
Test.Display("Custom"); Test.Display();
Les paramètres avec une valeur par défaut sont utilisés si aucun argument n'est fourni.
15. Quelle est la sortie du code suivant ?
public class Test {
public static void Method(T item) where T : class { Console.WriteLine(item.GetType().Name); }
}
Test.Method(new Test());
Le nom du type de l'objet est affiché.
16. Quelle est la sortie du code suivant ?
public class Example {
public int this[int index] { get { return index; } set { Console.WriteLine("Index set to " + value); } }
}
Example example = new Example(); example[5] = 10; Console.WriteLine(example[5]);
Les indexeurs permettent de définir des comportements personnalisés lors de l'accès aux éléments via des crochets.
17. Quelle est la sortie du code suivant ?
public class Test
{ public static void Display(T[] array) { foreach (T item in array) Console.Write(item + " "); }
}
Test.Display(new int[] { 1, 2, 3 }); Test.Display(new string[] { "A", "B" });
Les tableaux d'entiers et de chaînes sont traités correctement grâce aux génériques.
18. Quelle est la sortie du code suivant ?
public class Test {
public static void Print(T item) where T : struct { Console.WriteLine(item); } }
Test.Print(10); Test.Print(3.14);
Les types de valeur sont les types structurés et peuvent être utilisés avec les contraintes génériques.
19. Quelle est la sortie du code suivant ?
public class Test {
public static void Print(T item) { Console.WriteLine(item?.ToString()); } }
Test.Print(null); Test.Print("Hello");
Le ?. opérateur vérifie si l'objet est nul avant d'appeler ToString().
20. Quelle est la sortie du code suivant ?
public class Test
{ public static void Print(T[] array) { foreach (var item in array) Console.Write(item + " "); } }
Test.Print(new List { 1, 2, 3 }.ToArray());
Les listes peuvent être converties en tableaux pour être traitées par les méthodes génériques.
Ajouter un commentaire
Veuillez vous connecter pour ajouter un commentaire.
Pas encore de commentaires.