Classes, Objects, and Inheritance

Welcome, students 👋 In this lesson, you will learn how programmers organize code using classes, objects, and inheritance. These ideas are essential in object-oriented programming, which is a major way software is built in many real-world systems such as games, banking apps, school databases, and social media platforms 📱🎮

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

explain the meaning of class, object, attribute, method, and inheritance
describe how a class is used to create objects
apply inheritance to reduce repeated code and make programs easier to maintain
connect these ideas to practical software design in the IB Computer Science SL syllabus
use examples to show how classes, objects, and inheritance solve real programming problems

What are classes and objects?

A class is a blueprint for creating data and behavior in a program. It describes what kind of information something has and what it can do. An object is a specific instance of a class.

A simple way to think about this is to imagine a class as a cookie cutter and an object as one cookie made from it 🍪. The cutter gives the shape, but each cookie is a separate item.

For example, a class called $\text{Student}$ might describe:

name
student ID
grade level
methods such as $\text{updateGrade()}$ or $\text{displayInfo()}$

An object created from that class could represent one real student, such as a learner named Maya. Another object could represent another student with different values for the same class structure.

This is useful because a program can manage many similar things without rewriting the same code again and again. Instead of creating separate variables for every student, the program stores each student as an object with its own attributes.

For example, if $\text{student1}$ and $\text{student2}$ are objects of the class $\text{Student}$, they may both have a $\text{name}$ attribute, but their values would differ:

$\text{student1.name} = \text{"Maya"}$
$\text{student2.name} = \text{"Omar"}$

The class defines the structure, and the object holds the actual data.

Attributes and methods

Classes usually contain two important parts: attributes and methods.

An attribute is a piece of data stored in an object. It describes the object. A method is a function that belongs to a class and defines what an object can do.

For a class $\text{Car}$, possible attributes might be:

$\text{colour}$
$\text{speed}$
$\text{fuelLevel}$

Possible methods might be:

$\text{accelerate()}$
$\text{brake()}$
$\text{refuel()}$

If a car object has $\text{speed} = 50$, the method $\text{brake()}$ might reduce that value. If the method $\text{accelerate()}$ is called, the speed might increase.

This combination of data and behavior is one reason object-oriented programming is powerful. In real systems, objects often represent real-world items. A school system might use objects for students, teachers, classes, and timetable entries. A game might use objects for players, enemies, and items.

A useful idea in programming is that methods help protect the data by controlling how values change. For example, a method may check whether a car’s fuel is enough before allowing it to move. This helps programs behave correctly and makes debugging easier.

How objects are created

When a program creates an object, it is usually based on the class definition. The class provides the template, and the object gets its own values.

A class definition may look like this in pseudocode:

$$\text{class Student}$$

Inside the class, the programmer defines attributes and methods. When the program runs, it may create several objects from that class. Each object is separate, so changing one does not automatically change another.

This matters in real life. Imagine a school database storing thousands of students. If each student were coded separately, the program would become long and hard to manage. With classes, one definition can support many objects. That saves time and reduces mistakes.

Another important term is instance. An instance is another word for an object created from a class. So if $\text{Maya}$ is an instance of $\text{Student}$, that means Maya is one specific object created from the $\text{Student}$ class.

Here is a real-world example:

Class: $\text{BankAccount}$
Attributes: $\text{accountNumber}$, $\text{balance}$, $\text{ownerName}$
Methods: $\text{deposit()}$, $\text{withdraw()}$, $\text{showBalance()}$

Each customer’s account is an object. The class defines the rules for all accounts, but each account object stores different values.

Inheritance: reusing and extending classes

Inheritance is a way to create a new class from an existing class. The new class is called a subclass or derived class, and the original class is called a superclass or base class.

Inheritance allows a subclass to inherit attributes and methods from the superclass. It can also add new features or change existing behavior.

This is useful when several classes share common features. Instead of rewriting the same code, a programmer can put shared features in one superclass and reuse them in subclasses.

For example, suppose a school system has a superclass $\text{Person}$ with attributes such as:

$\text{name}$
$\text{dateOfBirth}$

A subclass $\text{Student}$ could inherit these and add:

$\text{gradeLevel}$
$\text{studentID}$

