Skip to content
wannacode

What is it really?

Problem

Only some of them can charge

A company has a fleet of regular and electric cars. Every evening the electric ones need to be charged. ElectricCar inherits from Car and adds Charge(), so they are all in one Car[] array:

Car[] fleet =
{
    new Car("Skoda"),
    new ElectricCar("Tesla", 35),
    new Car("Dacia"),
    new ElectricCar("Nissan", 60)
};
foreach (Car c in fleet)
{
    c.Charge();
}

The program does not compile:

"'Car' does not contain a definition for 'Charge'".

You know why from the lesson on polymorphism: the type of the variable decides what you can call. c is a Car, and Car has no charging.

A regular car really cannot be charged. You have to ask each car: "are you electric?"

The idea

Ask the object what it is

foreach (Car c in fleet)
{
    if (c is ElectricCar e)
    {
        e.Charge();
        Console.WriteLine(e.Brand + ": charged to " + e.Battery + "%");
    }
}
Output
Tesla: charged to 100%
Nissan: charged to 100%

c is ElectricCar e does two things at once:

  • it checks whether the object c points to is an ElectricCar;
  • if it is, it creates a variable e of type ElectricCar that points to the same object.

Through e you can now call Charge(). The cars stay the same. You just look at the object through a more specific type.

This is called a type check. Going from the parent type to the child type is called a downcast: down the chain Object → Car → ElectricCar.

e exists only inside the if. Outside it, the object is just a Car again.

foreach (Car c in fleet)
{
    if (c is ElectricCar e)
    {
        e.Charge();
        Console.WriteLine(e.Brand + ": charged to " + e.Battery + "%");
    }
}
Step by step, in words
  1. fleet is an array of Car: 2 regular and 2 electric cars.
  2. c points to Skoda: is says "no". The body of the if is skipped.
  3. c points to Tesla: is says "yes". e is a second arrow to the same car, and it charges it.
  4. c points to Dacia: is says "no". The body of the if is skipped.
  5. c points to Nissan: is says "yes". e is a second arrow to the same car, and it charges it.
  6. The cars do not change. The check only looks at the object through a more specific type.

Try it

Is it a car?

What will the program print?

Car c = new ElectricCar("Tesla", 35);
Car d = new Car("Skoda");
Console.WriteLine(c is Car);
Console.WriteLine(c is ElectricCar);
Console.WriteLine(d is ElectricCar);
Answer

The idea

Other forms you will run into

Besides is there is also as. It tries the conversion, and if the object is not of that type, it gives null instead of an error:

ElectricCar e = fleet[1] as ElectricCar;
if (e != null)
{
    e.Charge();
    Console.WriteLine(e.Brand + ": " + e.Battery + "%");
}
ElectricCar none = fleet[0] as ElectricCar;
Console.WriteLine(none == null);
Output
Tesla: 100%
True

fleet[0] is "Skoda", so as gives null. Then you have to check for null before you call methods. With is ElectricCar e the check and the conversion are in one place, so it is shorter.

More precisely, if you are curious
  • The classic cast (ElectricCar)c exists too. If the object is not an ElectricCar, the program stops with InvalidCastException.
  • The check is always false for null: null is Car is false. So after a successful is you never have null.
  • The check works with interfaces too: a is ISwimmable s asks whether the object's class implements the contract.

Try it

Find the bug

The program counts the regular and the electric cars. The fleet has two of each, but it prints:

Output
Regular: 4, electric: 0

Which line is the bug on?

Pick the line with the bug.

The idea

A check or a method?

You want to print what each car runs on. A type check can do it:

foreach (Car c in fleet)
{
    if (c is ElectricCar)
    {
        Console.WriteLine(c.Brand + ": electricity");
    }
    else
    {
        Console.WriteLine(c.Brand + ": gasoline");
    }
}

But this is the salary with an if per role from the lesson on polymorphism. Every car has an energy source, just a different one. That is a job for a method in Car, overridden in ElectricCar:

