Advanced Programming II

INTRODUCTION:

If you have ever used a banking app on your phone, played a video game, or even registered for JAMB online, you have interacted with software built using Object-Oriented Programming — whether you knew it or not. OOP is not just a computer science term thrown around in textbooks. It is the backbone of most modern software applications used every day in Nigeria and around the world.

For SSS 3 students, this topic comes at the perfect time. You are preparing for WAEC and NECO examinations, and OOP concepts are regularly tested. More importantly, if you plan to study Computer Science, Software Engineering, or any technology-related course at the university level, a solid understanding of OOP will give you a head start.

In this lesson, we will break down OOP in a way that makes sense — using real-life Nigerian examples that you can connect with. By the end of this article, you will not just memorize definitions. You will actually understand what OOP is and why programmers all over the world rely on it.

LEARNING OBJECTIVES

By the end of this lesson, students should be able to:

1. Define Object-Oriented Programming and explain its importance in modern software development.
2. Identify and describe the four main principles of OOP — Encapsulation, Inheritance, Polymorphism, and Abstraction.
3. Distinguish between a class and an object with relevant examples.
4. Demonstrate how to create a simple class with attributes and methods.
5. Explain how OOP is applied in real-life Nigerian technology solutions.
6. Analyze the advantages and disadvantages of using OOP in programming.

OBJECT-ORIENTED PROGRAMMING (OOP)

Object-Oriented Programming, commonly shortened to OOP, is a style of programming that organizes software design around data — specifically, around things called objects — rather than around functions or logic alone.

Think of it this way. In a traditional Nigerian market, you have different items for sale — bags of rice, cartons of tomatoes, bottles of groundnut oil. Each item has its own properties (name, price, weight) and its own actions (being sold, being weighed, being stored). OOP works in a very similar way. Instead of writing one long list of instructions, you group related data and actions together into units called objects.

OOP was developed to make programming more organized, reusable, and easier to manage — especially as software programs became more complex over time.

OOP explained with code.

OOP explanation

KEY CONCEPTS IN OOP

Classes and Objects

Before we talk about the four pillars of OOP, we need to understand two very important concepts: classes and objects. These two are at the heart of everything in OOP.

A class is like a blueprint or template. It describes what something should look like and what it can do, but it is not the actual thing itself.

An object is the actual thing created from that blueprint. It is a specific instance of a class.

Let us use a Nigerian example. Think of "Student" as a class. The class "Student" might describe that every student has a name, an age, a school, and the ability to read, write, and take exams. Now, when we talk about a specific student — say, Chukwuemeka, who is 17 years old and attends Government Secondary School in Enugu — that specific student is an object of the class "Student."

Here is how you might write a simple class in Python, one of the most popular programming languages used in Nigerian universities today:

class Student: def init(self, name, age, school): self.name = name self.age = age self.school = school

def introduce(self):
    print("My name is " + self.name + " and I attend " + self.school)

student1 = Student("Chukwuemeka", 17, "Government Secondary School, Enugu") student1.introduce()

In the code above, Student is the class. student1 (Chukwuemeka) is the object. The words name, age, and school are called attributes — they store information about the object. The word introduce is called a method — it is an action the object can perform.

Attributes and Methods

Every object in OOP has two major features:

• Attributes: These are the characteristics or properties of the object. For a car object, attributes might include colour, model, and speed.
• Methods: These are the actions or behaviors the object can perform. For a car object, methods might include start(), stop(), and accelerate().

THE FOUR PILLARS OF OOP

These are the four fundamental principles that define Object-Oriented Programming. Every serious OOP programmer must understand them.

1. Encapsulation

Encapsulation means bundling data (attributes) and the methods that work on that data together inside a single unit — the class. It also means hiding the internal details of how something works from the outside world.

A practical example: When you use an ATM machine in Nigeria to withdraw money, you do not see the computer code running behind the scenes. You simply insert your card, enter your PIN, and collect your cash. The internal workings are hidden from you. That is encapsulation in real life.

In programming, encapsulation helps protect data from being accidentally changed by other parts of the program. It also makes code easier to manage.

2. Inheritance

Inheritance allows one class to take on the properties and methods of another class. The class that is inherited from is called the parent class or base class. The class that inherits is called the child class or derived class.

