When I started learning object-orientation in the mid 90s. They forced us to think abstraction, abstraction, abstraction. Everything that could be put higher up in the hierarchy was better, even member variables.
Nowadays, some people say that one should focus more on interface reuse rather than object reuse. In this toy example, the _field looks very innocent. But if you add a few extra parent classes and a couple of more member variables on each level, the complexity increases very fast. The risk that future changes will mess things up is high.
It is also generally considered unsafe to change base class implementation,
since it is hard to foresee how derived classes use the implementation.
If one inherits just the interface, it is more safe to do changes.
I would like to recommend the book "Refactoring improving the design of exisisting code", by Martin Fowler, Kent Beck, etc. It is a very old book, but is full of refactoring tricks. I have learned a lot from it.
I like unit-tests. Therefore Dependency Injection is very important. Meaning that from my test I can plug in test classes easily. This is not possible when you create objects directly from classes as you do with
public Derived():base(new SomeCompositeDataTypeImpl())
I would probably do like this
new Derived(new SomeCompositeDataTypeImpl())
in order to make it more testable.
I like interfaces inheritance and object delegation a lot,
and avoid object inheritance as much as I can, but that is me.