// in Car
public virtual string Energy()
{
    return "gasoline";
}


// in ElectricCar
public override string Energy()
{
    return "electricity";
}
foreach (Car c in fleet)
{
    Console.WriteLine(c.Brand + ": " + c.Energy());
}
Output
Skoda: gasoline
Tesla: electricity
Dacia: gasoline
Nissan: electricity

Tomorrow a hybrid car comes along. With the method, you write a new class. With the checks, you hunt down every if in the program.

The rule:

  • Every object does it, each in its own way: a method in the parent, and overriding.
  • Only some objects can do it (charging, pedaling): a type check.

Try it

What is missing?

foreach (Car c in fleet)
{
    if (c  ElectricCar e)
    {
        e.Charge();
    }
}

In short

The four pillars of OOP

With this lesson you have finished the modules "Classes and objects" and "Inheritance and polymorphism". Object-oriented programming rests on four ideas. You already use all of them:

  • Encapsulation. The object's data is hidden, and from outside you reach it only through methods that guard the rules. Account keeps the balance private and offers only Deposit() and Withdraw(). Encapsulation
  • Inheritance. What is shared sits in one place, the parent, and the child adds its own. Manager is an Employee with a bonus. Inheritance
  • Polymorphism. One call, different behavior depending on the object. e.MonthlyPay() in one loop works out the pay of an employee, a manager and an intern. Polymorphism
  • Abstraction. You say what the object must be able to do, and each class decides how. The abstract Shape promises an area, the IPayable interface promises an amount to pay. Abstract classes, Interfaces

Exercise

What is it really?

Solve these in your editor.

1. Parking lot. A SimpleCar[] array of regular and family cars (FamilyCar inherits from SimpleCar). For each one, print its type. Watch the order of the checks.

Output
This is a SimpleCar
This is a FamilyCar
This is a SimpleCar

2. Dances. A DanceMove[] array of regular and breakdance moves. For the breakdance moves, also print the complexity. For that you need the variable from the check.

Output
moonwalk: DanceMove
windmill: BreakDanceMove, complexity 8
salsa: DanceMove

3. Fleet. Take Car and ElectricCar from the exercise in the "Inheritance" lesson. In a Car[] array, put a "Skoda" with 40 L, a "Tesla" with efficiency 5, a "Dacia" with 5 L and a "Nissan" with efficiency 4. Each one drives 100 km: the electric ones with DriveElectric, the rest with Drive. Then print the kilometers and the fuel or the battery.

Output
Skoda: 100 km, fuel 30 L
Tesla: 100 km, battery 80%
Not enough fuel for 100 km
Dacia: 0 km, fuel 5 L
Nissan: 100 km, battery 75%

4. Zoo. An abstract class Animal with Sound(), and child classes Cat, Dog and Fish. Only Fish implements ISwimmable with Swim(). In a loop over the animals, call each one's sound, and for the ones that can swim, also call Swim().

Output
Meow, meow!
Woof, woof!
The fish is silent.
The fish swims.

More tasks

  • Pedals. In the exercise from the "Abstract classes" lesson, garage[1].Pedal() did not compile. Fix it with a type check: in the loop over Vehicle[], every vehicle starts, and the bicycle also pedals.
  • Payments by kind. From the "Interfaces" lesson: the IPayable[] array holds employees and invoices. Print the total for salaries and the total for invoices separately. For Ivan, Maria and the two invoices: €5,500 in salaries and €2,140 in invoices.

Test

Check yourself

1. c is ElectricCar e is true. What is e?
2. c points to an ElectricCar. What is c is Car?
3. You check whether a car is a Car or an ElectricCar. In what order?
4. The program has many ifs like "if it is an ElectricCar, do one thing, otherwise do another". What does that tell you?
5. c points to a regular car. What does c as ElectricCar give?

Made by Ivo Gergov as part of Evo Tech's campaign for accessible programming education ·