Chapter 18 - Classes

Classes are a fundamental concept in object-oriented programming (OOP). They act as blueprints for creating objects and define the structure and behavior that those objects will have. A class can encapsulate data (attributes) and behavior (methods) in a single unit, making it easier to manage complexity in large programs. In this article, we'll explore classes, their types, and how they can be used in various programming languages.

What Are Classes?

A class is a template for creating objects. It allows you to define properties (data members) and methods (functions) that will belong to objects created from the class. For example, a Car class might include attributes like color, make, and model and methods like start(), stop(), and drive().

Here's an example of a simple class definition in Python:

class Car:
    def __init__(self, make, model, color):
        self.make = make
        self.model = model
        self.color = color

    def drive(self):
        print(f"The {self.color} {self.make} {self.model} is driving.")

    def stop(self):
        print(f"The {self.color} {self.make} {self.model} has stopped.")

Different Types of Classes in Programming

Concrete Classes

Concrete classes are the most basic type of classes. They can be instantiated directly to create objects. For example, the Car class shown above is a concrete class because you can create instances of it:

my_car = Car("Toyota", "Corolla", "Blue")
my_car.drive()
my_car.stop()

Abstract Classes

Abstract classes serve as templates for other classes. They cannot be instantiated directly. Instead, they define methods that must be implemented by subclasses. Abstract classes are useful for creating a common interface across multiple derived classes.

Example in Python:

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

# dog = Animal()  # This would raise an error
my_dog = Dog()
print(my_dog.speak())

Static Classes

Static classes are used when you don't need to instantiate a class but want to group related functions together. They typically contain only static methods and static variables.

Example in Python:

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b

    @staticmethod
    def multiply(a, b):
        return a * b

print(MathUtils.add(5, 10))
print(MathUtils.multiply(5, 10))

Inner Classes

Inner classes are classes defined within other classes. They are often used to logically group related classes together or to encapsulate helper classes.

Example in Python:

class OuterClass:
    class InnerClass:
        def display(self):
            print("This is the inner class.")

outer = OuterClass()
inner = outer.InnerClass()
inner.display()

Singleton Classes

A singleton class ensures that only one instance of the class can exist. This is useful for managing shared resources like database connections or configuration settings.

Example in Python:

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

singleton1 = Singleton()
singleton2 = Singleton()
print(singleton1 is singleton2)  # True

Key Concepts of Classes

Encapsulation

Encapsulation is the bundling of data and methods that operate on that data into a single unit (class). It also involves restricting access to certain components of an object to enforce proper usage.

Example in Python:

class Person:
    def __init__(self, name):
        self.__name = name  # Private attribute

    def get_name(self):
        return self.__name

    def set_name(self, name):
        self.__name = name

person = Person("John")
print(person.get_name())

Inheritance

Inheritance allows a class to derive properties and methods from another class. This promotes code reuse and logical hierarchy.

Example in Python:

class Vehicle:
    def __init__(self, brand):
        self.brand = brand

    def drive(self):
        print("Driving a vehicle.")

class Car(Vehicle):
    def drive(self):
        print(f"Driving a {self.brand} car.")

car = Car("Toyota")
car.drive()

Polymorphism

Polymorphism allows objects of different classes to be treated as objects of a common superclass. This is often implemented using method overriding.

Example in Python:

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

def animal_speak(animal):
    print(animal.speak())

animal_speak(Dog())
animal_speak(Cat())

Classes in Other Programming Languages

Classes in PHP

class Car {
    public $make;
    public $model;

    public function __construct($make, $model) {
        $this->make = $make;
        $this->model = $model;
    }

    public function drive() {
        echo "The {$this->make} {$this->model} is driving.\n";
    }
}

$car = new Car("Toyota", "Corolla");
$car->drive();

Classes in Go

Go does not have traditional classes but uses structs and methods to achieve similar functionality.

type Car struct {
    Make  string
    Model string
}

func (c Car) Drive() {
    fmt.Printf("The %s %s is driving.\n", c.Make, c.Model)
}

func main() {
    car := Car{"Toyota", "Corolla"}
    car.Drive()
}

Classes in C++

#include <iostream>
using namespace std;

class Car {
public:
    string make;
    string model;

    Car(string m, string mo) : make(m), model(mo) {}

    void drive() {
        cout << "The " << make << " " << model << " is driving." << endl;
    }
};

int main() {
    Car car("Toyota", "Corolla");
    car.drive();
    return 0;
}

Classes in Zig

Zig doesn't have a class system like other object-oriented languages, but you can achieve similar functionality using structs and methods.

const std = @import("std");

const Car = struct {
    make: []const u8,
    model: []const u8,

    pub fn drive(self: Car) void {
        std.debug.print("The {s} {s} is driving.\n", .{ self.make, self.model });
    }
};

pub fn main() void {
    const car = Car{ .make = "Toyota", .model = "Corolla" };
    car.drive();
}

Conclusion

Classes are a powerful feature in object-oriented programming that help developers model real-world entities and relationships. By understanding the different types of classes and their key concepts, you can create organized, reusable, and maintainable code across various programming languages.

Last modified: 26 January 2025