Object Technology

Object Technology did not spring full blown from one person's mind. It is a collaboration of ideas that were developed over decades, so the terms may not always be consistent among implementations. Please tell us if you believe a definition is not correct or is incomplete.

Behavior

The behavior of an object is how it acts and reacts to messages sent to it by other objects. Behavior is typically implemented within an object as methods that are defined in its class. "Behavior is how an object acts and reacts, in terms of its state changes and message passing; the outwardly visible and testable activity of an object" 1
Class

A class is a general specification or description for a set of objects that defines their common structure (data), behavior(methods), and relationships.
Component

A unit of code that provides a set of services through well-defined interfaces and is specifically designed and packaged to be reusable. A component acts like a "black box" that hides or encapsulates the details of how the services are actually implemented. Components can be mixed and matched to form larger systems. "For most of the industry, components are synonymous with encapsulated binary objects, most notably Java Beans and ActiveX controls. Support for inheritance andpolymorphism is not critical for the definition of components." 5
Event

"Some occurrance that may cause the state of an object to change." 1

Identity

A property of an object that distinguishes the object from all others.

Inheritance

Inheritance is a relationship between classes where one class is a parent of another. It implements "is-a" relationships between objects. Inheritance takes advantage of the commonality among objects to reduce complexity.
Instance

See Object.
Instantiation

Creating an object from a class definition.

Interface

"An interface is a collection of operations that specify a service of a class or component. An interface therefore describes the externally visable behavior of that element. An interface might represent the complete behavior of a class or component or only a part of that behavior". 7
JavaBeans

JavaBeans is the component architecture for the Java programming language. "A Java Bean is a reusable software component that can be manipulated visually in a builder tool." ... "Individual Java Beans will vary in the functionality they support, but the typical unifying features that distinguish a Java Bean are:

Support for "introspection" so that a builder tool can analyze how a bean works

Support for "customization" so that when using an application builder a user can customize the appearance and behaviorof a bean. Support for "events" as a simple communication metaphor that can be used to connect up beans. Support for "properties", both for customization and for programmatic use. Support for "persistence", so that a bean can be customized in an application builder and then have its customized statesaved away and reloaded later." 2

Message

"An operation that one object performs on another." 1

Methods

"A class's methods typically contain the code that understands and manipulates an object's state. Some classes have public fields for programmers to manipulate directly, but in most cases this isn't a very good idea." 6 Methods implement an objects's outward behavior.
Object

An object is an abstraction or simulation of physical things such as people and machines or intangible things such as events and processes that captures their characteristics and behavior. Objects and classes are the basic building blocks for object-oriented software design. "Something you can do things to. An object has state, behavior, and identity; the structure and behavior of similar objects are defined in their common class." 1
Persistence

Persistence allows the state of an object to be saved to non-volatile storage such as a file or database and later restored even though the original creator of the object no longer exists.
Property

A Property is a named characteristic or attribute of an object.

Polymorphism

"A concept in type theory, according to which a name (such as a variable declaration) may denote objects of many differentclasses that are related by some common superclass; thus, any object denoted by this name is able to respond to some common set of operations in different ways." 1 Method overloading is also considered by some to be a form of polymorphism.
State

"The state of an object represents the cumulative results of its behavior." 1 It is the sum of an object's property values at an instance in time.
Structure

"The concrete representation of the state of an object. An object does not share its state with any other object, although all objects of the same class do share the same representation of their state." 1
Unified Modeling Language (UML)

The Unified Modeling Language is a graphical notation for describing object-oriented designs. It has been adopted as a standard by the Open Management Group with wide industry support. "The Unified Modeling Language (UML) is a language for specifying, visualizing, constructing, and documenting the artifacts of software systems, as well as for business modeling and other non-software systems." 4

Object-Oriented Analysis and Design (OOAD) is a relatively new methodology compared to Model Driven Design or Rapid Application Development. In other methodologies purposely separate dataconcerns and process concerns. OOAD techniques are an attempt to eliminate the separation of concerns between data and processes. In the attempt of merging the data and process concerns into a single object, OOAD introduce object diagrams that document a system in terms of its objects and interactions.

The purpose of the new, object-oriented analysis and design technique are to: 1. 2. Study existing objects to see if they can be reused or adapted for new uses Define new or modified objects that will be combined with existing objects into a useful business computing application.

This new format saves everyone a lot of time, but is typically used in a hybrid approach. With the new technology and new design aspects, converting of old systems is not always black and white or straight forward, the conversion of data, documents, and upgrade in knowledge has prevented this model from replacing more traditional methodologies.

Object-oriented analysis and design

From Wikipedia, the free encyclopedia
Wikiversity has learning materials about Object Oriented Software Design

Object-oriented analysis and design (OOAD) is a software engineering approach that models a system as a group of interacting objects. Each object represents some entity of interest in the system being modeled, and is characterised by its class, its state (data elements), and its behavior. Various models can be created to show the static structure, dynamic behavior, and run-time deployment of these collaborating objects. There are a number of different notations for representing these models, such as the Unified Modeling Language (UML). Object-oriented analysis (OOA) applies object-modeling techniques to analyze the functional requirements for a system. Object-oriented design (OOD) elaborates the analysis models to produce implementation specifications. OOA focuses on what the system does, OOD onhow the system does it.
Contents
[hide]

