Programmation Orientée Objet

Chapter 1: Basic Principles

• The chapter is about basic principles of computer science, specifically focusing on the object-oriented approach.
• Dr. Sarra Namane, from the Department of Computer Science at Badji Mokhtar University, Annaba, lectured on this topic.
• The class is for second-year engineering students, during the 2024/2025 academic year.

Introduction

• Software manipulates data; understanding, analyzing, updating, and storing data is crucial for effective use.
• Object-Oriented Programming (OOP) is a method to manage complex data and actions.
• OOP organises data and actions logically, making data management easier to understand and maintain.
• Using classes and objects allows for a readily understandable manner of organizing and working with data.

Introduction (2)

• Our environment perception focuses on specific objects like cars, people, trees, and buildings, ignoring ambient elements like air, temperature, and light.
• Cognitive mechanisms are fundamental in understanding these object-oriented programming concepts.
• Objects have attributes like shape, size, color, etc., which differentiate between them (e.g., car and tree).
• Attributes are important in segmenting and understanding objects, based on perceptual attraction .

The trio <entity, attribute, value>

• The world is described using the trio <entity, attribute, value>.
• An entity is anything identifiable or recognizable (physical or abstract). Examples include cars, people, projects, companies.
• Attributes characterise entities (e.g., color, age, size) to form a coherent object.
• Attributes define and make objects more perceivable.
• Attributes can be common to multiple objects (e.g., colour).
• Classification groups objects with similar attribute patterns into classes.

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

• Example of a "Student" entity.
• Attributes include Student ID, Name, Age, Address, Mobile Number.
• Values are given for each of the attributes (e.g., 125425235, Labiod imene).

What is Object-Oriented Programming?

• Object-Oriented Programming (OOP) is a coding paradigm that structures code around data called "objects".
• This method simplifies program development, making data modelling logical.
• OOP uses classes to model data, leading to the creation of reusable blueprints for objects.
• It reduces complexity and development time.

What is an Object?

• An object combines data (state) and actions (behaviour).
• State represents data, like colour, brand or speed for a car.
• Methods define behaviour, like accelerate, brake, and honk for a car.
• Identity is what makes an object unique, even when attributes are identical.

Object Storage of Objects in Memory

• Each object has a specific memory allocation.
• Primitive Data Types simplify memory management (integers, floats, characters).
• The object size in memory is determined by its attributes' size.

Example of object memory size calculation

• Calculation of memory usage of an object with attributes for age, height, gender, and name.
• Each attribute occupies a specific amount of memory bits.
• The total memory used is the sum of the memory taken for each attribute.

The Referent of an Object

• Each object has a unique name as an identifier.
• A physical memory address corresponds to the object's name.
• No two objects can occupy the same memory address.
• A referent is a variable pointing to the object's memory address.
• Memory areas for referents store symbolic names.
• Memory addresses are typically 32 bits.
• A referent is a 32-bit value holding the physical address of an object.

The Referent of an Object (2)

• Stack Memory: Stores temporary data for methods.
• Heap Memory: Stores objects. The heap is managed automatically by Java to free up memory.

Stack memory example

• Example of how local variables (a, b, result) are stored in the stack during the execution of an add() method.
• When the method ends, these variables are removed from the stack.

Heap memory example

• Example illustrating how an object (e.g., a Person object) is stored in the heap memory space.
• The Garbage Collector in Java removes unused heap objects automatically.

Indirect Addressing

• Multiple referents can point to the same object in memory, allowing flexible access.
• Objects referenced by different names in various parts of a program can access it.
• This avoids redundant storage of object data.

Multiple Referents Example

• Demonstrating how multiple references to the same object can lead to changes reflecting on all references to that object.
  • When an attribute of one reference point changes, it changes for all.

The Object in Its Passive Version

• Objects are perceived as wholes, rather than individual parts (e.g., a car, not just the engine).
• Objects consist of parts/sub-objects (e.g., car has wheels, engine, etc.)
• Public interface details how other objects interact (e.g., methods to start or stop).
• Internal functioning contains implementation details of the object.
• Logical separation of aspects is essential for easy code organisation and readability.

Object Composition

• Composition involves a primary object (composite) containing other objects (components).
• Component objects rely entirely on the composite object for existence.
• Real-world example: A house contains rooms, and the rooms cannot exist independently of the house.

Dependence Relationship

• Objects are connected, but their existence isn't dependent on each other.
• Example of passengers and a car, passengers don't depend on the car.
• Realistic modelling allows for flexible interactions/associations between objects, not strict containment.

The object in its active version

• Objects are dynamic, changing state as needed.
• Objects interact based on signals and reactions (e.g., a car stopping at a red light).
• Objects can change their attributes and behaviour due to transitions between various states.
• Active objects make systems richer in details and complexity.

Object State

• Objects have a current state determined by their attributes.
• State changes affect these attributes, but object identity remains unchanged.
• Changing attributes does not alter the object's memory address.
• Objects exist in memory from creation until deletion (lifecycle).

Object Lifecycle

• An object goes from creation to deletion.
• States include creation, usage, modification, and destruction.
• Memory allocated and attributes initialized during creation.
• Object status changes based on program interactions and conditions.
• Objects are removed from memory when no longer required.

Responsibility