Think of it like a family in Nigeria. A child inherits certain traits from their parents — eye colour, height, or even a family business skill. In OOP, a child class inherits attributes and methods from the parent class but can also have its own unique features.

Example: If we have a parent class called Animal with a method called breathe(), then a child class called Dog can inherit the breathe() method automatically. The Dog class can also have its own unique method called bark(), which the parent class Animal does not have.

This saves time and reduces repetition in code. Instead of writing the same code over and over again, you write it once in the parent class and let child classes inherit it.

3. Polymorphism

Polymorphism comes from a Greek word meaning "many forms." In OOP, it means that the same method name can behave differently depending on the object that is calling it.

Imagine a Nigerian teacher who teaches different subjects. When she is in a Mathematics class, she explains equations. When she is in an English class, she teaches grammar. The action is called "teach" in both cases, but what she actually does is different depending on the class she is in. That is polymorphism.

In programming, polymorphism allows different classes to use the same method name, but each class implements that method in its own way.

4. Abstraction

Abstraction means showing only the necessary details to the user and hiding the complex background details.

When you make a call with your phone, you simply dial the number and press the call button. You do not need to understand how radio signals, network towers, and data packets work behind the scenes. The phone abstracts all of that complexity away from you.

In OOP, abstraction helps programmers design systems that are simple to use on the outside, even if they are complex on the inside.

PRACTICAL EXAMPLES OF OBJECT-ORIENTED PROGRAMMING (OOP) FOR SSS 3 STUDENTS

Practical Examples of OOP

Understanding OOP becomes much easier when you see it working in real life. Instead of just reading definitions, let us walk through practical, hands-on examples that connect directly to things you already know and use every day in Nigeria. We will use Python for all code examples because it is beginner-friendly and widely used in Nigerian secondary schools and universities.

Each example will show you the class, the objects created from it, the attributes, and the methods — step by step.

EXAMPLE 1 — STUDENT RECORD SYSTEM (School Setting)

Imagine your school wants to store information about every student digitally. Instead of writing separate code for each student, a programmer creates one class called Student and then creates individual objects for each student.

class Student: def init(self, name, age, class_level, state_of_origin): self.name = name self.age = age self.class_level = class_level self.state_of_origin = state_of_origin self.scores = [] 

def add_score(self, subject, score):

    self.scores.append((subject, score))
    print(f"{self.name}'s score in {subject} has been recorded as {score}.")

def display_info(self):
    print(f"Name: {self.name}")
    print(f"Age: {self.age}")
    print(f"Class: {self.class_level}")
    print(f"State of Origin: {self.state_of_origin}")
    print(f"Scores: {self.scores}")

def promote(self):
    print(f"{self.name} has been promoted to the next class. Congratulations!")

student1 = Student("Amaka Okonkwo", 16, "SSS 2", "Anambra") student2 = Student("Emeka Bello", 17, "SSS 3", "Kogi")

student1.add_score("Mathematics", 85) student1.add_score("English", 78) student1.display_info()

student2.add_score("Physics", 91) student2.promote()

What is happening here?

• Student is the class — the blueprint.
• student1 (Amaka) and student2 (Emeka) are objects — real students created from the blueprint.
• name, age, class_level, state_of_origin, and scores are attributes — the information stored about each student.
• add_score(), display_info(), and promote() are methods — things each student object can do.

Notice that even though both students were created from the same class, they each have their own unique data. Amaka's scores are different from Emeka's scores. That is the power of objects.

EXAMPLE 2 — BANK ACCOUNT SYSTEM (Nigerian Banking Context)

This example is inspired by how Nigerian banks like GTBank, First Bank, or Access Bank manage customer accounts in their systems.

class BankAccount: def init(self, account_holder, account_number, balance): self.account_holder = account_holder self.account_number = account_number self.balance = balance 

def deposit(self, amount):

    self.balance += amount
    print(f"NGN {amount} deposited successfully.")
    print(f"New balance for {self.account_holder}: NGN {self.balance}")

def withdraw(self, amount):
    if amount > self.balance:
        print("Insufficient funds. Transaction declined.")
    else:
        self.balance -= amount
        print(f"NGN {amount} withdrawn successfully.")
        print(f"Remaining balance: NGN {self.balance}")

