Object (computer science)

In computer science, an object is any entity that can be manipulated by the commands of a programming language, such as a value, variable, function, or data structure. (With the later introduction of object-oriented programming the same word, "object", refers to a particular instance of a class)

Object-oriented programming

In the domain of object-oriented programming an object is usually taken to mean an ephemeral compilation of attributes (object elements) and behaviors (methods or subroutines) encapsulating an entity. In this way, while primitive or simple data types are still just single pieces of information, object-oriented objects are complex types that have multiple pieces of information and specific properties (or attributes). Instead of merely being assigned a value, (like int =10), objects have to be "constructed". In the real world, if a Ford Focus is an "object" - an instance of the car class, its physical properties and its function to drive would have been individually specified. Once the properties of the Ford Focus "object" had been specified into the form of the car class, it can be endlessly copied to create identical objects that look and function in just the same way. As an alternative example, animal is a superclass of primate and primate is a superclass of human. Individuals such as Joe Bloggs or John Doe would be particular examples or 'objects' of the human class, and consequently possess all the characteristics of the human class (and of the primate and animal superclasses as well).

"Objects" are the foundation of object-oriented programming, and are fundamental data types in object-oriented programming languages. These languages provide extensive syntactic and semantic support for object handling, including a hierarchical type system, special notation for declaring and calling methods, and facilities for hiding selected fields from client programmers. However, objects and object-oriented programming can be implemented in any language.

Objects are used in software development to implement abstract data structures, by bringing together the data components with the procedures that manipulate them. Objects in object-oriented programming are key in the concept of inheritance; thereby improving program reliability , simplification of software maintenance, the management of libraries, and the division of work in programmer teams. Object-oriented programming languages are generally designed to exploit and enforce these potential advantages of the object model. Objects can also make it possible to handle very disparate objects by the same piece of code, as long as they all have the proper method.

Properties of an Object

Three properties characterize objects:

1. Identity: the property of an object that distinguishes it from other objects
2. State: describes the data stored in the object
3. Behavior: describes the methods in the object's interface by which the object can be used

Mechanism

The modern concept of "object" and the object-oriented approach to programming were introduced by the Simula programming language originally released in 1967, popularized by Smalltalk released two years later in 1969, and became standard tools of the trade with the spread of C++ originally released in 1983.

In the "pure" object-oriented approach, the data fields of an object should only be accessed through its methods (subroutines). It is claimed that this rule makes it easy to guarantee that the data will always remain in a valid state. Syntactically, in almost all object-oriented programming languages, a dot(.) operator (placed between an object and its symbolic method name) is used to call a particular method/function of an object. For example, consider an arithmetic class named Arith_Class. This class contains functions like add(), subtract(), multiply() and divide(), that process results for two numbers given to them. This class could be used to find the product of 78 and 69 by first creating an object of the class and then invoking its multiply method, as follows:

 1  int result = 1 ;                        // Initialization
 2  arith_Obj1 = new Arith_Class();           // Creating a new object of Arith_Class
 3  result = arith_Obj1.multiply(78,69);      // returned value of multiply function, store in result variable.

In a language where each object is created from a class, an object is called an instance of that class. If each object has a type, two objects with the same class would have the same data type. Creating an instance of a class is sometimes referred to as instantiating the class.

A real-world example of an object would be "my dog", which is an instance of a type (a class) called "dog", which is a subclass of a class "animal". In the case of a polymorphic object, some details of its type can be selectively ignored, for example a "dog" object could be used by a function looking for an "animal". So could a "cat", because it too belongs to the class of "animal". While being accessed as an "animal", some member attributes of a "dog" or "cat" would remain unavailable, such as the "tail" attribute, because not all animals have tails.

A "ghost" is an object that is unreferenced in a program, and can thus serve no purpose. In a garbage-collected language, the garbage collector marks the memory occupied by the object as free, although it still holds the object's data until it is overwritten.

Specialized Objects

There are certain specialized objects which can be created by the kind of Design Pattern which is used for creating them and usually those objects are named after their design patterns themselves. Some terms for specialized kinds of objects include

• Singleton object: An object that is the only instance of its class during the lifetime of the program.
• Functor (function object): an object with a single method (in C++, this method would be the function operator, "operator()") that acts much like a function (like a C/C++ pointer to a function).
• Immutable object: an object set up with a fixed state at creation time and which does not vary afterward.
• First-class object: an object that can be used without restriction.
• Container: an object that can contain other objects.
• Factory object: an object whose purpose is to create other objects.
• Metaobject: an object from which other objects can be created (Compare with class, which is not necessarily an object)
• Prototype: a specialized metaobject from which other objects can be created by copying
• God object: an object that knows too much or does too much. The God object is an example of an anti-pattern.
• Filter object

Objects in distributed computing

The definition of an object as an entity that has a distinct identity, state, and behavior, and, it is claimed, the principle of encapsulation, can be carried over to the realm of distributed computing. Paradoxically, encapsulation does not extend to an object's behavior since they (or even their method names) are not serialized along with the data. A number of extensions to the basic concept of an object have been proposed that share these common characteristics:

• Distributed objects are "ordinary" objects (objects in the usual sense - i.e. not OOP objects) that have been deployed at a number of distinct remote locations, and communicate by exchanging messages over the network. Examples include web services and DCOM objects.
• Protocol objects are components of a protocol stack that encapsulate network communication within an object-oriented interface.
• Replicated objects are groups of distributed objects (called replicas) that run a distributed multi-party protocol to achieve a high degree of consistency between their internal states, and that respond to requests in a coordinated manner. Referring to the group of replicas jointly as an object reflects the fact that interacting with any of them exposes the same externally visible state and behavior. Examples include fault-tolerant CORBA objects.
• Live distributed objects (or simply live objects) generalize the replicated object concept to groups of replicas that might internally use any distributed protocol, perhaps resulting in only a weak consistency between their local states.

Some of these extensions, such as distributed objects and protocol objects, are domain-specific terms for special types of "ordinary" objects used in a certain context (such as remote invocation or protocol composition). Others, such as replicated objects and live distributed objects, are more non-standard, in that they abandon the assumption that an object resides in a single location at a time, and apply the concept to groups of entities (replicas) that might span across multiple locations, might have only weakly consistent state, and whose membership might dynamically change.

Objects and the Semantic Web

It is claimed that the Semantic Web can be seen as a distributed data objects framework, and can therefore be validly seen as an object-oriented framework. However, a distributed object is regarded as an "ordinary" object, and not an OOP object because it is separated from its methods with which it was previously encapsulated. It is also claimed that it is valid to use a UML diagram to express a Semantic Web graph.

Both the Semantic Web and object-oriented programming have:

• Classes
• Attributes (also known as Relationships)
• Instances

Furthering this, Linked Data also introduces Dereferenceable Uniform Resource Identifiers, which provide data-by-reference which is found in object-oriented programming and object-oriented databases in the form of object identifiers.

See also

• Object lifetime
• Object copy
• Design pattern (computer science)
• Business object (computer science)
• Actor model

External links

• What Is an Object? from The Java Tutorials