Pourquoi une classe abstraite devrait-elle implémenter une méthode abstraite d'une classe de base abstraite?

Question

Dans l'exemple suivant, la classe Derived implémente la méthode abstraite method de la classe Main. Mais je ne peux pas penser à une raison pour remplir le corps de la méthode dans l'implémentation de la classe Derived. Je ne devrais sûrement que mettre en œuvre des méthodes abstraites dans des classes réelles.

Alors, comment puis-je éviter de le faire? Que puis-je faire d'autre?

abstract class Main 
{ 
    public abstract void method(); 
} 
abstract class Derived : Main 
{ 
    public override void method() 
    { 
    } 
} 

class RealClass : Derived 
{ 

} 

Answer 1

Habituellement, si quelqu'un a spécifié qu'une classe abstraite a une méthode abstraite, c'est soit parce que cette classe dépend de cette méthode pour une partie de ce qu'elle fait, soit parce que cela fait partie d'une API attendue pour la classe parent à mettre en œuvre à ce moment. Dans les deux cas, doit être une implémentation une fois que vous arrivez à une implémentation non-abstraite de la classe.

Notez également que si vous implémentez une interface , vous devez indiquer comment cette interface sera mise en œuvre, même si vous appelez simplement l'abstrait membre et passer la responsabilité sur la sous-classe

public interface IPet {string GetNoise(); int CountLegs(); void Walk();} 
public abstract class Pet : IPet 
{ 
    public string Name {get; set;} 
    public abstract string GetNoise(); // These must be here 
    public abstract int CountLegs(); 
    public abstract void Walk(); 
} 

Quand il s'agit de mettre en œuvre la sous-classe, vous avez quelques choix selon les circonstances. Si votre implémentation est elle-même une classe abstraite, vous ne devriez pas avoir besoin d'implémenter la méthode abstraite.

public abstract class Quadruped : Pet 
{ 
    public override int CountLegs() { return 4; } 
} 

Si votre mise en œuvre est non abstraite, mais la raison standard pour la méthode en question ne vraiment pas appliquer dans votre cas, vous pouvez faire une méthode no-op (dans le cas des méthodes vides), ou renvoyer une valeur fictive, ou même lancer une exception NotImplementedException pour indiquer que la méthode n'aurait jamais dû être appelée en premier lieu.

public class Fish : Pet 
{ 
    public override string GetNoise() {return "";} // dummy value: fish don't make noise 
    public override int CountLegs() {return 0;} 
    public override void Walk() {} // No-op 
    // public override void Walk() { throw new NotImplementedException("Fish can't walk"); } 
} 

Est-ce que cela répond à votre question?

Answer 2

S'il n'y a pas la mise en œuvre de method à Derived alors vous pouvez juste faire Derived abstrait ainsi:

abstract class Derived : Main 
{ 
} 

class RealClass : Derived 
{ 
    public override void method() { ... } 
} 

EDIT: Pour clarifier les commentaires - s'il n'y a pas mise en œuvre effective d'une méthode abstraite une sous-classe, alors on n'a pas besoin d'être fourni. Cela nécessitera cependant que la classe dérivée soit elle-même abstraite et qu'une implémentation soit fournie quelque part dans la chaîne des classes descendantes à une sous-classe concrète. Je ne dis pas que vous devriez laisser l'implémentation de method vide, comme c'est dans la question, mais plutôt vous supprimez le remplacement dans Derived et marquez le résumé de la classe. Cela oblige RealClass à fournir une implémentation (ou elle-même être marquée abstraite).

Answer 3

Toutes les classes descendantes non abstraites doivent fournir des implémentations concrètes de méthodes abstraites. Si vous ne fournissez pas une implémentation, il est impossible d'appeler cette méthode.

Si certaines classes concrètes ne présentent pas une implémentation correcte évidente d'une méthode abstraite, la conception de votre objet est incorrecte. Peut-être que vous devriez avoir une classe abstraite avec quelques méthodes abstraites (mais pas toutes). Cette classe pourrait avoir à la fois un descendant abstrait et des descendants concrets.