When trying to explain the concept of Inheritance in OOP, the common example is often the mammals example. IMHO, this is really a bad example, because it will lead the newbies to use this concept the wrong way. And moreover, it is not a common design that they will face in their day-to-day design job.
So, what will be a nice, simple and concrete problem that is solved using Inheritance ?
There's nothing wrong with a purely academic example like mammals. I also like the rectangle/square example because it points out why real-world taxonomies don't always directly translate to the inheritance relationship you'd expect.
In my opinion, the most canonical every day example is a GUI toolkit. It's something everyone has used, but that beginners may not have reasoned about how they work under the hood. You can talk about what behaviors are common to all containers, all widgets, events, etc. without requiring detailed knowledge of any given implementation.
My real-world example is the domain model of a simple HR application. I tell that we can create a base class called Employee, because of course, managers are employees too.
public class Employee
{
public string FirstName { get; set; }
public string LastName { get; set; }
public int Code { get; set; }
public string GetInsuranceHistory()
{
// Retrieving insurance history based on employee code.
}
}
Then I explain that developers are employees, testers are employees, project managers are employees. Thus they all can inherit from the employee class.
Developer and a Tester. Another similar situation is a contact database where you have Customer and Supplier, but as anyone who has created such a system will tell you, there's always a case where a Company is both. That's why most of these examples lead you in the wrong direction.
– Scott Whitlock
Nov 22 '12 at 17:47
Encapsulate what varies ... show them a template method pattern, it demonstrates the usefulness of inheritance by putting common behaviour in a base class and encapsulating varying behaviour in subclasses.
UI controls and Streams are also a very good example for the usefulness of inheritance.
Every instance of an object is a concrete example of the usefulness of inheritance!
If you mean specifically class inheritance, now you are in the world of taxonomies, and those will vary drastically by the goals of the system using them. The animals/mammals example uses a common and hopefully familiar taxonomy from biology, but it is (as you mentioned) nearly useless for the vast majority of programming problems.
So try something universal: the notion of a Program. Every program starts, runs, and ends. Every program has a name, and optional command-line parameters. So a base Program class would be very useful, to start execution, grab and process the command-line arguments, run the main logic, and shut down gracefully.
Which is why so many object-oriented programming languages provide a Program class, or something that behaves exactly like a Program class.
class Programm { public static void main(String[] args) { system.out.println('hello world'); }} is a minimal Java program. When i call it, there is no instance of Program. Program does not Inherit from anything. When i start 3 Processes (like you do with crhome), there may be 3 Programms, but in their individual areas of memory, there's still only one Program. Imho, singleton implies 'Only one Instance per Process', not per Machine. If so, it would be impossible to make singletons, nothing stops you from running any code twice.
– keppla
Sep 15 '11 at 9:12
I am working with cameras at work. We have devices that connect to different models, so we have an abstract "camera class" and every model inherits from this class to support specific functionality of that camera. It's a real world example and not difficult to understand.
Camera and a Phone (as we all do in our pockets now). Which base class should it inherit from? Or shouldn't it just implement both the ICamera and IPhone interfaces? (ha ha)
– Scott Whitlock
Nov 22 '12 at 18:01
This is another example popped out of my brain:
class Element_
{
double atomicWeight; //Atomic weight of element
double atomicNumber; // Atomic number of element
String Properties; // Properties of element
//Others, if any
}
class Isotope extends Element_ // There can exist Isotopes of element
{
double halflife;
//Others if any
}
isotope isn't a special case of Elemenet. I'd rather have an Element property on Isotope.
– CodesInChaos
Feb 17 '13 at 20:42
Real-world examples almost always get it wrong because they give examples where there's always the possibility of something being both TypeA and TypeB but the single inheritance hierarchy of many languages don't allow that.
The more I program the more I get away from inheritance.
Even the word "inherit" is used improperly here. For instance, you inherit about 50% of your father's traits and 50% of your mother's traits. Really your DNA is a composition of half your father's DNA and half your mother's DNA. That's because biology actually favors composition over inheritance, and you should too.
Simply implementing interfaces, or even better, "duck typing", plus dependency injection, is a much better thing to be teaching people who are new to object-oriented programming.
I'd just show them a real-life example. For instance, in most UI frameworks you derive from some kind of a "Dialog" or "Window" or "Control" class to make your own.
Good example is the compare function in sorting:
template<class T>
class CompareInterface {
public:
virtual bool Compare(T t1, T t2) const=0;
};
class FloatCompare : public CompareInterface<float> { };
class CompareImplementation : public FloatCompare {
public:
bool Compare(float t1, float t2) const { return t1<t2; }
};
template<class T>
void Sort(T*array, int size, CompareInterface<T> &compare);
The only problem is the newbies too often think performance is more important than good code...
My real world example is a vehicle:
public class Vehicle
{
public Vehicle(int doors, int wheels)
{
// I describe things that should be
// established and "unchangeable"
// when the class is first "made"
NumberOfDoors = doors;
NumberOfWheels = wheels;
}
public void RollWindowsUp()
{
WindowsUp = true;
}
// I cover modifiers on properties to show
// how to protect certain things from being
// overridden
public int NumberOfDoors { get; private set; }
public int NumberOfWheels { get; private set; }
public string Color { get; set; }
public bool WindowsUp { get; set; }
public int Speed { get; set; }
}
public class Car : Vehicle
{
public Car : base(4, 4)
{
}
}
public class SemiTruck : Vehicle
{
public SemiTruck : base(2, 18)
{
}
}
This example can get as detailed as you like, and there are all kinds of properties attached to vehicles to explain the use of any modifiers you might want to teach.
This non-mammal, non-bird, non-fish example might help:
public abstract class Person {
/* this contains thing all persons have, like name, gender, home addr, etc. */
public Object getHomeAddr() { ... }
public Person getName() { ... }
}
public class Employee extends Person{
/* It adds things like date of contract, salary, position, etc */
public Object getAccount() { ... }
}
public abstract class Patient extends Person {
/* It adds things like medical history, etc */
}
Then
public static void main(String[] args) {
/* you can send Xmas cards to patients and employees home addresses */
List<Person> employeesAndPatients = Factory.getListOfEmployeesAndPatients();
for (Person p: employeesAndPatients){
sendXmasCard(p.getName(),p.getHomeAddr());
}
/* or you can proccess payment to employees */
List<Employee> employees = Factory.getListOfEmployees();
for (Employee e: employees){
proccessPayment(e.getName(),e.getAccount());
}
}
NOTE: Just don't tell the secret: Person extends Mammal.
How about a hierarchy of algebraic expressions. Is good because it includes both inheritance and composition:
+--------------------+------------------------+
| Expression |<------------------+ |
+--------------------+----------+ | |
| + evaluate(): int |<---+ | | |
+--------------------+ | | | |
^ | | | |
| | | | |
+--------------+ +---------------+ +-------------+ ...
| Constant | | Negation | | Addition |
+--------------+ +---------------+ +-------------+
| -value: int | | | | |
+--------------+ +---------------+ +-------------+
| +evaluate() | | +evaluate() | | +evaluate() |
| +toString() | | +toString() | | +toString() |
+--------------+ +---------------+ +-------------+
Addition(Constant(5), Negation(Addition(Constant(3),Constant(2))))
(5 + -(3 + 2)) = 0
With the exception of the root expression Constant, all other expressions are both an Expression and contain one or more expressions.
I will use birds as example
like chicken , duck ,eagle
I will explain both have claws, pecks , and wings but their attributes are different.
Chickens cannot fly, cannot swim, can eat worms , can eat grains
Ducks cannot fly, can swim , can eat grains, cannot eat worms
Eagle can fly, cannot swim , can eat worms, cannot eat grains
Your typical rails-clone provides many practical examples: you have the (abstract) base model class, that encapsulates all data manipulation and you have the base controller class, that encapsulates all HTTP-communication.
