Object-oriented programming: Difference between revisions

From Citizendium
Jump to navigation Jump to search
imported>Eric Evers
mNo edit summary
imported>Eric Evers
mNo edit summary
Line 3: Line 3:
==Overview==
==Overview==


Object oriented programming is a technique to organize data and functions in a computer program. Specifically, data structures called objects are instantiated(created) from templates called classes. Attributes(member variables) and methods(member functions) are hidden inside of objects. Sometimes the attributes and methods are private and available only inside a class. Othertimes some attributes and methods are public and available to other classes or objects. OOP(object oriented programming)
Object oriented programming is a technique to organize data and functions in a computer program. Specifically, data structures called objects are instantiated(created) from templates called classes. Attributes(member variables) and methods(member functions) are hidden inside of objects. Sometimes the attributes and methods are private and available only inside a class. Othertimes some attributes and methods are public and available to other classes or objects. OOP(object oriented programming) was inspired by the branch mathematics called [[category theory]].  
is was inspired by the branch mathematics called [[category theory]].  


==Object oriented programming languages==
==Object oriented programming languages==

Revision as of 10:39, 8 November 2008

Object oriented programming

Overview

Object oriented programming is a technique to organize data and functions in a computer program. Specifically, data structures called objects are instantiated(created) from templates called classes. Attributes(member variables) and methods(member functions) are hidden inside of objects. Sometimes the attributes and methods are private and available only inside a class. Othertimes some attributes and methods are public and available to other classes or objects. OOP(object oriented programming) was inspired by the branch mathematics called category theory.

Object oriented programming languages

Some programming languages have object oriented structures build into them. Many languages can create object structures from scratch if needed. C++ has objects built in to it. One can program using objects with pure C, but only if you build your own objects from scratch. Some languages are pure object languages and strictly require that all code be an OOP(object oriented program).

Strict OOP languages include

Java, C#, Ruby and Eiffel

Some languages have OOP as an option and are not strict.

python, perl and C++

Geos was an object oriented OS written in assembler from stratch.

Inheritance

Child classes inherit attributes and methods from their parent classes. Some languages only allow one parent, these languages are single inheritance languages. This compares to others that are multiple inheritance languages.

Single inheritance languages

java, C#

Multiple inheritance languages

C++, python, Ruby, perl, Eiffel

Class inheritance is often described with a Class Diagram.

Example Class Diagram
+------------+
| Object     |    class name
+------------+
| id         |    attributes (variables)
+------------+
| get_id     |    methods (member functions)
| set_id     |
+------------+
    / \
     |   implements
     |
+-----------------------+
| Part                  |    class name
+-----------------------+
| container_obj = earth |    attributes
+-----------------------+
| get_container_obj     |    methods
| set_container_obj     |
+-----------------------+
    / \
     |   implements
     |
+------------+
| Container  |    class name
+------------+
| parts = [] |    attributes
+------------+
| get_parts  |    methods
| set_parts  | 
+------------+

In many lanugages, class names are capitalized, and attributes and methods are lowercase (java for example) In this class diagram, each container is a part, and each part is an object. Because of inheritance, each container class will include a container_obj attribute and an id number attribute inherited from their ancestors.

Typically, the parts attribute would need to be a list or an array. The length of the list of parts would start as empty. The arrow edges connecting children to parents are sometimes labeled with: implements. Arrows in diagrams point in the direction of dependency. The class Object is the parent of the class Part, and class Part is the parent of class Container.

Default values for attributes

Often attributes start with some default value. This is very handy because default values can help one to start programming very complex system quickly. This a the just-add-water idea of OOPS. In the diagram we see that the container_obj = earth, as a default value. The default value for parts = [], is an empty list. Consider the creation of an instance of window. The window can have many complicated attributes precreated such as scroll bars, default title text, edit icons and default menus for example. These can be ignored or modified as needs be. Default values for attributes can make learning and using OOPS superier to other programming design methods when used well.

Static variables

Static variables are variables that live at the class level. They are shared by all instances of a class. They can be used to help count and coordinate instances of a class. If varS is a static variable then each instance(instance1,instance2) does not get its own copy of varS, but shares the one copy of varS that lives in the generating Class. For example, each time an instance is created, varS could be incremented. Thereby keeping a count of the instances in existence at any one time.

+--------------------+
| Account            |    class name
+--------------------+
| varS               |
+--------------------+
+--------------------+
      /|\         /|\
       |           |
       |           |
 /----------\   /----------\
| instance_1 | | instance_2 |
 \----------/   \----------/

Static methods

Static methods are functions that live at the class level. They should only use static variables because they do not know about instance variables.

Overriding

When a child class uses a method with the same name as parent's method. Both functions should have the same signature.

+--------------+
| Boat         |    class name
+--------------+
+--------------+
| move()->go() |    methods
+--------------+
     / \
      |
      |
+---------------+
| Rowboat       |    class name
+---------------+
+---------------+
| move()->row() |    methods
+---------------+

Overloading

When a class uses more than one method with the same name, but with a different signature, that method is overloaded.

+---------------+
| Computer      |    class name
+---------------+
+---------------+
| sqrt({3,i})   | 
| sqrt( A )     |
+---------------+

Definition of signature:

A signature has two main parts and two optional parts.

* name of the function
* the number of arguments         (perl can ignore the number of arguments)

Optional parts (some languages require these in a signature, some do not)

* the types of the arguments      (perl can ignore argument type)
* the return type of the function (perl can ignore return type)