def check_balance(self):
    print(f"Account Holder: {self.account_holder}")
    print(f"Account Number: {self.account_number}")
    print(f"Current Balance: NGN {self.balance}")

account1 = BankAccount("Fatima Abdullahi", "0123456789", 50000) account2 = BankAccount("Chidi Eze", "9876543210", 120000)

account1.deposit(20000) account1.withdraw(15000) account1.check_balance()

account2.withdraw(200000)

What is happening here?

• BankAccount is the class.
• account1 (Fatima) and account2 (Chidi) are two separate bank account objects.
• Each account has its own balance, account number, and account holder name.
• The withdraw() method checks if the customer has enough money before allowing a withdrawal — just like a real ATM does.
• When Chidi tries to withdraw NGN 200,000 but only has NGN 120,000, the system prints "Insufficient funds." This is exactly how real banking software works.

The OOP principle at work here: Encapsulation — the balance data is kept safely inside the object and can only be changed through proper methods like deposit() and withdraw().

EXAMPLE 3 — INHERITANCE (Vehicle System)

This example shows how inheritance works. We will create a parent class called Vehicle and then create child classes for Car and Motorcycle.

class Vehicle: def init(self, brand, colour, speed): self.brand = brand self.colour = colour self.speed = speed 

def move(self):

    print(f"The {self.colour} {self.brand} is moving at {self.speed} km/h.")

def stop(self):
    print(f"The {self.brand} has stopped.")

class Car(Vehicle): def init(self, brand, colour, speed, number_of_doors): super().init(brand, colour, speed) self.number_of_doors = number_of_doors 

def air_condition(self):

    print(f"The air conditioner in the {self.brand} is now on. Cool ride!")

class Motorcycle(Vehicle): def init(self, brand, colour, speed, has_sidecar): super().init(brand, colour, speed) self.has_sidecar = has_sidecar 

def wheelie(self):

    print(f"The {self.brand} okada is doing a wheelie!")

car1 = Car("Toyota Camry", "Black", 120, 4) bike1 = Motorcycle("Bajaj", "Red", 80, False)

car1.move() car1.air_condition() car1.stop()

bike1.move() bike1.wheelie()

What is happening here?

• Vehicle is the parent class. It has basic attributes (brand, colour, speed) and methods (move, stop) that all vehicles share.
• Car and Motorcycle are child classes. They inherit everything from Vehicle automatically — so they can already move() and stop() without us rewriting that code.
• Car has an extra method: air_condition() — something specific to cars.
• Motorcycle has an extra method: wheelie() — something specific to motorcycles (or okadas, as we call them in Nigeria!).
• The word super() is used to call the parent class and pass the shared attributes to it.

The OOP principle at work here: Inheritance — child classes reuse the parent class code and also add their own unique features.

EXAMPLE 4 — POLYMORPHISM (Different Animals, Same Method Name)

Polymorphism means one method name behaves differently depending on which object calls it. Let us see this in action.

class Animal: def init(self, name): self.name = name 

def speak(self):

    print("This animal makes a sound.")

class Dog(Animal): def speak(self): print(f"{self.name} says: Woof! Woof!")

class Cat(Animal): def speak(self): print(f"{self.name} says: Meow!")

class Goat(Animal): def speak(self): print(f"{self.name} says: Meeeh! Meeeh!")

class Cow(Animal): def speak(self): print(f"{self.name} says: Mooo!")

dog1 = Dog("Bingo") cat1 = Cat("Whiskers") goat1 = Goat("Shanu") cow1 = Cow("Iya Beji")

animals = [dog1, cat1, goat1, cow1]

for animal in animals: animal.speak()

Output: Bingo says: Woof! Woof! Whiskers says: Meow! Shanu says: Meeeh! Meeeh! Iya Beji says: Mooo!

What is happening here?

• All four classes — Dog, Cat, Goat, and Cow — have a method called speak().
• But each class implements speak() differently.
• When we loop through all the animals and call speak(), Python automatically uses the correct version of speak() for each animal.
• This is polymorphism — the same method name, but different behavior depending on the object.

