I'd suggest that the most important characteristic of object oriented programming is that of complexity management.
The human brain can only hold so many concepts at one time - the oft quoted limit of remembering 7+/-2 independent items comes to mind.
When I'm working on a 600kloc system at work, I can't hold the whole thing in my head at once. If I had to do that, I'd be limited to working on much smaller systems.
Fortunately, I don't have to. The various design patterns and other structures that we've used on that project mean that I don't have to deal with the entire system at once - I can pick up individual pieces and work on them, knowing that they fit into the wider application in well defined ways.
All of the important OO concepts provide ways to manage complexity.
Encapsulation - let me deal with an external API that provides me with various services, without worrying how those services are implemented.
Abstraction - let me concentrate on the essential characteristics and ignore what's not relevant.
Composition - let me reuse components that have already been built in new combinations
Polymorphism - let me ask for a service without worrying about how different objects might provide it in different ways.
Inheritance - let me reuse an interface or an implementation, providing only the pieces that are different from what has gone before.
Single Responsibility Principle - lets keep the purpose for each object clear and concise, so it's easy to reason about
Liskov Substitution Prinicple - let's not lay traps for each other by introducing odd dependencies
Open/Closed Principle - let's allow extension and modification in ways that don't require us to risk breaking existing code
Dependency Injection - let's take composition to the next level and assemble the components together much later.
Interface oriented development - let's take abstraction to the next level and only depend on the abstraction, never on a concrete implementation.