KAHIBARO
Discord Login Register ☰
☰

4.11 Classes and Objects

Table of Contents

Why Classes and Objects Matter

In backend development you often need to represent real world things in code: users, orders, products, payments, emails, and more. Classes and objects are how most programming languages model these things.

You will learn the general ideas here. Later, in the “Object-Oriented Programming” and “Python” chapters, you will see language specific details and more advanced concepts.

Think of this chapter as a gentle first pass over the basics.

From Data To “Things”

So far you may have used only simple data types:

These are useful, but real backend data usually has structure.

Example: You want to handle a user in a system.

Using only basic types, you might write:

python 
user_id = 1
user_name = "Alice"
user_email = "alice@example.com"
user_is_active = True

If you need two users:

python 
user1_id = 1
user1_name = "Alice"
user1_email = "alice@example.com"
user1_is_active = True
user2_id = 2
user2_name = "Bob"
user2_email = "bob@example.com"
user2_is_active = False

This is messy and error prone. You have many related variables floating around with no clear relationship. Functions that work with “a user” will need many parameters.

Classes and objects fix this problem by letting you group data and behavior into a single “thing”.

What Is a Class?

A class is a blueprint or template that describes:

Analogy:

Example of a User class in a Python-like pseudocode:

python 
class User:
    # This runs when you create a new user
    def __init__(self, id, name, email, is_active):
        self.id = id
        self.name = name
        self.email = email
        self.is_active = is_active
    def deactivate(self):
        self.is_active = False
    def activate(self):
        self.is_active = True

In this example:

You do not use User directly to represent a single user. Instead, you create objects from it.

What Is an Object?

An object (also called an instance of a class) is a concrete version of the class blueprint, with actual values.

Analogy:

Using the previous User class, you create objects like this:

python 
alice = User(1, "Alice", "alice@example.com", True)
bob = User(2, "Bob", "bob@example.com", False)

Now:

You can call methods on each object separately:

python 
bob.activate()          # Changes bob.is_active to True
alice.deactivate()      # Changes alice.is_active to False

The key idea is that:

Classes Group Data and Behavior

The main power of classes is that they put related data and functions together.

Without a class, you might use separate functions:

python 
def deactivate_user(user):
    user["is_active"] = False
def activate_user(user):
    user["is_active"] = True
user = {
    "id": 1,
    "name": "Alice",
    "email": "alice@example.com",
    "is_active": True,
}

Here user is a dictionary or map, and the functions live somewhere else. You always need to pass user into the functions.

With a class, the same actions become methods of the object itself:

python 
alice = User(1, "Alice", "alice@example.com", True)
alice.deactivate()
alice.activate()

Now:

This is called encapsulation and is one of the central ideas in object oriented programming. You will cover it more in a later chapter, but for now remember:

Important: A class groups related data and behavior into a single unit, which makes code easier to understand and maintain.

Terminology: Fields, Attributes, Methods, Instances

Different languages use slightly different words, but they typically mean:

TermMeaning
ClassBlueprint that defines a new type of object
ObjectA specific value created from a class
InstanceAnother word for “object” of a class
FieldA piece of data stored in an object, sometimes called an attribute
AttributeOften the same as field, data that belongs to an object
MethodA function defined inside a class that works on the object’s data
ConstructorSpecial method that sets up a new object when it is created

You will see these terms used again and again in backend documentation and tutorials.

A Simple Backend Style Example

Imagine a simple API that manages tasks in a to do application. Each task has:

You can model this with a class:

python 
class Task:
    def __init__(self, id, title, due_date, completed=False):
        self.id = id
        self.title = title
        self.due_date = due_date
        self.completed = completed
    def complete(self):
        self.completed = True
    def reopen(self):
        self.completed = False
    def rename(self, new_title):
        self.title = new_title

Create and use objects:

python 
task1 = Task(1, "Write documentation", "2026-08-30")
task2 = Task(2, "Fix bug #123", "2026-08-29", completed=True)
task1.complete()           # task1.completed becomes True
task2.rename("Fix login bug")
task2.reopen()             # task2.completed becomes False

This models tasks in the same way you think about them in the real world. Each object represents a specific task, with its own life cycle.

Constructors and Initialization

Most object oriented languages have a constructor. This is a special function that runs when you create a new object.

In the pseudocode examples, __init__ played that role:

python 
class User:
    def __init__(self, id, name, email, is_active=True):
        self.id = id
        self.name = name
        self.email = email
        self.is_active = is_active

