Question

Ok so i’m messing around with a few things, specifically interfaces.

Say I have a class ‘Cat’ with its base as ‘Animal’ Animal has a method in it like so

public virtual void Walk()
{
    // Do walking stuff
}

So Cat would override it with:

public override void Walk()
{
    // Do cat specific walking stuff
}

Simple right?

Here’s my question though, is there a way to force cat to override the base Walk() method? So if another developer added a Dog class they would be forced to implement their own Walk method (even if it was just base.Walk()) ?

So interfaces kind of solves this, this is what i’ve tried

Cat : Animal : Interface
Animal has to implement the Walk method, but Cat doesn’t

Cat : Animal, Interface
Cat has to implement the Walk method, but if the developer doesn’t add or forgets the ‘,Interface’ then it will ‘break’ it.

can someone give me some pointer as to go about this ?

Thanks.

Edit 1

Here’s what I am aiming for, i hope it makes it clearer.

public class Animal
{
    public Animal()
    {
        Console.WriteLine("Animal");
    }

    public virtual void Walk()
    {

    }
}

public class Cat : Animal
{
    public Cat() : base()
    {
        Console.WriteLine("Cat");
    }

    public override void Walk()
    { 

    }
}

class Dog : Animal
{

    public Dog()
    {

    }

    public override void Walk()
    {
        // Dog implementation 
        // and / or calls base method
        base.Walk();
    }
}

This would create an error

class Dog : Animal
{

    public Dog()
    {

    }
}

Answer 1

This is when you want to mark the base class and the base method as abstract.

abstract class Animal 
{
    public abstract void Walk(); 
}

Derived classes will have to implement Walk in order to be instantiated.

class Cat : Animal 
{
    public override void Walk() { }
}

Note: this change makes Animal not instantiable on its own, all references to it would be via more derived classes.

Animal animal = new Cat();

Here’s my question though, is there a way to force cat to override the
base Walk() method? So if another developer added a Dog class they
would be forced to implement their own Walk method (even if it was
just base.Walk()) ?

This is where you have a disconnect, or opposing goals. To force children to implement a method, you mark it abstract. To allow the child to elect to use the base implementation, it would need to be virtual, which would then make it optional to override. Even if you were to basically use a template method pattern and make parts of the algorithm abstract to push the implementation into lower classes, the problem remains the same: you cannot force an override while also leaving a default implementation.*

You need to determine if you want to have a base implementation, in part or in whole.

---

*You chould theoretically have abstract void Walk(); protected void WalkImpl() { } in the base, which would allow the children to choose to invoke WalkImpl if they didn’t want to provide their own implementation.

class Cat : Animal
{
     protected override void Walk() { base.WalkImpl(); }
}

I’m not sure how I feel about this, however. You’re basically making the derived classes’ authors’ lives more difficult by forcing an override while still allowing them to use a default behavior. If the default behavior can be used, simply go with virtual and trust authors of derived classes to override when they feel it is appropriate.