Computer Science Chapter 1: Basic Principles

Chapter 1: Basic Principles: Which Object for Computer Science?

• The presentation is about basic principles in computer science, specifically focusing on which objects are used in computer science.
• The presenter is Dr. Sarra Namane from the Department of Computer Science at Badji Mokhtar University, Annaba.

Introduction

• Software relies on data. Understanding, analyzing, updating, and storing data effectively is crucial for software.
• Object-Oriented Programming (OOP) is one way to effectively manage data.
• OOP organizes data and actions into clear entities, making the software more understandable and manageable.

Introduction (2)

• Our perception of the environment focuses on specific objects (e.g., cars, people, buildings).
• Cognitive mechanisms are vital for understanding these objects and their relationships with each other.
• Our attention is selective, meaning we don't notice all details (e.g., air, temperature).
• Objects are differentiated by attributes (e.g., shape, color).

The trio <entity, attribute, value>

• We use entities, attributes, and their values to describe the world.
• An entity is anything recognizable (people, cars, projects, etc.).
• Attributes describe the properties of entities (age, color, size).
• Attributes are used to define and create perceivable objects.

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

• A visual diagram (e.g., a diagram of a student entity with attributes like student ID, name, age, address) is shown.
• The relationships between entities (e.g., student and the respective attribute values) represented.

What is Object-Oriented Programming?

• Object-oriented programming (OOP) organizes program code around data objects.
• OOP models software development based on data, simplifying code and improving organization.
• OOP enables a logical approach to modelling data.

What is an Object?

• An object combines data (state) and behavior (methods).
• State refers to object attributes (variables representing data inside an object).
• Methods refer to object behavior (processes or actions the object performs).
• Identity refers to an object’s uniqueness.

Storage of Objects in Memory

• Each object occupies a distinct memory location.
• Primitive data types (e.g., integers, characters) have fixed sizes (e.g., 32 or 64 bits).

Example of object memory size calculation

• An example demonstrates the sizing of different attribute types and how they influence object size in memory.

The Referent of an Object

• A referent is a variable that stores a memory address that identifies an object.
• Object names uniquely map to memory addresses.
• This ensures no two objects occupy the same memory space.

The Referent of an Object (2)

• Stack memory temporarily stores data for methods.
• Heap memory is used for object storage and managed automatically by the system.

Stack memory example

• Each function call creates a new stack area for local variables.
• Variables are removed from the stack when the function completes its operation.

Heap memory example

• Objects are stored in heap memory until they are no longer in use.
• The garbage collector automatically frees up unused objects from memory.

Indirect Addressing

• Multiple references can refer to the same object in memory.
• This allows multiple parts of a program to access and manipulate the same object without needing to copy it.
• Shared object references improve program efficiency by avoiding unnecessary duplication.

Multiple Referents Example

• Example code demonstrates how multiple references point to the same object in memory.
• Modifications to one reference are also reflected in other references.

The Object in Its Passive Version

• We often perceive objects (e.g., "the car") as wholes instead of their composing parts.
• Objects have public and internal interfaces.
• The public interface is what other objects interact with, while the internal functioning is how the object itself works.

Object Composition

• A composite object contains other objects called components.
• Components depend on the composite object and are accessed only through it.
• Real-world examples of composition are houses and cars that are composed of several parts.

Dependence Relationship

• Objects can depend on each other's existence but not necessarily on their internal structure.
• This is more indirect than composition.
• A book can use an author, but the author doesn't need the book.

The object in its active version

• Objects are not static.
• Objects interact and react to events.
• Objects change states.
• Objects have active behavior, meaning they respond to actions and interactions with other objects.

Object State

• Objects maintain a state, a condition defined by attributes and their values.
• Changes in object attributes alter the object state.
• Object identity remains constant even when attributes change.

Object Lifecycle