• Object state changes are driven by operations (methods).
• Example: A traffic light changes colour with an operation (e.g., change).
• Methods update attribute values depending on predefined rules and conditions.

Exercise

• Composition relationship between objects and how they influence memory management.
• Example: A house destroying a room also destroys the room, releasing memory space.

QCM (Multiple Choice Questions)

• Various questions assess understanding of OOP concepts.
• Questions test comprehension of different OOP elements and principles.

Introduction to the concept of a Class

• A class is a template or blueprint that defines the structure of an object.
• Classes specify data and code that will work with the data.
• Objects are created from classes, and data within the objects are called instance variables.
• Classes define object data and the actions these objects can perform.

Introduction to the concept of a Class (2)

• Example code of a Vehicle class with attributes (e.g., number of passengers).
• This shows how a class can be made, how attributes store data for the objects and how they manipulate it.

Class Constructor

• A constructor is a special method called when an object of a class is created.
• It initializes the object's attributes.
• Example code for a Car class constructor to initialize car model and year attributes.
• Explains usage of this keyword for referencing the current object's instance attributes/variables.

Getter

• Provides a method for retrieving an object's attribute value.
• The getter method follows the naming convention: getAttributeName().
• Provides easy access to the object's attributes.
• Example code illustrating fetching car model details.

Setter

• Defines methods for setting or updating an object's attribute values.
• The setter method follows the naming convention: setAttributeName().
• Allows changes to object attributes.
• Example code showcasing how to modify car model details

Object Instance

• In Java, you create an object instance using the new keyword.
• This illustrates creating an instance of the Book class.

Example of Object instance

• Example code with Vehicle objects demonstrating creation and access to their methods/variables.

Instance variables and class variables

• Instance variables are associated with specific object instances, and every object of the class will have its own instance variables.
• Class variables belong to the class, and a single copy is shared among all objects.
• Class variables are declared using static.

Instance variables and class variables (2)

• Detailed example code showing instance variable declaration (name,age) within a Person class.

Instance variables and class variables (3)

• Variables declared with static are class variables.
• They are associated with the class. A single copy is shared.
• They can be accessed directly using the class name.
• They are initialized once when the class is loaded.

Instance variables and class variables (4)

• Example code for static variable population within the Person class.
• population increments each time a Person is created.

QCM (Multiple Choice Questions) (2)

• Further multiple choice questions testing knowledge gained from previous concepts.
• Focuses on questions about constructors, scope.

QCM (Multiple Choice Questions) (3)

• More multiple choice questions, focusing now on differences between instance and class variables.

Object-Oriented Programming (OOP) Languages vs. Languages Manipulating Objects

• OOP languages (e.g., Java, C++) allow defining and creating custom classes.
• Classes, along with defined methods, specify objects' attributes.
• Other languages leverage pre-defined classes, accessing pre-built objects provided by libraries.

Executing the Method on a Specific Object

• The method needs to know which object it's acting on.
• Use the dot operator (myObject.method()) to connect the object to method execution.
• Objects can access object attributes/instance variables through a direct link/relationship.

Executing the Method on a Specific Object (2)

• The 'method' can only access attributes specific to that object (e.g., if you alter the object's variable, the change is restricted to that object within the application).

How Objects Communicate

• Objects interact to accomplish tasks; e.g., a teacher instructing a student.
• Methods act as actions/operations performed by objects, e.g., teachers 'teaching' and students 'learning'.
• Messages/interactions are transferred between the objects to trigger actions.

Finding Message Recipients

• Identify the object type (Car in the parking example) to ensure the recipient is the correct target.
• Optionally, maintain attribute referencing car objects within a Parking object for easier interaction and reduces need for repeated data passings; reducing overhead.

Finding Message Recipients (2)

• Example of a class structure for Car and Parking.
• The Parking class keeps reference to cars, allowing efficient object interaction.

What is Inheritance

• Inheritance is central in OOP.
• Subclasses (child classes) inherit attributes and methods from parent classes promoting code reusability.
• Classes organized hierarchically: general to specific (e.g., phone, iPhone 14).

Hierarchy of Objects

• Hierarchical categorization of objects (e.g., phone, iPhone 14, flip phone).
• Inheritance promotes logical structure, grouping similar objects by generalisation: specific to general.

Context-Specific Terminology

• General terms like "car" are contextually sufficient, but broader terms like "means of transport" aren't always precise.
• The required level of detail about an object is dictated by the specific context.

Contextual Dependence on the Right Taxonomy Level (2)

• Communication detail requirements vary based on the context (mechanics fixing a car vs. a person speaking casually).

Polymorphism

• Objects respond differently to shared messages.
• Methods or variables can adapt behaviours across different contexts.
• Polymorphism complements inheritance, enhancing the system's flexibility and adaptability.

Polymorphism example

• Click on the computer screen; different objects respond differently.
• A single event (click) triggers diverse behaviour across various objects.

References

• List of relevant books and online resources used to support the presented information and concepts.

Testez vos connaissances sur la programmation orientée objet. Ce quiz aborde les concepts fondamentaux tels que les attributs d'objet, l'héritage, les constructeurs et la polymorphie. Idéal pour les étudiants en informatique cherchant à solidifier leur compréhension de ce paradigme de programmation.