If you're used to Turbo Pascal, you ought to start with Delphi (or Free Pascal, an open-source clone of Delphi) so you'll already be familiar with the basic feel of the language. That way you aren't trying to learn two unfamiliar concepts at once.
As for understanding OOP from a procedural starting point, think about it this way:
A procedural program can be thought of as a collection of variables and code that takes input and uses it together with the internal variables to do a certain job. Object-oriented programming is that same pattern repeated on a smaller scale, applied to individual components of your program.
Each object is a collection of variables bound to procedures and functions (known collectively as "methods" when they're part of an object) that, being procedures and functions, can take input from the outside world, and work together with the internal state to do a certain job.
It can be understood quite easily from a top-down perspective. For example, in a Delphi program, your application is managed by an object called
Application. It contains information about the state of the program as a whole, and provides a built-in message/event loop that dispatches input events to your forms. Each form is an object that describes the user interface, plus code to define what happens when the user does something. When the user initiates something (by clicking on a button or a menu option, for example,) it's frequently handled by creating an object of the appropriate type for whatever task needs to be performed, then calling a method on it.
The benefit of this paradigm, thinking of objects as the same model as a program but on a smaller scale, is that you can build your program out of several smaller, more-or-less independent components. (And the more independent of each other, the better. That's known as loose coupling.) That reduces the number of details you have to hold in your mind at once when working with the code, and makes your program more robust and easier to modify and maintain.
The other major difference between procedural programming and object-oriented programming is Liskov substitution, which is a technical term meaning that object classes can inherit from other classes, and any instance of an inherited class can be treated by the program as if it was an instance of the class it derives from.
This allows all sorts of new opportunities for flexibility that are too involved to get into here, but keep in mind as you start to work with an OO language that when you see a method parameter that accepts an object type, what it really accepts is that class or anything that derives from it. The main benefit of this is polymorphism, which refers to declaring a
virtual method on the base class and then overriding it (providing a new implementation) in inherited classes. When a virtual method is called, the compiler inserts code to call the version of the method belonging to the actual object, not the method belonging to what the object is currently declared as.
To give one simple example, in Delphi there's a class called
TStream that is used for data streams. It has virtual methods called
Write which are used for reading from or writing to the stream, respectively. It has several descendant classes, including
TFileStream for accessing a file on disc,
TMemoryStream, which uses an in-memory buffer, and an HTTP stream whose name I can't recall at the moment. Each is implemented in a very different way, but if you're in a method with a
TStream parameter, you don't need to know or care how it works; you just call
Write and the other virtual methods.
Hope this helps you understand OOP a little bit better. :)