2301107005 - ADNAN PP.pptx array of objects

ARRAY OF OBJECTS
Submitted by Adnan PP
Register number-2301107005
Subject- Object Oriented Programming Language

INTRODUCTION TO ARRAYS
 An array is a data structure that stores a collection of elements.
 The size of the array is defined at the time of creation
 Elements in an array are of the same data type (e.g., integers,
floats).
 Elements are accessed using an index (starting from 0)
 Arrays occupy contiguous memory locations for faster access.
 Common data types: Integers, strings, booleans, objects, etc
 Example: int[] numbers = {1, 2, 3, 4, 5};

INTRODUCTION TO OBJECTS
 An object is an instance of a class in Object-Oriented Programming
(OOP).
 Objects are created from a class, which acts as a blueprint for
class.
 Objects have a state (attributes) and behavior (methods).
 Objects can combine data (attributes) and methods (functions)
and it is called as Encapsulation
 Objects also follow OOP concepts like inheritance, polymorphism,
and abstraction.
 Objects are used to represent real-world entities in programming.
 Example: car mycar = new car();

ARRAY OF OBJECTS
 An array of objects is a collection where each element is an object.
 Every element in the array refers to an object.
 Objects can have different properties and methods providing
flexible data storage
 The array holds objects of the same class type.
 Each object in the array may have different data values.
 Arrays of objects are used to store multiple instances of a class,
simplifying data management.
 Example: ClassName[] objectArray = new ClassName[size];

USE OF ARRAY OF OBJECTS
 Provide efficient data management by grouping similar objects
together in one structure.
 It simplifies iterations as it is easy to loop through objects using array
indexing.
 Reduces complexity by organizing related data in a simple format.
 It allows adding a large number of objects dynamically.
 Improves code readability by reducing the need for multiple variables.
 Provide data consistency as all objects are of the same class, ensuring
consistency.
 It is used to store data for entities such as users, products, or students.

BENEFITS OF ARRAY OF OBJECTS
 It uses contiguous memory, which is efficient for processing.
 Manages groups of similar objects with fewer lines of code thereby
simplifying code
 Objects within the array can be modified, added, or deleted easily.
 Improves Readability as it clearly defines and organizes data within the
program.
 Arrays allow for easy searching using indices.
 It supports dynamic resizing (e.g., ArrayList in Java).
 Perfect for representing related data, like a list of employees or
products.

SYNTAX OF ARRAY OF OBJECTS
 Objects in the array must be initialized individually.
 The array type must match the class of the objects it will hold.
 The array size is fixed, but the objects within can vary in state.
 Objects are instantiated within the array using the new keyword.
 Syntax : ClassName[] arrayName = new ClassName[size];
 Example : Student[] students = new Student[5];
students[0] = new Student("Alice", 20);
students[1] = new Student("Bob", 22);

ARRAY OF OBJETS IN C++
 Arrays of objects are declared using square brackets in c++.
 Objects in the array are initialized using constructor.
 Use dot notation to access attributes of objects in the array.
 In C++, arrays of objects can also be declared using pointers, which allows
dynamic memory management.
 Arrays of objects in C++ may require explicit memory management (eg.,
new and delete).
 The size of the array is fixed unless using dynamic memory allocation.
 Example : Student students[2] = {Student("Alice", 21), Student("Bob", 22)};

ARRAY OF OBJETS IN JAVA
 Define a class with attributes and methods.
 Create objects within the array using the class constructor.
 Declare an array of objects with a fixed size.
 Use dot notation to access object attributes
 Use a loop to process all objects in the array.
 Example: Student[] students = new Student[2];
students[0] = new Student("Alice", 21);
students[1] = new Student("Bob", 22);

ARRAY OF OBJETS IN JAVASCRIPT
 Use square brackets to declare the array.
 Objects are created using curly braces {} inside the array.
 Dot notation used to access object properties.
 Properties can be updated using dot notation.
 Use a loop to iterate over the array of objects.
 Example: let cars = [ {make: 'Toyota', model: 'Corolla'}, {make:
'Honda', model: 'Civic'} ];

ARRAY OF OBJETS IN PYTHON
 Define a class using the class function.
 Use the __int__ constructor to initialize attributes.
 Use a list to declare an array of objects.
 Use dot notation to access object attributes.
 Use a loop to iterate over the list and access object attributes.
 Example: class Student:
def __init__(self, name, age):
self.name = name
self.age = age
students = [Student("Alice", 21), Student("Bob", 22)]

ACCESSING ELEMENTS
 Arrays of objects are accessed by their index positions.
 The number of elements in the array is fixed (for static arrays).
 Use dot notation to access individual properties.
 Edge cases ensure the index is within the bounds of the array.
 Array out of bounds exception handle cases where you might access
invalid indexes.
 Access syntax : arrayName[index] is used to access the object at a
specific index.
 Example : Student s = students[0];
System.out.println(s.name);

MEMORY MANAGEMENT
 Arrays of objects may be allocated on the stack (fixed size) or the heap
(dynamic size).
 In languages like Java and C++, objects in arrays are stored as references
to memory locations.
 In languages like Java, memory is automatically managed using garbage
collection.
 In C++, you must manually manage memory using new and delete to
avoid memory leaks.
 Arrays provide faster memory access since they are contiguous in memory.
 Unlike arrays of primitives, arrays of objects store references rather than the
