Abstract classes and methods in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Abstract classes and methods

Define abstract class

↓

Declare abstract method(s)

↓

Create subclass

↓

Implement abstract method(s) in subclass

↓

Instantiate subclass object

↓

Call implemented method(s)

This flow shows how an abstract class with abstract methods is defined, subclassed, and how the subclass implements those methods before creating objects and calling them.

Execution Sample

C Sharp (C#)

using System;

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

class Dog : Animal {
  public override void Speak() {
    Console.WriteLine("Woof!");
  }
}

class Program {
  static void Main() {
    var dog = new Dog();
    dog.Speak();
  }
}

Defines an abstract class Animal with an abstract method Speak, then Dog class implements Speak, creates a Dog object, and calls Speak.

Execution Table

Step	Action	Evaluation	Result
1	Define abstract class Animal with abstract method Speak	No object created	Animal cannot be instantiated
2	Define class Dog inheriting Animal	Dog must implement Speak	Dog class ready
3	Implement Speak method in Dog	Speak prints 'Woof!'	Method implemented
4	Create Dog object	Dog instance created	dog variable holds Dog object
5	Call dog.Speak()	Calls Dog's Speak method	Output: Woof!
6	End of program	No more instructions	Program ends

💡 Program ends after calling Speak method on Dog instance

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
dog	null	Dog instance	Dog instance	Dog instance

Key Moments - 3 Insights

Why can't we create an object of the abstract class Animal?

Because abstract classes are incomplete by design and meant to be base classes only. Step 1 in the execution_table shows Animal cannot be instantiated.

What happens if Dog does not implement the abstract method Speak?

The Dog class would cause a compile error because it must implement all abstract methods from Animal. Step 2 and 3 show Dog must implement Speak.

When we call dog.Speak(), which method runs?

The Speak method implemented in Dog runs, as shown in Step 5 where output is 'Woof!'.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of the 'dog' variable after Step 4?

A null

B Dog instance

C Animal instance

D Undefined

💡 Hint

Check variable_tracker row for 'dog' after Step 4

At which step does the program output 'Woof!'?

A Step 3

B Step 4

C Step 5

D Step 6

💡 Hint

Look at execution_table Action and Result columns for output

If we remove the override of Speak in Dog, what happens?

A Compile error because Dog must implement Speak

B Program runs and prints nothing

C Dog inherits Speak from Animal and runs it

D Runtime error when calling Speak

💡 Hint

Refer to key_moments about implementing abstract methods

Concept Snapshot

abstract class ClassName {
  public abstract ReturnType MethodName();
}

- Abstract classes cannot be instantiated.
- Abstract methods have no body and must be overridden.
- Subclasses must implement all abstract methods.
- Allows defining a common interface with enforced implementation.

Full Transcript

This example shows how to use abstract classes and methods in C#. First, an abstract class Animal is defined with an abstract method Speak. Abstract classes cannot be instantiated directly. Then, a subclass Dog inherits Animal and implements the Speak method. We create a Dog object and call its Speak method, which prints 'Woof!'. This enforces that all subclasses provide their own version of Speak. The execution table traces each step from defining classes to calling methods. The variable tracker shows the dog variable holds the Dog instance after creation. Key moments clarify why abstract classes can't be instantiated and why subclasses must implement abstract methods. The quiz tests understanding of variable states, output steps, and compile errors when methods are missing.

Practice

1. What is true about an abstract class in C#?

easy

A. It can be instantiated like any other class.

B. It must have only abstract methods.

C. It cannot be instantiated directly.

D. It cannot have any methods.

Solution

1. Step 1: Understand abstract class instantiation rules

   An abstract class is designed as a base template and cannot be created as an object directly.

2. Step 2: Check other options for correctness

   Abstract classes can have both abstract and non-abstract methods, so options A, B, and D are incorrect.

3. Final Answer:

   It cannot be instantiated directly. -> Option C

4. Quick Check:

   Abstract class = no direct instantiation [OK]

Hint: Remember: abstract classes are blueprints, not objects. [OK]

Common Mistakes:

• Thinking abstract classes can be instantiated.
• Believing abstract classes must have only abstract methods.
• Confusing abstract classes with interfaces.

2. Which of the following is the correct way to declare an abstract method in C#?

easy

A. public abstract void Display() {}

B. public abstract void Display();

C. abstract public void Display() {}

D. public void abstract Display() {}

Solution

1. Step 1: Recall abstract method syntax

   Abstract methods have no body and end with a semicolon, declared with the 'abstract' keyword before the return type.

2. Step 2: Validate each option

   public abstract void Display(); matches the correct syntax. public void abstract Display() {} and C have wrong keyword order or include a body. public abstract void Display() {} incorrectly includes a method body.

3. Final Answer:

   public abstract void Display(); -> Option B

4. Quick Check:

   Abstract method = declaration only, no body [OK]

Hint: Abstract methods end with semicolon, no braces. [OK]

Common Mistakes:

• Adding method body to abstract methods.
• Wrong keyword order in declaration.
• Using braces {} with abstract methods.

3. What will be the output of the following code?

abstract class Animal {
    public abstract string Speak();
}

class Dog : Animal {
    public override string Speak() {
        return "Woof";
    }
}

class Program {
    static void Main() {
        Animal myDog = new Dog();
        System.Console.WriteLine(myDog.Speak());
    }
}

medium

A. Woof

B. Animal

C. Compile-time error

D. Runtime error

Solution

1. Step 1: Understand class inheritance and method override

   Dog inherits from abstract Animal and implements the abstract Speak method returning "Woof".

2. Step 2: Trace program execution

   Main creates a Dog object as Animal type and calls Speak(), which runs Dog's override returning "Woof".

3. Final Answer:

   Woof -> Option A

4. Quick Check:

   Override abstract method = Dog's Speak() output [OK]

Hint: Abstract method calls run subclass override. [OK]

Common Mistakes:

• Expecting abstract class method output.
• Thinking abstract classes can be instantiated.
• Confusing compile-time and runtime errors.

4. Identify the error in this code snippet:

abstract class Shape {
    public abstract double Area();
}

class Circle : Shape {
    public double Area() {
        return 3.14 * 5 * 5;
    }
}

medium

A. Circle class cannot inherit from Shape.

B. Area() method cannot return double.

C. Shape class cannot have abstract methods.

D. Circle must declare Area() as override.

Solution

1. Step 1: Check method overriding rules

   When a subclass implements an abstract method, it must use the 'override' keyword.

2. Step 2: Identify missing override keyword

   Circle's Area() method lacks 'override', causing a compile error.

3. Final Answer:

   Circle must declare Area() as override. -> Option D

4. Quick Check:

   Override abstract method = must use 'override' keyword [OK]

Hint: Override abstract methods with 'override' keyword. [OK]

Common Mistakes:

• Omitting 'override' keyword in subclass method.
• Thinking abstract methods can be implemented without override.
• Confusing return types.

5. You want to create a base class Vehicle with an abstract method StartEngine(). You also want to ensure every subclass implements StartEngine() differently. Which is the best approach?

hard

A. Make Vehicle an abstract class with an abstract StartEngine() method.

B. Make Vehicle a normal class and provide a default StartEngine() implementation.

C. Make Vehicle an interface with StartEngine() method.

D. Make Vehicle a sealed class with StartEngine() method.

Solution

1. Step 1: Understand requirement for different implementations

   Each subclass must implement StartEngine() differently, so a base method without body is needed.

2. Step 2: Choose correct class type and method declaration

   Abstract class Vehicle with abstract StartEngine() enforces subclasses to implement it uniquely.

3. Final Answer:

   Make Vehicle an abstract class with an abstract StartEngine() method. -> Option A

4. Quick Check:

   Abstract class + abstract method = enforced subclass implementation [OK]

Hint: Use abstract class + abstract method for enforced overrides. [OK]

Common Mistakes:

• Using sealed class which prevents inheritance.
• Using interface when base class behavior is needed.
• Providing default method when unique implementations required.