Object-oriented programming ( OOP ) is a programming paradigm that uses "objects" – data structures consisting of datafields and methods together with their interactions – to design applications and computer programs. Programming techniques may include features such as information hiding, data abstraction, encapsulation, modularity, polymorphism, and inheritance. It was not commonly used in mainstream software application development until the early 1990s. Many modern programming languages now support OOP.
Overview
An object is actually a discrete bundle of functions and procedures, all relating to a particular real-world concept such as a bank account holder or football player in a computer game. Other pieces of software can access the object only by calling its functions and procedures that have been allowed to be called by outsiders. Isolating objects in this way makes their software easy to manage and keep track of.
For example, the football player’s functions might include one to reveal the player’s current position on the field, and another to instruct the player to kick the ball. The account holder’s functions might include one to reveal the current balance or to draw out a sum.
Object-oriented programming has roots that can be traced to the 1960s. As hardware and software became increasingly complex, quality was often compromised. Researchers studied ways to maintain software quality and developed object-oriented programming in part to address common problems by strongly emphasizing discrete, reusable units of programming logic. The methodology focuses on data rather than processes, with programs composed of self-sufficient modules (objects) each containing all the information needed to manipulate its own data structure. This is in contrast to the existing modular programming which had been dominant for many years that focused on the function of a module, rather than specifically the data, but equally provided for code reuse, and self-sufficient reusable units of programming logic, enabling collaboration through the use of linked modules (subroutines). This more conventional approach, which still persists, tends to consider data and behavior separately.
An object-oriented program may thus be viewed as a collection of interacting objects , as opposed to the conventional model, in which a program is seen as a list of tasks (subroutines) to perform. In OOP, each object is capable of receiving messages, processing data, and sending messages to other objects and can be viewed as an independent 'machine' with a distinct role or responsibility. The actions (or "operators") on these objects are closely associated with the object. For example, the data structures tend to 'carry their own operators around with them' (or at least "inherit" them from a similar object or class).
The Simula programming language was the first to introduce the concepts underlying object-oriented programming (objects, classes, subclasses, virtual methods, coroutines, and discrete event simulation) as a superset of Algol. Simula also used automatic garbage collection which had been invented earlier for the functional programming language Lisp. Simula was used for physical modeling, such as models to study and improve the movement of ships and their content through cargo ports. Smalltalk was the first programming language to be called "object-oriented".
History
The concept of objects and instances in computing had its first major breakthrough with the PDP-1 system at MIT which was probably the earliest example of 'capability based' architecture. Another early example was Sketchpad created by Ivan Sutherland in 1963; however, this was an application and not a programming paradigm. Objects as programming entities were introduced in the 1960s in Simula 67, a programming language designed for performing simulations, created by Ole-Johan Dahl and Kristen Nygaard of the Norwegian Computing Center in Oslo. (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 them of grouping the different types of ships into different classes of objects; each class of objects being responsible for defining its own data and behavior.) Such an approach was a simple extrapolation of concepts earlier used in analog programming. On analog computers, mapping from real-world phenomena/objects to analog phenomena/objects (and conversely), was (and is) called 'simulation'. Simula not only introduced the notion of classes, but also of instances of classes, which is probably the first explicit use of those notions. The ideas of Simula 67 influenced many later languages, especially Smalltalk and derivatives of Lisp and Pascal.
The Smalltalk language, which was developed at Xerox PARC (by Alan Kay and others) in the 1970s, introduced the term object-oriented programming to represent the pervasive use of objects and messages as the basis for computation. Smalltalk creators were influenced by the ideas introduced in Simula 67, but Smalltalk was designed to be a fully dynamic system in which classes could be created and modified dynamically rather than statically as in Simula 67. Smalltalk and with it OOP were introduced to a wider audience by the August 1981 issue of Byte magazine.
In the 1970s, Kay's Smalltalk work had influenced the Lisp community to incorporate object-based techniques which were introduced to developers via the Lisp machine. Experimentation with various extensions to Lisp (like LOOPS and Flavors introducing multiple inheritance and mixins), eventually led to the Common Lisp Object System (CLOS, a part of the first standardized object-oriented programming language, ANSI Common Lisp), which integrates functional programming and object-oriented programming and allows extension via a Meta-object protocol. In the 1980s, there were a few attempts to design processor architectures which included hardware support for objects in memory but these were not successful. Examples include the Intel iAPX 432 and the Linn Smart Rekursiv.
Object-oriented programming developed as the dominant programming methodology during the mid-1990s, largely due to the influence of Visual FoxPro 3.0 or possibly C++. Its dominance was further enhanced by the rising popularity of graphical user interfaces, for which object-oriented programming seems to be well-suited. 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. OOP toolkits also enhanced the popularity of event-driven programming (although this concept is not limited to OOP). Some feel that association with GUIs (real or perceived) was what propelled OOP into the programming mainstream.
At ETH Zürich, Niklaus Wirth and his colleagues had also been investigating such topics as data abstraction and modular programming. Modula-2 included both, and their succeeding design, Oberon, included a distinctive approach to object orientation, classes, and such. The approach is unlike Smalltalk, and very unlike C++.
Object-oriented features have been added to many existing languages during that time, including Ada, BASIC, Fortran, 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.
More recently, a number of languages have emerged that are primarily object-oriented yet compatible with procedural methodology, such as Python and Ruby. Probably the most commercially important recent object-oriented languages are Visual Basic .NET (VB.NET) and C#, both designed for Microsoft's .NET platform, and Java, developed by Sun Microsystems. VB.NET and C# both support cross-language inheritance, allowing classes defined in one language to subclass classes defined in the other language.
Just as procedural programming led to refinements of techniques such as structured programming, modern object-oriented software design methods include refinements such as the use of design patterns, design by contract, and modeling languages (such as UML).
The term OOPS, which refers to an o bject- o riented p rogramming s ystem, was common in early development of object-oriented programming.
Fundamental concepts and features
See also: List of object-oriented programming termsA survey by Deborah J. Armstrong of nearly 40 years of computing literature identified a number of "quarks", or fundamental concepts, found in the strong majority of definitions of OOP. They are the following:
Not all of the above concepts are to be found in all object-oriented programming languages, and so object-oriented programming that uses classes is called sometimes class-based programming. In particular, prototype-based programming does not typically use classes . As a result, a significantly different yet analogous terminology is used to define the concepts of object and instance .
Main features
The attempt to distill OOP to a minimal set of features is considered futile by programming language researcher Benjamin Cuire Pierce. Nevertheless, he identifies the following as fundamental features that are found in most object-oriented languages and that, in concert, support the OOP programming style:
- Dynamic dispatch -- when a method is invoked on an object, the object itself determines what code ge
CommunicationObject Methods (System.ServiceModel.Channels)
Causes a communication object to transition from its current state into the closed state. EndClose: Completes an asynchronous operation to close a communication object.
Object Communication, Ebook Author Publisher, Digital Product Delivery
epub publishing and content delivery ... Object Communication provides in-house electronic publishing and sale of the author's works.
CommunicationObject Methods (System.ServiceModel.Channels)
Name Description; Abort: Causes a communication object to transition immediately from its current state into the closing state. BeginClose: Overloaded.
Fact Sheet #004 Object Communication (English)
D. Object Communication: Many students who are deaf-blind need a variety of communication systems for their different needs and settings. Using objects for communication is a form ...
NCDB Selected Topics: Communication, Object
DB-LINK is a federally-funded service that identifies, coordinates, and disseminates, at no cost, information related to children and youth from birth through 21 years of age.
Object Communication
COLORADO Assistance for those SERVICES TO with both vision CHILDREN WITH and hearing loss DEAFBLINDNESS (303) 866-6681 or (303) 866-6605 Fact Sheet Object Communication Many ...
Amazon.com: "Communication Object": Key Phrase page
Key Phrase page for Communication Object: Books containing the phrase Communication Object
Distributed object communication - Wikipedia, the free encyclopedia
Distributed object communication realizes communication between distributed objects in the distributed computing environment. The main role is to interconnect objects residing in ...
InfCommunicationObject
inf_communication_object_enqueued () void inf_communication_object_enqueued (InfCommunicationObject *object ...
NCDB Selected Topics: Object Communication (see Communication, Object ...
DB-LINK is a federally-funded service that identifies, coordinates, and disseminates, at no cost, information related to children and youth from birth through 21 years of age.