Object oriented design

From Wikipedia, the free encyclopedia

Object Oriented Design is the concept that forces programmers to plan out their code in order to have a better flowing program. The origins of object oriented design is debated, but the first languages that supported included it were Simula and SmallTalk. The term did not become popular until Grady Booch wrote the first paper titled Object-Oriented Design, in 1982.

Object Oriented Design is defined as a programming language that has 5 conceptual tools to aid the programmer. These programs are often more readable than non-object oriented programs, and debugging becomes easier with locality.

1 Object Oriented Design
- 1.1 Language Concepts
- 1.2 Programming Concepts
2 Current Languages
3 External links

[edit] Object Oriented Design

[edit] Language Concepts

The 5 Basic Concepts of Object Oriented Design are the implementation level features that are built into the programming language. These features are often referred to by these common names:

Encapsulation: A tight coupling or association of data structures with the methods or functions that act on the data. This is called a class, or object (an object is often the implementation of a class).
Data Protection: The ability to protect some components of the object from external entities. This is realized by language keywords to enable a variable to be declared as private or protected to the owning class.
Inheritance: The ability for a class to extend or override functionality of another class. The so called child class has a whole section that is the parent class and then it has its own set of functions and data.
Interface: A definition of functions or methods, and their signatures that are available for use to manipulate a given instance of an object.
Polymorphism: The ability to define different functions or classes as having the same name but taking different data types.

[edit] Programming Concepts

There are several concepts that were derived from the new languages once they became popular. The new standards that came around pushed on three major things:

Re-usability: The ability to re-use code for multiple applications. If a programmer has already written a power function, then it should be written that any program can make a call to that function and it should work exactly the same.
Privacy: or data protection, this is important for large programs and preventing loss of data.
Documentation: The commenting of a program in mark up that will not be converted to machine code. This mark up can be as long as the programmer wants, and allows for comprehensive information to be passed on to new programmers. This is important for both the re-usability and the maintainability of programs.