• Objects have a lifecycle that includes creation, usage, modification, and destruction.
• Object states are determined by different stages/actions within their life cycle.
• Initialization, usage/modification, and destruction are part of the lifecycle.

Responsibility

• State transitions within the object are driven by methods.
• The object changes state in response to method calls.

Exercise

• Composition relationships affect memory management, as dependent objects are destroyed when the containing object is destroyed.

QCM

• These are multiple-choice questions (MCQs) testing the student's understanding of object-oriented concepts.

QCM (2)

• These are multiple-choice questions (MCQs) testing the student's understanding of object-oriented concepts.

QCM (3)

• These are multiple-choice questions (MCQs) testing the student's understanding of object-oriented concepts.

QCM (4)

• These are multiple-choice questions (MCQs) testing the student's understanding of object-oriented concepts.

Introduction to the concept of a Class

• A class is a template defining the structure and behavior of an object.
• The data inside the object is called instance variables.
• Classes define both data and actions for an object.

Introduction to the concept of a Class (2)

• Example code shows a basic class called Vehicle, defining variables for passengers and other data.

Class Constructor

• Constructors are special methods that initialize object attributes when an object is created from a class.

Getter

• Getters are methods used to retrieve the value of an object's attribute.

Setter

• Setters are methods used to modify the value of an object's attribute.

Object instance

• Object instantiation creates a specific object from its class definition.

Example of Object instance

• Example Java code illustrating the instantiation and usage of an object.

Instance variables and class variables

• Instance variables belong to a specific object instance.
• Class variables belong to the class itself, shared by all instances.

Instance variables and class variables (2)

• Example code demonstrates instance variables in a class called Person.

Instance variables and class variables (3)

• Static variables (or class variables) are associated with the class.

Instance variables and class variables (4)

• Example code showcases a static variable (population) in a Person class.

QCM (multiple-choice questions)

• Questions about constructors, the this keyword, getters/setters, and static variables.

Object-Oriented Programming (OOP) Languages

• OOP languages allow programmers to create and define their own classes.
• Classes define the attributes and methods for the objects.

Object-Oriented Programming (OOP) Languages (2)

• Languages that manipulate objects primarily interact with pre-defined classes.

Executing the Method on a Specific Object

• Methods need to know the specific object they operate upon (e.g., using the dot operator).

Executing the Method on a Specific Object (2)

• The dot operator connects a method to the object.
• The object's attribute/data is accessed via this explicit connection.

How Objects Communicate

• Objects connect through methods to execute tasks.
• Methods, such as teach or learn, enable interactions between objects.

Finding Message Recipients

• OOP provides methods to identify the target object for operations.
• Objects can hold references to each other, allowing programs to operate effectively.

Finding Message Recipients (2)

• Example code demonstrates how a Parking class can store a reference to a Car object, allowing it to access the Car's attributes without receiving them as an argument every time.

Inheritance

• Inheritance allows a class (subclass/child class) to inherit attributes and methods from another class (superclass).
• This promotes code reusability and creates a hierarchical structure among classes.

Hierarchy of Objects

• Objects can be grouped in a hierarchy from general to specific.
• This structure allows more flexibility in object handling.

Contextual Dependence on the Right Taxonomic Level

• Vocabulary choices depend on context (e.g., "car" is appropriate in casual conversation, but "Toyota Corolla" is more suitable in a technical context).

Contextual Dependence on the Right Taxonomic Level (2)

• The level of detail depends on the situation or context.

Polymorphism

• Polymorphism allows objects to respond to the same message differently based on their specific type/functionality.
• Different objects respond to the same message in a type-specific way.

Polymorphism example

• Code or event examples can illustrate how different objects react differently to the same message.

References

• List of books and online resources for further study.

This quiz covers the basic principles of computer science, focusing on the significance of objects in software development and Object-Oriented Programming (OOP). Dr. Sarra Namane from Badji Mokhtar University provides insights into data management and cognitive understanding of the environment. Test your knowledge on these foundational concepts.