Inheritance isnt evil neither is composition, they just are tools/techniques and you have to use them wisely in your design. (thats why you have to think about your design instead of start writting code and doing iterations in a backstracking (test and error way)

“is-a”: inheritance
“has-a”: composition

lets imagine this 2 classes:
public abstract class Horse extends BaseLifeForm.
public abstract class Truck extends BaseMachine.

this is making an asumption: machines will never be a life form, so you have 2 hierarchies: lifeforms and machines. ¿but what if some day artificial intelligence makes possible that machines became a form of life? UPS!
anyways: horses will never have a “turn on” method…. ¿or not?

at the end, its all about making a design based in some scenario.

disclaimer: english is not my native language so dont blame my mistakes :)

Yes, you have to copy/paste the Xxx field declaration and this declared getter, but that’s all.
You are free to respect this IsXxx contract by either inheritance or aggregation.
(Even you are no more concerned by method name collision)

Meanwhile, C++ multi-inheritance provides two facilities:
– you don not have to { cast as Xxx / use xxx field / use asXxx getter }
– child classes have access to parent’s protected members

Actually i think the mostly used of inherintance is to simplify a composition.
By exemple, if to make a X you need a common B and custom C
with inheritence: X/B are base, C extends X/B
with agregation: X is interface, B and C classes, C’ assemble B and C to become a X
and you need extra interfaces to define communication between B and C, and the rest of the world…

Finally I agree: inheritence is bad, but a shortcut.

This could be written as a method,

void Dog.See(Cat cat)
{
Chase(cat);
}

Now suppose we have a class CatLovingDog that inherits from Dog.

void CatLovingDog.See(Cat cat)
{
Greet(cat);
}
———————————————————————-

No, rather than creating “some other kind of dog”, (the same fundamental inheritance problem discussed in the article), instead the thing to do is to modify the existing dog definition by adding a “CatAffinity” property.

void Dog.See(Cat cat)
{
if (this.CatAffinity > 0)
Greet(cat);
else
Chase(cat);
}

Chase or greet is not an “is-a”, nor is it a “has-a”. Instead it’s an attribute of a specific instance.

Your Ball example actually works equally well with this!

Interfaces when all implementations are best represented using multiple inheritance of course. Then again in my experience it is rare that a DarkHippo is going to crush villagers in the same way a DarkJedi will. :)