Object-Oriented Programming

Child Class

A class that inherits the characteristics of a parent class.

Abstraction/Information Hiding

Abstraction, or "Information Hiding," is a term associated with Encapsulation. Through the process of Abstraction, a programmer hides all but the relevant data about and interaction with an object, in order to reduce complexity and increase efficiency, especially when improvements or modifications need to be made from time to time.

Composition

Composition, closely associated with, but different than Inheritance, is the process of combining simpler objects into more complex objects. For example, a Car class might include a BodyType object, an Engine object, and a TransmissionType object, and therefore is "composed of" all of these different types of classes.

Encapsulation

Encapsulation is one of the three central principles (along with Inheritance and Polymorphism) of Object Oriented Programming. Encapsulation incorporates related data items and processes into a class definition, including instance variables, constructors, accessor and modifier (mutator) methods.

Functional Programming

Functional programming, as opposed to imperative or procedural programming, is a pure functional approach to problem solving. Functional programming is a form of declarative programming. Languages that support this style of programming include Scheme, Haskell, LISP, Racket, and F#.

Imperative (Procedural) Programming

Imperative, or Procedural, programming is a paradigm in which a developer writes code that describes in exacting detail the steps that the computer must take to accomplish the goal. Most of the mainstream programming languages, such as C++, Java, and Python, support procedural programming

Inheritance

Inheritance is one of the three pillars of OOP (Object Oriented Programming), along with Abstraction and Polymorphism. Inheritance allows classes to be defined based on previously defined and developed classes, receiving all of the characteristics of the parent class, and then expanding on those features.

Object-Oriented Programming

Object-Oriented Programming (OOP) is a programming language model using objects that contain data as the main focus, with actions and processes directly associated with the data.

"Has-a" Relationship

The concept of Composition, in which one class is composed of multiple, simpler classes, can be described using the phrase "has-a". For example, when a Car object includes Body and Engine objects, the Car "has-a" Body and the Car "has-an" Engine.

"Is-a" Relationship

The concept of inheritance, in which one class is derived from another class, can be described as an "is-a" relationship. For example, when a Student class inherits a Person class, the Student "is a" Person.

Class

The definition of an object, describing the type of data owned by the object, as well as methods that act on that data.

Polymorphic Objects

This aspect of polymorphism refers to how a parent object can reference any of its child objects, or any descendant several levels of inheritance down the way.

Object

This is an instance of a Class created during program execution that encapsulates data and related actions or processes, often called methods.

Class

This is the definition of an Object, describing the type of data owned by the object, as well as methods that act on that data.

Overriding Methods

This polymorphic feature of object-oriented programming is when methods inherited from parent classes, such as the toString Java method from the Object class, are redefined and customized to better fit the more specialized purpose of the inheriting class.

Polymorphism

This term literally means in Greek, "many forms", and is a key aspect of object-oriented programming, where methods or processes belonging to an object's definition can be redefined (overridden) or replicated (overloaded) as needed, and where parent objects are able to reference child objects in various data structures.

Overloading Methods

This the polymorphic feature of object-oriented programming where constructors and methods are named the same but operate on different input parameter signatures in order to perform the same task.