Object-oriented programming (OOP) refers to a special type of programming that combines
data structures with functions to create re-usable objects.
Otherwise, the term object-oriented is generally used to describe a system that deals primarily
with different types of objects, and where you can take the actions depends on what type of object
you are manipulating. For example, an object-oriented draw program might enable you to draw
many types of objects, such as circles, rectangles, triangles, etc. Applying the same action to each of
these objects, however, would produce different results. If the action is Make 3D, for instance, the
result would be a sphere, box, and pyramid, respectively.
Many languages support object oriented programming. In OOP data and functions are
grouped together in objects (encapsulation). An object is a particular instance of a class. [1] Each
object can contain different data, but all objects belonging to a class have the same functions
(called methods). So you could have a program with many e-mail objects, containing different
messages, but they would all have the same functionality, fixed by the email class. Objects often
restrict access to the data (data hiding).
Classes are a lot like types the exact relationship between types and classes can be complicated
and varies from language to language.
Via inheritance, hierarchies of objects can share and modify particular functions. You may
have code in one class that describes the features all e-mails have (a sender and a date, for
example) and then, in a sub-class for email containing pictures, add functions that display images.
[2]Often in the program you will refer to an e-mail object as if it was the parent (super-class)
because it will not matter whether the e-mail contains a picture, or sound, or just text. This code
will not need to be altered when you add another sub-class of e-mail objects, containing (say)
electronic cash.
Sometimes you may want an action on a super-class to produce a result that depends on
what sub-class it "really is". For example, you may want to display a list of email objects and
want each sub-class (text, image, etc) to display in a different colour. In many languages it is
possible for the super-class to have functions that sub-classes change to suit their own purposes
(polymorphism, implemented by the compiler using a technique called dynamic binding). So
each email sub-class may supply an alternative to the default, printing function, with its own
colour.
In many OO languages it is possible to find out what class an object is (run time type
information) and even what functions are connected with it (introspection / reflection). Others,
like C++ have little run time information available (at least in the standard language individual
libraries of objects can support RTTI with their own conventions).
[3]There are at least three approaches to OO languages: Methods in Classes, Multi-Methods
Separate from Classes, Prototypes.

Many languages follow Smalltalk in associating functions (methods) with classes. The
methods form part of a class definition and the language implementation will have (this is a
low-level detail hidden from the programmer) a vtable for each class which links methods to their
implementations. This indirection is necessary to allow polymorphism, but introduces a
performance penalty. In some languages (C++, at least), only some methods, marked as virtual
by the programmer, are treated in this way.

Some languages (e.g. common Lisp / CLOS) allow functions to specialise on the class of
any variable that they are passed (multi-methods). Functions cannot be associated with one class
because different versions of the function may exist for many different combinations of classes.

Other OO languages do away with classes completely (e.g. Self). Prototype-based languages
create new objects using an existing object as an example (prototype). Apart from solving some
problems with dynamic object creation, this approach also encourages delegation (function calls
are passed to other objects) rather than inheritance.

没有生词