How can you reuse code with inheritance and composition?

Using Animal to explain inheritance is very bad. Inheritance in the gene sense is completely different from inheritance in programming. It is easier to understand inheritance with UI controls, simple shapes and similar. Even video game references might be much easier to really understand class inheritance than comparison to animals.

I think if we ask right questions before we proceed, the we will be able to choose any of it properly. Questions: Are they same in nature ? Like do they share similar properties and can be said as same along with some more attributes in one part ? If yes, then it is candidate for inheritance. If they are not same, but it's just one just needs another to get a work done. If yes, then it is a composition. If two objects are same: Incline towards inheritance else composition.

In my experience Dog ,Cat are types of Animals (Birds definitely not)and we cannot say directly that these are examples of inheritance. Any relationship of same families would be a better example. Example: Cat,Lion,Tiger they belong to cat families

I do use interfaces, but I very rarely use OOP-style inheritance. If you inherit data and code from a class, then you have access to it, but that class does not "know" that it has been inherited. It has no access to the rest of the features of your derived class. So in that way, it's "no better" than composition, i.e. adding a class member instead. You could imagine a problem where mixing data and virtual functions would be useful, but I encounter that infrequently.

Given the increasing popularity of MLOps, I would find examples from this domain more relatable and in turn easier to understand. Moreover, with the possibility that some of our readers might be involved in MLOps projects or preparing for interviews, using this topic as a vehicle could be even more motivating. In MLOps, consider a generic Model class that has basic functionalities like loading data, training, and prediction. Now, you might have different types of models like RegressionModel or ClassificationModel. In modelling frameworks, Instead of redefining the basic functionalities for each model type, they "inherit" from the Model class, ensuring that all the base modelling features are aligned with what the framework expects.

It is called composition, but it can be described with decomposition. When designing an abstraction of an agent in the real world ( let’s say a car ), you start decompositioning the agent to smaller agents defined with clear goals and features ( the tires, the engine, the doors... ) This decomposition allows a more consistent abstraction of the agent compared to describing the agent as whole. Divide and conquer

Composition of objects are a way to define a template, which all objects must comply to. For example if you define a class Car, we can let the composition define general properties which must apply to all cars: it must have an engine, body and wheels in example. Each of these components may have varying specifications which lead to them also being objects which can further described via other compositions. In this way we can construct/deconstruct a car into a tree of requirements, of which some may have different properties down the line (i.e. an electric car does not need a fuel tank).

Composition another mechanism of re-use, often used to build a larger and more complex abstraction out of smaller pieces -- the lego model. It can be used as an alternative to inheritance wherein your new abstraction uses an existing component without coupling itself to it directly. This can allow you greater encapsulation, and looser coupling, because you aren't bound by the contract of the components that you compose.

The "is-a" relationship is hard to understand, and especially wrong in many translations. It is simpler to say: If you have nothing to override, ignore inheritance. Even if your purpose is just to add attributes, except if you have a really valid reason (like a performance constraint that avoids pointers), ignore inheritance. It is not that inheritance is better or worse than composition... inheritance is for when you know you need to override something. If not, it is not even supposed to be an option.

I saw this example: A red rose is a kind of flower, and a flower is a kind of plant. Polymorphism is a concept in type theory wherein a name may denote instances of many different classes as long as they are related by some common superclass. Based on that polymorphism definition, I think Animal is a good example for inheritance and polymorphism - Object-Oriented Analysis and Design with Applications

There's an art to using inheritance well, but it's best to use inheritance lightly with an eye to its tradeoffs. If what you're building is effectively the same as an existing component, obeys the same contract, and you want to add light customizations that are easiest to do with inheritance, that's typically the sweet spot. If you have any doubts that inheritance may not be the right solution, then it often won't be. Having said that, there are also times when it's the most expedient choice even when you've discovered significant cost to doing so.

Composition is most obviously correct when you're building a new component that can benefit from re-using other code but doesn't obey the same contract. Composition allows you to expose some of the code you're reusing or none -- and that flexibility is often crucial to making the decision. You might also use composition when the tradeoffs of inheritance are painful, even it it might feel like the right choice at first glance.

This topic is just wrong. There are no "trade-offs". They have different purposes. As a simple rule, if there's nothing to override, then there's no need to use inheritance.

I don't see how inheritance and composition could be compared. These are completely different concepts with different usage goals. The only similarity that I can think of, they are both abstraction mechanism that allow you to design the problem in a readable and consistent way in order to reuse code. Composition is the bread and butter of OOP. It allows the definition of the different agents and roles operating in the problem you are solving and their relationship of ownership. Inheritance in the other hand is an abstraction to define categories and sub categories of the same agents / roles. Inheritance should be used with moderation as it can be an anti-pattern. Protocols, interfaces and abstract class are a good alternative to inheritance

Choose inheritance for code reuse when there's a clear hierarchy and shared code. Use composition for flexibility and loose coupling between components. Often, a mix of both is useful.

It is well defined according to what I've read. Here is mentioning the implications of using composition or inheritance. And is part to consider in a good OOAD

This question doesn't make much sense because the question is not about inheritance or composition. You can use both at the same time. Inheritance only makes sense when a class has a strict and useful logical inheritance to one other class (unless your programming language allows multiple inheritance) with all its edge cases. When the relationship only is that it behaves like that other thing, then composition is the way to go, and it allows more flexibility. A Platypus is an Animal, but the Animal class does not inherit much to Platypus because all different types of Animal do not have much in common. But a Platypus behaves like a Mammal, like an EggLayer, like a PoisonousAnimal.

Introducing part of the SOLID principles here is an interesting choice. It also has nothing to do with "choosing" between inheritance and composition.

It's better when you don't know the use between two of them, I think it's better to use composition because it provides less dependency in your code