Slide 1: Title Slide

 Title of the course

 Your name and contact information
 Date

Slide 2: Introduction to OOP

 Definition of Object-Oriented Programming
 Importance and benefits of OOP
 Brief history and evolution

1. Definition of Object-Oriented Programming

 Object-Oriented Programming (OOP) is a programming paradigm based on the concept of
'objects,' which can contain data in the form of fields (often known as attributes) and code in the
form of procedures (often known as methods).
 Consider including a simple diagram showing the concept of objects, with attributes and
methods encapsulated within them.

2. Importance and Benefits of OOP

 Modularity: OOP helps in breaking down complex systems into smaller, manageable pieces.
 Reusability: Code can be reused through inheritance and polymorphism, reducing redundancy.
 Scalability: OOP makes it easier to extend and maintain code as systems grow.
 Maintainability: Encapsulation and abstraction make it easier to manage and update code with
minimal impact on other parts of the system.

1
3. Brief History and Evolution
 Early Beginnings: "The concept of OOP dates back to the 1960s with the development of
languages like Simula, which introduced classes and objects."
 Evolution: "In the 1980s and 1990s, OOP gained widespread adoption with languages like
Smalltalk, C++, and Java, which brought OOP principles to mainstream software development."
 Modern Usage: "Today, OOP is a foundational concept in many modern programming
languages, including Python, C#, and Ruby."
The development of Object-Oriented Programming:
o 1967: Simula 67 – Introduced core OOP concepts.
o 1980: Smalltalk – Pioneered many OOP features.
o 1985: C++ – Extended C with OOP.
o 1995: Java – Popularized OOP with cross-platform capabilities.
o 2000: C# – Modern OOP features in .NET framework.
o 2000s: Python, Ruby, TypeScript – Continued evolution and integration with modern
programming paradigms.

Slide 3: Core Concepts of OOP

 Overview of the four main principles: Encapsulation, Abstraction, Inheritance, Polymorphism

1. Overview of the Four Main Principles

 Object-Oriented Programming is built around four fundamental principles: Encapsulation,
Abstraction, Inheritance, and Polymorphism.

2
2. Encapsulation
 Encapsulation is the bundling of data (attributes) and methods (functions) that operate on the
data into a single unit, typically a class. It restricts direct access to some of the object's
components, which can help prevent unintended interference and misuse.
 Key Points:
o Private vs. Public: Access modifiers that control visibility (e.g., private, protected,
public).
o Getter and Setter Methods: Used to access and update private attributes.
 Example Java Code:
public class Person {
private String name; // Private attribute
private int age; // Private attribute

// Getter method for name

public String getName() {
return name;
}

// Setter method for name

public void setName(String name) {
this.name = name;
}

// Getter method for age

public int getAge() {
return age;
}

// Setter method for age

public void setAge(int age) {
this.age = age;
}
}
 Class Definition

o Class Name: Person

o Private Attributes:
 name (String)
 age (int)
o Public Methods:
 getName()

3
  setName(String name)
 getAge()
 setAge(int age)

3. Abstraction
 Abstraction is the concept of hiding the complex implementation details and showing only the
necessary features of an object. It allows us to work with complex systems by interacting with
simpler interfaces.
 Key Points:
o Abstract Classes and Methods: Abstract classes cannot be instantiated and are designed
to be inherited. Abstract methods must be implemented by subclasses.
 Example Java Code:
abstract class Animal {
// Abstract method (does not have a body)
public abstract void makeSound();
}

class Dog extends Animal {

// The body of makeSound() is provided here
public void makeSound() {
System.out.println("Bark");
}
}

class Cat extends Animal {

// The body of makeSound() is provided here
public void makeSound() {
System.out.println("Meow");
}
}
 Class Definitions
o Abstract Class: Animal
 Abstract Method: makeSound()
o Derived Classes:
 Class Dog:
 Implements makeSound() method to print "Bark".
 Class Cat:
 Implements makeSound() method to print "Meow".

4
  Diagram showing an abstract class with abstract methods and derived classes implementing
class Class Model
these methods.
«abstract»
Animal

«abstract»
+ makeSound(): void

Dog Cat

+ makeSound(): void + makeSound(): void

4. Inheritance
 Inheritance is a mechanism where a new class inherits attributes and methods from an existing
