Object-oriented programming

programming paradigm based on the concept of objects

concept of computer science; point of interaction between two things

in programming languages and type theory, accessing different types using a common interface

concept in object-oriented programming

software that supports solution development via inversion of control

language mechanism in programming languages that allows external code not to care about the internal workings of an object

technique for arranging complexity of computer systems

In object-oriented programming, SOLID is a mnemonic acronym for five principles intended to make source code more understandable, flexible, and maintainable. Although the principles apply to object-oriented programming, they can also form a core philosophy for methodologies such as agile software development and adaptive software development.

standard to facilitate communication between systems on diverse platforms

database management system

style of dynamic, structural typing with lazy checking of objects' attributes

Application Binary Interface by Microsoft

software class, data structure, or abstract data type (ADT) whose instances are collections of other objects

style of object-oriented programming

purely abstract class in object-oriented programming

in programming, the degree of interdependence between software modules

a computer-programming principle that states that software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification

inheritable and overridable function or method for which dynamic dispatch is facilitated

object-oriented programming principle stating that, in a computer program, if S is a subtype of T, then objects of type T may be replaced with objects of type S without altering any of the desirable properties of the program (correctness, etc.)

branch of software engineering

programming idiom for resource management that ties access to a resource to an object's lifetime

technical approach for analyzing and designing an application, system, or business

guideline for object-oriented programming: each unit should have only limited knowledge about other units (only those closely related to the current unit)

Modelica is an object-oriented, declarative, multi-domain modeling language for component-oriented modeling of complex systems, e.g., systems containing mechanical, electrical, electronic, hydraulic, thermal, control, electric power or process-oriented subcomponents. The free Modelica language is developed by the non-profit Modelica Association. The Modelica Association also develops the free Modelica Standard Library that contains about 1400 generic model components and 1200 functions in various domains, as of version 4.0.0.

software design paradigm

states that no client should be forced to depend on methods it does not use

class member variable with a single value across all instances

In object-oriented programming languages, a mixin (or mix-in) is a class that contains methods for use by other classes without having to be the parent class of those other classes. How those other classes gain access to the mixin's methods depends on the language. Mixins are sometimes described as being "included" rather than "inherited".

facility for object-oriented programming which is part of ANSI Common Lisp

type of class member in object-oriented programming which is accessed like a field but implemented as subroutine(s)

principle of segregation of the design decisions in a computer program that are most likely to change, thus protecting other parts of the program from extensive modification if the design decision is changed

class member variable with separate per-instance values

relationship between a generic type or a function and a component type on subtyping

approach to software design

object-oriented programming paradigm that distinguishes classes from instances

C++ template library for Win32 development

In programming language theory, subtyping (also called subtype polymorphism or inclusion polymorphism) is a form of type polymorphism. A subtype is a datatype that is related to another datatype (the supertype) by some notion of substitutability, meaning that program elements (typically subroutines or functions), written to operate on elements of the supertype, can also operate on elements of the subtype.

evaluating a member (property or method) of one object (the receiver) in the context of another

modeling and simulation environment for cyber-physical systems

technique in which a computer program extends or modifies supporting system software locally, affecting only the running instance of the program

language for software modeling and designing

DataFlex is an object-oriented high-level programming language and a fourth generation visual tool for developing Windows, web and mobile software applications on one framework-based platform. It was introduced and developed by Data Access Corporation beginning in 1982.

software design pattern

Object-Oriented Programming, Systems, Languages & Applications (OOPSLA) is an annual ACM research conference. OOPSLA mainly takes place in the United States, while the sister conference of OOPSLA, ECOOP, is typically held in Europe. It is operated by the Special Interest Group for Programming Languages (SIGPLAN) group of the Association for Computing Machinery (ACM).

layer of a computer program which provides simplified access to data stored in persistent storage of some kind, such as an entity-relational database

capability of some object-oriented programming languages to examine the type or properties of an object at runtime

programming keyword or special variable that refers to the object or class the currently running code belongs to

principle that every method should either be a command that performs an action, or a query that returns data to the caller, but not both; asking a question should not change the answer

the properties of objects in general in a particular system, or the object-oriented interface through which a program can examine and manipulate

developed by Grady Booch

design pattern in object-oriented programming

model element of Unified Modeling Language (UML)

In database design, object-oriented programming and design, has-a (has_a or has a) is a composition relationship where one object (often called the constituted object, or part/constituent/member object) "belongs to" (is part or member of) another object (called the composite type), and behaves according to the rules of ownership. In simple words, has-a relationship in an object is called a member field of an object. Multiple has-a relationships will combine to form a possessive hierarchy.

In knowledge representation, ontology components and ontology engineering, including for object-oriented programming and design, is-a (also written as is_a or is a) is a subsumptive relationship between abstractions (e.g., types, classes), wherein one class A is a subclass of another class B (and so B is a superclass of A). In other words, type A is a subtype of type B when A's specification implies B's specification. That is, any object (or class) that satisfies A's specification also satisfies B's specification, because B's specification is weaker.

OpenModelica is a free and open source environment based on the Modelica modeling language for modeling, simulating, optimizing and analyzing complex dynamic systems. This software is actively developed by Open Source Modelica Consortium, a non-profit, non-governmental organization. The Open Source Modelica Consortium is run as a project of RISE SICS East AB in collaboration with Linköping University.

inter-process communication mechanism developed by Microsoft

component model used in OpenOffice.org and derivatives

computing device or component designed to receive signals from other components

In the computer programming of applications on Microsoft Windows through the Windows API, the IUnknown interface is the fundamental interface of Component Object Model (COM). The COM specification mandates that COM objects must implement this interface. Furthermore, every other COM interface must be derived from IUnknown. IUnknown exposes two essential features of all COM objects: object lifetime management through reference counting, and access to object functionality through other interfaces. As well as being a foundational part of Microsoft's COM and DCOM models of objects, there are implem

overloadable collection indexing operator