How do I implement multiple kinds of an object in OOP?

Question

I have multiple kinds of an object, say Car for example.

Do I have each kind in an inherited class/subclass of Car?

Do I place these under a cartype namespace so as not to mess up the main namespace?

Then later when I need an array of cars, should I declare it as var currentCars():Car or var currentCars():Object? Would the former support any subclass of Car?

Answer 1

You can have an inifinite number of classes inheriting from your Car class as long as you don't have overriden methods that conflict.

As for namespaces, I usually put the classes that inherit from another one in the same namespace, not sure if not being in the same namespace works though.

Oh and when you need an array, you declare it just like any other data type.

You see, when you declare a class Car you create a data type Car.

So when you need to declare an array of cars, you go like this:

var currentCars():Car

Answer 2

Specific answers are difficult because they really depend on the particulars of your problem space, but in general you would use subclasses of Car if all kinds of Car shared some functionality. E.g.:

public class Car {
    public void Start() { }
}

And then you could have different types of Car:

public class Sedan : Car {
    public void OpenAllFourDoors() { }
}

public class Coupe : Car {
    public void OpenAllTwoDoors() { }
}

You don't generally need to put the class hierarchy into its own namespace, there are other sets of guidance for namespace definitions. Typically, expect namespaces to take the form of something like CompanyName.ProductName.ModuleName or something similar.

Later, when you need an array (or, more commonly, a collection) of cars, you would create a collection of Car. When you grab a reference from this collection, though, you won't be able to OpenAllFourDoors or OpenAllTwoDoors because you won't know which subclass of Car you're working with.

(Apologies for C#-centric syntax)