Nigerian connection: Goats and cows are very common animals in Nigerian homes and farms, especially during Eid-el-Kabir celebrations. Using them here makes the example easy to remember!

EXAMPLE 5 — ABSTRACTION (Phone Call System)

Abstraction hides complex details and shows only what the user needs. Let us build a simple phone system.

class Phone: def init(self, owner, network): self.owner = owner self.network = network self.__signal_strength = 95 

def __connect_to_network(self):

    print(f"Connecting to {self.network} network... Signal: {self.__signal_strength}%")

def make_call(self, recipient):
    self.__connect_to_network()
    print(f"{self.owner} is calling {recipient}... Please wait.")
    print("Call connected!")

def end_call(self):
    print("Call ended. Goodbye!")

phone1 = Phone("Ngozi", "MTN") phone1.make_call("Uncle Emeka") phone1.end_call()

What is happening here?

• The method __connect_to_network() is a private method — it runs in the background but the user (Ngozi) does not need to know about it or call it directly.
• __signal_strength is a private attribute — hidden from outside the class.
• When Ngozi wants to make a call, she simply uses make_call(). The complex network connection happens automatically behind the scenes.
• This is abstraction — hiding the complicated parts and giving the user a simple interface.

Nigerian connection: Every Nigerian who has ever used MTN, Glo, Airtel, or 9mobile has experienced abstraction. You press call — you do not worry about base stations, radio signals, or data packets.

EXAMPLE 6 — COMPLETE MINI PROJECT (Market Sales System)

Let us combine everything we have learned into one small project — a market sales system inspired by a typical Nigerian market.

class Product: def init(self, name, price, quantity): self.name = name self.price = price self.quantity = quantity 

def display_product(self):

    print(f"Product: {self.name} | Price: NGN {self.price} | In Stock: {self.quantity}")

def sell(self, units):
    if units > self.quantity:
        print(f"Sorry, only {self.quantity} units of {self.name} available.")
    else:
        self.quantity -= units
        total = units * self.price
        print(f"{units} unit(s) of {self.name} sold. Total: NGN {total}")
        print(f"Remaining stock: {self.quantity}")

class Market: def init(self, market_name, location): self.market_name = market_name self.location = location self.products = [] 

def add_product(self, product):

    self.products.append(product)
    print(f"{product.name} has been added to {self.market_name}.")

def show_all_products(self):
    print(f"\n--- Products available at {self.market_name}, {self.location} ---")
    for product in self.products:
        product.display_product()

rice = Product("Bag of Rice (50kg)", 75000, 20) tomatoes = Product("Basket of Tomatoes", 8000, 15) palm_oil = Product("Keg of Palm Oil (25L)", 18000, 10)

balogun = Market("Balogun Market", "Lagos Island")

balogun.add_product(rice) balogun.add_product(tomatoes) balogun.add_product(palm_oil)

balogun.show_all_products()

rice.sell(3) tomatoes.sell(20) palm_oil.sell(5)

Output: Bag of Rice (50kg) has been added to Balogun Market. Basket of Tomatoes has been added to Balogun Market. Keg of Palm Oil (25L) has been added to Balogun Market.

--- Products available at Balogun Market, Lagos Island --- Product: Bag of Rice (50kg) | Price: NGN 75000 | In Stock: 20 Product: Basket of Tomatoes | Price: NGN 8000 | In Stock: 15 Product: Keg of Palm Oil (25L) | Price: NGN 18000 | In Stock: 10

3 unit(s) of Bag of Rice (50kg) sold. Total: NGN 225000 Remaining stock: 17 Sorry, only 15 units of Basket of Tomatoes available. 5 unit(s) of Keg of Palm Oil (25L) sold. Total: NGN 90000 Remaining stock: 5

All four OOP principles used here:

• Encapsulation: Product data (name, price, quantity) is bundled inside the Product class and managed through methods.
• Abstraction: The user simply calls sell() without knowing how the internal stock calculations work.
• Inheritance: This can be extended — you could create child classes like PerishableProduct or ElectronicsProduct that inherit from Product.
• Polymorphism: Different product types could override the sell() or display_product() methods to behave differently.

QUICK REFERENCE TABLE

