ABSTRACTION: (1) Modeling real world entities or concepts in terms of software constructs.
(2) Making program design reflect how human beings think of a problem (as in OOP) rather than how a computer handles it internally (as in Assembly Language). ABSTRACT DATA TYPE (ADT): A programmer-defined data type; in C++, a structure or class; in Java and other fully-OOP languages, a class.

EXTENSIBILITY: The capability offered by a language to create abstract data types that “extend” the language's built-in features.

OBJECT-ORIENTED PROGRAMMING (OOP): Designing and organizing programs as a collection of units called objects (see below) that interact with the program and with each other.

OBJECT: A self-contained programming unit that represents an entity or concept which is part of the problem to be solved. Here, “entity or concept” can mean: a person (client, employee, student, etc.); a physical object (car, elevator, room); a computer hardware/software device (printer, menu, text box); an abstract convention (bank account, date, schedule), etc. This programming unit contains both the properties (or attributes) of the object (color, height, age) and its behaviors (its functionality; e.g., move, register, withdraw money, etc.). The properties are represented by variables (called data members, fields, etc.), and the behaviors by methods (aka member functions).

CLASS: The definition or “blueprint” of a type of object; or, more technically, an abstract data type that defines a certain kind of object that we want to use in a program. An individual object is a single instance of a class “come to life”, just as a variable is a single instance of a primitive data type.

ENCAPSULATION: (1) “Wrapping up” the properties and behaviors of a class into a single, self-contained unit – this is the fundamental organizing principle of OOP which distinguishes it from the traditional top-down procedural paradigm. (2) The strategy of gathering together and hiding the internal workings of the class from the "outside world", making it a "black box" (see implementation hiding below). INSTANTIATION: Creating a “concrete” instance (i.e., an object) of a class; e.g., declaring a student object of a Student class to represent a single student (an instance of the class).

METHOD: A function that is part of a class (i.e., a member function), representing a behavior of that type of object or a service that it provides.

STATE: The current values (or settings) of an object's properties.

IMPLEMENTATION vs. INTERFACE -- IMPLEMENTATION HIDING: When a class is created, its “internal workings” are kept hidden from the client programmers. The client programmer is only aware of the methods that he/she can call to utilize the class, and does not have to worry about and cannot tamper with its inner workings or data directly. The inner workings are known as the implementation; the methods that can be called are the interface. Think of a television set – the user interacts with it through a panel of buttons (the "interface") without touching or understanding the wires and chips, etc. behind it (the "implementation"). This helps keep programs error-free, allows for modifications to the implementation without affecting the interface, and simplifies usage for the client-programmer. SENDING A MESSAGE: Having the program or an object call a method of another object, requesting it to perform some task. Since the inner workings of a class are hidden from the outside world, this is how different parts of the program interact.

CONSTRUCTOR: A special method that is implicitly called whenever a new object is instantiated. Its main purpose is to initialize the object's properties to "safe" values, but it can also be used for more specific tasks like opening a file stream, producing a random number, etc.

[cont'd…]

[…cont'd]

DESTRUCTOR: A special method that is implicitly called when an object's lifetime ends. Its main