Object-Oriented Programming Basics

# CHAPTER 12

Object-Oriented Programming Basics #

1. Introduction #

2. Learning Objectives #

• Define what an Object and a Class are.

• Understand the paradigm shift from Procedural to OOP.

• Identify the 4 Pillars of OOP: Encapsulation, Abstraction, Inheritance, and Polymorphism.

3. Classes vs. Objects #

• Class (The Blueprint): A class is a template. It defines the properties (data) and behaviors (methods) that a certain entity should have. Think of an architectural blueprint for a house.

• Object (The Instance): An object is the actual, physical thing built from the blueprint. From one House class, you can create 100 House objects, each painted a different color.

4. Procedural vs. Object-Oriented #

string p1Name = "Arthur";
int p1Health = 100;
string p2Name = "Dragon";
int p2Health = 300;

void TakeDamage(string name, ref int health, int damage) { ... }

As you add more players, this becomes impossible to manage.

*OOP Way:* We bundle the data and the methods into a single Player class.

Player p1 = new Player("Arthur");
Player p2 = new Player("Dragon");

p1.TakeDamage(50);

The data and logic are encapsulated inside the object. Much cleaner!

5. The 4 Pillars of OOP #

#### Pillar 1: Encapsulation (Data Protection) Encapsulation is the mechanism of hiding the internal state of an object and requiring all interaction to be performed through an object's methods. *Analogy:* You don't directly modify the internal engine valves of your car to speed up. The internal engine is *encapsulated*. You press the gas pedal (a public method).

#### Pillar 2: Abstraction (Simplification) Abstraction means hiding complex implementation details and showing only the essential features to the user. *Analogy:* When you use your smartphone, you press an icon to open an app. You are abstracted away from the millions of lines of machine code executing in the background.

#### Pillar 3: Inheritance (Code Reusability) Inheritance allows a new class to adopt the properties and methods of an existing class. *Analogy:* An Animal class might have a Breathe() method. If we create a Dog class and a Cat class, they can *inherit* from Animal. We don't have to rewrite the Breathe() code for every single animal.

#### Pillar 4: Polymorphism (Many Forms) Polymorphism allows methods to do different things based on the object it is acting upon. *Analogy:* If you call the Speak() method on a Dog object, it barks. If you call Speak() on a Cat object, it meows. The same method name yields different behaviors.

6. OOP and Memory Explanation #

7. Common Mistakes #

• Blurring the line between Class and Object: "I am changing the variable in the Class." No, you change variables in the *Object*. The class is just the blueprint. Changing the blueprint doesn't paint the house.

• Overcomplicating designs: Beginners often try to create massive, deep inheritance trees (e.g., Vehicle -> Car -> SportsCar -> Ferrari). Modern software design favors simpler architectures.

8. Exercises #

1. 1. Look around your room. Pick a physical item (e.g., a Television). On paper, design a "Class" for it. List 3 Properties (e.g., brand, volume) and 2 Methods (e.g., TurnOn(), ChangeChannel()).

9. MCQs with Answers #

10. Interview Questions #

• Q: Name the 4 pillars of OOP and give a brief definition of each.

• Q: Explain the difference between a Class and an Object.

11. Summary #

12. Next Chapter Recommendation #