Scribd
Upload
3 views

C#

The document analyzes key concepts in object-oriented programming, focusing on abstract vs virtual methods, interfaces vs abstract classes, method overriding, 'is-a' vs 'has-a' relationships, safe casting, and extending vs implementing. It provides code examples and explanations for each concept, demonstrating their practical applications in a programming context. The analysis emphasizes the importance of these principles in structuring and designing software effectively.

Uploaded by

9w68mqqvn9
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
3 views

C#

The document analyzes key concepts in object-oriented programming, focusing on abstract vs virtual methods, interfaces vs abstract classes, method overriding, 'is-a' vs 'has-a' relationships, safe casting, and extending vs implementing. It provides code examples and explanations for each concept, demonstrating their practical applications in a programming context. The analysis emphasizes the importance of these principles in structuring and designing software effectively.

Uploaded by

9w68mqqvn9
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 5

RAD: Code Analysis

Department of Computer Science

GROUP MEMBERS ID NO

1. Michael Tibebu RCD/0729/2014


2. Bemnet Getasetegn RCD/0708/2014

SECTION: B
SUBMITTED TO: Haileyesus Tilahun
DUE DATE: DEC 13, 2024

1. Abstract vs Virtual Methods


Code Context:
• Abstract Method: The Drive method in the Vehicle class is defined as abstract,
meaning it must be overridden in any derived class.
public abstract void Drive();

• Virtual Method: The Refuel method in the Vehicle class is virtual, meaning it
provides a default implementation but can be optionally overridden in derived classes.
public virtual void Refuel()
{
Console.WriteLine($"{Name} is refueled.");
}

Analysis:
• Abstract methods enforce that derived classes must implement the method (Drive
is implemented in both Car and Bike classes).
• Virtual methods provide flexibility. The Refuel method has a default
implementation in Vehicle but is overridden in both Car and Bike classes for specific
behavior.

2. Interface vs Abstract Class

Code Context:
• Interface: IFuelEfficiency defines a contract with a single method:
public interface IFuelEfficiency
{
double GetFuelEfficiency();
}

• Abstract Class: Vehicle provides both fields (Name), constructors, and methods
(Drive and Refuel).

Analysis:
• Purpose: Interfaces define a contract that can be implemented by any class (e.g.,
Car implements IFuelEfficiency), while abstract classes provide a base structure with
shared logic and fields (Name in Vehicle).
• Use Case: The Car class inherits from Vehicle (abstract class) and implements
IFuelEfficiency (interface), showing how they can complement each other.

3. Override

Code Context:
The Car and Bike classes both override the Drive and Refuel methods from the Vehicle
class:
public override void Drive()
{
Console.WriteLine($"{Name} is being driven.");
}
public override void Refuel()
{
Console.WriteLine($"{Name} does not need refueling.");
}

Analysis:
• override keyword ensures that the method in the derived class (Car or Bike)
replaces the base class implementation (Vehicle) for that method.
• Importance: Overrides allow class-specific behavior while adhering to the base
class interface.

4. “Is-a” vs “Has-a”

Code Context:
• “Is-a”: Car and Bike inherit from Vehicle, meaning they are specialized types of
vehicles. This demonstrates an “is-a” relationship.
public class Car : Vehicle
public class Bike : Vehicle

• “Has-a”: The Garage class contains an array of Vehicle objects, illustrating a


“has-a” relationship.
private Vehicle[] vehicles;
Analysis:
• “Is-a” represents inheritance (e.g., a Car is a Vehicle).
• “Has-a” represents composition/aggregation (e.g., a Garage has a collection of
Vehicle objects).

5. Safe Castings

Code Context:
Safe casting is used with the is keyword in the Main method:
if (vehicle is Car castedCar)
{
Console.WriteLine($"Fuel Efficiency: {castedCar.GetFuelEfficiency()}
km/l");
}

Types of Casting:
• Upcasting: Assigning a derived class (Car) to a base class
reference (Vehicle):
Vehicle vehicle = car;

• Downcasting: Checking if a Vehicle is a Car and casting it:


if (vehicle is Car castedCar) { }

Why is it used?
• Upcasting allows treating objects uniformly (as Vehicle)
regardless of their specific type.
• Downcasting restores specific functionality (GetFuelEfficiency
from Car).

6. Extending vs Implementing

Code Context:
• Extending: Car and Bike extend the Vehicle class:
public class Car : Vehicle

• Implementing: Car implements the IFuelEfficiency interface:


public class Car : Vehicle, IFuelEfficiency

Analysis:
• Extending allows inheriting shared behavior and properties from
a base class.
• Implementing provides a way to ensure a class adheres to a
contract defined by the interface (e.g., GetFuelEfficiency).

This analysis connects key concepts in object-oriented programming


with the provided code, highlighting the principles in practice.

You might also like