Object-Oriented Design Glossary (University of Alberta)

Generalization

A design principle that helps reduce the amount of redundancy when solving problems, by taking repeated, common, or shared characteristics between two or more classes, and factoring them out into another class, so that code can be reused and characteristics can be inherited by subclasses.

Abstraction

A design principle that suggests that a concept in the problem domain should be simplified down to its essentials within some context.

Multiple inheritance

A form of inheritance that occurs when a subclass has two or more superclasses. Java doesn't support multiple inheritance.

Coupling

Design complexity that occurs between a module and other modules.

Cohesion

Design complexity that occurs within a module. It represents the clarity of the responsibilities of a module.

Override

Occurs when a subclass can provide its own implementation for an inherited superclass's method. The subclass's methods override the superclass's.

Abstraction barrier

A barrier achieved through encapsulation, which allows the internal workings of a class to be hidden from the outside world when it is not relevant. It reduces complexity for users of a class.

General idea

A class or broad term used to describe a large grouping of more distinct classes.

Explicit constructor

A constructor in Java that indicated that values can be assigned to attributes during instantiation.

Implicit constructor

A constructor in Java that occurs when a constructor has not been written. All attributes are assigned zero or null when using the default constructor.

Abstract data type

A data type that is defined by the programmer and not built into the language. It is a grouping of related information that is denoted with a type that allows data to be organized in a meaningful way.

Encapsulation

A fundamental design principle in object-oriented modelling and programming. Encapsulation involves three ideas. It bundles attribute values and behaviours that manipulate those values into a self-contained object. It also exposes certain data and functions of the object to other objects, or alternately restricts access to certain data and function to only within that object.

Extends

A keyword in Java that indicated inheritance

Implements

A keyword in Java that indicates a declaration that the contract is going to be fulfilled as described in the interface.

Abstract

A keyword used in Java to indicate that a class cannot be instantiated.

Implementation inheritance

A kind of inheritance that suggests that a superclass can have multiple subclasses, but that a subclass can only inherit from one superclass. This kind of single implementation is the only one allowed in Java.

Black box

A kind of thinking associated with encapsulation. In black box thinking, a class acts like a "black box" that you cannot see inside for details about how attributes are represented or how methods compute their result. What happens in the box does not matter to achieving expected behaviours. When a method is called, inputs and outputs may be obtained, even if the inner workings of the box are hidden.

Decomposition

A major design principle of object-oriented modelling and programming. It takes a whole thing and divides it up into different parts. It could also take separate parts with different functionalities, and combine them together to form a whole.

Namespace

A namespace is a package that classes can be organized and represented by.

Imperative paradigm

A paradigm that broke up large programs into smaller programs, called subroutines. This paradigm made use of global data.

Modelling Phase

A phase in model checking, where the model description is entered, sanity checks are performed, and desired properties are described. This would be provided in whatever programming language your system uses.

Analysis Phase

A phase in model checking, where you check if all the desired properties are satisfied, and if any are violated.

COBOL

A popular programming language from the 1960s, that follows an imperative paradigm.

Fortran

A popular programming language from the 1960s, that follows an imperative paradigm.

Liskov substitution principle

A principle that states that a subclass can replace a superclass, if and only if the subclass does not change the functionality of the superclass.

Module

A program unit that includes classes and the methods within them.

Algol 68

A programming language from the 1970s that supports the notion of an abstract data type.

Pascal

A programming language from the 1970s that supports the notion of an abstract data type.

Modula-2

A programming language from the mid-1970s that provided a means to organize problems and allowed developers to create multiple, but unique, copies of their abstract data types more easily

C

A programming language from the mid-1970s, that provided a means to organize problems and allowed developers to create multiple, but unique, copies of their abstract data types more easily.

Design patterns

A reusable solution to a problem identified in software design.

"Don't Repeat Yourself" rule (D.R.Y. rule)

A rule related to the design principle of generalization. D.R.Y. suggests that we should write programs that are capable of performing the same tasks but with less code. Code should be reused because different classes or methods can share the same blocks of code. D.R.Y. helps make systems easier to maintain.

Properties

A section of UML class diagrams where attributes of the abstraction are defined. This is equivalent to Java's member variables.

Operations

A section of UML class diagrams, where behaviours of the abstraction are defined. This is equivalent to methods in a Java class.

Header file

A separate file in C, that declares what can be accessed in other files. In C, each file contains all associated data and functions that manipulate that data.

Deadlock

A situation when the system cannot continue because two tasks are waiting for the same resource.

Model checking

A systematic check of a system's state model in all its possible states

Object-oriented analysis

A type of analysis that identifies key objects in a conceptual design problem.

Entity object

A type of object, often identified in the problem space, that represent items used in the application.

Boundary objects

A type of object, usually introduced in the solution space of a software problem that connect to services outside of the system.

Control objects

A type of object, usually introduced in the solution space of a software problem, that receives events and coordinates actions.

Aggregation

A type of relationship of the design principle of aggregation. Aggregation indicates a "has-a" relationship, where a whole has parts that belong to it. Parts might be shared among wholes in this relationship.

Association

A type of relationship of the design principle of decomposition. Association indicates that there is a loose relationship between two objects. This means that objects may interact with each over for a time.

Composition

A type of relationship of the design principle of decomposition. Composition is an exclusive containment of parts, otherwise known as a strong has-a relationship. In a composition relationship, a whole cannot exist without its parts, and if a whole is destroyed, then the parts are destroyed too.

Programming Paradigms

A typical pattern or example of the thought-process or theory underlying programming languages and coding within a specific time frame.

Boolean value

