Object-oriented programming (OOP) is a computer programming paradigm that emphasizes the following aspects:

  • Objectss - packaging data and functionality together into units within a running computer program; objects are the basis of modularity and structure in an object-oriented computer program.
  • Abstraction - combining multiple smaller operations into a single unit that can be referred to by name.
  • Encapsulation - separating implementation from interfaces.
  • Polymorphism - using the same name to invoke different operations on objects of different data types.
  • Inheritance - defining objects data types as extensions and/or restrictions of other object data types.

Notes: Abstraction is important to but not unique to OOP. Reusability is a benefit often attributed to OOP.

OOP is often called a paradigm rather than style or type of programming to emphasize the point that OOP can change the way software is developed, by changing the way that programmers and software engineers think about software.

Table of contents
1 Basic
2 OOP with procedural languages
3 Definition
4 Class-based models
5 Object-based models
6 History
7 Further reading
8 See also:
9 External link


The most fundamental aspect of object-oriented programming is that a computer program is composed of a collection of what are called objects. Each object is capable of receiving messages and sending messages to other objects, and the user accesses the object via an interface independent from the internal structure of the object (encapsulation). This technique is known as abstraction with use of objects.

In OOP, programmers are supposed to concentrate on distributing responsibility over objects, which is in contrast to the view in traditional paradigms such as imperative programming in which programmers are more concerned about steps of data processes to produce certain results. The proponents of OOP claim that the use of OOP style programming can make programs easier to write, maintain, reuse and prove correct (at least in some cases).

Fundamentally, these advantages come from the fact that OOP is modular, being composed of objects (similar to sub-programs) which are simple, self contained and easily identifiable. Modularity allows the program parts to correspond to real aspects of the problem situation and thereby to model the real world. Indeed, object oriented programming often begins from a written statement of the problem situation. Then by a process of inserting objects or variables for nouns, methods for verbs and attributes for adjectives, then a good start is made on a framework for a program that models, and deals with, that situation.

This is a highly intuitive way to work. OOP is a major advance on the previous complexities of procedure based methods. In large projects, procedural methods tended to develop very complicated conditional loops and branches, difficult to understand and to maintain.


Inheritance: One object's data and/or functionality may be based on those of other objects, from which the former object is said to inherit. This allows commonalities among different kinds of objects to be expressed once and reused multiple times. Inheritance is also commonly held to include subtyping, whereby one type of object is defined to be a more specialised version of another type (see Liskov substitution principle), though non-subtyping inheritance is also possible. Inheritance is typically expressed by describing classes of objects arranged in an inheritance hierarchy reflecting common behavior.

OOP with procedural languages

In procedural languages, OOP often appears as a form where data types are extended to behave like an object in OOP, very similar to an abstract data type with an extension such as inheritance. Each method is actually a subprogram which is syntactically bound to a class.


The definitions of OOP are disputed. In the most general sense, object-oriented programming refers to the practice of viewing software primarily in terms of the "things" (objects) it manipulates, rather than the actions it performs. Other paradigms such as functional and procedural programming focus primarily on the actions, with the objects being secondary considerations; in OOP, the situation is converse.

Widely-used terminology distinguishes object-oriented programming from object-based. The former is held to include inheritance (described below), while the latter does not. See Dispute over the definition of object-oriented programming

Class-based models

The most popular and developed model of OOP is a classed based model, as opposed to object-based model. In this model, objects are entities that combine both state (i.e., data) and behavior (i.e., procedures, or methodss). Objects are defined by a classes, which is a definition, or blueprint, of all objects of a specific type. An object is considered to be an instance of a class. A class is similar to a structure, with the addition of method pointers, member access control, and an implicit member data type which locates instances of the class (i.e.: actual objects of that class) in the class hierarchy (essential for runtime inheritance features).

Object-based models

Object-based programming techniques include the concept of an object (encapsulation, and abstraction) but do not include the class-based models of inheritance.


The concepts of object-oriented programming first took root in Simula 67, a language designed for making simulations, created by Ole-Johan Dahl and Kristen Nygaard of the Norwegian Computing Centre in Oslo. (Reportedly, the story is that they were working on ship simulations, and were confounded by the combinatorial explosion of how the different attributes from different ships could affect one another. The idea occurred to group the different types of ships into different classes of objects, each class of objects being responsible for defining its own data and behavior.) They were later refined in Smalltalk, which was developed in Simula at Xerox PARC, but was designed to be a fully dynamic system in which objects could be created and modified "on the fly" rather than having a system based on static programs.

Object-oriented programming "took off" as the dominant programming methodology during the mid-1980s, largely due to the influence of C++, an extension of the C programming language. Its dominance was further cemented by the rising popularity of Graphical user interfaces, for which object-oriented programming is allegedly well-suited. Indeed, the rise of GUIs changed the user focus from the sequential instructions of text-based interfaces to the more dynamic manipulation of tangible components. An example of a closely related dynamic GUI library and OOP language can be found in the Cocoa frameworks on Mac OS X, written in Objective C, an object-oriented, dynamic messaging extension to C based on Smalltalk.

Object-oriented features were added to many existing languages during that time, including Ada, BASIC, Lisp, Pascal, and others. Adding these features to languages that were not initially designed for them often led to problems with compatibility and maintainability of code. "Pure" object-oriented languages, on the other hand, lacked features that many programmers had come to depend upon. To bridge this gap, many attempts have been made to create new languages based on object-oriented methods but allowing some procedural features in "safe" ways. Bertrand Meyer's Eiffel was an early and moderately successful language with those goals.

In the past decade Java has emerged in wide use partially because of it similarity to the C language but more importantly because if its implementation using a virtual machine that theoretically runs code unchanged on many different platforms, the latter of which makes it the darling of larger development shops with heterogeneous environments.

More recently, a number of languages have emerged that are primarily object-oriented yet compatible with procedural methodology, such as Python and Ruby. Besides Java, probably the most commercially important recent object-oriented languages are VB.NET and C Sharp designed for Microsoft's .NET platform.

Just as procedural programming led to refinements of technique such as structured programming, modern object-oriented software design methods include refinements such as the use of design patterns, design by contract, and modelling languages (such as UML).

Further reading

See also:

External link