OOP Concept | What It Means | Nigerian Example Class | Blueprint or template | "Student" as a general idea Object | Specific instance of a class | Amaka Okonkwo, SSS 3A Attribute | Property or characteristic | Name, age, account balance Method | Action the object can perform | deposit(), withdraw(), promote() Encapsulation | Bundling data and hiding details | ATM hiding bank processes Inheritance | Child class getting parent features | Okada inheriting Vehicle features Polymorphism | Same method, different behavior | Different animals making sounds Abstraction | Showing only what is needed | Pressing "call" on your phone

PRACTICAL APPLICATIONS OF OOP IN NIGERIA

OOP is not just theory — it is powering real systems in Nigeria right now. Here are some examples you might recognize:

• Banking Applications: Apps from Zenith Bank, GTBank, and Access Bank are built using OOP principles. Each customer account is an object with attributes like account number, balance, and account name. Methods like deposit(), withdraw(), and checkBalance() are used to perform transactions.

• School Management Systems: Many Nigerian private schools now use software to manage student records, results, and attendance. These systems are built using OOP, where each Student, Teacher, and Subject is a class.

• E-commerce Platforms: Nigerian platforms like Jumia and Konga use OOP in their backend systems. A Product is a class with attributes like name, price, and stock quantity. A Customer is a class with attributes like name, address, and purchase history.

• Hospital Management: Systems in government and private hospitals use OOP to manage Patient records, Appointments, and Doctor information.

• JAMB CBT System: The Computer-Based Testing platform used for JAMB examinations is powered by software built with OOP concepts. Each Candidate is an object. Each Question is an object. The system manages thousands of objects at once.

ADVANTAGES OF OOP

• Reusability: Once you write a class, you can reuse it in other programs without rewriting code. This saves time and effort.
• Scalability: OOP makes it easier to expand and grow a program as new features are needed.
• Easy Maintenance: Because code is organized into classes, finding and fixing errors is faster and less stressful.
• Real-world Modeling: OOP mirrors how we naturally think about the world — in terms of things (objects) and their behaviors.
• Security: Encapsulation helps protect sensitive data from being accidentally modified.

DISADVANTAGES OF OOP

• Steeper Learning Curve: For beginners, OOP can be harder to understand than simple procedural programming.
• More Code: OOP programs can sometimes require more lines of code to set up, even for simple tasks.
• Slower Performance: In some cases, OOP programs can run slightly slower than procedural programs because of the extra layers of structure.
• Complexity: For very small programs, using OOP might be unnecessary and overcomplicate things.

ETHICAL CONSIDERATIONS IN OOP AND SOFTWARE DEVELOPMENT

As future programmers and software developers, there are important ethical responsibilities you must keep in mind:

• Data Privacy: When you build systems that store user data — like names, bank details, or health records — you must protect that data responsibly. Nigeria's Data Protection Act (NDPA) requires organizations to handle personal data with care.

• Security: Poorly written OOP code can create security vulnerabilities. Always practice safe coding habits to protect users from hackers and data theft.

• Honest Software: Never use your programming skills to build software that deceives, manipulates, or harms users. Ethical programmers build tools that genuinely help people.

• Intellectual Property: Do not copy other programmers' code without permission. Respect copyright and give credit where it is due.

CLASSROOM AND HOME ACTIVITIES

Activity 1 — Identify the Class and Object Look around your classroom or home. Pick five things (e.g., chair, textbook, phone, fan, desk). For each item, write down what its class would be and list three attributes and two methods it might have if it were programmed as an object.

Activity 2 — Design a Class on Paper Without a computer, design a class called "BankAccount" on paper. Write out at least four attributes (e.g., account number, owner name, balance, account type) and three methods (e.g., deposit, withdraw, check balance). Share with a classmate and compare designs.

Activity 3 — Inheritance Exercise Create a parent class called "Vehicle" with attributes like speed and colour and a method called move(). Then create two child classes — "Car" and "Motorcycle" — that inherit from Vehicle. Add one unique attribute and one unique method to each child class.

Activity 4 — Real-Life OOP Identification List five apps or digital services commonly used in Nigeria (such as bank apps, ride-hailing apps, or school portals). For each one, identify at least two objects you think the system uses, and describe their likely attributes and methods.

ASSESSMENT QUESTIONS

Section A — Objective Questions

