CS 203 Object Oriented Programming Handout: lab 9

Lap Content:
➢ Inheritance
➢ Encapsulation
➢ Polymorphism

Inheritance:
▪ Inheritance in C# allows one class (child/derived class) to inherit the members (fields,
properties, methods, and events) of another class (parent/base class).
▪ The constructor of derived class call the constructor of parent class the complete the code
of the derived class constructor
Example 1

internal class Program

{
private static void Main(string[] args)
{
Dog dog = new Dog();
}
}
class Animal
{
public Animal()
{
Console.WriteLine("Animal constructor called.");
}
}

class Dog : Animal

{
public Dog()
{
Console.WriteLine("Dog constructor called.");
}
}

Output:
Animal constructor called.
Dog constructor called.

1|P age
Explanation:
Parameter less parent constructor automatically called before constructor of child class

Example 2

internal class Program

{
private static void Main(string[] args)
{
Dog dog = new Dog("buddy");
}
}
class Animal
{
public Animal(string name)
{
Console.WriteLine($"Animal constructor called. Name: {name}");
}
}

class Dog : Animal

{
public Dog(string name) : base(name)
{
Console.WriteLine("Dog constructor called.");
}
}

Output:
Animal constructor called. Name: Buddy
Dog constructor called.

Explanation:
Because base class has a parameterized constructor the derived class constructor must explicitly call
Example 3
internal class Program
{
private static void Main(string[] args)
{
Dog dog1 = new Dog();
Console.WriteLine();
Dog dog2 = new Dog("Buddy");
}
}
class Animal
2|P age
 {
public Animal()
{
Console.WriteLine("Default Animal constructor called.");
}

public Animal(string name)

{
Console.WriteLine($"Animal constructor called. Name: {name}");
}
}

class Dog : Animal

{
public Dog() : base()
{
Console.WriteLine("Default Dog constructor called.");
}

public Dog(string name) : base(name)

{
Console.WriteLine("Dog constructor called with a name.");
}
}

Output:
Default Animal constructor called.
Default Dog constructor called.

Animal constructor called. Name: Buddy

Dog constructor called with a name.

Explanation:
Multiple constructors may be called derived class constructor based on parameters passed

Encapsulation
▪ Encapsulation is the process of hiding the internal implementation details of a class and
exposing data only through defined methods (getters and setters).
▪ This concept enhances security, reusability, and maintainability of code in object-oriented
systems.

Data Members Members functions

Attributes: Methods:
- Name: string + set_name (name:string): void
- Age: int + get_name(): string
+ set_age (age:int): void
+ get_age(): int 3|P age
+------------------------+
 Class

Example 2
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PracticeApp
{
class Program
{
static void Main(string[] args)
{
Person person = new Person();

// Setting Name and Age

person.Name="Omar;
person.Age=30;

// Getting Name and Age

Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
// Output: Name: Omar, Age: 30
}

class Person
{
private string name;
private int age;

// Set and Get proberty for Name

public string Name
{
set { name = value; }

4|P age
 get { return name; }
}

// Set and Get proberty for Age

public int Age
{
set
{
if (value > 0)
age = value;
}

get { return age; }

}
}
}

Polymorphism:
• Polymorphism is one of the key principles of Object-Oriented Programming (OOP) that allows objects
to take on multiple forms. In C#, polymorphism is achieved through method overriding (runtime
polymorphism) and method overloading (compile-time polymorphism).

1- Method overloading :
o Creating multiple methods with the same name but different parameters (type, number, or order)
within the same class.
o perform similar tasks but with different inputs.

Example
internal class Program
{
private static void Main(string[] args)
{
Calculator calc = new Calculator();
Console.WriteLine(calc.Add(5, 3)); // Output: 8
Console.WriteLine(calc.Add(5.2, 3.3)); // Output: 8.5
}
}

class Calculator
{
5|P age
 public int Add(int a, int b)
{
return a + b;
}

public double Add(double a, double b)

{
return a + b;
}
}

2- Method overriding
o Redefining a method in a derived class that exists in the base class, using the same name and
parameters.
o provide a specific implementation of a method in the derived class.
o Method in parent class called virtual method: method declared in a base class using the virtual
keyword, and it is intended to be overridden by derived classes using the override keyword.
o The base class method must use virtual keyword
o The derived class method must use override keyword
Example
internal class Program
{
private static void Main(string[] args)
{
Animal animal = new Dog();
animal.Speak(); // Calls Dog's overridden method

}
}

class Animal
{
public virtual void Speak()
{
Console.WriteLine("The animal makes a sound.");
}
}

class Dog : Animal

{
public override void Speak()
{
6|P age
 Console.WriteLine("The dog barks.");
}
}

Example
class Program
{
static void Main(string[] args)
{
Computer pc = new Computer(16,256,"pc name",12);
pc.ram = 64;
pc.display();
Phone mobile = new Phone(16, 256, "pc name", "android");
mobile.type = "my phone";
mobile.display();
Console.Read();
}
}
class Computer:Device
{
public Computer(int ram, int rom, string name, int generation):base(ram,rom,name)
{

this.generation = generation;
}
public void display()
{
base.display();
Console.WriteLine("generation is "+generation);
}
public int generation;
}
class Phone : Device
{
public Phone(int ram, int rom, string name,string type):base(ram,rom,name)
{
this.type = type;
}
public string type
{
set
{
if (value.ToLower().Equals("android")|| value.ToLower().Equals("ios"))
{
Type = value;
}else
{
Console.WriteLine("only android and ios options is allowed");
}
}
get
{
return Type;
}
}

7|P age
 string Type;

}
class Device
{
public Device(int ram, int rom, string name)
{
this.ram = ram;
this.rom = rom;
this.name = name;
}

public int ram

{
set
{
Rom = rom % 8 == 0 ? rom : value;
}
get { return Ram; }
}
private int Ram;
private int Rom;
public int rom
{
set
{
Rom = rom % 8 == 0? rom:value;
}
get { return Rom; }
}
public string name;
public void display()
{
Console.WriteLine("ram is "+ram);
Console.WriteLine("rom is "+rom);
Console.WriteLine("name is "+name);
}
}

8|P age