Can't use virtual and override on the same method in C#
c#, polymorphism
Solution
You can declare a certain method as `virtual` only once, but you can `override` it as many times as you want - an override is not final, and it does not limit classes that inherit from the first overriding class. The method that will eventually execute is the last one the overrides the virtual method. So your code does behave as expected.
C# is very verbose with regard to overriding - you have more specifiers than C++ or Java. It is so to let the programmer specify the exact intent:
- You use `virtual` to specify a method can be overridden by subclasses.
- You use `override` to specify you are overriding a method that you know is virtual (if it's not, the compiler will report an error).
- You use `sealed` to prevent further overriding.
- And you use `new` to hide instead of override.
This can be confusing and sometimes annoying, but it ensures you actually know what you're doing, and it makes your intention self-documented.
Problem
So apparently you cannot use the `virtual` modifier with the `override` modifier. `virtual` - a method that can be overridden `override` - a method that is overriding a method of the same name in its parent's class This leads me to believe that if I override a method in a child class, if that child has a child you can't override that method again. And it is safe to say that if you put `override` and `virtual` in a method declaration you will get a compile error in C#. However I can't understand why the code I made below works the way in which it does ``` using System; public class DrawingObject { public virtual void Draw() { Console.WriteLine("Drawing Object"); } } public class DrawDemo { public static int Main() { DrawingObject[] dObj = new DrawingObject[3]; dObj[0] = new DrawingObject(); dObj[1] = new Line(); dObj[2] = new LittleLine(); foreach (DrawingObject drawObj in dObj) { drawObj.Draw(); } Console.Read(); return 0; } } public class Line : DrawingObject { public override void Draw() {// the method above me is in fact virtual because LittleLine overid it? Console.WriteLine("I'm a Line."); } } public class LittleLine : Line { public override void Draw() { Console.WriteLine("I'm a Little Line."); } } ``` Here's the output: Drawing Object I'm a Line. I'm a Little Line. So the draw method in `Line` looks as though it was overridden by `LittleLine`. Is this code not actually overriding it, or is the compiler doing some other trick? Or am I not understanding the context of `virtual` and `override`?