A value that is either true or false.

Concern

A very general notion. Could include anything that matters in providing a solution to a problem.

Counterexamples

A violation of a desired property, as discovered during the analysis phase of model checking.

Models

A visual representation of a software design.

Class, responsibility, collaborator (CRC) cards

A visual technique for recording, organizing, and refining components in software design at a high level during conceptual design. CRC uses small cards indicating class, responsibilities, and collaborations of components in software.

Inheritance

According to the principle of generalization, repeated, common, or shared characteristics between two or more classes are taken and factored into another class. Subclasses can then inherit the attributes and behaviours of this generalized or parent class.

Activities

Actions that are performed when in a certain state.

Do activities

Actions that occur once, or multiple times while the object is in a certain state.

Exit activities

Actions that occur when the state is exited and moves on to another state.

Entry activities

Actions that occur when the state is just entered from another state.

Information hiding

Allows modules in a system to give others the minimum amount of information needed to use them correctly and "hide" everything else. This allows modules to be worked on separately.

Class

An abstract concept that unifies a component together. For example, a component might be a dog. The dog would be part of a dog class.

Public

An access modifier and level in Java that indicates that an attribute or method can be accessed by any other class in the system. The implementation of the behaviour for the method cannot be changed by other classes at this level, although attributes can be retrieved and modified by other classes.

Protected

An access modifier and level in Java. A protected attribute or method is one that can only be accessed by the encapsulating class itself, all subclasses, and all classes within the same package.

Default

An access modifier and level in Java. Also known as the no modifier access, as it does not need to be explicitly declared. Attributes and methods with no modifier will only allow access to subclasses and to the encapsulating class.

Private

An access modifier and level in Java. Private attributes and methods are not accessible by any class other than by the encapsulating class itself.

Local variables

An idea where subroutines or procedures could contain nested procedures, allowing each to have their own variables.

Access modifiers

Change that classes are able to access attributes and behaviours.

Abstract classes

Classes that cannot be instantiated.

Components

Components correspond to objects or concepts of a software that must work together for the software to work.

Collaborators

Components that work or interact with another identified component in software design, in order to fulfill its responsibilities.

Concept

Concepts may include instances of people, places, or things, often grouped as a distinct object in software design.

Connections

Connections indicate how different components of a software design relate to each other.

Global data

Data that is located all in one place in the computer's memory for a program.

Ease

How obvious the connections are between a module and other modules in a system.

Polymorphism

In object-oriented languages, polymorphism is when two classes have the same description of a behaviour, but the implementation of the behaviour may be different.

Flexibility

Indicates how interchangeable other modules are for a specific module. The more replaceable, the better the design.

Interface inheritance

Interfaces cannot be instantiated, but can be used as reference type for the object of an implementing class, and can be extended by another interface. This is known as interface inheritance.

Object-oriented modelling

Involves the practice of representing key concepts through objects in the software.

Maintainable

Maintainability refers to the ease of modifying a software system or component in order to correct or improve faults, performance, or other attributes, or the ability to adapt to a changed environment.

Methods

Methods manipulate the attribute values or data in an object of a class, in order to achieve the actual behaviours.

Loosely coupled

Occurs if a module finds it easy to connect to other modules. Considered a characteristic of good design.

High cohesion

Occurs if a module performs one task and nothing else, or if it has a clear purpose. This is considered a characteristic of good design.

Low cohesion

Occurs if a module tries to encapsulate more than one purpose, or if it has an unclear purpose. This characteristic is considered bad design.

Parts

Portions or fragments with different functionalities that can be combined together to form a whole thing. Related to decomposition.

Conceptual mock-ups

Provide a visual expression of initial thoughts for how requirements will be satisfied in a software product.

Flexible

Software flexibility refers to the ability for the solution to adapt to possible or future changes in its requirements

Code reviews

Systematic examinations of written code, similar to peer review in writing.

Design

The activity of planning out a software solution, including evaluating different alternatives.

Data integrity

The assurance that the attribute values of an object have been changed in an appropriate manner by an approved party.

Data

The attribute values of an object.

Context

The background or framework surrounding a problem. For example, the problem of creating an app could be within a gaming context.

Functions

The behaviours that manipulate attribute values within an object.

Attributes

The characteristics of an object. Basic attributes are ones that do not disappear over time, although their values may change.

Conceptual integrity

The concept of creating consistent software. Conceptual integrity requires making decisions about how a system will be designed and implemented so it seems as if only a single mind guided all the work.

Instantiated

The creation of an instance of an object.

Package

The means by which Java organizes related classes into a single namespace.

Object-oriented design

The method revolving around perceiving concepts as objects, which requires programmers to plan out their code to have better software that is flexible, reusable, and maintainable. It involves refining the details of objects, including attributes and behaviours.

Class name

The name provided to a class of objects in design.

Degree

The number of connections between a module and other modules in a system.

Interface

The point where two objects meet and interact. Interfaces are created through encapsulation, when certain methods are exposed and made accessible to objects of other classes. Interfaces are not classes, but are used to describe behaviours. Can also indicate a keyword in Java, that indicates an interface is being created.

Implementation

The process of putting a method or event into effect.

Behaviours

The responsibilities that an abstraction does for its purpose.

Conceptual design

The stage of software design, where broad-level concepts are planned out, often with the help of conceptual mock-ups. The conceptual design helps establish what the major components, connections, and associated responsibilities are for the software solution.

Data ambiguity

When inheritance occurs from two or more superclasses, and the inherited attributes inherited have the same name or the inherited behaviours have the same method signatures, and it is impossible to tell between them.