Object-Oriented Programming Concepts

Chapter 1: Basic Principles of Computer Science

• The chapter focuses on the fundamental principles of computer science, specifically using object-oriented programming (OOP) to manage data.
• Software relies on data, and effective use demands understanding, analysis, updates, and data storage.
• OOP organizes data and actions clearly, making it understandable.
• Data classes and objects streamline data management, making it logical.

Introduction

• Software works with data; to effectively use data, one needs to understand, analyze, update, and store it.
• Object-Oriented Programming (OOP) organizes data and actions related to it in a straightforward manner.
• OOP simplifies software development, enabling efficient data management.
• Necessary data classes and objects enable logical data handling.

Introduction (2)

• People's perception of the environment focuses on specific objects.
• Cognitive mechanisms play a role in this selective perception.
• Selective attention filters out nonessential elements (ambient).
• Objects are characterized by specific attributes (e.g., shape, color).

The trio <entity, attribute, value>

• The trio <entity, attribute, value> describes the world using identifiable entities with attributes and values (e.g., car, color, make).
• An entity is anything identifiable, be it a physical object, a concept, or an event.
• Entities are perceived through their attributes.
• Attributes define and make entities identifiable.
• Many objects share common attributes (e.g., both cars and trees have color).

An example of the trio <entity, attribute, value>

• A diagram (presumably a simplified ER diagram) shows a "Student" entity with attributes like Student_ID, Name, Age, Address, etc., and their corresponding values.
• Entities (like "Student" ) are characterized by multiple attributes (color, age, size).

What is Object-Oriented Programming?

• OOP is a coding paradigm organizing code around data (objects), not functions or procedures.
• OOP simplifies software development by enabling the modeling of any needed data, logically.
• OOP employs classes to define data models and blueprints for creating objects, allowing intuitive world modeling.

What is an Object?

• An object combines data (state) and behavior (methods) within a self-contained unit.
• State is the object's data, stored in variables or attributes (e.g., color, speed).
• Methods define the object's actions or behavior (e.g., accelerate, brake).
• Identity is what makes an object unique.

Storage of Objects in Memory

• Each object is allocated memory space in the program.
• Primitive data types have known sizes for simplified memory management.
• Examples include integers (32 bits) and floating-point numbers (64 bits).
• Unicode characters use 16 bits.
• Object attributes (e.g., dimensions, colors, and brands) are stored using these primitive types.

Example of Object Memory Size Calculation

• An example calculates the memory size of an object with attributes like age (32 bits), height (64 bits), gender (16 bits), and a name (160 bits (string with 10 characters)).
• Total memory is 272 bits.

The Referent of an Object

• Each object in a program has a unique name serving as an identifier.
• This name corresponds uniquely to the object's memory address.
• Addresses are unique, ensuring no two objects occupy the same space.
• A referent is a variable storing an object's memory address; it's used for symbolic representations.
• Memory addresses are typically 32 bits.
• Efficient memory access is enabled by the referent function representing the physical address.

The Referent of an Object (2)

• Stack memory is a short-term storage area for method data.
• Heap memory is used to store Java objects; objects are allocated here, and unused objects are cleared automatically.
• When a method finishes, data is removed from the stack.

Stack memory example

• An example code snippet demonstrates how local variables are stored on the stack during method calls (e.g., 'add(int a, int b)' ).
• The variables are placed on the stack when a method is called and removed from the stack when the method is completed.

Heap memory example

• A code snippet demonstrates an example of how an object is stored and accessed via heap memory in Java.

Indirect Addressing

• Several referents can access the same object in memory.
• Referents have different names but point to the same object in memory.
• This allows the use of objects in multiple parts or contexts of a program without needing to duplicate data.
• Indirect addressing is a common OOP technique.

Multiple Referents Example

• A code example demonstrates how variables can refer to the same object's data (e.g., if one object changes the value of an attribute, all referring variables will reflect the change).

The Object in Its Passive Version

• Objects are often perceived as wholes, not components, though they do consist of sub-objects or parts.
• The public interface focuses on how other objects interact with it.
• The internal functionality focuses on internal object actions.
• OOP separates exposed aspects from internal details for better organization.

Object Composition

• A primary object (composite) contains other objects (components)
• Components depend on the composite object (cannot exist independently).
• Components are accessible only through the composite.
• A house serves as a real-world example of composition (containing rooms, walls, doors).

Dependence Relationship

• Objects can be connected but not fully dependent on each other.
• A book depends on an author but can exist independently.
• This is an association (not composition).

The object in its active version

• Objects aren't static; they react to events and can change.
• Interactions involve objects responding to signals or other objects.
• State changes affect object attributes, reflecting their behavior.
• Active objects contribute to program complexity and authenticity.

Object State

• An object's state reflects its current condition based on attribute values.
• Attributes can change, influencing an object's behavior, but the fundamental identity remains constant.
• Modification of attributes updates their values in memory without altering the object's address.
• An object's lifecycle follows creation, state changes, and eventual deletion.