1 Object-oriented systems 2 Object-oriented analysis 3 Object-oriented design 4 Literature 5 See also 6 References 7 External links

[edit]Object-oriented

systems

An object-oriented system is composed of objects. The behavior of the system results from the collaboration of those objects. Collaboration between objects involves them sending messages to each other. Sending a message differs from calling a function in that when a target object receives a message, it decides on its own

what function to carry out to service that message. The same message may be implemented by many different functions, the one selected depending on the state of the target object. The implementation of "message sending" varies depending on the architecture of the system being modeled, and the location of the objects being communicated with.
[edit]Object-oriented

analysis

Object-oriented analysis (OOA) is the process of analyzing a task (also known as a problem domain), to develop a conceptual model that can then be used to complete the task. A typical OOA model would describe computer software that could be used to satisfy a set of customer-defined requirements. During the analysis phase of problem-solving, a programmer might consider a written requirements statement, a formal vision document, or interviews with stakeholders or other interested parties. The task to be addressed might be divided into several subtasks (or domains), each representing a different business, technological, or other areas of interest. Each subtask would be analyzed separately. Implementation constraints, (e.g., concurrency, distribution, persistence, or how the system is to be built) are not considered during the analysis phase; rather, they are addressed during object-oriented design (OOD). The conceptual model that results from OOA will typically consist of a set of use cases, one or more UML class diagrams, and a number ofinteraction diagrams. It may also include some kind of user interface mock-up.
[edit]Object-oriented

design

Main article: Object oriented design During object-oriented design (OOD), a developer applies implementation constraints to the conceptual model produced in object-oriented analysis. Such constraints could include not only constraints imposed by the chosen architecture but also any non-functional technological or environmental constraints, such as transaction throughput, response time, run-time platform, development environment, or those inherent in the programming language. Concepts in the analysis model are mapped onto implementation classes and interfaces resulting in a model of the solution domain, i.e., a detailed description of how the system is to be built.

OOPS Technical Terms

Abstract class

In programming languages, an abstract type is a type in a nominative type system which cannot be instantiated. (However, it may have concrete subtypes that do have instances.) An abstract type may have no implementation, or an incomplete implementation. It may include abstract methods or abstract properties that are shared by its subtypes.
Accessibility Abstract method Abstraction (computer science) Access control Accessor method Allocated class Aspect-oriented armstrong number

Bridge pattern Builder pattern Base class

Cascaded message Cast Chain-of-responsibility pattern Class Class hierarchy Class method Class object Cohesion Collaborator Collection class Composition

Constructor Container (data structure) Contravariance Copy constructor Coupling Covariance

Data-driven design Data hiding Default constructor Deep copy Delegation Dependency injection Destructor Dispatch table Dynamic binding (computer science) (also called Late Binding) Dynamic class Dynamic dispatch Dynamic variable Dynamically typed language

Early binding Encapsulation (computer science) European Conference on Object-Oriented Programming Exception handling

Facade - pattern Factory method pattern Factory object Factory pattern Finalizer First-class function Fragile base class Function composition

fibonacci series

Generic Programming

Heap-based memory allocation Hybrid language

Immutable object (also called immutable value) Information hiding Inheritance (computer science) Initialize Inline function Inner class Instance Instance method Instance variable (also called data member) Interaction diagram Interface (computer science) Inversion of control Iterator

Late binding Liskov substitution principle

Member accessibility Members, any contents of a class: Attributes, Methods andInner classes Message passing Message selector (also called method selector) Metaclass Metaprogramming Method designator Method lookup Mixin Mock object Modelviewcontroller

Modular programming Multiple dispatch Multiple inheritance Multitier architecture Mutable variable Mutator method

Name mangling Namespace Native method Nested class

Object (computer science) Object hierarchy Object type OOPSLA annual conference on Object-Oriented Programming Systems Language and Application Open/closed principle Orthogonality Overload

package Parametric overloading Parameterized classes Parnas's principles Partial class Patterns Persistent object Policy-based design Polymorphic Primitive data type private, a way of encapsulation in object-oriented programming Programming paradigm protected, a way of encapsulation in object-oriented programming Protocol

Prototype pattern Prototype-based programming Pseudo-variable public, a way of encapsulation in object-oriented programming Pure polymorphism Pure virtual function (also called pure virtual method)

Rapid prototyping (rapid application development) Recursion Reference variable Refinement Reflection Responsibility-driven design Reverse polymorphism Run-time type information

Scope Shadowed name Shallow copy, as opposed to deep copy Single Responsibility Principle Single-assignment variable Singleton pattern Singly rooted hierarchy Slicing Specification class, a class implementing abstract class Stack-based memory allocation Static method Statically typed language, as opposed to Dynamically typed language Strongly-typed programming language Subclass (also called child class or derived class) Subclass coupling SOLID Substitutability, principle of Subtype


Superclass (also called parent class or base class)

Tiers Template method pattern Trait Type Type conversion (also called typecasting)

Verb: to program to (see discussion) Virtual class Virtual function (also called virtual method) Virtual function pointer (also called virtual method pointer) Virtual inheritance (Object Oriented Programming) Virtual method table (also called vtable, virtual function table or virtual method table)

Weak reference

Yo-yo problem