Introduction C # OOP Questions et réponses d'entrevue
C # est un langage de programmation orienté objet, fonctionnel, générique et orienté composant. Il est utilisé pour créer une variété d'applications, il est particulièrement efficace pour créer des applications de bureau et des jeux Windows. Le développement Web peut également être effectué efficacement avec C # et il est devenu de plus en plus populaire pour les développements mobiles. Ainsi, il constitue un excellent choix pour tout programmeur qui souhaite faire du développement web et jeu. Il s'agit d'un langage de type statique, de sorte que le code source écrit est soigneusement vérifié avant de se transformer en application. C'est une langue complexe à apprendre et la maîtriser peut prendre beaucoup de temps. Il existe différents outils multiplates-formes disponibles qui permettent des applications écrites en C # qui peuvent être utilisées sur mobile et bureau.
Si vous recherchez un emploi lié au C # OOP, vous devez vous préparer pour les questions d'entrevue C # OOP 2019. Bien que chaque entretien soit différent et que la portée d'un travail soit également différente, nous pouvons vous aider avec les meilleures questions d'entrevue C # OOP avec des réponses, qui vous aideront à franchir le pas et à réussir votre entrevue.
Vous trouverez ci-dessous les principales questions d'entrevue C # OOP 2019 qui sont fréquemment posées lors d'une entrevue.Ces principales questions sont divisées en deux parties:
Partie 1 - Questions d'entrevue C # OOP (de base)
Cette première partie couvre les questions et réponses de base de l'entretien C # OOP
1. Quelle est la différence entre l'interface et la classe abstraite?
Répondre:
Une différence est répertoriée ci-dessous:
- Une classe abstraite peut avoir des méthodes non abstraites (méthodes concrètes) alors qu'en cas d'interface toutes les méthodes doivent être abstraites.
- Une classe abstraite peut déclarer ou utiliser n'importe quelle variable alors qu'une interface n'est pas autorisée à le faire.
- Dans une classe abstraite, tous les membres ou fonctions de données sont privés par défaut tandis que dans l'interface tous sont publics, nous ne pouvons pas les modifier manuellement.
- Une classe abstraite utilise un constructeur tandis que dans une interface, nous n'avons aucun type de constructeur.
- Une classe peut implémenter n'importe quel nombre d'interfaces, mais une sous-classe ne peut tout au plus utiliser qu'une seule classe abstraite.
2. Que sont les délégués et leurs utilisations?
Répondre:
Un objet délégué est une variable de type référence utilisée pour contenir la référence à une méthode. La référence peut être modifiée lors de l'exécution qui est détenue par un objet d'un délégué. Un objet délégué peut contenir de nombreuses références de fonctions qui sont également connues sous le nom de liste d'invocation qui fait référence aux fonctions dans une séquence FIFO, nous pouvons ajouter de nouvelles fonctions dans cette liste au moment de l'exécution par un opérateur + = et supprimer par l'opérateur - =.
Les délégués sont particulièrement utilisés pour implémenter les événements et les méthodes de rappel. Tous les délégués sont implicitement dérivés du système. Délégué classe.
Passons aux prochaines questions d'entrevue C # OOP
3. Quelle est la différence entre une liaison tardive et une liaison anticipée?
Répondre:
Dans le polymorphisme de compilation ou la liaison anticipée, nous utiliserons plusieurs méthodes avec le même nom mais un type de paramètre différent ou peut-être le nombre ou le paramètre à cause de cela, nous pouvons effectuer des tâches différentes avec le même nom de méthode dans la même classe qui est également connu sous le nom de surcharge de méthode.
public class TestData
(
public int Add(int a, int b, int c)
(
return a + b + c;
)
public int Add(int a, int b)
(
return a + b;
)
)
class Program
(
static void Main(string() args)
(
TestData dataClass = new TestData();
int add2 = dataClass.Add(45, 34, 67);
int add1 = dataClass.Add(23, 34);
)
)
Le polymorphisme dynamique / d'exécution est également connu sous le nom de liaison tardive. Ici, le nom de la méthode et la signature de la méthode (le nombre de paramètres et le type de paramètre doivent être identiques et peuvent avoir une implémentation différente). La substitution de méthode est un exemple de polymorphisme dynamique.
public class Drawing
(
public virtual double Area()
(
return 0;
)
)
public class Square : Drawing
(
public double Length ( get; set; )
public Square()
(
Length = 6;
)
public override double Area()
(
return Math.Pow(Length, 2);
)
)
public class Rectangle : Drawing
(
public double Height ( get; set; )
public double Width ( get; set; )
public Rectangle()
(
Height = 5.3;
Width = 3.4;
)
public override double Area()
(
return Height * Width;
)
)
class Program
(
static void Main(string() args)
(
Drawing square = new Square();
Console.WriteLine("Area :" + square.Area());
Drawing rectangle = new Rectangle();
Console.WriteLine("Area :" + rectangle.Area());
)
)
4. Que se passerait-il si les interfaces héritées ont des noms de méthode conflictuels?
Répondre:
Ce sont les questions d'entretien C # OOP courantes posées lors d'un entretien. si nous avons des méthodes en conflit dans une même classe, nous ne pouvons pas implémenter leur corps indépendamment dans la même classe en raison du même nom et de la même signature, nous devons donc utiliser le nom de l'interface avant le nom de la méthode pour éliminer cette confusion de méthode.
interface testInterface1 (
void Show();
)
interface testInterface2 (
void Show();
)
class Abc: testInterface1,
testInterface2 (
void testInterface1.Show() (
Console.WriteLine("For testInterface1 !!");
)
void testInterface2.Show() (
Console.WriteLine("For testInterface2 !!");
)
)
5. Quelles sont les différentes manières de surcharger une méthode?
Répondre:
La surcharge de méthode est un autre nom pour le polymorphisme à la compilation, où nous pouvons créer une méthode avec le même nom mais avec une signature différente. Cela se fait au moment de la compilation et nous pouvons le faire de plusieurs façons, mais le nom de la méthode reste le même.
Un certain nombre de paramètres peuvent être différents.
Le type de paramètre peut être différent.
L'ordre des paramètres peut être différent.
Exemple -
static int volume ( int x )(
return (x * x * x);
)
static double volume (float f, int i)(
return 3.14 * f * f * I;
)
static long volume (long l, int b, int n)(
return l * b * h;
)
Partie 2 - Questions d'entrevue C # OOP (Avancé)
Cette première partie couvre les questions et réponses avancées de l'entretien C # OOP
6. Qu'est-ce qu'un modificateur d'accessibilité et combien y en a-t-il en C #?
Répondre:
Les modificateurs d'accès sont des mots clés utilisés pour spécifier l'accessibilité déclarée d'un membre ou d'un type. En C #, il existe 5 différents types de modificateurs d'accès.
Public - Aucune restriction sur l'accès aux membres publics.
Privé - accès limité dans une définition de classe, si aucun n'est spécifié, c'est la valeur par défaut.
Protégé - l'accès est limité à la définition de classe et à toute classe qui hérite de la classe.
Interne - l'accès est limité exclusivement aux classes définies par le projet en cours
Le membre interne protégé est accessible n'importe où dans le même assembly et également accessible en héritant de cette classe, il peut être accessible en dehors de l'assembly dans la classe dérivée uniquement.
7. Qu'est-ce qu'une méthode virtuelle en C #?
Répondre:
Une méthode virtuelle est une méthode qui peut être redéfinie dans des classes dérivées. Une méthode virtuelle a une implémentation dans une classe de base ainsi que dérivée de la classe. Il est utilisé lorsque la fonctionnalité de base d'une méthode est la même, mais parfois plus de fonctionnalités sont nécessaires dans la classe dérivée. Une méthode virtuelle est créée dans la classe de base qui peut être remplacée dans la classe dérivée. Nous créons une méthode virtuelle dans la classe de base à l'aide du mot-clé virtuel et cette méthode est remplacée dans la classe dérivée à l'aide du mot-clé override.
Lorsqu'une méthode virtuelle est invoquée, le type d'exécution de l'objet est vérifié pour un membre prioritaire. Le membre prioritaire dans la classe la plus dérivée est appelé, qui peut être le membre d'origine si aucune classe dérivée n'a remplacé le membre. Par défaut, les méthodes ne sont pas virtuelles. Nous ne pouvons pas remplacer une méthode non virtuelle.
Passons aux prochaines questions d'entrevue C # OOP
8. Comment éviter NULL en C #?
Répondre:
Null n'est pas un objet. Nous pouvons avoir une classe, mais une variable avec une valeur NULL signifie qu'elle ne pointe vers aucun objet. Nous pourrions rencontrer un morceau de code qui contient de nombreuses instructions conditionnelles qui vérifieraient si la valeur d'une variable est NULL. Vérifions une méthode statique:
chaîne statique publique DisplayUpperString (chaîne s) (
string upper = string.Empty;
If( s == null ) (
upper = null;
)
else (
upper = s.ToUpper();
)
return upper;
)
Ce code est très bien et convertit en majuscules une chaîne donnée.
Mais d'un point de vue OO, envisagez de construire un objet qui ne représente rien, plutôt que de l'évaluer pour NULL.
public static String DisplayUpperString (PossibleString s) (
chaîne supérieure = s.ToPossibleUpper ();
retour supérieur;
)
Maintenant, la fonction est moins encombrée, plus lisible et n'utilise plus la vérification d'une valeur NULL.
9. Quelle est la méthode d'extension en C # et comment les utiliser?
Répondre:
Ce sont les questions les plus fréquemment posées lors des entretiens C # OOP. Une méthode d'extension est un type spécial de méthode statique, mais elles sont appelées comme s'il s'agissait de méthodes d'instance sur le type étendu. Cette méthode vous permet d'ajouter des méthodes aux types existants sans créer de nouveau type dérivé, sans recompiler ou autrement modifier le type d'origine. Les méthodes d'extension ne sont dans la portée que lorsque vous importez explicitement l'espace de noms dans votre code source avec une directive using.
10. Le mot-clé «this» peut-il être utilisé dans une méthode statique?
Répondre:
Puisque "ce" mot clé renvoie une référence à l'instance actuelle d'une classe, nous ne pouvons donc pas l'utiliser dans une méthode statique. Et les membres statiques existent sans aucune instance de la classe et appellent avec le nom de la classe, pas par instance. Ainsi, nous pouvons dire que «ce» mot-clé est un type spécial de variable de référence qui est implicitement défini dans chaque constructeur et méthode non statique comme premier paramètre de la classe de type dans laquelle il est défini.
Article recommandé
Ceci a été un guide pour la liste des questions et réponses d'entrevue C # OOP afin que le candidat puisse réprimer facilement ces questions d'entrevue C # OOP. Ici, dans cet article, nous avons étudié les principales questions d'entrevue C # OOP qui sont souvent posées lors des entretiens. Vous pouvez également consulter les articles suivants pour en savoir plus -
- Questions d'entretiens chez Hadoop Admin
- 12 questions d'entretiens chez Amazing Spark
- 10 Questions d'Entrevue Ab Initio Importantes
- 25 questions d'entrevue les plus importantes en informatique
- Quels sont les avantages de C # et Js