Compared with procedural programming, OOP allows us to build higher level abstractions by bundling code & data together. Any time we can reduce the number of items that the consuming client has to deal with, that is positive.
In procedural programming, a simple structure can combine, say an
int x and an
int y. Using a structure, a consuming client can now operate in terms of a single concept, a coordinate, instead of a pair of
int's, and, this is a good thing. This single coordinate is harder to mix up than two
OOP goes a step further offering to bundle not just data members together, but also code/behavioral members. This is a logical next step in allowing the construction of larger abstractions. Just as bundling several data elements together reduces the client's load, so does bundling behaviors, so this is a good thing.
If I use a serializer and deserializer bundled together in one object, I'm less likely to use the wrong serializer with the wrong deserializer, whereas that is much easier to happen if as a client, I have to use separate procedures.
OOP supports multiplicity of objects, multiplicity of implementations, and, bundlings into higher levels of abstraction so consuming clients have to deal with fewer things. It allows us to express some formal relationships that go otherwise unstated in procedural programming (e.g. that some functions are logically related to each other).
OOP also allows for a certain amount of code reuse through the mechanisms of base classes, class hierarchy, virtual methods, overrides, and virtual dispatch. While this can be duplicated in non-OO procedural languages, it can be cumbersome, and, it is just that: duplicating OOP.
OOP allows placing some abstractions in hierarchy, such that the hierarchy itself is a bundling of additional abstractions into one; again, bundling to reduce the number of individual and separate items the client has to deal with is a positive thing.
Yes, all that means better intellisense in the IDEs, and that's a good thing as well. This comes by formally expressing relationships that in other languages might have gone implicitly unstated, such as functions being related by naming/prefixing rather than any formally expressed grouping/relationship.
To reiterate @Amon, OOP has also been over-hyped, and that's why we have mantras like composition over inheritance, and don't create deep class hierarchies. I personally like: don't create a subclass when all you need is an instance.