class. This allows for code reusability and the creation of a hierarchical relationship between
classes.
 Key Points:
o Base Class and Derived Class: The base class is the parent class, and the derived class
inherits from it.
o Method Overriding: Derived classes can override methods of the base class.
 Example Java Code:
class Animal {
public void eat() {
System.out.println("Eating");
}
}

class Dog extends Animal {

public void bark() {
System.out.println("Woof");
}
}

public class Main {

public static void main(String[] args) {
Dog dog = new Dog();
dog.eat(); // Inherited method
dog.bark(); // Derived class method
}
}

5
  Diagram of a class hierarchy showing base and derived classes.
Dog Animal

+ bark(): void + eat(): void

5. Polymorphism
 Polymorphism allows objects of different classes to be treated as objects of a common base
class. It enables one interface to be used for a general class of actions, with specific actions
defined in derived classes.
 Key Points:
o Method Overloading and Overriding: Overloading refers to defining multiple methods
with the same name but different parameters. Overriding refers to redefining a method in
a derived class.
 Example Java Code:
abstract class Animal {
public abstract void makeSound () ;
}

class Dog extends Animal {

@Override
public void makeSound () {
System.out.println("Bark");
}
}

class Cat extends Animal {

@Override
public void makeSound () {
System.out.println("Meow");
}
}

public class Main {

public static void makeAnimalSound (Animal animal) {
animal.makeSound();
}

public static void main(String[] args) {

Dog dog = new Dog();
Cat cat = new Cat();
makeAnimalSound (dog); // Output: Bark

6
 makeAnimalSound (cat); // Output: Meow
}
}
class Class Model
 Diagram showing method overriding and a function demonstrating polymorphism.
«abstract»
Animal

«abstract»
+ makeSound(): void

Dog Cat

+ makeSound(): void + makeSound(): void

Slide 4: Encapsulation
 Definition and explanation
 How it works (e.g., private vs. public access)
 Example Java or C# code

1. Definition and explanation

Encapsulation is one of the core principles of object-oriented programming (OOP). It refers to
the practice of bundling data (attributes) and methods (functions) that operate on the data into a
single unit or class. Encapsulation restricts direct access to some of an object's components,
which can prevent accidental or unauthorized modification of data. This is achieved through
access modifiers such as private, protected, and public.
 Private Access: Attributes and methods that are only accessible within the class.
 Public Access: Attributes and methods that are accessible from outside the class.

2. How Encapsulation Works

Encapsulation works by defining the access level of the class members:
 Private Attributes/Methods: Only accessible within the class. This prevents external code from
modifying these attributes directly.
 Public Methods: Provide a controlled interface to access and modify private attributes.

7
3. Example Code in C#

Slide 5: Abstraction
 Definition and explanation
 Abstract classes and methods
 Example code in Python

Slide 6: Inheritance
 Definition and explanation
 Base and derived classes
 Example code in Python

Slide 7: Polymorphism
 Definition and explanation
 Method overriding and overloading
 Example code in Python

Slide 8: Classes and Objects

 Definition of a class
 Definition of an object
 How classes and objects interact

Slide 9: Constructors and Destructors

 Definition and purpose
 Syntax and usage in Python

Slide 10: Access Modifiers

 Explanation of public, protected, and private access
 How to implement access control in Python
8
Slide 11: Composition vs. Inheritance
 Explanation of both concepts
 When to use each

Slide 12: Design Principles

 SOLID principles
 Single Responsibility Principle
 Open/Closed Principle
 Liskov Substitution Principle
 Interface Segregation Principle
 Dependency Inversion Principle

Slide 13: Real-World Examples

 Examples of OOP in real-world applications
 Case studies or examples from industry

Slide 14: Practical Implementation

 Example project or case study
 Walkthrough of implementing OOP concepts in a practical scenario

Slide 15: Common Pitfalls and Best Practices

 Common mistakes to avoid
 Tips for effective OOP design

Slide 16: Summary and Q&A

 Recap of key points
 Open floor for questions

Slide 17: Further Reading and Resources

 Recommended books, websites, and tutorials
9
  Additional learning materials

Slide 18: Contact Information

 Your contact details
 How to reach you for follow-up questions

10