When you write:

python 
user = User(1, "Alice", "alice@example.com")

The constructor fills in the initial values. The object starts its life in a valid state.

In backend systems, you often get data from outside, for example from an HTTP request or from a database. Constructors help you turn that raw data into well structured objects.

Example: creating a user from JSON data:

python 
json_data = {
    "id": 1,
    "name": "Alice",
    "email": "alice@example.com",
}
user = User(
    id=json_data["id"],
    name=json_data["name"],
    email=json_data["email"],
)

Methods Use the Object’s Own Data

Methods are functions that automatically receive the object they belong to, usually named self or this depending on the language.

In this example:

python 
class Product:
    def __init__(self, name, price, tax_rate):
        self.name = name
        self.price = price
        self.tax_rate = tax_rate
    def total_price(self):
        return self.price * (1 + self.tax_rate)

When you call:

python 
p = Product("Book", 10.0, 0.19)
print(p.total_price())

Inside total_price, the following happens:

This pattern is very useful in backend code. For example:

The code for these actions stays with the data it acts on.

Classes in Backend Structure

In backend applications, classes are used almost everywhere. Some typical categories:

Class kindBackend example
Data modelUser, Product, Order, Invoice, Session
ServiceEmailService, PaymentService, AuthService
Controller/HandlerUserController, TaskApiHandler
UtilityPasswordHasher, TokenGenerator, Logger

Later chapters about architecture and frameworks will show structured ways to use such classes. For now, you just need to be comfortable with the basic idea:

Multiple Objects From One Class

One blueprint can create many objects, each with its own state.

Example with a Session class:

python 
class Session:
    def __init__(self, user_id):
        self.user_id = user_id
        self.is_valid = True
    def invalidate(self):
        self.is_valid = False

Now you can have sessions for many users:

python 
s1 = Session(user_id=1)
s2 = Session(user_id=2)
s3 = Session(user_id=3)
s2.invalidate()
print(s1.is_valid)  # True
print(s2.is_valid)  # False
print(s3.is_valid)  # True

All three share the same structure and behavior, but each keeps its own data. This is exactly how real systems work: one type of thing, many actual instances of it.

Identity, State, Behavior

You can describe objects with three key words:

  1. Identity
    • Which specific object is this in memory or in the system.
    • Example: user with id 1 vs user with id 2.
  2. State
    • The current values of its fields.
    • Example: is_active, email, name for a user.
  3. Behavior
    • What the object can do, its methods.
    • Example: activate, deactivate, change_email.

In code:

python 
class User:
    def __init__(self, id, name, email, is_active=True):
        self.id = id              # identity (in database)
        self.name = name          # part of state
        self.email = email        # part of state
        self.is_active = is_active
    def change_email(self, new_email):   # behavior
        self.email = new_email
    def deactivate(self):                # behavior
        self.is_active = False

Remember:
A class defines identity, state, and behavior for its objects.
An object is the combination of a specific identity, its current state, and its available behavior.

Example: Modeling an Order

Here is a more complete example to connect classes and objects to a realistic backend concept, an online order.

Requirements:

Pseudocode:

python 
class OrderItem:
    def __init__(self, product_name, quantity, unit_price):
        self.product_name = product_name
        self.quantity = quantity
        self.unit_price = unit_price
    def total_price(self):
        return self.quantity * self.unit_price
class Order:
    def __init__(self, id):
        self.id = id
        self.items = []
        self.is_paid = False
    def add_item(self, item):
        self.items.append(item)
    def total_amount(self):
        total = 0
        for item in self.items:
            total += item.total_price()
        return total
    def mark_paid(self):
        self.is_paid = True

Use it like this:

python 
order = Order(id=1001)
item1 = OrderItem("Book", 2, 10.0)      # 2 * 10.0 = 20.0
item2 = OrderItem("Pen", 5, 1.5)        # 5 * 1.5 = 7.5
order.add_item(item1)
order.add_item(item2)
print(order.total_amount())   # 27.5
order.mark_paid()
print(order.is_paid)          # True

Here you see:

This style is very common in backend development.

When To Use Classes

You do not always need classes. For small scripts, simple functions and basic data types are enough.

Classes are useful when:

You will get better at choosing when to use classes as you practice and as you see real backend code.

Summary

Views: 7

Comments

Please login to add a comment.

Don't have an account? Register now!

© 2025 Kahibaro
Visitors: 3161 / 24h
Impressum / Imprint
Datenschutz / Data Policy