1. Which of the following best describes a class in OOP? a) A specific instance of an object b) A blueprint or template used to create objects c) A method that performs an action d) A variable that stores data

2. The OOP principle that hides complex internal details from the user is called: a) Inheritance b) Polymorphism c) Abstraction d) Encapsulation

3. Which principle of OOP allows a child class to use the properties of a parent class? a) Polymorphism b) Encapsulation c) Abstraction d) Inheritance

4. In OOP, the characteristics or properties of an object are called: a) Methods b) Functions c) Attributes d) Classes

5. Which of the following is a real-life example of polymorphism? a) A student inheriting their parent's traits b) A phone hiding its network processes from the user c) A teacher teaching differently in different subject classes d) A bank account storing a customer's balance

Section B — Theory Questions

1. Define Object-Oriented Programming and explain why it is considered more organized than procedural programming. Use one practical example from everyday Nigerian life to support your answer.

2. Explain the four pillars of OOP (Encapsulation, Inheritance, Polymorphism, and Abstraction). For each pillar, provide one real-life example that a Nigerian student can relate to.

3. A software company in Lagos is building a school management system for a secondary school. Describe how OOP can be applied in designing this system. Mention at least three classes, their attributes, and their methods.

SUMMARY

In this lesson, we covered the following key points:

• Object-Oriented Programming (OOP) is a programming style that organizes code around objects rather than just functions.
• A class is a blueprint, while an object is a specific instance created from that blueprint.
• Every object has attributes (properties) and methods (actions).
• The four pillars of OOP are Encapsulation, Inheritance, Polymorphism, and Abstraction.
• Encapsulation bundles data and methods together and hides internal details.
• Inheritance allows child classes to reuse properties from parent classes.
• Polymorphism allows different objects to use the same method name in different ways.
• Abstraction simplifies complex systems by showing only what is necessary.
• OOP is widely used in real Nigerian applications — from banking apps to school management systems.
• Ethical programming includes respecting data privacy, security, and intellectual property.

CONCLUSION

Object-Oriented Programming is more than just a topic in your SSS 3 Computer Studies curriculum. It is a way of thinking — a structured, logical approach to solving problems with code. The skills you develop by mastering OOP today will open doors for you in university-level Computer Science, software development careers, and the fast-growing Nigerian tech industry.

Nigeria's technology sector is booming. From fintech companies in Lagos to startups in Abuja and Port Harcourt, Nigerian developers are building solutions that compete on a global stage. Many of those solutions are powered by the very OOP concepts you are learning right now.

Take time to practice. Write out classes on paper even if you do not have access to a computer every day. Think about the world around you in terms of objects, attributes, and methods. The more naturally OOP thinking comes to you, the better programmer you will become.

Your future in tech starts with understanding the basics — and you are already on the right path.

FREQUENTLY ASKED QUESTIONS (FAQ)

Q1: What is the difference between a class and an object in OOP? A class is a template or blueprint that defines how something should look and behave. An object is the actual item created from that template. For example, "Car" is a class, while your uncle's red Toyota Camry is an object of that class.

Q2: Why is OOP important for Nigerian students to learn? Nigeria's technology industry is growing rapidly. Most modern software — including banking apps, school systems, and e-commerce platforms — is built using OOP. Learning OOP gives Nigerian students a competitive advantage in tech careers and university studies.

Q3: Which programming languages support OOP? Many popular programming languages support OOP, including Python, Java, C++, C#, and JavaScript. Python is particularly beginner-friendly and widely taught in Nigerian secondary schools and universities.

Q4: Is OOP difficult to learn for beginners? OOP can seem challenging at first because it requires a shift in how you think about programming. However, with consistent practice and real-life examples — like those shared in this lesson — it becomes much easier to understand over time.

Q5: How is OOP different from procedural programming? In procedural programming, a program is written as a sequence of instructions executed step by step. In OOP, the program is organized around objects — each with its own data and behavior. OOP is generally better for large, complex programs because it is easier to manage and expand.

Q6: Can OOP be used with Python, which is taught in Nigerian schools? Yes, absolutely. Python fully supports OOP and is one of the most popular languages for teaching OOP concepts. The examples in this lesson were written in Python to reflect what many Nigerian students are already learning in school.