Another subclass $\text{Teacher}$ could inherit the same basic features and add:

$\text{subject}$
$\text{salary}$

This is a strong design because both students and teachers are people, so it makes sense for them to share common data.

Inheritance is not only about saving time. It also improves consistency. If the program needs to change the way all people are stored, the programmer can update the superclass instead of changing every subclass separately.

Why inheritance matters in IB Computer Science SL

In the IB Computer Science SL course, inheritance is important because it helps students understand how programs are structured in a modular and efficient way. This fits the broader Option Topic Bank because option topics often involve deeper application, problem-solving, and system design.

When students study classes and inheritance, they are learning how to model real situations in code. This is a core computational thinking skill. Instead of seeing code as a list of instructions only, students learn to organize programs around objects that represent real or abstract things.

For example, in a library system:

class $\text{Item}$ might store common properties such as $\text{title}$ and $\text{year}$
subclass $\text{Book}$ might add $\text{author}$ and $\text{ISBN}$
subclass $\text{DVD}$ might add $\text{duration}$ and $\text{regionCode}$

This structure matches how libraries actually work. Books and DVDs are both items, but each has different details.

For IB exam-style reasoning, students may need to identify whether a class hierarchy is appropriate, explain what should be placed in a superclass, or show how inheritance reduces duplication. A common exam idea is to ask which attributes belong in a superclass and which belong only in a subclass. The key rule is that shared features belong higher in the hierarchy, while special features belong lower down.

Example of reasoning with a class hierarchy

Consider a transport system.

A superclass $\text{Vehicle}$ may include:

$\text{maxSpeed}$
$\text{numberOfWheels}$
$\text{start()}$
$\text{stop()}$

A subclass $\text{Car}$ may add:

$\text{numberOfDoors}$

A subclass $\text{Motorcycle}$ may add:

$\text{hasSidecar}$

A subclass $\text{Bus}$ may add:

$\text{passengerCapacity}$

This design works because all vehicles can start and stop, but not all vehicles have the same extra features.

If the programmer changes how $\text{start()}$ works, the change can apply to all vehicle types. That is much more efficient than updating every class separately.

In code, a subclass may also override a method. That means it uses the same method name but gives it a different behavior. For example, the method $\text{start()}$ might behave differently for a car and a bus. This helps programmers represent real differences while still sharing a common structure.

Common misunderstandings

Students sometimes confuse classes and objects. Remember:

a class is the blueprint
an object is a specific example made from the blueprint

Another common misunderstanding is thinking inheritance is just copying code. It is more than that. Inheritance creates a relationship between classes, where the subclass is a specialized version of the superclass.

It is also important to avoid using inheritance when the classes do not share a true relationship. For example, a $\text{Car}$ is not a type of $\text{Engine}$, even though a car has an engine. Inheritance should represent an “is-a” relationship, not a “has-a” relationship.

A good test is to ask:

Is the subclass really a kind of the superclass?
Do they share common attributes and methods?
Will inheritance make the program simpler and clearer?

If the answer is yes, inheritance may be a good choice. If not, another relationship such as composition may be better.

Conclusion

Classes, objects, and inheritance are central ideas in object-oriented programming. A class defines the structure of data and behavior, an object is one specific instance of that class, and inheritance allows new classes to reuse and extend existing ones. These ideas help programmers build organized, reusable, and realistic models of the world.

In IB Computer Science SL, understanding these ideas supports both theory and practical problem solving. You should be able to describe the terms clearly, identify good class structures, and explain why inheritance is helpful in larger programs. These skills are important across the Option Topic Bank because they strengthen your ability to design and analyze software systems.

Study Notes

A class is a blueprint for creating objects.
An object is a specific instance of a class.
An attribute stores data about an object.
A method is a function belonging to a class.
Inheritance lets a subclass reuse and extend a superclass.
A superclass contains shared features; a subclass contains special features.
Inheritance is useful when classes have an is-a relationship.
Classes and objects help organize programs into reusable parts.
Inheritance reduces repeated code and can make maintenance easier.
Real-world examples include school systems, bank accounts, vehicles, and games 🎓💳🚗
In IB Computer Science SL, these concepts support modeling, abstraction, and structured problem solving.