actual object data.
 Improper memory management can lead to slow performance or crashes
due to memory issues.

ITERATING OVER ARRAY OF OBJETS
 For looping through arrays use for or for-each loops to iterate over arrays of
object.
 For accessing object properties Inside the loop use dot notation inside the
loop to access attributes.
 Iterating over large arrays can be resource-intensive.
 Use other looping constructs like while oops for more control.
 For arrays of arrays or objects, consider nested loops for deeper access.
 Example : for (Student s : students) {
System.out.println(s.name); }

MODIFYING ELEMENTS
 We can change properties of individual objects using dot notation.
 You can reassign an object in the array.
 objects can be removed from an array using methods like remove()
 Changing an object doesn’t affect the array size; the size is fixed upon
declaration.
 When modifying, ensure the object’s state remains valid.
 Example : cars[0].model = ‘Swift';

MULTIDIMENSIONAL ARRAY OF OBJETS
 Arrays containing arrays of objects or objects containing arrays are called
as multidimensional array of objects.
 It is useful for representing complex data structures.
 We can use multiple indices or dot notation to access nested data.
 It can dynamically access subarrays or nested objects.
 Multi-dimensional arrays are harder to manage and debug.
 It is ideal for representing data with inherent hierarchies (e.g., products,
categories).

ARRAY OF PRIMITIVES
 Arrays of primitives store basic types (e.g., int, float), while arrays of
objects store instances of classes.
 Primitives are stored directly in memory, while objects are stored as
references to memory.
 Primitives are simple to initialize.
 Arrays of primitives have faster access times.
 Arrays of primitives are better for simple data.
 Arrays of primitives consume less memory.

ADVANTAGES
 Arrays of objects allow easy grouping of related data (e.g., students,
employees).
 Faster access compared to other data structures, due to contiguous
memory allocation.
 Easier to maintain and modify as related objects are stored in one structure.
 Using array indices to access objects speeds up searching and retrieval.
 Simplifies the process of iterating through all objects using loops.
 All objects in the array are instances of the same class, providing uniformity.
 The array can hold complex objects, allowing for diverse data handling
and manipulation.

DISADVANTAGES
 In some languages, arrays have a fixed size that cannot be changed after
initialization.
 Storing references to objects requires more memory than primitive arrays.
 Managing arrays of objects can become complex with large data sets and
multiple nested objects.
 Arrays of objects don't provide additional methods for searching or sorting
(you may need additional code or structures).
 Unlike dynamic structures (e.g., ArrayList or Vector), static arrays cannot
grow beyond their initial size.
 Handling large arrays of objects may slow down applications due to
increased memory consumption.

PERFORMANCE
 Arrays of objects generally offer fast access due to contiguous memory
storage.
 Objects introduce additional memory overhead due to references and
object metadata.
 In Java, objects are subject to garbage collection, which can
introduce performance overhead.
 CPUs can optimize array access by caching nearby memory locations
in arrays.
 In languages like Java and C++, static arrays have a fixed size, which
can limit performance in some cases.
 Working with large arrays of objects can cause memory fragmentation
and slowdowns.

COMMON MISTAKES
 Forgetting to initialize objects in the array results in null references or runtime
errors.
 Trying to access an index outside the array bounds leads to errors or
crashes.
 Not properly releasing memory when objects are no longer needed (in
languages like C++).
 Accidentally overwriting objects in the array without proper checks.
 Misunderstanding zero-based indexing and using the wrong index values.
 Modifying the object in the array without proper validation or checks can
cause data inconsistencies.

USE CASES OF ARRAY OF OBJETS
 Database Records : Store multiple records (e.g., student profiles, product
inventories) in arrays of objects.
 Inventory Management : Represent multiple items in a store, each with
properties (e.g., name, price, stock).
 E-commerce Applications: Store customer orders and shopping cart items
as objects in arrays.
 Game Development: Represent multiple game entities like players,
enemies, or weapons using arrays of objects.
 Social Media : Manage a collection of user profiles, messages, or posts.
 Employee Management Systems: Use arrays of objects to represent a team
or company

REAL WORLD EXAMPLES
 Library Systems : An array of books, where each book is an object with
attributes like title, author, and genre.
 Online Shopping : Products in an e-commerce website stored as objects in
an array, with properties like name, price, and availability.
 Inventory Systems : An array of product objects in a retail store, where each
object holds details like SKU, price, and quantity in stock.
 Student Management : A collection of student objects, with each having
properties such as name, grade, and age.
 Employee Database : An array of employee objects, each containing
details like employee ID, department, and salary.
 Online Banking : Accounts and transactions stored as objects in an array,
making it easier to manage and update information.

CONCLUSION
 Arrays of objects are a powerful data structure for managing collections of
complex data.
 They simplify managing related data in various applications like employee
databases, product inventories, and more.
 Provides an efficient way to group objects and manipulate them together.
 Easier code maintenance, better organization, and simplified iteration
through object data.
 Arrays of objects allow for more flexibility in data handling compared to
primitive arrays.
 Understanding arrays of objects is essential for working with OOP concepts
and managing collections of complex data efficiently.

2301107005 - ADNAN PP.pptx array of objects

More Related Content

Similar to 2301107005 - ADNAN PP.pptx array of objects (20)

Recently uploaded (20)

2301107005 - ADNAN PP.pptx array of objects