Object Lifecycle

• An object's lifecycle encompasses its existence from creation to deletion.
• Stages include creation, usage, attribute modification, and destruction.
• Memory is allocated, initializing attributes during creation.
• Object state changes based on internal and external interactions.

Responsibility

• Object state changes are driven by operations or methods for the object’s internal changes.
• Methods like "change" modify attribute values for an object like a traffic light.

Exercise (Composition relationship)

• The composition relationship dictates that a dependent object (e.g., a Room) cannot exist without its parent (House).
• When the parent is destroyed, the dependent object is also destroyed.
• This impacts memory management in OOP programs.

QCM

• Multiple choice questions about object composition, their lifecycle, and attribute changes follow the rules of object-oriented (OOP) programming languages.

Introduction to the concept of a Class

• A class is a blueprint or template outlining an object's structure and behavior.
• Objects are instances created based on class blueprints.
• Instance variables hold the object's data, while methods specify its actions.

Introduction to the concept of a Class (2)

• An example of a class (presumably the 'Vehicle' class) demonstrates instance variables (e.g., 'passengers') and methods ('getPassengers', 'setPassengers') defining object behavior.

Class Constructor

• A special method in a class, the constructor, initializes object attributes when created.
• The "this" keyword refers to the current object, allowing access to instance variables and methods.

Getter

• A getter method retrieves an object's attribute value.
• It follows a standard naming convention (e.g., getAttributeName()).

Setter

• A setter method sets or updates an object's attribute value.
• It follows a standard naming convention (e.g., setAttributeName()).

Object instance

• An object instance represents a class's specific realization.
• The 'new' keyword creates an object from a class and allocates memory space to hold the object's attribute values.

Example of Object instance

• An example demonstrates the creation of ‘Vehicle’ objects and how to use the instance variables via methods.

Instance variables and class variables

• Instance variables belong to a specific object instance.
• Class variables are associated with the class itself, shared among all instances.
• Instance variables are declared within a class outside a method, constructor, or block.

Instance variables and class variables (2)

• An example shows how instance variables (name, age) within the 'Person' class are defined.

Instance variables and class variables (3)

• Static variables (class variables) are associated with the class, not object instances.
• A class variable is shared across all objects of the class.
• Class variables are declared using the static keyword.

Instance variables and class variables (4)

• A code snippet demonstrates class variables (population) defined, shared among objects, and modified.

QCM (Additional)

• Additional multiple-choice questions cover the role of constructors, the 'this' keyword, getter, and setter methods, the distinction between instance and class variables.

Object-Oriented Programming (OOP) Languages

• OOP languages (e.g., Java and C++) allow programmers to create and modify their classes.
• Defining attributes and methods using classes define the objects' behavior.

Languages Manipulating Objects

• Languages like JavaScript primarily interact with predefined classes.
• They create instances of existing classes rather than defining new ones.
• Existing classes specify methods and attributes.

Executing the Method on a Specific Object

• A method applied to a specific object needs to identify which object it acts upon.
• The dot notation associates a method with an object (object.method()).
• This method acts only on that object's attributes.

How Objects Communicate

• Objects in OOP interact to perform tasks.
• Interactions are often seen as messages passed between objects.
• Methods act on an object's attributes when called by another object.

Finding Message Recipients

• Object-oriented programming (OOP) ensures appropriate object handling via well-defined methods for objects.
• Messages to an object only reflect that object's behavior.
• The receiving object's type (e.g., Car) or any special attributes are verified.

Finding Message Recipients (2)

• The recipient object (e.g., Parking) needs a reference to the object sending the message (e.g., Car) to respond effectively.
• This maintains object integrity and consistency.

Inheritance

• Inheritance creates new classes (subclasses) from existing classes (superclasses)
• Subclasses inherit attributes and methods of their superclass(es).
• This promotes code reuse and organizes classes hierarchically.

Hierarchy of Objects

• OOP organizes classes in a hierarchy, from general to specific.
• This hierarchy mirrors how people categorize objects in the real world.
• Specific objects (e.g., iPhone) are subclasses of a broader category (e.g., phone).

Contextual Dependence on the Right Taxonomic Level

• Everyday language often uses broad terms (e.g., "car").
• Using very broad terms can be problematic in technical contexts.
• The level of specificity in communication should reflect the context.

Contextual Dependence on the Right Taxonomic Level (2)

• The level of detail in communication depends on the context.
• In technical contexts (e.g., with mechanics), a more specific term (e.g., "Toyota Corolla") is necessary.

Polymorphism

• Polymorphism allows different objects to respond to the same message (method call) differently.
• The behavior differs according to the specific object's type.
• Polymorphism complements inheritance in OOP.

Polymorphism example

• An example illustrates how different types of objects (e.g., windows, icons) can react differently to the same action (e.g., a mouse click).

This quiz explores fundamental concepts in object-oriented programming, focusing on memory management, object references, and the relationships between objects. Test your understanding of stack vs. heap memory, object properties, and composite objects in programming.